Related Articles

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

• Difficulty Level : Hard
• 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:

1. At first, factorize the number N. Thus, find out all the prime factors of N.
2. Store prime factors of the number N in an array.
3. We can determine the total number of natural numbers which are not greater than R and are divisible by prime factors of N.
4. Suppose that the value is y. So, exactly y natural numbers not greater than R have at least a single common divisor with N.
5. So, these y numbers can not be relatively prime to N.
6. Thus, the number of natural number not greater than R which are relatively prime to N will be R – y .
7. Now, similarly we need to find out the number of relatively prime numbers of N which are not greater than L-1.
8. 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 ``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 = { 0 };``    ``long` `long` `i, j;` `    ``// 0(false) means prime,``    ``// 1(true) means not prime``    ``check = 1, check = 1,``    ``check = 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 = { 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 - parity;``}` `// 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;``    ``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 prime = ``new` `Vector();` `// 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``;``    ``for``(``int` `I = 0; I < 1000007; I++)``        ``check[I] = ``false``;`` ` `    ``int` `i, j;`` ` `    ``// 0(false) means prime,``    ``// 1(true) means not prime``    ``check = ``false``;``    ``check = ``true``;``    ``check = ``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``;``    ``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 - parity;``}`` ` `// 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``;``    ``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

 ``
Output:
`6`

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 arrow_drop_up