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

Изображение, иллюстрирующее арифметическую прогрессию и сумму её членов

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

Арифметическая прогрессия (АП) — это последовательность чисел, у которой каждый следующий член получается прибавлением постоянной разности d к предыдущему. Коротко:

a — первый член (first term)
d — разность (common difference)
n — число членов (no. of terms)

Пример последовательности:

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

Сумма конечных n членов называется арифметическим рядом (series).

Задача

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

Пример: a = 1, d = 2, n = 5. Последовательность: 1 + 3 + 5 + 7 + 9. Сумма = 25.

Итеративный подход (сложение членов)

Идея простая: пройти по всем n членам, накапливая сумму и увеличивая текущий член на d.

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 sum_of_arithmetic_series(first_term, common_difference, no_of_terms):
    result = 0
    for _ in range(no_of_terms):
        result += first_term
        first_term += common_difference
    return result

first_term = 1
common_difference = 2
no_of_terms = 5
print("Первый член:", first_term)
print("Разность:", common_difference)
print("Число членов:", no_of_terms)
print("Сумма ряда:", sum_of_arithmetic_series(first_term, common_difference, no_of_terms))

Вывод:

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

JavaScript — итерация

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

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

Вывод (в консоли):

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

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;
}

Вывод:

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

Примечание: итеративный метод прост и универсален. Он стабилен при любых значениях целых параметров, но его сложность O(n).

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

Для конечной арифметической прогрессии есть формула, дающая сумму за O(1):

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

где a — первый член, d — разность, n — число членов.

Почему формула работает? Коротко

Сумма первых n членов равна n умноженному на среднее арифметическое первого и последнего члена. Последний член = a + (n-1)*d. Среднее = (a + last) / 2 = (2a + (n-1)d)/2. Умножаем на n и получаем формулу выше.

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;
}

Замечание: в целочисленной арифметике важно избегать потерь при делении — при необходимости приводите к long long или используйте умножение до деления.

Python — формула

# Python: сумма по формуле

def sum_of_arithmetic_series(first_term, common_difference, no_of_terms):
    return (no_of_terms / 2) * (2 * first_term + (no_of_terms - 1) * common_difference)

print("Сумма ряда:", sum_of_arithmetic_series(1, 2, 5))

В Python деление / даст float; если нужен целочисленный результат при целых входных данных, используйте выражение (no_of_terms * (2 * first_term + (no_of_terms - 1) * common_difference)) // 2.

JavaScript и C — формула

В JavaScript и C реализация аналогична — обращайте внимание на типы (в JS числа — float64, в C лучше использовать long long при больших n или a).

Когда использовать итерацию, а когда формулу

Итерация полезна, если вы одновременно вычисляете дополнительные свойства каждого члена (накапливаете статистики, фильтруете, применяете условие). Она работает для произвольных типов, не только чисел.
Формула идеальна, когда нужно только значение суммы и важна скорость / простота.
Формула может переполнить тип при больших значениях; в таких случаях используйте больший целочисленный тип или арифметику с плавающей точкой.

Ментальные модели и эвристики

«Среднее первого и последнего» — самая простая мысль: сумма = n × (среднее крайних).
Проверяйте граничные случаи: n = 0, n = 1, d = 0 (последовательность постоянна).
Если a и d целые и n чётно, выражение (n/2) можно выполнить целочисленно без потерь.

Краткая методология (микро-процесс)

Проверить входы: n >= 0.
Если нужно дополнительная обработка каждого члена — выбрать итерацию.
Иначе — использовать формулу с учётом типов и возможного переполнения.
Добавить тесты на граничные значения.

Критерии приёмки

При n = 5, a = 1, d = 2 функция возвращает 25.
При n = 0 функция возвращает 0.
При d = 0 функция возвращает n * a.
Для больших n и больших a/d не должно происходить неоправданного переполнения (зависит от требований и выбранного типа).

Тестовые случаи / примеры

a = 1, d = 2, n = 5 -> 25
a = 10, d = 0, n = 4 -> 40
a = 5, d = -1, n = 6 -> 5 + 4 + 3 + 2 + 1 + 0 = 15
a = 0, d = 3, n = 0 -> 0
Большие значения: a = 10^9, d = 10^9, n = 10^5 — проверьте типы и потенциальное переполнение

Чек-лист для разработчика

Проверить граничные значения n = 0 и n = 1
Выбрать тип данных (int, long long, float)
Реализовать и итеративный, и формульный методы (если нужно)
Написать модульные тесты по набору тест-кейсов
Документировать сложность: итерация O(n), формула O(1)

Пример сравнения: Итерация vs Формула

Простота: формула > итерация
Универсальность: итерация > формула (можно изменять шаги)
Производительность: формула O(1) гораздо быстрее при больших n
Надёжность: итерация менее подвержена переполнению при аккуратном использовании конечной арифметики (но требует n итераций)

Итог

Итерация и формула — два простых способа найти сумму арифметической прогрессии. Формула даёт мгновенный результат и обычно предпочтительна для чистого вычисления суммы; итерация стоит выбрать, если нужно обработать или отфильтровать сами члены. Всегда проверяйте граничные случаи и подбирайте типы данных исходя из ожидаемых диапазонов.

Важно: выбирайте реализацию, учитывая требования к точности, производительности и потенциальное переполнение типов.