Count of natural numbers in range [L, R] which are relatively prime with N

Last Updated : 17 Jun, 2021

Given three integers N, L, and R. The task is to calculate the number of natural numbers in the range [L, R] (both inclusive) which are relatively prime with N.

Examples:

Input: N = 10, L = 1, R = 25
Output: 10
Explanation:
10 natural numbers (in the range 1 to 25) are relatively prime to 10.
They are 1, 3, 7, 9, 11, 13, 17, 19, 21, 23.
Input: N = 12, L = 7, R = 38
Output: 11
Explanation:
11 natural numbers (in the range 1 to 38) are relatively prime to 12.
They are 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37.

Approach:

At first, factorize the number N. Thus, find out all the prime factors of N.
Store prime factors of the number N in an array.
We can determine the total number of natural numbers which are not greater than R and are divisible by prime factors of N.
Suppose that the value is y. So, exactly y natural numbers not greater than R have at least a single common divisor with N.
So, these y numbers can not be relatively prime to N.
Thus, the number of natural number not greater than R which are relatively prime to N will be R – y .
Now, similarly we need to find out the number of relatively prime numbers of N which are not greater than L-1.
Then, subtract the result for L-1 from the answer for R.

Below is the implementation of the above approach:

C++

// C++ code to count of natural
// numbers in range [L, R] which
// are relatively prime with N
 
#include <bits/stdc++.h>
using namespace std;
#define maxN (long long)1000000000000
 
// container of all the primes
// up to sqrt(n)
vector<int> prime;
 
// Function to calculate prime
// factors of n
void sieve(long long n)
{
    // run the sieve of Eratosthenes
    bool check[1000007] = { 0 };
    long long i, j;
 
    // 0(false) means prime,
    // 1(true) means not prime
    check[0] = 1, check[1] = 1,
    check[2] = 0;
 
    // no even number is
    // prime except for 2
    for (i = 4; i <= n; i += 2)
        check[i] = true;
 
    for (i = 3; i * i <= n; i += 2)
        if (!check[i]) {
 
            // all the multiples of each
            // each prime numbers are
            // non-prime
            for (j = i * i; j <= n; j += 2 * i)
                check[j] = true;
        }
 
    prime.push_back(2);
 
    // get all the primes
    // in prime vector
    for (int i = 3; i <= n; i += 2)
        if (!check[i])
            prime.push_back(i);
 
    return;
}
 
// Count the number of numbers
// up to m which are divisible
// by given prime numbers
long long count(long long a[],
                int n, long long m)
{
    long long parity[3] = { 0 };
 
    // Run from i= 000..0 to i= 111..1
    // or check all possible
    // subsets of the array
    for (int i = 1; i < (1 << n); i++) {
        long long mult = 1;
        for (int j = 0; j < n; j++)
            if (i & (1 << j))
                mult *= a[j];
 
        // take the multiplication
        // of all the set bits
 
        // if the number of set bits
        // is odd, then add to the
        // number of multiples
        parity[__builtin_popcount(i) & 1]
            += (m / mult);
    }
 
    return parity[1] - parity[0];
}
 
// Function calculates all number
// not greater than 'm' which are
// relatively prime with n.
long long countRelPrime(
    long long n,
    long long m)
{
 
    long long a[20];
    int i = 0, j = 0;
    long long pz = prime.size();
    while (n != 1 && i < pz) {
 
        // if square of the prime number
        // is greater than 'n', it can't
        // be a factor of 'n'
        if ((long long)prime[i]
                * (long long)prime[i]
            > n)
            break;
 
        // if prime is a factor of
        // n then increment count
        if (n % prime[i] == 0)
            a[j] = (long long)prime[i], j++;
 
        while (n % prime[i] == 0)
            n /= prime[i];
        i++;
    }
 
    if (n != 1)
        a[j] = n, j++;
    return m - count(a, j, m);
}
 
void countRelPrimeInRange(
    long long n, long long l,
    long long r)
{
    sieve(sqrt(maxN));
    long long result
        = countRelPrime(n, r)
          - countRelPrime(n, l - 1);
    cout << result << "\n";
}
 
// Driver code
int main()
{
    long long N = 7, L = 3, R = 9;
    countRelPrimeInRange(N, L, R);
 
    return 0;
}

Java

// Java code to count of natural
// numbers in range [L, R] which
// are relatively prime with N
import java.util.*;
 
class GFG{
 
static int maxN = 100000000;
 
// Container of all the primes
// up to sqrt(n)
static Vector<Integer> prime = new Vector<Integer>();
 
// Function to calculate prime
// factors of n
static void sieve(int n)
{
     
    // Run the sieve of Eratosthenes
    boolean[] check = new boolean[1000007];
    for(int i = 0; i < 1000007; i++)
        check[i] = false;
 
    int i, j;
 
    // 0(false) means prime,
    // 1(true) means not prime
    check[0] = false;
    check[1] = true;
    check[2] = false;
 
    // No even number is
    // prime except for 2
    for(i = 4; i <= n; i += 2)
        check[i] = true;
 
    for(i = 3; i * i <= n; i += 2)
        if (!check[i])
        {
             
            // All the multiples of each
            // each prime numbers are
            // non-prime
            for(j = i * i; j <= n; j += 2 * i)
                check[j] = true;
        }
 
    prime.add(2);
 
    // Get all the primes
    // in prime vector
    for(i = 3; i <= n; i += 2)
        if (!check[i])
            prime.add(i);
 
    return;
}
 
static int countSetBits(int n)
{
    int count = 0;
    while (n > 0)
    {
        count += n & 1;
        n >>= 1;
    }
    return count;
}
 
// Count the number of numbers
// up to m which are divisible
// by given prime numbers
static int count(int a[],
                 int n, int m)
{
    int[] parity = new int[3];
    for(int i = 0; i < 3; i++)
        parity[i] = 0;
 
    // Run from i= 000..0 to i= 111..1
    // or check all possible
    // subsets of the array
    for(int i = 1; i < (1 << n); i++)
    {
        int mult = 1;
        for(int j = 0; j < n; j++)
            if ((i & (1 << j)) != 0)
                mult *= a[j];
 
        // Take the multiplication
        // of all the set bits
 
        // If the number of set bits
        // is odd, then add to the
        // number of multiples
        parity[countSetBits(i) & 1] += (m / mult);
    }
    return parity[1] - parity[0];
}
 
// Function calculates all number
// not greater than 'm' which are
// relatively prime with n.
static int countRelPrime(int n, int m)
{
    int[] a = new int[20];
    int i = 0, j = 0;
    int pz = prime.size();
     
    while(n != 1 && i < pz)
    {
         
        // If square of the prime number
        // is greater than 'n', it can't
        // be a factor of 'n'
        if ((int)prime.get(i) *
            (int)prime.get(i) > n)
            break;
 
        // If prime is a factor of
        // n then increment count
        if (n % prime.get(i) == 0)
        {
            a[j] = (int)prime.get(i);
            j++;
        }
 
        while (n % prime.get(i) == 0)
            n /= prime.get(i);
             
        i++;
    }
 
    if (n != 1)
    {
        a[j] = n;
        j++;
    }
    return m - count(a, j, m);
}
 
static void countRelPrimeInRange(int n, int l,
                                 int r)
{
    sieve((int)Math.sqrt(maxN));
     
    int result = countRelPrime(n, r) -
                 countRelPrime(n, l - 1);
                  
    System.out.println(result);
}
 
// Driver code
public static void main(String[] args)
{
    int N = 7, L = 3, R = 9;
     
    countRelPrimeInRange(N, L, R);
}
}
 
// This code is contributed by grand_master

Python3

# Python3 code to count of natural
# numbers in range [L, R] which
# are relatively prime with N
from math import sqrt, floor
 
maxN = 1000000000000
 
# Container of all the primes
# up to sqrt(n)
prime = []
 
# Function to calculate prime
# factors of n
def sieve(n):
     
    # Run the sieve of Eratosthenes
    check = [0] * (1000007)
    i, j = 0, 0
 
    # 0(false) means prime,
    # 1(True) means not prime
    check[0] = 1
    check[1] = 1
    check[2] = 0
 
    # No even number is
    # prime except for 2
    for i in range(4, n + 1, 2):
        check[i] = True
 
    for i in range(3, n + 1, 2):
        if i * i > n:
            break
        if (not check[i]):
 
            # All the multiples of each
            # each prime numbers are
            # non-prime
            for j in range(2 * i, n + 1, 2 * i):
                check[j] = True
 
    prime.append(2)
 
    # Get all the primes
    # in prime vector
    for i in range(3, n + 1, 2):
        if (not check[i]):
            prime.append(i)
 
    return
 
# Count the number of numbers
# up to m which are divisible
# by given prime numbers
def count(a, n, m):
     
    parity = [0] * 3
 
    # Run from i = 000..0 to i = 111..1
    # or check all possible
    # subsets of the array
    for i in range(1, 1 << n):
        mult = 1
        for j in range(n):
            if (i & (1 << j)):
                mult *= a[j]
 
        # Take the multiplication
        # of all the set bits
 
        # If the number of set bits
        # is odd, then add to the
        # number of multiples
        parity[bin(i).count('1') & 1] += (m // mult)
 
    return parity[1] - parity[0]
 
# Function calculates all number
# not greater than 'm' which are
# relatively prime with n.
def countRelPrime(n, m):
 
    a = [0] * 20
    i = 0
    j = 0
    pz = len(prime)
    while (n != 1 and i < pz):
 
        # If square of the prime number
        # is greater than 'n', it can't
        # be a factor of 'n'
        if (prime[i] * prime[i] > n):
            break
 
        # If prime is a factor of
        # n then increment count
        if (n % prime[i] == 0):
            a[j] = prime[i]
            j += 1
 
        while (n % prime[i] == 0):
            n //= prime[i]
        i += 1
 
    if (n != 1):
        a[j] = n
        j += 1
    return m - count(a, j, m)
 
def countRelPrimeInRange(n, l, r):
     
    sieve(floor(sqrt(maxN)))
    result = (countRelPrime(n, r) -
              countRelPrime(n, l - 1))
    print(result)
 
# Driver code
if __name__ == '__main__':
     
    N = 7
    L = 3
    R = 9
     
    countRelPrimeInRange(N, L, R)
 
# This code is contributed by mohit kumar 29

C#

// C# code to count of natural
// numbers in range [L, R] which
// are relatively prime with N
using System;
using System.Collections.Generic;
 
class GFG{
     
static int maxN = 100000000;
 
// Container of all the primes
// up to sqrt(n)
static List<int> prime = new List<int>();
  
// Function to calculate prime
// factors of n
static void sieve(int n)
{
     
    // Run the sieve of Eratosthenes
    bool[] check = new bool[1000007];
    for(int I = 0; I < 1000007; I++)
        check[I] = false;
  
    int i, j;
  
    // 0(false) means prime,
    // 1(true) means not prime
    check[0] = false;
    check[1] = true;
    check[2] = false;
  
    // No even number is
    // prime except for 2
    for(i = 4; i <= n; i += 2)
        check[i] = true;
  
    for(i = 3; i * i <= n; i += 2)
        if (!check[i])
        {
             
            // All the multiples of each
            // each prime numbers are
            // non-prime
            for(j = i * i; j <= n; j += 2 * i)
                check[j] = true;
        }
  
    prime.Add(2);
     
    // Get all the primes
    // in prime vector
    for(i = 3; i <= n; i += 2)
        if (!check[i])
            prime.Add(i);
  
    return;
}
  
static int countSetBits(int n)
{
    int count = 0;
     
    while (n > 0)
    {
        count += n & 1;
        n >>= 1;
    }
    return count;
}
  
// Count the number of numbers
// up to m which are divisible
// by given prime numbers
static int count(int[] a, int n, int m)
{
    int[] parity = new int[3];
    for(int i = 0; i < 3; i++)
        parity[i] = 0;
  
    // Run from i= 000..0 to i= 111..1
    // or check all possible
    // subsets of the array
    for(int i = 1; i < (1 << n); i++)
    {
        int mult = 1;
        for(int j = 0; j < n; j++)
            if ((i & (1 << j)) != 0)
                mult *= a[j];
  
        // Take the multiplication
        // of all the set bits
  
        // If the number of set bits
        // is odd, then add to the
        // number of multiples
        parity[countSetBits(i) & 1] += (m / mult);
    }
    return parity[1] - parity[0];
}
  
// Function calculates all number
// not greater than 'm' which are
// relatively prime with n.
static int countRelPrime(int n, int m)
{
    int[] a = new int[20];
    int i = 0, j = 0;
    int pz = prime.Count;
     
    while (n != 1 && i < pz)
    {
         
        // If square of the prime number
        // is greater than 'n', it can't
        // be a factor of 'n'
        if ((int)prime[i] * (int)prime[i] > n)
            break;
             
        // If prime is a factor of
        // n then increment count
        if (n % prime[i] == 0)
        {
            a[j] = (int)prime[i];
            j++;
        }
  
        while (n % prime[i] == 0)
            n /= prime[i];
              
        i++;
    }
  
    if (n != 1)
    {
        a[j] = n;
        j++;
    }
    return m - count(a, j, m);
}
  
static void countRelPrimeInRange(int n, int l,
                                 int r)
{
    sieve((int)Math.Sqrt(maxN));
      
    int result = countRelPrime(n, r) -
                 countRelPrime(n, l - 1);
                   
    Console.WriteLine(result);
}
 
// Driver Code
static void Main()
{
    int N = 7, L = 3, R = 9;
     
    countRelPrimeInRange(N, L, R);
}
}
 
// This code is contributed by divyeshrabadiya07

Javascript

<script>
 
// Javascript code to count of natural
// numbers in range [L, R] which
// are relatively prime with N
let maxN = 100000000;
 
// Container of all the primes
// up to sqrt(n)
let prime = [];
 
// Function to calculate prime
// factors of n
function sieve(n)
{
     
    // Run the sieve of Eratosthenes
    let check = new Array(1000007);
    for(let i = 0; i < 1000007; i++)
        check[i] = false;
  
    let i, j;
  
    // 0(false) means prime,
    // 1(true) means not prime
    check[0] = false;
    check[1] = true;
    check[2] = false;
  
    // No even number is
    // prime except for 2
    for(i = 4; i <= n; i += 2)
        check[i] = true;
  
    for(i = 3; i * i <= n; i += 2)
        if (!check[i])
        {
             
            // All the multiples of each
            // each prime numbers are
            // non-prime
            for(j = i * i; j <= n; j += 2 * i)
                check[j] = true;
        }
  
    prime.push(2);
  
    // Get all the primes
    // in prime vector
    for(i = 3; i <= n; i += 2)
        if (!check[i])
            prime.push(i);
  
    return;
}
 
function countSetBits(n)
{
    let count = 0;
    while (n > 0)
    {
        count += n & 1;
        n >>= 1;
    }
    return count;
}
 
// Count the number of numbers
// up to m which are divisible
// by given prime numbers
function count(a, n, m)
{
    let parity = new Array(3);
    for(let i = 0; i < 3; i++)
        parity[i] = 0;
  
    // Run from i= 000..0 to i= 111..1
    // or check all possible
    // subsets of the array
    for(let i = 1; i < (1 << n); i++)
    {
        let mult = 1;
        for(let j = 0; j < n; j++)
            if ((i & (1 << j)) != 0)
                mult *= a[j];
  
        // Take the multiplication
        // of all the set bits
  
        // If the number of set bits
        // is odd, then add to the
        // number of multiples
        parity[countSetBits(i) & 1] += (m / mult);
    }
    return parity[1] - parity[0];
}
 
// Function calculates all number
// not greater than 'm' which are
// relatively prime with n.
function countRelPrime(n, m)
{
    let a = new Array(20);
    let i = 0, j = 0;
    let pz = prime.length;
      
    while(n != 1 && i < pz)
    {
         
        // If square of the prime number
        // is greater than 'n', it can't
        // be a factor of 'n'
        if (prime[i] *
            prime[i] > n)
            break;
  
        // If prime is a factor of
        // n then increment count
        if (n % prime[i] == 0)
        {
            a[j] = prime[i];
            j++;
        }
  
        while (n % prime[i] == 0)
            n = Math.floor(n/prime[i]);
              
        i++;
    }
  
    if (n != 1)
    {
        a[j] = n;
        j++;
    }
    return m - count(a, j, m);
}
 
function countRelPrimeInRange(n, l, r)
{
    sieve(Math.floor(Math.sqrt(maxN)));
      
    let result = countRelPrime(n, r) -
                 countRelPrime(n, l - 1);
                   
    document.write(result);
}
 
// Driver code
let N = 7, L = 3, R = 9;
 
countRelPrimeInRange(N, L, R);
 
// This code is contributed by unknown2108
 
</script>

Output:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

My Personal Notes

Related Articles

C++

Java

Python3

C#

Javascript