# Number of terms in Geometric Series with given conditions

• Difficulty Level : Medium
• Last Updated : 18 May, 2022

A geometric progression is a sequence of integers b1, b2, b3, …, where for each i > 1, the respective term satisfies the condition bi = bi-1 * q, where q is called the common ratio of the progression.
Given geometric progression b defined by two integers b1 and q, and m “bad” integers a1, a2, .., am, and an integer l, write all progression terms one by one (including repetitive) while the condition |bi| <= l is satisfied (|x| means the absolute value of x).
Calculate how many numbers there will be in our sequence, or print “inf” if there are infinitely many integers.
Note: If a term equals one of the “bad” integers, skip it and move forward to the next term.

Examples:

```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. ```

Approach:
We can divide our solution into different cases:
Case 1: If the starting value of a series is greater than the given limit, output is 0.
Case 2: If the starting value of a series q is 0, there are three more cases:
Case 2.a: If 0 is not given as a bad integer, the answer will become inf.
Case 2.b: If b1 != 0 but q is 0 and b1 is also not a bad integer, the answer will be 1.
Case 2.c: If 0 is given as a bad integer and b1 = 0, the answer will be 0.
Case 3: If q = 1, we will check if b1 is given as a bad integer or not. If it is, then the answer will be 0, else the answer will be inf.
Case 4: If q = -1, check if b1 and -b1 are present or not. If they are present, our answer will be 0, else our answer will be inf.
Case 5: If none of the above cases hold, simply run a loop from b1 to l and calculate the number of elements.

Below is the implementation of the above approach:

## C++

 `// CPP program to find number of terms  ` `// in Geometric Series` `#include ` `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 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

 ``

Output:

`3`

This article is contributed by Sarthak Kohli. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.