Сумма арифметической прогрессии

Иллюстрация арифметической прогрессии

Что такое арифметическая прогрессия?

Сумма конечной арифметической последовательности называется арифметическим рядом (серией). Арифметическая последовательность задаётся так:

a, a+d, a+2d, a+3d, a+4d, ...

где

a = первый член
nd = разность (common difference)

Определение в одну строку: арифметическая прогрессия — последовательность, у которой разность между соседними членами постоянна.

Постановка задачи

Даны первый член a, разность d и количество членов n. Нужно найти сумму первых n членов арифметического ряда.

Пример: a = 1, d = 2, n = 5. Ряд: 1 + 3 + 5 + 7 + 9 = 25.

Итеративный подход (перебор)

Идея: пройти по n членам, накапливая сумму и прибавляя d к текущему члену. Подходит, когда нужно явно сгенерировать члены ряда или когда n невелико.

C++: итерация

// Программа на C++ для суммы арифметического ряда (итерация)
#include 
using namespace std;

// Функция для вычисления суммы арифметической прогрессии
int sumOfArithmeticSeries(int firstTerm, int commonDifference, int noOfTerms)
{
    int result = 0;
    for (int i = 0; i < noOfTerms; i++)
    {
        result = result + firstTerm;
        firstTerm = firstTerm + commonDifference;
    }
    return result;
}

int main()
{
    int firstTerm = 1;
    int commonDifference = 2;
    int noOfTerms = 5;
    cout << "Первый член: " << firstTerm << endl;
    cout << "Разность: " << commonDifference << endl;
    cout << "Количество членов: " << noOfTerms << endl;
    cout << "Сумма ряда: " << sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms) << endl;
    return 0;
}

Вывод:

Первый член: 1
Разность: 2
Количество членов: 5
Сумма ряда: 25

Python: итерация

# Python: сумма арифметической прогрессии (итерация)

def sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms):
    result = 0
    for i in range(noOfTerms):
        result = result + firstTerm
        firstTerm = firstTerm + commonDifference
    return result

firstTerm = 1
commonDifference = 2
noOfTerms = 5
print("Первый член:", firstTerm)
print("Разность:", commonDifference)
print("Количество членов:", noOfTerms)
print("Сумма ряда:", sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms))

Вывод аналогичен: 25

JavaScript: итерация

// JavaScript: сумма арифметической прогрессии (итерация)
function sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms) {
  var result = 0;
  for (let i = 0; i < noOfTerms; i++) {
    result = result + firstTerm;
    firstTerm = firstTerm + commonDifference;
  }
  return result;
}

var firstTerm = 1;
var commonDifference = 2;
var noOfTerms = 5;
document.write("Первый член: " + firstTerm + "
");
document.write("Разность: " + commonDifference + "
");
document.write("Количество членов: " + noOfTerms + "
");
document.write("Сумма ряда: " + sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms));

C: итерация

// C: сумма арифметической прогрессии (итерация)
#include 

int sumOfArithmeticSeries(int firstTerm, int commonDifference, int noOfTerms)
{
    int result = 0;
    for (int i = 0; i < noOfTerms; i++)
    {
        result = result + firstTerm;
        firstTerm = firstTerm + commonDifference;
    }
    return result;
}

int main()
{
    int firstTerm = 1;
    int commonDifference = 2;
    int noOfTerms = 5;
    printf("Первый член: %d\n", firstTerm);
    printf("Разность: %d\n", commonDifference);
    printf("Количество членов: %d\n", noOfTerms);
    printf("Сумма ряда: %d\n", sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms));
    return 0;
}

Вывод равен 25.

Эффективный подход: формула (O(1))

Формула для суммы первых n членов арифметической прогрессии:

S = (n / 2) * (2 * a + (n - 1) * d)

где:

a = первый член
n = количество членов
d = разность

Формула выводится просто: сумма пар первого и последнего, второго и предпоследнего и т.д.

C++: формула

// C++: сумма арифметической прогрессии (формула)
#include 
using namespace std;

int sumOfArithmeticSeries(int firstTerm, int commonDifference, int noOfTerms)
{
    return (noOfTerms / 2) * (2 * firstTerm + (noOfTerms - 1) * commonDifference);
}

int main()
{
    int firstTerm = 1;
    int commonDifference = 2;
    int noOfTerms = 5;
    cout << "Первый член: " << firstTerm << endl;
    cout << "Разность: " << commonDifference << endl;
    cout << "Количество членов: " << noOfTerms << endl;
    cout << "Сумма ряда: " << sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms) << endl;
    return 0;
}

Python: формула

# Python: сумма арифметической прогрессии (формула)

def sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms):
    return (noOfTerms / 2) * (2 * firstTerm + (noOfTerms - 1) * commonDifference)

firstTerm = 1
commonDifference = 2
noOfTerms = 5
print("Сумма ряда:", sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms))

JavaScript: формула

function sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms) {
  return (noOfTerms / 2) * (2 * firstTerm + (noOfTerms - 1) * commonDifference);
}

document.write("Сумма ряда: " + sumOfArithmeticSeries(1, 2, 5));

C: формула

#include 

int sumOfArithmeticSeries(int firstTerm, int commonDifference, int noOfTerms)
{
    return (noOfTerms / 2) * (2 * firstTerm + (noOfTerms - 1) * commonDifference);
}

int main()
{
    int firstTerm = 1;
    int commonDifference = 2;
    int noOfTerms = 5;
    printf("Сумма ряда: %d\n", sumOfArithmeticSeries(firstTerm, commonDifference, noOfTerms));
    return 0;
}

Когда формула может не сработать (практические оговорки)

Если n не целое или отрицательное — сначала проверьте корректность входных данных. n должен быть целым и >= 0.
Для очень больших n, a или d возможен переполнение целочисленного типа (особенно в C/C++/C). Используйте 64‑битные типы или плавающую арифметику.
При нецелых значениях (вещественные a, d) используйте плавающие типы и учитывайте погрешность.
Для бесконечных рядов формула не применяется — речь только о конечной сумме первых n членов.

Важно: всегда валидируйте входные данные: n >= 0 и типы достаточной разрядности.

Быстрота и ресурсы — краткая «карточка» (Fact box)

Итеративный подход: временная сложность O(n), память O(1).
Формула: временная сложность O(1), память O(1).
Риски: переполнение для больших чисел; при плавающей арифметике — округления.

Критерии приёмки (тесты / примеры)

Таблица тестовых случаев (вход => ожидаемый):

a	d	n	Ожидаемая сумма
1	2	5	25

| 5 | 0 | 10 | 50 (каждый член 5, 10*5) | 10 | -2 | 3 | 24 (10 + 8 + 6) | 0 | 1 | 0 | 0 (нет членов)

Минимальные критерии приёмки:

Работает для n = 0 (должно вернуть 0).
Корректен для отрицательной d.
Обрабатывает большие значения без неожиданного переполнения (или документирует ограничения).

Быстрый план действий (мини‑методология)

Проверить входные данные: n целое и >= 0.
Для простых случаев использовать формулу (O(1)).
Если нужно явно перечислить члены — использовать итерацию.
При больших значениях применить типы с большей разрядностью или контроль переполнения.
Написать набор тестов, включающий граничные случаи.

Чек-листы по ролям

Студент:
- Понять формулу и вывести её от руки на простом примере.
- Реализовать функцию в выбранном языке.
- Прогнать тестовые примеры.
Разработчик ПО:
- Защитить функцию от переполнения.
- Добавить валидацию входных данных.
- Документировать поведение для вещественных и отрицательных параметров.

Модель принятия решения (когда использовать что)

flowchart TD
  A[Нужно только число S?] -->|Да| B[Использовать формулу O'1']
  A -->|Нет, нужно перечисление| C[Итерация: генерировать члены]
  B --> D[Проверить на переполнение]
  C --> D
  D --> E{Большие числа?}
  E -->|Да| F[Использовать 64-бит или BigInt]
  E -->|Нет| G[ОК]

1‑строчный глоссарий

Арифметическая прогрессия: последовательность с постоянной разностью между соседними членами.
Ряд/сумма: сумма первых n членов прогрессии.

Краткое резюме

Формула S = n/2 * (2a + (n-1)d) даёт O(1) решение для суммы первых n членов.
Итерация полезна, если нужно явно получить члены или когда n невелико.
Всегда проверяйте вход и учитывайте переполнение/погрешности при вещественных типах.

Спасибо за чтение — с этими приёмами вы сможете быстро и безопасно вычислять суммы арифметических прогрессий в большинстве языков программирования.