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

График популярности основных языков программирования

Когда вы стремитесь улучшить навыки программирования, рано или поздно полезно понять геометрические прогрессии. В геометрической прогрессии каждый следующий член получается умножением предыдущего на постоянный множитель.

В этой статье вы узнаете, как найти сумму конечной геометрической прогрессии (геометрического ряда) двумя способами: итеративно и с использованием формулы. Для каждой методики приведены реализации на Python, C++, JavaScript и C, а также разбор особых случаев и тест-кейсы.

Что такое геометрическая прогрессия и геометрический ряд

Геометрическая прогрессия (или геометрическая последовательность) выглядит так:

a, ar, ar^2, ar^3, ...

где

a = первый член
r = общее соотношение (common ratio)

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

S_n = a + ar + ar^2 + … + ar^{n-1}

Если n стремится к бесконечности и |r| < 1, ряд сходится к a / (1 - r).

Задача

Даны: первый член a, общее соотношение r и число членов n. Требуется найти сумму первых n членов геометрического ряда.

Пример: a = 1, r = 2, n = 8. Ряд: 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128. Сумма: 255.

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

Идея: пройти по n членам, аккумулируя сумму и умножая текущий член на r на каждом шаге. Сложность O(n). Этот подход прост и стабилен для небольших n, но медленнее при очень больших n.

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

// C++ program to find the sum of geometric series  
#include   
using namespace std;  
  
// Function to find the sum of geometric series  
float sumOfGeometricSeries(float firstTerm, float commonRatio, int noOfTerms)  
{  
 float result = 0;  
 for (int i=0; i

Вывод:

First Term: 1  
Common Ratio: 2  
Number of Terms: 8  
Sum of the geometric series: 255

`Python — итерация`

# Python program to find the sum of geometric series  
  
# Function to find the sum of geometric series  
def sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms):  
    result = 0  
    for i in range(noOfTerms):  
        result = result + firstTerm  
        firstTerm = firstTerm * commonRatio  
    return result  
  
firstTerm = 1  
commonRatio = 2  
noOfTerms = 8  
print("First Term:", firstTerm)  
print("Common Ratio:", commonRatio)  
print("Number of Terms:", noOfTerms)  
print("Sum of the geometric series:", sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms))

Вывод: тот же — 255.

`JavaScript — итерация`

// JavaScript program to find the sum of geometric series  
  
// Function to find the sum of geometric series  
function sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms) {  
 var result = 0;  
 for (let i=0; i

`C — итерация`

// C program to find the sum of geometric series  
#include   
  
// Function to find the sum of geometric series  
float sumOfGeometricSeries(float firstTerm, float commonRatio, int noOfTerms)  
{  
 float result = 0;  
 for (int i=0; i

Вывод: 255.

Важно: итеративный метод проще для понимания и безопаснее при r близком к 1 для небольших n, но требует O(n) времени.

`Формула (эффективный подход)`

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

S_n = a * (1 - r^n) / (1 - r)

где a — первый член, r — общее соотношение, n — число членов.

Эта формула даёт результат за O(1) времени, но требует осторожности при r ≈ 1 и для очень больших степеней из‑за проблем с переполнением или потери точности с плавающей точкой.

`Когда формула применима и когда нет`

Работает для любого r, r != 1. Для r = 1 сумма равна a * n.
Для отрицательного r формула остаётся верной, но члены ряда чередуются по знаку.
Для очень больших n и |r| > 1 члены растут экспоненциально — может возникнуть переполнение.
Для |r| < 1 при n → ∞ сумма сходится к a / (1 - r).

`C++ — формула`

// C++ program to find the sum of geometric series  
#include   
using namespace std;  
  
// Function to find the sum of geometric series  
float sumOfGeometricSeries(float firstTerm, float commonRatio, int noOfTerms)  
{  
 return (firstTerm * (1 - pow(commonRatio, noOfTerms))) / (1 - commonRatio);  
}  
  
int main()  
{  
 float firstTerm = 1;  
 float commonRatio = 2;  
 int noOfTerms = 8;  
 cout << "First Term: " << firstTerm << endl;  
 cout << "Common Ratio: " << commonRatio << endl;  
 cout << "Number of Terms: " << noOfTerms << endl;  
 cout << "Sum of the geometric series: " << sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms) << endl;  
  
 return 0;  
}

`Python — формула`

# Python program to find the sum of geometric series  
  
# Function to find the sum of geometric series  
def sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms):  
    return (firstTerm * (1 - pow(commonRatio, noOfTerms))) / (1 - commonRatio)  
  
firstTerm = 1  
commonRatio = 2  
noOfTerms = 8  
print("First Term:", firstTerm)  
print("Common Ratio:", commonRatio)  
print("Number of Terms:", noOfTerms)  
print("Sum of the geometric series:", sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms))

`JavaScript — формула`

// JavaScript program to find the sum of geometric series  
  
// Function to find the sum of geometric series  
function sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms) {  
 return (firstTerm * (1 - Math.pow(commonRatio, noOfTerms))) / (1 - commonRatio);  
}  
  
  
var firstTerm = 1;  
var commonRatio = 2;  
var noOfTerms = 8;  
document.write("First Term: " + firstTerm + "  \n");  
document.write("Common Ratio: " + commonRatio + "  \n");  
document.write("Number of Terms: " + noOfTerms + "  \n");  
document.write("Sum of the geometric series: " + sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms));

`C — формула`

// C program to find the sum of geometric series  
#include   
#include   
  
// Function to find the sum of geometric series  
float sumOfGeometricSeries(float firstTerm, float commonRatio, int noOfTerms)  
{  
 return (firstTerm * (1 - pow(commonRatio, noOfTerms))) / (1 - commonRatio);  
}  
  
int main()  
{  
 float firstTerm = 1;  
 float commonRatio = 2;  
 int noOfTerms = 8;  
 printf("First Term: %f \n", firstTerm);  
 printf("Common Ratio: %f \n", commonRatio);  
 printf("Number of Terms: %d \n", noOfTerms);  
 printf("Sum of the geometric series: %f \n", sumOfGeometricSeries(firstTerm, commonRatio, noOfTerms));  
  
 return 0;  
}

`Практические замечания и рекомендации`

Если r == 1, возвращайте a * n, чтобы избежать деления на ноль.
Если n велико и |r| > 1, члены быстро растут и может случиться переполнение. Рассмотрите использование длинной арифметики (bigint/bigfloat) или проверку пределов до вычислений.
Для вычисления r^n используйте встроенные pow с типом с плавающей точкой или целочисленную экспоненциацию по возведению в степень (быстрое возведение в степень) для целых r и больших n.
При работе с float/double следите за потерей точности, особенно когда r близко к 1: выражение (1 - r^n) может привести к вычитанию близких по величине чисел. В таких случаях итеративный метод может дать более надёжный результат для небольших n.

`Когда формула даёт плохую точность (контрпример)`

a = 1e8, r = 1.0000001, n = 1000000. Здесь r^n может оказаться огромным, а выражение (1 - r^n) потеряет точность из‑за вычитания близких величин или переполнения.
r отрицательно и |r| близко к 1: чередование знака приводит к сильной отмене при суммировании в плавающей арифметике.

В таких случаях используйте специализированные численные приёмы (например, Kahan summation) или работайте в более точных типах.

`Мини‑методика для практического выбора метода`

Если n небольшой (< 10^6) и простота важна — используйте итеративный метод.
Если n большой и r далеко от 1 — формула быстрее, но проверяйте переполнение.
Если r == 1 — верный ответ a * n.
Если требуется высокая точность для плавающих типов — используйте увеличенную точность (double/long double) и алгоритмы аккумулированной суммы.

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

Базовый тест: a = 1, r = 2, n = 8 -> 255.
r = 1: любое a, n -> a * n.
r = 0: сумма равна a (только первый член ненулевой).
Отрицательное r: a = 1, r = -2, n = 4 -> 1 - 2 + 4 - 8 = -5.
Большие n, |r| < 1: сходится к a / (1 - r) по мере роста n.
Проверка на переполнение: подобрать параметры, при которых pow(r, n) выходит за границы типа, и убедиться, что код корректно обрабатывает ошибку или предупреждает.

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

Обработаны граничные случаи: r == 1, r == 0, n == 0.
Используется подходящий тип (int/long/double) для входных данных.
Добавлены тесты для отрицательных r и больших n.
Документирована ожидаемая сложность (итерация O(n), формула O(1)).
При необходимости добавлены проверки на переполнение и потери точности.

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

Итеративный метод прост и стабилен для небольших n.
Формула даёт O(1)-решение, но требует осторожности при r ≈ 1 и при опасности переполнения/потери точности.
Всегда проверяйте граничные случаи (r == 1, r == 0, отрицательный r) и добавляйте тесты.

Если хотите, могу добавить версии с использованием целочисленного быстрого возведения в степень, реализации с аккумулированной суммой (Kahan) или готовые unit-тесты для выбранного языка.

Сумма геометрической прогрессии — примеры на Python, C++, JavaScript и C