Una progresión geométrica es una sucesión de números enteros b1, b2, b3,…, donde para cada i > 1, el término respectivo satisface la condición b i = b i-1 * q, donde q se denomina razón común de la progresión.
Dada la progresión geométrica b definida por dos enteros b1 y q, y m enteros “malos” a1, a2, .., am, y un entero l, escribir todos los términos de progresión uno por uno (incluidos los repetitivos) mientras la condición |b i | <= l se cumple (|x| significa el valor absoluto de x).
Calcula cuántos números habrá en nuestra secuencia, o escribe «inf» si hay infinitos números enteros.
Nota: Si un término es igual a uno de los enteros «malos», sáltelo y avance al siguiente término.
Ejemplos:
Input : b1 = 3, q = 2, l = 30,
m = 4
6 14 25 48
Output : 3
The progression will be 3 12 24.
6 will also be there but because
it is a bad integer we won't include it
Input : b1 = 123, q = 1, l = 2143435
m = 4
123 11 -5453 141245
Output : 0
As value of q is 1, progression will
always be 123 and would become infinity
but because it is a bad integer we
won't include it and hence our value
will become 0
Input : b1 = 123, q = 1, l = 2143435
m = 4
5234 11 -5453 141245
Output : inf
In this case, value will be infinity
because series will always be 123 as
q is 1 and 123 is not a bad integer.
Planteamiento:
Podemos dividir nuestra solución en diferentes casos:
Caso 1: Si el valor inicial de una serie es mayor que el límite dado, la salida es 0.
Caso 2: Si el valor inicial de una serie q es 0, hay tres más casos:
Caso 2.a: Si no se da 0 como un entero malo, la respuesta será inf.
Caso 2.b: Si b1 != 0 pero q es 0 y b1 tampoco es un entero malo, la respuesta será 1.
Caso 2.c: Si 0 se da como un entero malo y b1 = 0, la respuesta será sea 0.
Caso 3: Si q = 1, comprobaremos si b1 se da como un entero malo o no. Si es así, entonces la respuesta será 0, de lo contrario, la respuesta será inf.
Caso 4:Si q = -1, verifique si b1 y -b1 están presentes o no. Si están presentes, nuestra respuesta será 0, de lo contrario, nuestra respuesta será inf.
Caso 5: si ninguno de los casos anteriores se cumple, simplemente ejecute un ciclo de b1 a l y calcule la cantidad de elementos.
A continuación se muestra la implementación del enfoque anterior:
C++
// CPP program to find number of terms
// in Geometric Series
#include <bits/stdc++.h>
using namespace std;
// A map to keep track of the bad integers
map<int, bool> mapp;
// Function to calculate No. of elements
// in our series
void progression(int b1, int q, int l,
int m, int bad[])
{
// Updating value of our map
for (int i = 0; i < m; i++)
mapp[bad[i]] = 1;
// if starting value is greate
// r than our given limit
if (abs(b1) > l)
cout << "0";
// if q or starting value is 0
else if (q == 0 || b1 == 0)
{
// if 0 is not a bad integer,
// answer becomes inf
if (mapp[0] != 1)
cout << "inf";
// if q is 0 and b1 is not and b1
// is not a bad integer, answer becomes 1
else if (mapp[0] == 1 && mapp[b1] != 1)
cout << "1";
else // else if 0 is bad integer and
// b1 is also a bad integer,
// answer becomes 0
cout << "0";
}
else if (q == 1) // if q is 1
{
// and b1 is not a bad integer,
// answer becomes inf
if (mapp[b1] != 1)
cout << "inf";
else // else answer is 0
cout << "0";
}
else if (q == -1) // if q is -1
{
// and either b1 or -b1 is not
// present answer becomes inf
if (mapp[b1] != 1 || mapp[-1 * b1] != 1)
cout << "inf";
else // else answer becomes 0
cout << "0";
}
else // if none of the above case is true,
// simply calculate the number of
// elements in our series
{
int co = 0;
while (abs(b1) <= l) {
if (mapp[b1] != 1)
co++;
b1 *= 1LL * q;
}
cout << co;
}
}
// driver code
int main()
{
// starting value of series,
// number to be multiplied,
// limit within which our series,
// No. of bad integers given
int b1 = 3, q = 2, l = 30, m = 4;
// Bad integers
int bad[4] = { 6, 14, 25, 48 };
progression(b1, q, l, m, bad);
return 0;
}
Java
// Java program to find number of terms
// in Geometric Series
import java.util.*;
class GFG
{
// A map to keep track of the bad integers
static HashMap<Integer, Boolean> map = new HashMap<>();
// Function to calculate No. of elements
// in our series
static void progression(int b1, int q, int l,
int m, int[] bad)
{
// Updating value of our map
for (int i = 0; i < m; i++)
map.put(bad[i], true);
// if starting value is greate
// r than our given limit
if (Math.abs(b1) > l)
System.out.print("0");
// if q or starting value is 0
else if (q == 0 || b1 == 0)
{
// if 0 is not a bad integer,
// answer becomes inf
if (!map.containsKey(0))
System.out.print("inf");
// if q is 0 and b1 is not and b1
// is not a bad integer, answer becomes 1
else if (map.get(0) == true && !map.containsKey(b1))
System.out.print("1");
// else if 0 is bad integer and
// b1 is also a bad integer,
// answer becomes 0
else
System.out.print("0");
}
// if q is 1
else if (q == 1)
{
// and b1 is not a bad integer,
// answer becomes inf
if (!map.containsKey(b1))
System.out.print("inf");
// else answer is 0
else
System.out.print("0");
}
// if q is -1
else if (q == -1)
{
// and either b1 or -b1 is not
// present answer becomes inf
if (!map.containsKey(b1) || !map.containsKey(-1 * b1))
System.out.print("inf");
// else answer becomes 0
else
System.out.print("0");
}
// if none of the above case is true,
// simply calculate the number of
// elements in our series
else
{
int co = 0;
while (Math.abs(b1) <= l)
{
if (!map.containsKey(b1))
co++;
b1 *= q;
}
System.out.print(co);
}
}
// Driver Code
public static void main(String[] args)
{
// starting value of series,
// number to be multiplied,
// limit within which our series,
// No. of bad integers given
int b1 = 3, q = 2, l = 30, m = 4;
// Bad integers
int[] bad = { 6, 14, 25, 48 };
progression(b1, q, l, m, bad);
}
}
// This code is contributed by
// sanjeev2552
Python3
# Python3 program to find number of terms
# in Geometric Series
# A map to keep track of the bad integers
mpp=dict()
# Function to calculate No. of elements
# in our series
def progression(b1, q, l, m, bad):
# Updating value of our map
for i in range(m):
mpp[bad[i]] = 1
# if starting value is greate
# r than our given limit
if (abs(b1) > l):
print("0",end="")
# if q or starting value is 0
elif (q == 0 or b1 == 0) :
# if 0 is not a bad integer,
# answer becomes inf
if (0 not in mpp.keys()):
print("inf",end="")
# if q is 0 and b1 is not and b1
# is not a bad integer, answer becomes 1
elif (mpp[0] == 1 and b1 not in mpp.keys()) :
print("1",end="")
else:
# b1 is also a bad integer,
# answer becomes 0
print("0",end="")
elif (q == 1): # if q is 1
# and b1 is not a bad integer,
# answer becomes inf
if (b1 not in mpp.keys()) :
print("inf",end="")
else: # else answer is 0
print("0",end="")
elif (q == -1): # if q is -1
# and either b1 or -b1 is not
# present answer becomes inf
if (b1 not in mpp.keys() or -1 * b1 not in mpp.keys()) :
print("inf",end="")
else :# else answer becomes 0
print("0",end="")
else :# if none of the above case is true,
# simply calculate the number of
# elements in our series
co = 0
while (abs(b1) <= l):
if (b1 not in mpp.keys()):
co+=1
b1 *= q
print(co,end="")
# Driver code
# starting value of series,
# number to be multiplied,
# limit within which our series,
# No. of bad integers given
b1 = 3
q = 2
l = 30
m = 4
# Bad integers
bad=[6, 14, 25, 48]
progression(b1, q, l, m, bad)
# This code is contributed by mohit kumar 29
C#
// C# program to find number of terms
// in Geometric Series
using System;
using System.Collections.Generic;
class GFG
{
// A map to keep track of the bad integers
static Dictionary<int,
bool> map = new Dictionary<int,
bool>();
// Function to calculate No. of elements
// in our series
static void progression(int b1, int q, int l,
int m, int[] bad)
{
// Updating value of our map
for (int i = 0; i < m; i++)
if(!map.ContainsKey(bad[i]))
map.Add(bad[i], true);
// if starting value is greate
// r than our given limit
if (Math.Abs(b1) > l)
Console.Write("0");
// if q or starting value is 0
else if (q == 0 || b1 == 0)
{
// if 0 is not a bad integer,
// answer becomes inf
if (!map.ContainsKey(0))
Console.Write("inf");
// if q is 0 and b1 is not and b1
// is not a bad integer, answer becomes 1
else if (map[0] == true &&
!map.ContainsKey(b1))
Console.Write("1");
// else if 0 is bad integer and
// b1 is also a bad integer,
// answer becomes 0
else
Console.Write("0");
}
// if q is 1
else if (q == 1)
{
// and b1 is not a bad integer,
// answer becomes inf
if (!map.ContainsKey(b1))
Console.Write("inf");
// else answer is 0
else
Console.Write("0");
}
// if q is -1
else if (q == -1)
{
// and either b1 or -b1 is not
// present answer becomes inf
if (!map.ContainsKey(b1) ||
!map.ContainsKey(-1 * b1))
Console.Write("inf");
// else answer becomes 0
else
Console.Write("0");
}
// if none of the above case is true,
// simply calculate the number of
// elements in our series
else
{
int co = 0;
while (Math.Abs(b1) <= l)
{
if (!map.ContainsKey(b1))
co++;
b1 *= q;
}
Console.Write(co);
}
}
// Driver Code
public static void Main(String[] args)
{
// starting value of series,
// number to be multiplied,
// limit within which our series,
// No. of bad integers given
int b1 = 3, q = 2, l = 30, m = 4;
// Bad integers
int[] bad = { 6, 14, 25, 48 };
progression(b1, q, l, m, bad);
}
}
// This code is contributed by Rajput-Ji
Javascript
<script>
// Javascript program to find number of terms
// in Geometric Series
// A map to keep track of the bad integers
let map = new Map();
// Function to calculate No. of elements
// in our series
function progression(b1,q,l,m,bad)
{
// Updating value of our map
for (let i = 0; i < m; i++)
map.set(bad[i], true);
// if starting value is greate
// r than our given limit
if (Math.abs(b1) > l)
document.write("0");
// if q or starting value is 0
else if (q == 0 || b1 == 0)
{
// if 0 is not a bad integer,
// answer becomes inf
if (!map.has(0))
document.write("inf");
// if q is 0 and b1 is not and b1
// is not a bad integer, answer becomes 1
else if (map[0] == true && !map.has(b1))
document.write("1");
// else if 0 is bad integer and
// b1 is also a bad integer,
// answer becomes 0
else
document.write("0");
}
// if q is 1
else if (q == 1)
{
// and b1 is not a bad integer,
// answer becomes inf
if (!map.has(b1))
document.write("inf");
// else answer is 0
else
document.write("0");
}
// if q is -1
else if (q == -1)
{
// and either b1 or -b1 is not
// present answer becomes inf
if (!map.has(b1) || !map.has(-1 * b1))
document.write("inf");
// else answer becomes 0
else
document.write("0");
}
// if none of the above case is true,
// simply calculate the number of
// elements in our series
else
{
let co = 0;
while (Math.abs(b1) <= l)
{
if (!map.has(b1))
co++;
b1 *= q;
}
document.write(co);
}
}
// Driver Code
// starting value of series,
// number to be multiplied,
// limit within which our series,
// No. of bad integers given
let b1 = 3, q = 2, l = 30, m = 4;
// Bad integers
let bad = [ 6, 14, 25, 48 ];
progression(b1, q, l, m, bad);
// This code is contributed by patel2127
</script>
Producción:
3
Este artículo es una contribución de Sarthak Kohli . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA