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

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

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