Programa para imprimir GP (Progresión Geométrica)

Dado el primer término (a), la razón común (r) y un número entero n de la serie de Progresión Geométrica, la tarea es imprimir los n términos de la serie.
Ejemplos: 
 

Input : a = 2 r = 2, n = 4
Output : 2 4 8 16

Acercarse : 
 

Sabemos que la serie de progresión geométrica es como = 2, 4, 8, 16, 32 ……. 
En esta serie 2 es el término inicial de la serie. 
Razón común = 4 / 2 = 2 (razón común en la serie). 
entonces podemos escribir la serie como:
t1 = a1 
t2 = a1 * r ^(2-1) 
t3 = a1 * r ^(3-1) 
t4 = a1 * r ^(4-1) 
. 
. 
. 
. 
tN = a1 * r ^(n-1) 
 

Para imprimir la serie Progresión Geométrica usamos la fórmula simple. 
 

TN = a1 * r(n-1)

// CPP program to print GP.
#include <bits/stdc++.h>
using namespace std;
 
void printGP(int a, int r, int n)
{
    int curr_term;
    for (int i = 0; i < n; i++) {
        curr_term = a * pow(r, i);
        cout << curr_term << " ";
    }
}
 
// Driver code
int main()
{
    int a = 2; // starting number
    int r = 3; // Common ratio
    int n = 5; // N th term to be find
    printGP(a, r, n);
    return 0;
}

// Java program to print GP.
class GFG {
    static void printGP(int a, int r, int n)
    {
        int curr_term;
        for (int i = 0; i < n; i++) {
            curr_term = a * (int)Math.pow(r, i);
            System.out.print(curr_term + " ");
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a = 2; // starting number
        int r = 3; // Common ratio
        int n = 5; // N th term to be find
        printGP(a, r, n);
    }
}
// This code is contributed by Anant Agarwal.

# Python 3 program to print GP.
 
def printGP(a, r, n):
    for i in range(0, n):
        curr_term = a * pow(r, i)
        print(curr_term, end =" ")
     
 
# Driver code
 
a = 2 # starting number
r = 3 # Common ratio
n = 5 # N th term to be find
 
printGP(a, r, n)
 
# This code is contributed by
# Smitha Dinesh Semwal

// C# program to print GP.
using System;
 
class GFG {
 
    static void printGP(int a, int r, int n)
    {
 
        int curr_term;
 
        for (int i = 0; i < n; i++) {
            curr_term = a * (int)Math.Pow(r, i);
            Console.Write(curr_term + " ");
        }
    }
 
    // Driver code
    public static void Main()
    {
 
        int a = 2; // starting number
        int r = 3; // Common ratio
        int n = 5; // N th term to be find
 
        printGP(a, r, n);
    }
}
 
// This code is contributed by vt_m.

<?php
// PHP program to print GP.
 
// function to print GP
function printGP($a, $r, $n)
{
    for ($i = 0; $i < $n; $i++)
    {
        $curr_term = $a * pow($r, $i);
        echo $curr_term, " ";
    }
}
 
    // Driver Code
     
    // starting number
    $a = 2;
     
    // Common ratio
    $r = 3;
     
    // N th term to be find
    $n = 5;
    printGP($a, $r, $n);
 
// This code is contributed by ajit.
?>

<script>
 
// JavaScript program to print GP.
 
function printGP(a, r, n)
{
    let curr_term;
    for (let i = 0; i < n; i++) {
        curr_term = a * Math.pow(r, i);
        document.write(curr_term + " ");
    }
}
   
// Driver code
 
    let a = 2; // starting number
    let r = 3; // Common ratio
    let n = 5; // N th term to be find
    printGP(a, r, n);
  
   
// This code is contributed by Surbhi Tyagi
 
</script>

2 6 18 54 162

Complejidad de tiempo: O(nlog ₂ n), donde n representa el entero dado.
Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.