Given a range represented by two positive integers **L** and **R**. The task is to count the numbers from the range having GCD of powers of prime factors equal to 1. In other words, if a number **X** has its prime factorization of the form **2 ^{p1} * 3^{p2} * 5^{p3} * …** then the GCD of

**p**should be equal to

_{1}, p_{2}, p_{3}, …**1**.

**Examples:**

Input:L = 2, R = 5

Output:3

2, 3, and 5 are the required numbers having GCD of powers of prime factors equal to 1.

2 = 2^{1}

3 = 3^{1}

5 = 5^{1}

Input:L = 13, R = 20

Output:7

**Prerequisites:** Perfect Powers in a Range

**Naive Approach:** Iterate over all numbers from **L** to **R** and prime factorise each number then calculate the GCD of powers of the prime factors. If the **GCD = 1**, increment a **count** variable and finally return it as the answer.

**Efficient Approach:** The key idea here is to notice that the valid numbers are not perfect powers since the powers of prime factors number are in such a way that their GCD is always greater than 1. In other words, all perfect powers are not valid numbers.

**For e.g.**

2500 is perfect power whose prime factorization is 2500 = 2

^{2}* 5^{4}. Now the GCD of (2, 4) = 2 which is greater than 1.

If some number has x^{th}power of a factor in its prime factorization, then the powers of other prime factors will have to be multiples of x in order for the number to be invalid.

Hence, we can find the total number of perfect powers lying in the range and subtract it from the total numbers.

Below is the implementation of the above approach:

## CPP

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` ` ` `using` `namespace` `std; ` ` ` `#define N 1000005 ` `#define MAX 1e18 ` ` ` `// Vector to store powers greater than 3 ` `vector<` `long` `int` `> powers; ` ` ` `// Set to store perfect squares ` `set<` `long` `int` `> squares; ` ` ` `// Set to store powers other than perfect squares ` `set<` `long` `int` `> s; ` ` ` `void` `powersPrecomputation() ` `{ ` ` ` `for` `(` `long` `int` `i = 2; i < N; i++) { ` ` ` ` ` `// Pushing squares ` ` ` `squares.insert(i * i); ` ` ` ` ` `// if the values is already a perfect square means ` ` ` `// present in the set ` ` ` `if` `(squares.find(i) != squares.end()) ` ` ` `continue` `; ` ` ` ` ` `long` `int` `temp = i; ` ` ` ` ` `// Run loop until some power of current number ` ` ` `// doesn't exceed MAX ` ` ` `while` `(i * i <= MAX / temp) { ` ` ` `temp *= (i * i); ` ` ` ` ` `// Pushing only odd powers as even power of a number ` ` ` `// can always be expressed as a perfect square ` ` ` `// which is already present in set squares ` ` ` `s.insert(temp); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Inserting those sorted ` ` ` `// values of set into a vector ` ` ` `for` `(` `auto` `x : s) ` ` ` `powers.push_back(x); ` `} ` ` ` `long` `int` `calculateAnswer(` `long` `int` `L, ` `long` `int` `R) ` `{ ` ` ` ` ` `// Precompute the powers ` ` ` `powersPrecomputation(); ` ` ` ` ` `// Calculate perfect squares in ` ` ` `// range using sqrtl function ` ` ` `long` `int` `perfectSquares = ` `floor` `(sqrtl(R)) - ` `floor` `(sqrtl(L - 1)); ` ` ` ` ` `// Calculate upper value of R ` ` ` `// in vector using binary search ` ` ` `long` `int` `high = upper_bound(powers.begin(), ` ` ` `powers.end(), R) ` ` ` `- powers.begin(); ` ` ` ` ` `// Calculate lower value of L ` ` ` `// in vector using binary search ` ` ` `long` `int` `low = lower_bound(powers.begin(), ` ` ` `powers.end(), L) ` ` ` `- powers.begin(); ` ` ` ` ` `// Calculate perfect powers ` ` ` `long` `perfectPowers = perfectSquares + (high - low); ` ` ` ` ` `// Compute final answer ` ` ` `long` `ans = (R - L + 1) - perfectPowers; ` ` ` `return` `ans; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `long` `int` `L = 13, R = 20; ` ` ` `cout << calculateAnswer(L, R); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of above idea ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `static` `int` `N = ` `1000005` `; ` ` ` `static` `long` `MAX = (` `long` `) 1e18; ` ` ` ` ` `// Vector to store powers greater than 3 ` ` ` `static` `Vector<Long> powers = ` `new` `Vector<>(); ` ` ` ` ` `// Set to store perfect squares ` ` ` `static` `TreeSet<Long> squares = ` `new` `TreeSet<>(); ` ` ` ` ` `// Set to store powers other than perfect squares ` ` ` `static` `TreeSet<Long> s = ` `new` `TreeSet<>(); ` ` ` ` ` `static` `void` `powersPrecomputation() ` ` ` `{ ` ` ` `for` `(` `long` `i = ` `2` `; i < N; i++) ` ` ` `{ ` ` ` ` ` `// Pushing squares ` ` ` `squares.add(i * i); ` ` ` ` ` `// if the values is already a perfect square means ` ` ` `// present in the set ` ` ` `if` `(squares.contains(i)) ` ` ` `continue` `; ` ` ` ` ` `long` `temp = i; ` ` ` ` ` `// Run loop until some power of current number ` ` ` `// doesn't exceed MAX ` ` ` `while` `(i * i <= MAX / temp) ` ` ` `{ ` ` ` `temp *= (i * i); ` ` ` ` ` `// Pushing only odd powers as even power of a number ` ` ` `// can always be expressed as a perfect square ` ` ` `// which is already present in set squares ` ` ` `s.add(temp); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Inserting those sorted ` ` ` `// values of set into a vector ` ` ` `for` `(` `long` `x : s) ` ` ` `powers.add(x); ` ` ` `} ` ` ` ` ` `static` `long` `calculateAnswer(` `long` `L, ` `long` `R) ` ` ` `{ ` ` ` ` ` `// Precompute the powers ` ` ` `powersPrecomputation(); ` ` ` ` ` `// Calculate perfect squares in ` ` ` `// range using sqrtl function ` ` ` `long` `perfectSquares = (` `long` `) (Math.floor(Math.sqrt(R)) - ` ` ` `Math.floor(Math.sqrt(L - ` `1` `))); ` ` ` ` ` `// Calculate upper value of R ` ` ` `// in vector using binary search ` ` ` `long` `high = Collections.binarySearch(powers, R); ` ` ` ` ` `// Calculate lower value of L ` ` ` `// in vector using binary search ` ` ` `long` `low = Collections.binarySearch(powers, L); ` ` ` ` ` `// Calculate perfect powers ` ` ` `long` `perfectPowers = perfectSquares + (high - low); ` ` ` ` ` `// Compute final answer ` ` ` `long` `ans = (R - L + ` `1` `) - perfectPowers; ` ` ` `return` `ans; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `long` `L = ` `13` `, R = ` `20` `; ` ` ` `System.out.println(calculateAnswer(L, R)); ` ` ` `} ` `} ` ` ` `// This code is contributed by ` `// sanjeev2552 ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` `from` `bisect ` `import` `bisect as upper_bound ` `from` `bisect ` `import` `bisect_left as lower_bound ` `from` `math ` `import` `floor ` `N ` `=` `1000005` `MAX` `=` `10` `*` `*` `18` ` ` `# Vector to store powers greater than 3 ` `powers ` `=` `[] ` ` ` `# Set to store perfect squares ` `squares ` `=` `dict` `() ` ` ` `# Set to store powers other than perfect squares ` `s ` `=` `dict` `() ` ` ` `def` `powersPrecomputation(): ` ` ` ` ` `for` `i ` `in` `range` `(` `2` `, N): ` ` ` ` ` `# Pushing squares ` ` ` `squares[i ` `*` `i] ` `=` `1` ` ` ` ` `# if the values is already a perfect square means ` ` ` `# present in the set ` ` ` `if` `(i ` `not` `in` `squares.keys()): ` ` ` `continue` ` ` ` ` `temp ` `=` `i ` ` ` ` ` `# Run loop until some power of current number ` ` ` `# doesn't exceed MAX ` ` ` `while` `(i ` `*` `i <` `=` `(` `MAX` `/` `/` `temp)): ` ` ` `temp ` `*` `=` `(i ` `*` `i) ` ` ` ` ` `# Pushing only odd powers as even power of a number ` ` ` `# can always be expressed as a perfect square ` ` ` `# which is already present in set squares ` ` ` `s[temp]` `=` `1` ` ` ` ` `# Inserting those sorted ` ` ` `# values of set into a vector ` ` ` `for` `x ` `in` `s: ` ` ` `powers.append(x) ` ` ` `def` `calculateAnswer(L, R): ` ` ` ` ` `# Precompute the powers ` ` ` `powersPrecomputation() ` ` ` ` ` `# Calculate perfect squares in ` ` ` `# range using sqrtl function ` ` ` `perfectSquares ` `=` `floor((R)` `*` `*` `(.` `5` `)) ` `-` `floor((L ` `-` `1` `)` `*` `*` `(.` `5` `)) ` ` ` ` ` `# Calculate upper value of R ` ` ` `# in vector using binary search ` ` ` `high ` `=` `upper_bound(powers,R) ` ` ` ` ` `# Calculate lower value of L ` ` ` `# in vector using binary search ` ` ` `low ` `=` `lower_bound(powers,L) ` ` ` ` ` `# Calculate perfect powers ` ` ` `perfectPowers ` `=` `perfectSquares ` `+` `(high ` `-` `low) ` ` ` ` ` `# Compute final answer ` ` ` `ans ` `=` `(R ` `-` `L ` `+` `1` `) ` `-` `perfectPowers ` ` ` ` ` `return` `ans ` ` ` ` ` `# Driver Code ` ` ` `L ` `=` `13` `R ` `=` `20` `print` `(calculateAnswer(L, R)) ` ` ` `# This code is contributed by mohit kumar 29 ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of above idea ` `using` `System; ` `using` `System.Collections.Generic; ` ` ` `public` `class` `GFG ` `{ ` ` ` ` ` `static` `int` `N = 100005; ` ` ` `static` `long` `MAX = (` `long` `) 1e18; ` ` ` ` ` `// List to store powers greater than 3 ` ` ` `static` `List<` `long` `> powers = ` `new` `List<` `long` `>(); ` ` ` ` ` `// Set to store perfect squares ` ` ` `static` `HashSet<` `long` `> squares = ` `new` `HashSet<` `long` `>(); ` ` ` ` ` `// Set to store powers other than perfect squares ` ` ` `static` `HashSet<` `long` `> s = ` `new` `HashSet<` `long` `>(); ` ` ` ` ` `static` `void` `powersPrecomputation() ` ` ` `{ ` ` ` `for` `(` `long` `i = 2; i < N; i++) ` ` ` `{ ` ` ` ` ` `// Pushing squares ` ` ` `squares.Add(i * i); ` ` ` ` ` `// if the values is already a perfect square means ` ` ` `// present in the set ` ` ` `if` `(squares.Contains(i)) ` ` ` `continue` `; ` ` ` ` ` `long` `temp = i; ` ` ` ` ` `// Run loop until some power of current number ` ` ` `// doesn't exceed MAX ` ` ` `while` `(i * i <= MAX / temp) ` ` ` `{ ` ` ` `temp *= (i * i); ` ` ` ` ` `// Pushing only odd powers as even power of a number ` ` ` `// can always be expressed as a perfect square ` ` ` `// which is already present in set squares ` ` ` `s.Add(temp); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Inserting those sorted ` ` ` `// values of set into a vector ` ` ` `foreach` `(` `long` `x ` `in` `s) ` ` ` `powers.Add(x); ` ` ` `} ` ` ` ` ` `static` `long` `calculateAnswer(` `long` `L, ` `long` `R) ` ` ` `{ ` ` ` ` ` `// Precompute the powers ` ` ` `powersPrecomputation(); ` ` ` ` ` `// Calculate perfect squares in ` ` ` `// range using sqrtl function ` ` ` `long` `perfectSquares = (` `long` `) (Math.Floor(Math.Sqrt(R)) - ` ` ` `Math.Floor(Math.Sqrt(L - 1))); ` ` ` ` ` `// Calculate upper value of R ` ` ` `// in vector using binary search ` ` ` `long` `high = Array.BinarySearch(powers.ToArray(), R); ` ` ` ` ` `// Calculate lower value of L ` ` ` `// in vector using binary search ` ` ` `long` `low = Array.BinarySearch(powers.ToArray(), L); ` ` ` ` ` `// Calculate perfect powers ` ` ` `long` `perfectPowers = perfectSquares + (high - low); ` ` ` ` ` `// Compute readonly answer ` ` ` `long` `ans = (R - L + 1) - perfectPowers; ` ` ` `return` `ans; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main(String[] args) ` ` ` `{ ` ` ` `long` `L = 13, R = 20; ` ` ` `Console.WriteLine(calculateAnswer(L, R)); ` ` ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

**Output:**

7

## Recommended Posts:

- Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
- Check if a number exists having exactly N factors and K prime factors
- Pair of integers having least GCD among all given pairs having GCD exceeding K
- Print all prime factors and their powers
- Smallest subsequence having GCD equal to GCD of given array
- Count of quadruplets from range [L, R] having GCD equal to K
- Count numbers from range whose prime factors are only 2 and 3
- Count numbers from range whose prime factors are only 2 and 3 using Arrays | Set 2
- Maximum number of prime factors a number can have with exactly x factors
- Sum of largest divisible powers of p (a prime number) in a range
- Count of numbers whose sum of increasing powers of digits is equal to the number itself
- K-Primes (Numbers with k prime factors) in a range
- Find and Count total factors of co-prime A or B in a given range 1 to N
- Count of all possible pairs having sum of LCM and GCD equal to N
- Count all prime numbers in a given range whose sum of digits is also prime
- First element of every K sets having consecutive elements with exactly K prime factors less than N
- Count common prime factors of two numbers
- Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
- Find number of factors of N when location of its two factors whose product is N is given
- Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime

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.