GFG App
Open App
Browser
Continue

# 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:
Explanation:
2 = 2
3 = 3
4 = 2 * 2
6 = 2 * 3
8 = 2 * 2 * 2
9 = 3 * 3
Input: L = 100, R = 200
Output:

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`

## Javascript

 ``

Output:

`6`

Time Complexity: O(log2(R) * log3(R)), as we are traversing in nested loops where we increment in multiple of 2 and 3.

Auxiliary Space: O(log2(R) * log3(R)), as we are using extra space.
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