Skip to content
Related Articles

Related Articles

Count numbers from range whose prime factors are only 2 and 3 using Arrays | Set 2
  • Difficulty Level : Medium
  • Last Updated : 10 Jun, 2020

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
Recommended Articles
Page :