Count numbers having GCD with N equal to the number itself

Given a positive integer N, the task is to find the number of positive integers whose GCD with the given integer N is the number itself.

Examples:

Input: N = 5
Output: 2
Explanation:
Following are the numbers whose GCD with N is the number itself:

1. Number 1: GCD(1, 5) = 1.
2. Number 1: GCD(5, 5) = 5.

Therefore, the total count is 2.

Input: N = 10
Output: 4

Approach: The given problem can be solved based on the observation that the necessary condition for GCD of any number(say K) with N is K if and only if K is a factor of N. Therefore, the idea is to find the number of factors of N. Follow the below steps to solve the problem:

• Initialize a variable, say count as 0, to count the number of factors of N.
• Iterate over the range [1, sqrt(N)] and perform the following steps:
  • If the current number i divides the given integer N, then increment count by 1.
  • If the value of i and N / i is not the same, then increment count by 1.
• After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

// C++ program for the above approach

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

// Function to count numbers whose
// GCD with N is the number itself
int countNumbers(int N)
{
    // Stores the count of factors of N
    int count = 0;

    // Iterate over the range [1, sqrt(N)]
    for (int i = 1; i * i <= N; i++) {

        // If i is divisible by i
        if (N % i == 0) {

            // Increment count
            count++;

            // Avoid counting the
            // same factor twice
            if (N / i != i) {
                count++;
            }
        }
    }

    // Return the resultant count
    return count;
}

// Driver Code
int main()
{
    int N = 10;
    cout << countNumbers(N);

    return 0;
}

// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

public class GFG {

    // Function to count numbers whose
    // GCD with N is the number itself
    static int countNumbers(int N)
    {
        // Stores the count of factors of N
        int count = 0;

        // Iterate over the range [1, sqrt(N)]
        for (int i = 1; i * i <= N; i++) {

            // If i is divisible by i
            if (N % i == 0) {

                // Increment count
                count++;

                // Avoid counting the
                // same factor twice
                if (N / i != i) {
                    count++;
                }
            }
        }

        // Return the resultant count
        return count;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int N = 10;
        System.out.println(countNumbers(N));
    }
}

// This code is contributed by Kingash.

# Python3 program for the above approach

# Function to count numbers whose
# GCD with N is the number itself
def countNumbers(N):
    
    # Stores the count of factors of N
    count = 0
    
    # Iterate over the range [1, sqrt(N)]
    for i in range(1, N + 1):
        if i * i > N:
            break

        # If i is divisible by i
        if (N % i == 0):

            # Increment count
            count += 1
            
            # Avoid counting the
            # same factor twice
            if (N // i != i):
                count += 1

    # Return the resultant count
    return count

# Driver Code
if __name__ == '__main__':
    
    N = 10
    print(countNumbers(N))

# This code is contributed by mohit kumar 29

// C# program for the above approach
using System;
public class GFG {

    // Function to count numbers whose
    // GCD with N is the number itself
    static int countNumbers(int N)
    {
        // Stores the count of factors of N
        int count = 0;

        // Iterate over the range [1, sqrt(N)]
        for (int i = 1; i * i <= N; i++) {

            // If i is divisible by i
            if (N % i == 0) {

                // Increment count
                count++;

                // Avoid counting the
                // same factor twice
                if (N / i != i) {
                    count++;
                }
            }
        }

        // Return the resultant count
        return count;
    }

    // Driver Code
    public static void Main(string[] args)
    {
        int N = 10;
        Console.WriteLine(countNumbers(N));
    }
}

// This code is contributed by ukasp.

<script>

// Javascript program for the above approach


// Function to count numbers whose
// GCD with N is the number itself
function countNumbers(N)
{
    // Stores the count of factors of N
    var count = 0;

    // Iterate over the range [1, sqrt(N)]
    for (i = 1; i * i <= N; i++) {

        // If i is divisible by i
        if (N % i == 0) {

            // Increment count
            count++;

            // Avoid counting the
            // same factor twice
            if (parseInt(N / i) != i) {
                count++;
            }
        }
    }

    // Return the resultant count
    return count;
}

// Driver Code
var N = 10;
document.write(countNumbers(N));

// This code is contributed by Amit Katiyar 

</script>

4

Time Complexity: O(N^1/2)
Auxiliary Space: O(1), since N extra space has been taken.

kapil16garg

Follow

Improve

Article Tags :

• Greedy
• Mathematical
• DSA
• divisibility
• HCF
• factor

+2 More

Practice Tags :

• Greedy
• Mathematical