Count of numbers upto M with GCD equals to K when paired with M (original) (raw)

Last Updated : 12 Jul, 2025

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

`

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

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