Skip to content
Related Articles

Related Articles

Improve Article

Count numbers up to N whose GCD with N is less than that number

  • Last Updated : 12 Jun, 2021

Given an integer N, the task is to count the values of K ( where 1 ≤ K≤ N ), such that 1< GCD(K, N) < K.

Examples:

Input: N = 10
Output: 3
Explanation: The values of K which satisfies the given conditions are: 

  • K = 4, gcd(4, 10) = 2
  • K = 6, gcd(6, 10) = 2
  • K = 8, gcd(8, 10) = 2

Input: N = 15
Output: 4
Explanation: The values of K which satisfies the given conditions are: 

  • K = 6, gcd(6, 15) = 3
  • K = 9, gcd(9, 15) = 3
  • K = 10, gcd(10, 15) = 5
  • K = 12, gcd(12, 15) = 3

Naive Approach: The simplest approach is to iterate over the range [1, N], and check for each number, whether it satisfies the given condition or not. Finally, print the count of such numbers.



Time Complexity: O(N*log(N))
Auxiliary Space: O(1) 

Efficient Approach: The idea is to find all the numbers in the range [1, N], for which gcd(K, N) = 1 and gcd(K, N) = K and then finally remove all these numbers from N to get the final answer. Follow the steps below to solve the problem:

  • Store all the prime factors of N using Sieve of Eratosthenes.
  • Store the count of all the numbers in the range [1, N] for which gcd(N, K) = K in a variable count1.
  • Store the count of all the numbers in the range [1, N] for which gcd(N, K) = 1 using Euler’s Totient Function in a variable count2.
  • Remove these numbers from N, by updating ans to N – (count1 + count2).
  • Print the value of ans as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Store the all prime numbers
// using Seive of Eratosthenes
const int MAXN = 100001;
vector<int> spf;
 
// Function to fill the prime numbers
// using Sieve of Erastosthenes
void sieve()
{
    // Create a boolean array and
    // initialize all entries it as 0
    int p[MAXN + 1] = { 0 };
 
    p[2] = 1;
    for (long long int i = 3; i < MAXN; i += 2) {
        p[i] = 1;
    }
 
    // Push the first prime number
    spf.push_back(2);
 
    for (long long i = 3; i < MAXN; i += 2) {
 
        // If the current number is prime
        if (p[i]) {
 
            // Store the prime numbers
            // in spf which is prime
            spf.push_back(i);
 
            // Mark all its multiples as false
            for (long long int j = i * i; j < MAXN;
                 j += 2 * i)
                p[j] = 0;
        }
    }
}
 
// Function to count the values of K where
// 1≤K≤N such that 1< gcd(K, N) < K
void countK(int N)
{
    // Precalculate prime numbers
    sieve();
    int N1 = N;
 
    // Store the smallest prime number
    int div = spf[0];
 
    int index = 1, C = 0;
 
    // Store the count of those numbers in the
    // range [1, N] for which gcd(N, K) = K
    int count1 = 1;
 
    // Store the count of those numbers from
    // the range [1, N] such that gcd(N, K) = 1
    float count2 = N;
 
    // Iterate through all prime factors of N
    while (div * div <= N) {
        if (N % div == 0) {
            C = 0;
            while (N % div == 0) {
                N /= div;
                C++;
            }
 
            count1 = count1 * (C + 1);
 
            // count2 is determined by
            // Euler's Totient Function
            count2 *= (1.0 - (1.0 / (float)div));
        }
 
        div = spf[index];
 
        index++;
    }
    if (N != 1) {
 
        count1 *= 2;
        count2 = count2 * (1.0 - (1.0 / (float)N));
    }
 
    int ans = N1 - count1 - count2;
 
    // Add 1 to result as 1 is contributed
    // twice due to count1 and count2
    ans = ans + 1;
 
    // Print the result
    cout << ans;
 
    return;
}
 
// Driver Code
int main()
{
    // Given Input
    int N = 10;
 
    // Function Call
    countK(N);
 
    return 0;
}

Python3




# Python3 program for the above approach
 
# Store the all prime numbers
# using Seive of Eratosthenes
MAXN = 100001
spf = []
 
# Function to fill the prime numbers
# using Sieve of Erastosthenes
def sieve():
     
    global MAXN
     
    # Create a boolean array and
    # initialize all entries it as 0
    p = [0] * (MAXN + 1)
    p[2] = 1
     
    for i in range(3, MAXN, 2):
        p[i] = 1
 
    # Push the first prime number
    spf.append(2)
 
    for i in range(3, MAXN, 2):
         
        # If the current number is prime
        if (p[i]):
 
            # Store the prime numbers
            # in spf which is prime
            spf.append(i)
 
            # Mark all its multiples as false
            for j in range(i * i, MAXN, 2 * i):
                p[j] = 0
 
# Function to count the values of K where
# 1≤K≤N such that 1< gcd(K, N) < K
def countK(N):
     
    # Precalculate prime numbers
    sieve()
    N1 = N
 
    # Store the smallest prime number
    div = spf[0]
 
    index, C = 1, 0
 
    # Store the count of those numbers in the
    # range [1, N] for which gcd(N, K) = K
    count1 = 1
 
    # Store the count of those numbers from
    # the range [1, N] such that gcd(N, K) = 1
    count2 = N
 
    # Iterate through all prime factors of N
    while (div * div <= N):
        if (N % div == 0):
            C = 0
             
            while (N % div == 0):
                N //= div
                C += 1
 
            count1 = count1 * (C + 1)
 
            # count2 is determined by
            # Euler's Totient Function
            count2 *= (1.0 - (1.0 / div))
 
        div = spf[index]
 
        index += 1
 
    if (N != 1):
        count1 *= 2
        count2 = count2 * (1.0 - (1.0 / N))
 
    ans = N1 - count1 - count2
 
    # Add 1 to result as 1 is contributed
    # twice due to count1 and count2
    ans = ans + 1
 
    # Print the result
    print(int(ans))
 
# Driver Code
if __name__ == '__main__':
     
    # Given Input
    N = 10
 
    # Function Call
    countK(N)
 
# This code is contributed by mohit kumar 29
Output: 
3

 

Time Complexity: O(N*log(log(N)))
 Auxiliary Space: O(N) 

 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :