# Count numbers from range whose prime factors are only 2 and 3 using Arrays | Set 2

Given two positive integers L and R, the task is to count the elements from the range [L, R] whose prime factors are only 2 and 3.

Examples:

Input: L = 1, R = 10
Output: 6
Explanation:
2 = 2
3 = 3
4 = 2 * 2
6 = 2 * 3
8 = 2 * 2 * 2
9 = 3 * 3

Input: L = 100, R = 200
Output: 5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

For a simpler approach, refer to Count numbers from range whose prime factors are only 2 and 3.

Approach:
To solve the problem in an optimized way, follow the steps given below:

• Store all the powers of 2 which are less than or equal to R in an array power2[ ].
• Similarly, store all the powers of 3 which are less than or equal to R in another array power3[].
• Initialise third array power23[] and store the pairwise product of each element of power2[] with each element of power3[] which are less than or equal to R.
• Now for any range [L, R], we will simply iterate over array power23[] and count the numbers in the range [L, R].

Below is the implementation of above approach:

## C++

 `// C++ program to count the elements ` `// in the range [L, R] whose prime ` `// factors are only 2 and 3. ` ` `  `#include ` `using` `namespace` `std; ` `#define ll long long int ` ` `  `// Function which will calculate the ` `// elements in the given range ` `void` `calc_ans(ll l, ll r) ` `{ ` ` `  `    ``vector power2, power3; ` ` `  `    ``// Store the current power of 2 ` `    ``ll mul2 = 1; ` `    ``while` `(mul2 <= r) { ` `        ``power2.push_back(mul2); ` `        ``mul2 *= 2; ` `    ``} ` ` `  `    ``// Store the current power of 3 ` `    ``ll mul3 = 1; ` `    ``while` `(mul3 <= r) { ` `        ``power3.push_back(mul3); ` `        ``mul3 *= 3; ` `    ``} ` ` `  `    ``// power23[] will store pairwise product of ` `    ``// elements of power2 and power3 that are <=r ` `    ``vector power23; ` ` `  `    ``for` `(``int` `x = 0; x < power2.size(); x++) { ` `        ``for` `(``int` `y = 0; y < power3.size(); y++) { ` ` `  `            ``ll mul = power2[x] * power3[y]; ` `            ``if` `(mul == 1) ` `                ``continue``; ` ` `  `            ``// Insert in power23][] ` `            ``// only if mul<=r ` `            ``if` `(mul <= r) ` `                ``power23.push_back(mul); ` `        ``} ` `    ``} ` ` `  `    ``// Store the required answer ` `    ``ll ans = 0; ` `    ``for` `(ll x : power23) { ` `        ``if` `(x >= l && x <= r) ` `            ``ans++; ` `    ``} ` ` `  `    ``// Print the result ` `    ``cout << ans << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``ll l = 1, r = 10; ` ` `  `    ``calc_ans(l, r); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to count the elements ` `// in the range [L, R] whose prime ` `// factors are only 2 and 3. ` `import` `java.util.*; ` `class` `GFG{ ` ` `  `// Function which will calculate the ` `// elements in the given range ` `static` `void` `calc_ans(``int` `l, ``int` `r) ` `{ ` ` `  `    ``Vector power2 = ``new` `Vector(), ` `                    ``power3 = ``new` `Vector(); ` ` `  `    ``// Store the current power of 2 ` `    ``int` `mul2 = ``1``; ` `    ``while` `(mul2 <= r) ` `    ``{ ` `        ``power2.add(mul2); ` `        ``mul2 *= ``2``; ` `    ``} ` ` `  `    ``// Store the current power of 3 ` `    ``int` `mul3 = ``1``; ` `    ``while` `(mul3 <= r)  ` `    ``{ ` `        ``power3.add(mul3); ` `        ``mul3 *= ``3``; ` `    ``} ` ` `  `    ``// power23[] will store pairwise product of ` `    ``// elements of power2 and power3 that are <=r ` `    ``Vector power23 = ``new` `Vector(); ` ` `  `    ``for` `(``int` `x = ``0``; x < power2.size(); x++) ` `    ``{ ` `        ``for` `(``int` `y = ``0``; y < power3.size(); y++)  ` `        ``{ ` `            ``int` `mul = power2.get(x) *  ` `                      ``power3.get(y); ` `            ``if` `(mul == ``1``) ` `                ``continue``; ` ` `  `            ``// Insert in power23][] ` `            ``// only if mul<=r ` `            ``if` `(mul <= r) ` `                ``power23.add(mul); ` `        ``} ` `    ``} ` ` `  `    ``// Store the required answer ` `    ``int` `ans = ``0``; ` `    ``for` `(``int` `x : power23)  ` `    ``{ ` `        ``if` `(x >= l && x <= r) ` `            ``ans++; ` `    ``} ` ` `  `    ``// Print the result ` `    ``System.out.print(ans + ``"\n"``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `l = ``1``, r = ``10``; ` ` `  `    ``calc_ans(l, r); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 program to count the elements  ` `# in the range [L, R] whose prime  ` `# factors are only 2 and 3.  ` ` `  `# Function which will calculate the  ` `# elements in the given range  ` `def` `calc_ans(l, r): ` ` `  `    ``power2 ``=` `[]; power3 ``=` `[];  ` ` `  `    ``# Store the current power of 2  ` `    ``mul2 ``=` `1``;  ` `    ``while` `(mul2 <``=` `r):  ` `        ``power2.append(mul2);  ` `        ``mul2 ``*``=` `2``;  ` ` `  `    ``# Store the current power of 3  ` `    ``mul3 ``=` `1``;  ` `    ``while` `(mul3 <``=` `r):  ` `        ``power3.append(mul3);  ` `        ``mul3 ``*``=` `3``;  ` ` `  `    ``# power23[] will store pairwise  ` `    ``# product of elements of power2  ` `    ``# and power3 that are <=r  ` `    ``power23 ``=` `[];  ` ` `  `    ``for` `x ``in` `range``(``len``(power2)): ` `        ``for` `y ``in` `range``(``len``(power3)): ` ` `  `            ``mul ``=` `power2[x] ``*` `power3[y];  ` `            ``if` `(mul ``=``=` `1``): ` `                ``continue``;  ` ` `  `            ``# Insert in power23][]  ` `            ``# only if mul<=r  ` `            ``if` `(mul <``=` `r): ` `                ``power23.append(mul);  ` ` `  `    ``# Store the required answer  ` `    ``ans ``=` `0``;  ` `    ``for` `x ``in` `power23: ` `        ``if` `(x >``=` `l ``and` `x <``=` `r): ` `            ``ans ``+``=` `1``;  ` ` `  `    ``# Print the result  ` `    ``print``(ans);  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``l ``=` `1``; r ``=` `10``; ` `     `  `    ``calc_ans(l, r);  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# program to count the elements ` `// in the range [L, R] whose prime ` `// factors are only 2 and 3. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Function which will calculate the ` `// elements in the given range ` `static` `void` `calc_ans(``int` `l, ``int` `r) ` `{ ` ` `  `    ``List<``int``> power2 = ``new` `List<``int``>(), ` `              ``power3 = ``new` `List<``int``>(); ` ` `  `    ``// Store the current power of 2 ` `    ``int` `mul2 = 1; ` `    ``while` `(mul2 <= r) ` `    ``{ ` `        ``power2.Add(mul2); ` `        ``mul2 *= 2; ` `    ``} ` ` `  `    ``// Store the current power of 3 ` `    ``int` `mul3 = 1; ` `    ``while` `(mul3 <= r)  ` `    ``{ ` `        ``power3.Add(mul3); ` `        ``mul3 *= 3; ` `    ``} ` ` `  `    ``// power23[] will store pairwise product of ` `    ``// elements of power2 and power3 that are <=r ` `    ``List<``int``> power23 = ``new` `List<``int``>(); ` ` `  `    ``for` `(``int` `x = 0; x < power2.Count; x++) ` `    ``{ ` `        ``for` `(``int` `y = 0; y < power3.Count; y++)  ` `        ``{ ` `            ``int` `mul = power2[x] *  ` `                      ``power3[y]; ` `            ``if` `(mul == 1) ` `                ``continue``; ` ` `  `            ``// Insert in power23,] ` `            ``// only if mul<=r ` `            ``if` `(mul <= r) ` `                ``power23.Add(mul); ` `        ``} ` `    ``} ` ` `  `    ``// Store the required answer ` `    ``int` `ans = 0; ` `    ``foreach` `(``int` `x ``in` `power23)  ` `    ``{ ` `        ``if` `(x >= l && x <= r) ` `            ``ans++; ` `    ``} ` ` `  `    ``// Print the result ` `    ``Console.Write(ans + ``"\n"``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `l = 1, r = 10; ` ` `  `    ``calc_ans(l, r); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```6
```

Time Complexity: O(log2(R) * log3(R))

Note: The approach can be further optimized. After storing powers of 2 and 3, the answer can be calculated using two pointers instead of generating all the numbers My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : AnkitRai01, 29AjayKumar