Encuentra el término N de la serie 5, 10, 20, 40…

Dado un entero positivo N , la tarea es encontrar el N-ésimo término de la serie

5, 10, 20, 40….hasta N términos

Ejemplos :

Entrada : N = 5
Salida: 80

Entrada: N = 3
Salida: 20

Acercarse: 

1er término = 5 * (2 ^ (1 – 1)) = 5

2do término = 5 * (2 ^ (2 – 1)) = 10

3er término = 5 * (2 ^ (3 – 1)) = 20

4to término = 5 * (2 ^ (4 – 1)) = 40

.

.

N-ésimo término = 5 * (2 ^ (N – 1))

El término N de la serie dada se puede generalizar como:

T _N = (un * (r ^ (N – 1))

Se pueden seguir los siguientes pasos para derivar la fórmula:

La serie 5, 10, 20, 40….hasta N términos 

está en GP con 

primer término a = 5

razón común r = 2 porque cada término es el doble del anterior.

El enésimo término de un GP es

T _N = (un * (r ^ (N – 1))

Ilustración:

Entrada: N = 5
Salida: 80
Explicación:
T _N = (a * (r ^ (N – 1))
     = (5 * (2 ^ (5 – 1))
     = (5 * 16)
     = 80

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

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate nth term
int nTerm(int a, int r, int n)
{
    return a * pow(r, n - 1);
}
 
// Driver code
int main()
{
    // Value of N
    int N = 5;
 
    // First term of the series
    int a = 5;
 
    // Common ratio
    int r = 2;
 
    cout << nTerm(a, r, N);
    return 0;
}

// C program to implement
// the above approach
#include <math.h>
#include <stdio.h>
 
// Function to calculate nth term
int nTerm(int a, int r, int n)
{
    return a * pow(r, n - 1);
}
 
// Driver code
int main()
{
    // Value of N
    int N = 5;
 
    // First term
    int a = 5;
 
    // Common ratio
    int r = 2;
 
    printf("%d", nTerm(a, r, n));
    return 0;
}

// Java program to implement
// the above approach
import java.io.*;
 
class GFG {
    // Driver code
    public static void main(String[] args)
    {
        // Value of N
        int N = 5;
 
        // First term
        int a = 5;
 
        // Common ratio
        int r = 2;
        System.out.println(nTerm(a, r, N));
    }
 
    // Function to calculate nth term
    public static int nTerm(int a, int r, int n)
    {
        return a * ((int)Math.pow(r, n - 1));
    }
}

# python3 program to implement
# the above approach
 
# Function to calculate nth term
def nTerm(a, r, n):
 
    return a * pow(r, n - 1)
 
# Driver code
if __name__ == "__main__":
 
    # Value of N
    N = 5
 
    # First term of the series
    a = 5
 
    # Common ratio
    r = 2
 
    print(nTerm(a, r, N))
 
# This code is contributed by rakeshsahni

using System;
 
public class GFG
{
   
    // Function to calculate nth term
    public static int nTerm(int a, int r, int n)
    {
        return a * ((int)Math.Pow(r, n - 1));
    }
    static public void Main()
    {
 
        // Code
        // Value of N
        int N = 5;
 
        // First term
        int a = 5;
 
        // Common ratio
        int r = 2;
        Console.Write(nTerm(a, r, N));
    }
}
 
// This code is contributed by Potta Lokesh

<script>
      // JavaScript code for the above approach
 
      // Function to calculate nth term
      function nTerm(a, r, n) {
          return a * Math.pow(r, n - 1);
      }
 
      // Driver code
 
      // Value of N
      let N = 5;
 
      // First term of the series
      let a = 5;
 
      // Common ratio
      let r = 2;
 
      document.write(nTerm(a, r, N));
 
 
     // This code is contributed by Potta Lokesh
  </script>

80

Complejidad del tiempo: O(1) 

Espacio Auxiliar: O(1)