Number of terms in Geometric Series with given conditions

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 condition |bi| <= l is satisfied (|x| means absolute value of x).


Calculate how many numbers will be there in our sequence, or print “inf” in case of 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 in different cases:
Case 1: If starting value of series is greater than the given limit, output is 0.
Case 2: If starting value of series or q is 0, there are three more cases:
Case 2.a: If 0 is not given as a bad integer, answer will become inf.
Case 2.b: If b1 != 0 but q is 0 and b1 is also not a bad integer, answer will become 1.
Case 2.c: If 0 is given as a bad integer and b1 = 0, answer will become 0.
Case 3: If q = 1 we will check if b1 is given as a bad integer or not. If it is then answer will be 0 else answer will be inf.
Case 4: If q = -1, check if b1 and -b1 is 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 for b1 till l and calculate the number of elements.

Below is the implementation of above approach:

// 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, 
         // simpy 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;
}

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 contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Practice Tags :

Recommended Posts:



0 Average Difficulty : 0/5.0
No votes yet.






User Actions