Count of numbers upto M with GCD equals to K when paired with M

Given two integers M and K, the task is to count the number of integers between [0, M] such that GCD of that integer with M equals K. 

Examples:

Input: M = 9, K = 1 
Output: 6 
Explanation:
The possible numbers such that when paired with 9, there GCD is 1, are 1, 2, 4, 5, 7, 8.

Input: M = 10, K = 5 
Output: 1  

Approach:

• Integers having GCD K with M will be of the form K, 2K, 3K, …..and so on up to M.
• Let’s consider the coefficients of K i.e 1, 2, 3, 4…up to (M/K).
• Now we just have to find the count of such coefficients which have GCD with the number (M/K) = 1. So now the problem reduces to find the number of integers between 1 to (M/K) having Gcd with (m/k) = 1.
• To find this we will use the Euler totient function of (M/K).

Below is the implementation of the above approach:  

C++

// C++ program to Count of numbers
// between 0 to M which have GCD
// with M equals to K.

#include <bits/stdc++.h>
using namespace std;

// Function to calculate GCD
// using euler totient function
int EulerTotientFunction(int limit)
{
    int copy = limit;

    // Finding the prime factors of
    // limit to calculate it's
    // euler totient function
    vector<int> primes;

    for (int i = 2; i * i <= limit; i++) {
        if (limit % i == 0) {
            while (limit % i == 0) {
                limit /= i;
            }
            primes.push_back(i);
        }
    }
    if (limit >= 2) {
        primes.push_back(limit);
    }

    // Calculating the euler totient
    // function of (m/k)
    int ans = copy;
    for (auto it : primes) {
        ans = (ans / it) * (it - 1);
    }
    return ans;
}

// Function print the count of
// numbers whose GCD with M
// equals to K
void CountGCD(int m, int k)
{

    if (m % k != 0) {
        // GCD of m with any integer
        // cannot  be equal to k
        cout << 0 << endl;
        return;
    }

    if (m == k) {
        // 0 and m itself will be
        // the only valid integers
        cout << 2 << endl;
        return;
    }

    // Finding the number upto which
    // coefficient of k can come
    int limit = m / k;

    int ans = EulerTotientFunction(limit);

    cout << ans << endl;
}
// Driver code
int main()
{

    int M = 9;
    int K = 1;
    CountGCD(M, K);

    return 0;
}

Java

// Java program to Count of numbers
// between 0 to M which have GCD
// with M equals to K.
import java.util.*;

class GFG{

// Function to calculate GCD
// using euler totient function
static int EulerTotientFunction(int limit)
{
    int copy = limit;

    // Finding the prime factors of
    // limit to calculate it's
    // euler totient function
    Vector<Integer> primes = new Vector<Integer>();

    for (int i = 2; i * i <= limit; i++) {
        if (limit % i == 0) {
            while (limit % i == 0) {
                limit /= i;
            }
            primes.add(i);
        }
    }
    if (limit >= 2) {
        primes.add(limit);
    }

    // Calculating the euler totient
    // function of (m/k)
    int ans = copy;
    for (int it : primes) {
        ans = (ans / it) * (it - 1);
    }
    return ans;
}

// Function print the count of
// numbers whose GCD with M
// equals to K
static void CountGCD(int m, int k)
{

    if (m % k != 0) {
        // GCD of m with any integer
        // cannot  be equal to k
        System.out.print(0 +"\n");
        return;
    }

    if (m == k) {
        // 0 and m itself will be
        // the only valid integers
        System.out.print(2 +"\n");
        return;
    }

    // Finding the number upto which
    // coefficient of k can come
    int limit = m / k;

    int ans = EulerTotientFunction(limit);

    System.out.print(ans +"\n");
}

// Driver code
public static void main(String[] args)
{

    int M = 9;
    int K = 1;
    CountGCD(M, K);

}
}

// This code is contributed by sapnasingh4991

Python3

# Python3 program to Count of numbers
# between 0 to M which have GCD
# with M equals to K.

# Function to calculate GCD
# using euler totient function
def EulerTotientFunction(limit):
    copy = limit

    # Finding the prime factors of
    # limit to calculate it's
    # euler totient function
    primes = []

    for i in range(2, limit + 1):
        if i * i > limit:
            break
        if (limit % i == 0):
            while (limit % i == 0):
                limit //= i
            primes.append(i)

    if (limit >= 2):
        primes.append(limit)

    # Calculating the euler totient
    # function of (m//k)
    ans = copy
    for it in primes:
        ans = (ans // it) * (it - 1)

    return ans

# Function print the count of
# numbers whose GCD with M
# equals to K
def CountGCD(m, k):

    if (m % k != 0):

        # GCD of m with any integer
        # cannot be equal to k
        print(0)
        return

    if (m == k):

        # 0 and m itself will be
        # the only valid integers
        print(2)
        return

    # Finding the number upto which
    # coefficient of k can come
    limit = m // k

    ans = EulerTotientFunction(limit)

    print(ans)

# Driver code
if __name__ == '__main__':

    M = 9
    K = 1
    CountGCD(M, K)

# This code is contributed by mohit kumar 29

C#

// C# program to Count of numbers
// between 0 to M which have GCD
// with M equals to K.
using System;
using System.Collections.Generic;

class GFG{

// Function to calculate GCD
// using euler totient function
static int EulerTotientFunction(int limit)
{
    int copy = limit;

    // Finding the prime factors of
    // limit to calculate it's
    // euler totient function
    List<int> primes = new List<int>();

    for (int i = 2; i * i <= limit; i++)
    {
        if (limit % i == 0)
        {
            while (limit % i == 0)
            {
                limit /= i;
            }
            primes.Add(i);
        }
    }
    if (limit >= 2)
    {
        primes.Add(limit);
    }

    // Calculating the euler totient
    // function of (m/k)
    int ans = copy;
    foreach (int it in primes)
    {
        ans = (ans / it) * (it - 1);
    }
    return ans;
}

// Function print the count of
// numbers whose GCD with M
// equals to K
static void CountGCD(int m, int k)
{
    if (m % k != 0)
    {
        // GCD of m with any integer
        // cannot be equal to k
        Console.Write(0 + "\n");
        return;
    }

    if (m == k)
    {
        // 0 and m itself will be
        // the only valid integers
        Console.Write(2 + "\n");
        return;
    }

    // Finding the number upto which
    // coefficient of k can come
    int limit = m / k;

    int ans = EulerTotientFunction(limit);

    Console.Write(ans + "\n");
}

// Driver code
public static void Main(String[] args)
{
    int M = 9;
    int K = 1;
    CountGCD(M, K);
}
}

// This code is contributed by PrinciRaj1992

Javascript

<script>

// JavaScript program to Count of numbers
// between 0 to M which have GCD
// with M equals to K.

// Function to calculate GCD
// using euler totient function
function EulerTotientFunction(limit)
{
    let copy = limit;

    // Finding the prime factors of
    // limit to calculate it's
    // euler totient function
    let primes = [];

    for (let i = 2; i * i <= limit; i++) {
        if (limit % i == 0) {
            while (limit % i == 0) {
                limit /= i;
            }
            primes.push(i);
        }
    }
    if (limit >= 2) {
        primes.push(limit);
    }

    // Calculating the euler totient
    // function of (m/k)
    let ans = copy;
    for (let it in primes) {
        ans = (ans / primes[it]) * (primes[it] - 1);
    }
    return ans;
}

// Function print the count of
// numbers whose GCD with M
// equals to K
function CountGCD(m, k)
{

    if (m % k != 0) {
        // GCD of m with any integer
        // cannot  be equal to k
        document.write(0 +"<br/>");
        return;
    }

    if (m == k) {
        // 0 and m itself will be
        // the only valid integers
        document.write(2 +"<br/>");
        return;
    }

    // Finding the number upto which
    // coefficient of k can come
    let limit = Math.floor(m / k);

    let ans = EulerTotientFunction(limit);

    document.write(ans +"\n");
}

// Driver Code

    let M = 9;
    let K = 1;
    CountGCD(M, K);

</script>

Output:

6

Time Complexity: O((m / k)^1/2 * log(m/k))

Auxiliary Space: O((m / k)^1/2)