Skip to content
Related Articles

Related Articles

Table of Contents

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: 

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)

My Personal Notes
arrow_drop_up
Previous
ML - Neural Network Implementation in C++ From Scratch
Next

PyQt5 ComboBox – Different border size when editable and in off state
Recommended Articles
Page :
Sum of GCD of all numbers upto N with N itself
26, May 20
Maximize count of equal numbers in Array of numbers upto N by replacing pairs with their sum
28, Aug 20
Count of numbers upto M divisible by given Prime Numbers
31, Jul 20
Count numbers < = N whose difference with the count of primes upto them is > = K
19, Dec 18
Find the number of pairs such that their gcd is equals to 1
18, Sep 19
Print any pair of integers with sum of GCD and LCM equals to N
09, May 20
Series with largest GCD and sum equals to n
09, Oct 17
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
13, Jan 21
Find all Ramanujan Numbers that can be formed by numbers upto L
19, Feb 21
Count numbers upto N which are both perfect square and perfect cube
17, Dec 18
Count of numbers upto N having absolute difference of at most K between any two adjacent digits
14, Jul 20
Count of numbers upto N digits formed using digits 0 to K-1 without any adjacent 0s
03, Jul 20
Total count of sorted numbers upto N digits in range [L, R] (Magnificent necklace combinatorics problem)
07, Jul 21
Count of Octal numbers upto N digits
04, Mar 20
Count of all values of N in [L, R] such that count of primes upto N is also prime
03, Jul 20
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Smallest subsequence having GCD equal to GCD of given array
20, Oct 20
Find N distinct integers with GCD of sequence as 1 and GCD of each pair greater than 1
07, Dec 21
Count numbers whose maximum sum of distinct digit-sum is less than or equals M
30, Mar 20
Count of N-digit numbers whose bitwise AND of adjacent digits equals 0
05, Jul 21
Count of n digit numbers whose sum of digits equals to given sum
02, Sep 15
Program to print tetrahedral numbers upto Nth term
24, Jul 18
Program to print pentatope numbers upto Nth term
25, Jul 18
Sum of the numbers upto N that are divisible by 2 or 5
11, Oct 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
jayrajiitr16
@jayrajiitr16
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!