 GFG App
Open App Browser
Continue

# Count of distinct integers belonging to first N terms of at least one of given GPs

Given two Geometric Progressions (a1, r1) and (a2, r2) where (x, y) represents GP with initial term and common ratio y and an integer N, the task is to find the count of the distinct integers that belong to the first N terms of at least one of the given geometric progressions.

Examples:

Input: N = 5, a1 = 3, r1 = 2, a2 = 6, r2 = 2
Output: 6
Explanation: The first 5 terms of the given geometric progressions are {3, 6, 12, 24, 48} and {6, 12, 24, 48, 96} respectively. Hence, the total count of distinct integers in the GP is 6.

Input: N = 5, a1 = 3, r1 = 2, a2 = 2, r2 = 3
Output: 9
Explanation: The first 5 terms of the given geometric progressions are {3, 6, 12, 24, 48} and {2, 6, 18, 54, 162} respectively. Hence, the total count of distinct integers in the GP is 9.

Approach: The given problem can be solved by the observation that the total count of distinct integers can be calculated by generating the first N terms of both the Geometric Progressions and removing the duplicates terms. This can be achieved by the use of the set data structure. Firstly, generate all the N terms of the 1st GP and insert the terms into a set S. Similarly, insert the terms of the 2nd GP into the set S. The size of the set S is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the count of distinct` `// integers that belong to the first N` `// terms of at least one of them is GP` `int` `UniqueGeometricTerms(``int` `N, ``int` `a1,` `                         ``int` `r1, ``int` `a2,` `                         ``int` `r2)` `{` `    ``// Stores the integers that occur in` `    ``// GPs in a set data-structure` `    ``set<``int``> S;`   `    ``// Stores the current integer of` `    ``// the first GP` `    ``long` `long` `p1 = a1;`   `    ``// Iterate first N terms of first GP` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Insert the ith term of GP in S` `        ``S.insert(p1);` `        ``p1 = (``long` `long``)(p1 * r1);` `    ``}`   `    ``// Stores the current integer` `    ``// of the second GP` `    ``long` `long` `p2 = a2;`   `    ``// Iterate first N terms of second GP` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``S.insert(p2);` `        ``p2 = (``long` `long``)(p2 * r2);` `    ``}`   `    ``// Return Answer` `    ``return` `S.size();` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5;` `    ``int` `a1 = 3, r1 = 2, a2 = 2, r2 = 3;`   `    ``cout << UniqueGeometricTerms(` `        ``N, a1, r1, a2, r2);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG` `{`   `// Function to find the count of distinct` `// integers that belong to the first N` `// terms of at least one of them is GP` `static` `int` `UniqueGeometricTerms(``int` `N, ``int` `a1,` `                         ``int` `r1, ``int` `a2,` `                         ``int` `r2)` `{` `    ``// Stores the integers that occur in` `    ``// GPs in a set data-structure` `    ``HashSet S=``new` `HashSet();`   `    ``// Stores the current integer of` `    ``// the first GP` `    ``int` `p1 = a1;`   `    ``// Iterate first N terms of first GP` `    ``for` `(``int` `i = ``0``; i < N; i++) {`   `        ``// Insert the ith term of GP in S` `        ``S.add(p1);` `        ``p1 = (p1 * r1);` `    ``}`   `    ``// Stores the current integer` `    ``// of the second GP` `    ``int` `p2 = a2;`   `    ``// Iterate first N terms of second GP` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``S.add(p2);` `        ``p2 = (p2 * r2);` `    ``}`   `    ``// Return Answer` `    ``return` `S.size();` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``5``;` `    ``int` `a1 = ``3``, r1 = ``2``, a2 = ``2``, r2 = ``3``;`   `    ``System.out.print(UniqueGeometricTerms(` `        ``N, a1, r1, a2, r2));`   `}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python 3 program for the above approach`   `# Function to find the count of distinct` `# integers that belong to the first N` `# terms of at least one of them is GP` `def` `UniqueGeometricTerms(N, a1, r1, a2, r2):` `  `  `    ``# Stores the integers that occur in` `    ``# GPs in a set data-structure` `    ``S ``=` `set``()`   `    ``# Stores the current integer of` `    ``# the first GP` `    ``p1 ``=` `a1`   `    ``# Iterate first N terms of first GP` `    ``for` `i ``in` `range``(N):` `      `  `        ``# Insert the ith term of GP in S` `        ``S.add(p1)` `        ``p1 ``=` `(p1 ``*` `r1)`   `    ``# Stores the current integer` `    ``# of the second GP` `    ``p2 ``=` `a2`   `    ``# Iterate first N terms of second GP` `    ``for` `i ``in` `range``(N):` `        ``S.add(p2)` `        ``p2 ``=` `(p2 ``*` `r2)`   `    ``# Return Answer` `    ``return` `len``(S)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `5` `    ``a1 ``=` `3` `    ``r1 ``=` `2` `    ``a2 ``=` `2` `    ``r2 ``=` `3`   `    ``print``(UniqueGeometricTerms(N, a1, r1, a2, r2))`   `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `// Function to find the count of distinct` `// integers that belong to the first N` `// terms of at least one of them is GP` `static` `int` `UniqueGeometricTerms(``int` `N, ``int` `a1,` `                         ``int` `r1, ``int` `a2,` `                         ``int` `r2)` `{` `    ``// Stores the integers that occur in` `    ``// GPs in a set data-structure` `    ``HashSet<``int``> S=``new` `HashSet<``int``>();`   `    ``// Stores the current integer of` `    ``// the first GP` `    ``int` `p1 = a1;`   `    ``// Iterate first N terms of first GP` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Insert the ith term of GP in S` `        ``S.Add(p1);` `        ``p1 = (p1 * r1);` `    ``}`   `    ``// Stores the current integer` `    ``// of the second GP` `    ``int` `p2 = a2;`   `    ``// Iterate first N terms of second GP` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``S.Add(p2);` `        ``p2 = (p2 * r2);` `    ``}`   `    ``// Return Answer` `    ``return` `S.Count;` `}`   `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``int` `N = 5;` `    ``int` `a1 = 3, r1 = 2, a2 = 2, r2 = 3;`   `    ``Console.Write(UniqueGeometricTerms(` `        ``N, a1, r1, a2, r2));` `}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`9`

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up