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

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

6

Time Complexity: O(2^N * log(R))
Auxiliary Space: O(N + maxN)