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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count the elements
// in the range [L, R] whose prime
// factors are only 2 and 3.
  
#include <bits/stdc++.h>
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<ll> 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<ll> 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer> power2 = new Vector<Integer>(),
                    power3 = new Vector<Integer>();
  
    // 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<Integer> power23 = new Vector<Integer>();
  
    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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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

competitive-programming-img




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