Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Medium
  • Last Updated : 18 Nov, 2021

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: 

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.

Input: M = 9, K = 1 
Output:
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)




My Personal Notes arrow_drop_up
Recommended Articles
Page :