Encuentra la suma de n términos de la serie 1 , 2a , 3a2 , 4a3 , 5a4 , …

Dada una serie. $1, 2a, 3a^{2}, 4a^{3}, 5a^{4},.....$ y el valor de a. Encuentre la suma del primer término n de la serie.

Ejemplos:

Entrada : a = 3, n = 4
Salida : 142

Entrada : a = 5, n = 1
Salida : 1

Enfoque de fuerza bruta :

Un enfoque simple puede ser iterar N términos de la serie y sumarlos para calcular la suma de cualquier valor de a. Siga los pasos a continuación para comprender el enfoque:

Para cada iteración:

Calcular un ⁿ [ n = 0 ].
Multiplica una ⁿ por (n+1).
Suma (n+1)*a ⁿ para sumar e incrementar n en 1.
Repita los procesos anteriores n veces.

Ilustración:

a = 3 y n = 4

El bucle se ejecutará n número de veces, es decir, 4 en este caso.

Bucle 1: Inicialmente el valor de a = 1, n = 0, sum = 0

un ^norte = 3 ⁰
= 1

un ^norte * (n+1) = 3 ⁰ * (0+1)
= 1 * (1)
= 1

suma = suma + un ^norte * (n+1)
= 0 + 1
= 1

Incremente n en 1.

Bucle 2: El valor de a = 3, n = 1, suma = 1

un ^norte = 3 ¹
= 3

un ^norte * (n+1) = 3 ¹ * (1+1)
= 3 * (2)
= 6

suma = suma + un ^norte * (n+1)
= 1 + 6
= 7

Incrementa el valor de n en 1.

Bucle 3: El valor de a = 3, n = 2, suma = 7

un ^norte = 3 ²
= 9

un ^norte * (n+1) = 3 ² * (2+1)
= 9 * (3)
= 27

suma = suma + un ^norte * (n+1)
= 7 + 27
= 34

Incremente n en 1.

Ciclo 4: El valor de a = 3, n = 3, suma = 34

un ^norte = 3 ³
= 27

un ^norte * (n+1) = 3 ³ * (3+1)
= 27 * (4)
= 108

suma = suma + un ^norte * (n+1)
= 34 + 108
= 142

Incrementa el valor de n en 1.

A continuación se muestra la implementación del enfoque anterior:

C++

// C++ implementation for the
// approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate
// the sum
void calcSum(int a, int n)
{
  // Edge Cases
  if (n < 0)
  {
    cout << "Invalid Input";
    return;
  }
 
  if (a == 0 || n == 1)
  {
    cout << 1;
    return;
  }
 
  // Initialize the variables
  int Sum = 0;
 
  // Calculate Sum upto N terms
  for(int i = 0; i < n; i++)
  {
    int r = pow(a, (i)) * (i + 1);
    Sum += r;
  }
 
  // Print Sum
  cout << Sum;
}
 
// Driver Code
int main()
{
  int a = 3;
  int n = 4;
   
  // Invoke calcSum function with
  // values of a and n
  calcSum(a, n);
  return 0;
}

Java

// Java implementation for the
// approach
import java.util.*;
 
class GFG{
 
// Function to calculate
// the sum
static void calcSum(int a, int n)
{
   
  // Edge Cases
  if (n < 0)
  {
    System.out.print("Invalid Input");
    return;
  }
 
  if (a == 0 || n == 1)
  {
    System.out.print(1);
    return;
  }
 
  // Initialize the variables
  int Sum = 0;
 
  // Calculate Sum upto N terms
  for(int i = 0; i < n; i++)
  {
    int r = (int) (Math.pow(a, (i)) * (i + 1));
    Sum += r;
  }
 
  // Print Sum
  System.out.print(Sum);
}
 
// Driver Code
public static void main(String[] args)
{
  int a = 3;
  int n = 4;
   
  // Invoke calcSum function with
  // values of a and n
  calcSum(a, n);
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python 3 implementation for the
# approach
 
# Function to calculate
# the sum
def calcSum(a, n):
 
    # Edge Cases
    if (n < 0):
        print("Invalid Input")
        return
 
    if (a == 0 or n == 1):
 
        print(1)
        return
 
    # Initialize the variables
    Sum = 0
 
    # Calculate Sum upto N terms
    for i in range(n):
        r = pow(a, (i)) * (i + 1)
        Sum += r
 
    # Print Sum
    print(Sum)
 
# Driver Code
if __name__ == "__main__":
 
    a = 3
    n = 4
 
    # Invoke calcSum function with
    # values of a and n
    calcSum(a, n)
 
    # This code is contributed by ukasp.

C#

// C# program to find GCD of two
// numbers
using System;
using System.Collections;
 
class GFG {
 
// Function to calculate
// the sum
static void calcSum(int a, int n)
{
  // Edge Cases
  if (n < 0)
  {
    Console.Write("Invalid Input");
    return;
  }
 
  if (a == 0 || n == 1)
  {
    Console.Write(1);
    return;
  }
 
  // Initialize the variables
  int Sum = 0;
 
  // Calculate Sum upto N terms
  for(int i = 0; i < n; i++)
  {
    int r = (int)Math.Pow(a, (i)) * (i + 1);
    Sum += r;
  }
 
  // Print Sum
  Console.Write(Sum);
}
 
// Driver method
public static void Main()
{
    int a = 3;
    int n = 4;
   
    // Invoke calcSum function with
    // values of a and n
    calcSum(a, n);
}
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

<script>
 
// JavaScript implementation for the 
// approach
 
// Function to calculate
// the sum
function calcSum(a, n)
{
     
    // Edge Cases
    if (n < 0)
    {
        document.write("Invalid Input");
        return;
    }
 
    if (a == 0 || n == 1)
    {
        document.write(1);
        return;
    }
 
    // Initialize the variables
    let Sum = 0;
 
    // Calculate Sum upto N terms
    for(let i = 0; i < n; i++)
    {
        let r = Math.pow(a, (i)) * (i + 1);
        Sum += r;
    }
 
    // Print Sum
    document.write(Sum);
}
 
// Driver Code
let a = 3;
let n = 4;
 
// Invoke calcSum function with
// values of a and n
calcSum(a, n);
 
// This code is contributed by Potta Lokesh
 
</script>

Producción:

142

Complejidad temporal: O(n)
Espacio auxiliar: O(1)

Enfoque eficiente

En este enfoque, se propone una solución eficiente utilizando el concepto de progresión geométrica. La suma de la serie de n términos en una Progresión Geométrica (PG) con primer término a y razón común r se da como:

$S_{n} = \frac{a(r^{n}-1)}{r - 1}$

Usemos este concepto para llegar a una solución al problema.

Dejar $S = 1 +2a + 3a^{2} + 4a^{3} +............+n^{ésimo} término$

Claramente, el término n es $na^{n-1}$

$S = 1 +2a + 3a^{2} + 4a^{3} +............+na^{n-1}............ .$ . (1)

Multiplicamos ambos lados por ‘a’, obtenemos,

$Sa = (1 +2a + 3a^{2} + 4a^{3} +............+na^{n-1})a$

$Sa = 0 + a +2a^{2} + 3a^{3} + 4a^{4} +............+ (n - 1)a^{n - 1} + na^{n}............$ (2)

Restando la ecuación (2) de (1), obtenemos

$S - Sa = (1 +2a + 3a^{2} + 4a^{3} +............+na^{n-1}) - (0 + a +2a^{2} + 3a^{3} + 4a^{4} +............+ na^{n})$

$S(1 - a) = 1 + a + a^{2} + a^{3} +..............+ a^{n - 1} - na^{n}$

Claramente esta es la Progresión Geométrica (GP) de n términos con el primer término 1 y la razón común a.

GP de n términos con primer término a y razón común r es:

$S_{n} = \frac{a(r^{n}-1)}{r - 1}$

Usando la fórmula anterior, tenemos

$S(1 - a) = \frac{1(a^{n} - 1)}{(a - 1)} - na^{n}$

Dividiendo ambos lados por (1 – a), obtenemos

$\frac{S(1 - a)}{(1 - a)} = \frac{1(a^{n} - 1)}{(a - 1)} * \frac{1}{(1 - a)} - na^{n} * \frac{1}{(1 - a)}$

$S = \frac{-1(1 - a^{n})}{(a - 1)} * \frac{-1}{(a - 1)} - \frac{na^{n}}{(1 - a)}$

$S = \frac{1(1 - a^{n})}{(a - 1)^{2}} - \frac{na^{n}}{(1 - a)}$

Por lo tanto, la suma de la serie $S = 1 +2a + 3a^{2} + 4a^{3} +............+n^{th} term$ es

$\frac{(1 - a^{n})}{(a - 1)^{2}} - \frac{na^{n}}{(1 - a)}$

Para a != 1 la fórmula para la suma de la serie es:

$S = \frac{(1 - a^{n})}{(a - 1)^{2}} - \frac{na^{n}}{(1 - a)}$

Para a = 1, la fórmula para la suma de la serie es:
La serie se reduce a la suma de los primeros n números naturales y la fórmula se convierte en:

$S = \frac{n(n + 1)}{2}$

Ilustración:

Para a = 3, n = 4

Dado que a != 1, utilice la fórmula

$S = \frac{(1 - a^{n})}{(a - 1)^{2}} - \frac{na^{n}}{(1 - a)}$

Sustituyendo los valores de a y n en la fórmula anterior, obtenemos

$S = \frac{(1 - 3^{4})}{(3 - 1)^{2}} - \frac{4 * 3^{4}}{(1-3)}$

$S = \frac{1 - 81}{2^{2}} - \frac{324}{-2}$

S = -20 – (-162)

S = 142

Entonces, la suma de la serie $S = 1 +2a + 3a^{2} + 4a^{3} +............+n^{th} term$ con valor de a = 3 y n = 4 es 142.

A continuación se muestra la implementación del enfoque anterior:

C++

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate
// the sum
void calcSum(int a, int n)
{
  // Edge Cases
  if (n < 0)
  {
    cout << "Invalid Input";
    return;
  }
 
  if (a == 0 || n == 1)
  {
    cout << 1;
    return;
  }
 
  // Sum of First N Natural Numbers
  // In case a = 1
  if (a == 1)
  {
    // Avoiding Overflow
    if (n % 2 == 0)
      cout << (n / 2) * (n + 1);
 
    else
      cout << ((n + 1) / 2) * n;
  }
 
  // Calculate Sum with the help
  // of formula
  int r = pow(a, n);
  int d = pow(a - 1, 2);
  int Sum = (1 - r * (1 + n - n * a)) / d;
 
  // Print Sum
  cout << Sum;
}
 
// Driver Code
int main()
{
  int a = 3;
  int n = 4;
   
  // Invoke calcSum function
  // with values of a and n
  calcSum(a, n);
  return 0;
}

Java

// Java program to implement
// the above approach
class GFG {
 
    // Function to calculate
    // the sum
    public static void calcSum(int a, int n)
    {
       
        // Edge Cases
        if (n < 0) {
            System.out.println("Invalid Input");
            return;
        }
 
        if (a == 0 || n == 1) {
            System.out.println(1);
            return;
        }
 
        // Sum of First N Natural Numbers
        // In case a = 1
        if (a == 1) {
            // Avoiding Overflow
            if (n % 2 == 0)
                System.out.println((n / 2) * (n + 1));
 
            else
                System.out.println(((n + 1) / 2) * n);
        }
 
        // Calculate Sum with the help
        // of formula
        int r = (int) Math.pow(a, n);
        int d = (int) Math.pow(a - 1, 2);
        int Sum = (1 - r * (1 + n - n * a)) / d;
 
        // Print Sum
        System.out.println(Sum);
    }
 
    // Driver Code
    public static void main(String args[]) {
        int a = 3;
        int n = 4;
 
        // Invoke calcSum function
        // with values of a and n
        calcSum(a, n);
    }
}
 
// This code is contributed by saurabh_jaiswal.

Python3

# Python program to implement
# the above approach
 
# Function to calculate
# the sum
def calcSum(a, n):
   
    # Edge Cases
    if (n < 0):
        print("Invalid Input");
        return;
 
    if (a == 0 or n == 1):
        print(1);
        return;
 
    # Sum of First N Natural Numbers
    # In case a = 1
    if (a == 1):
       
        # Avoiding Overflow
        if (n % 2 == 0):
            print((n // 2) * (n + 1));
 
        else:
            print(((n + 1) // 2) * n);
 
    # Calculate Sum with the help
    # of formula
    r =  pow(a, n);
    d = pow(a - 1, 2);
    Sum = (1 - r * (1 + n - n * a)) // d;
 
    # Print Sum
    print(Sum);
 
# Driver Code
if __name__ == '__main__':
    a = 3;
    n = 4;
 
    # Invoke calcSum function
    # with values of a and n
    calcSum(a, n);
 
# This code is contributed by 29AjayKumar

C#

// C# program to implement
// the above approach
 
using System;
class GFG {
 
    // Function to calculate
    // the sum
    public static void calcSum(int a, int n)
    {
       
        // Edge Cases
        if (n < 0) {
            Console.WriteLine("Invalid Input");
            return;
        }
 
        if (a == 0 || n == 1) {
            Console.WriteLine(1);
            return;
        }
 
        // Sum of First N Natural Numbers
        // In case a = 1
        if (a == 1) {
            // Avoiding Overflow
            if (n % 2 == 0)
                Console.WriteLine((n / 2) * (n + 1));
 
            else
                Console.WriteLine(((n + 1) / 2) * n);
        }
 
        // Calculate Sum with the help
        // of formula
        int r = (int) Math.Pow(a, n);
        int d = (int) Math.Pow(a - 1, 2);
        int Sum = (1 - r * (1 + n - n * a)) / d;
 
        // Print Sum
        Console.WriteLine(Sum);
    }
 
    // Driver Code
    public static void Main() {
        int a = 3;
        int n = 4;
 
        // Invoke calcSum function
        // with values of a and n
        calcSum(a, n);
    }
}
 
// This code is contributed by gfgking.

Javascript

<script>
// Javascript program to implement
// the above approach
 
// Function to calculate
// the sum
function calcSum(a, n)
{
  // Edge Cases
  if (n < 0)
  {
    document.write("Invalid Input");
    return;
  }
 
  if (a == 0 || n == 1)
  {
    document.write(1);
    return;
  }
 
  // Sum of First N Natural Numbers
  // In case a = 1
  if (a == 1)
  {
    // Avoiding Overflow
    if (n % 2 == 0)
      document.write((n / 2) * (n + 1));
 
    else
      document.write(((n + 1) / 2) * n);
  }
 
  // Calculate Sum with the help
  // of formula
  let r = Math.pow(a, n);
  let d = Math.pow(a - 1, 2);
  let Sum = (1 - r * (1 + n - n * a)) / d;
 
  // Print Sum
  document.write(Sum);
}
 
// Driver Code
let a = 3;
let n = 4;
   
// Invoke calcSum function
// with values of a and n
calcSum(a, n);
 
// This code is contributed by Samim Hossain Mondal.
</script>

Producción:

142

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)

Publicación traducida automáticamente

Artículo escrito por akashjha2671 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Deja una respuesta Cancelar la respuesta