Open In App

Count numbers in range 1 to N which are divisible by X but not by Y

Last Updated : 16 Oct, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

Given two positive integers X and Y, the task is to count the total numbers in range 1 to N which are divisible by X but not Y.

Examples:

Input: x = 2, Y = 3, N = 10 Output: 4 Numbers divisible by 2 but not 3 are : 2, 4, 8, 10 Input : X = 2, Y = 4, N = 20 Output : 5 Numbers divisible by 2 but not 4 are : 2, 6, 10, 14, 18

A

Simple Solution

is to count numbers divisible by X but not Y is to loop through 1 to N and counting such number which is divisible by X but not Y.

Approach

  1. For every number in range 1 to N, Increment count if the number is divisible by X but not by Y.
  2. Print the count.
    1. Below is the implementation of above approach:
    2. C++ 
      // C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

// Function to count total numbers divisible by
// x but not y in range 1 to N
int countNumbers(int X, int Y, int N)
{
    int count = 0;
    for (int i = 1; i <= N; i++) {
        // Check if Number is divisible
        // by x but not Y
        // if yes, Increment count
        if ((i % X == 0) && (i % Y != 0))
            count++;
    }
    return count;
}

// Driver Code
int main()
{

    int X = 2, Y = 3, N = 10;
    cout << countNumbers(X, Y, N);
    return 0;
}
      Java 
      // Java implementation of above approach

class GFG {

    // Function to count total numbers divisible by
    // x but not y in range 1 to N
    static int countNumbers(int X, int Y, int N)
    {
        int count = 0;
        for (int i = 1; i <= N; i++) {
            // Check if Number is divisible
            // by x but not Y
            // if yes, Increment count
            if ((i % X == 0) && (i % Y != 0))
                count++;
        }
        return count;
    }

    // Driver Code
    public static void main(String[] args)
    {

        int X = 2, Y = 3, N = 10;
        System.out.println(countNumbers(X, Y, N));
    }
}
      Python3 
      # Python3 implementation of above approach 

# Function to count total numbers divisible 
# by x but not y in range 1 to N 
def countNumbers(X, Y, N): 

    count = 0; 
    for i in range(1, N + 1):
        
        # Check if Number is divisible 
        # by x but not Y 
        # if yes, Increment count 
        if ((i % X == 0) and (i % Y != 0)): 
            count += 1; 

    return count; 

# Driver Code 
X = 2;
Y = 3;
N = 10; 
print(countNumbers(X, Y, N)); 
    
# This code is contributed by mits
      C# 
      // C# implementation of the above approach
using System;
class GFG {

    // Function to count total numbers divisible by
    // x but not y in range 1 to N
    static int countNumbers(int X, int Y, int N)
    {
        int count = 0;
        for (int i = 1; i <= N; i++) {
            // Check if Number is divisible
            // by x but not Y
            // if yes, Increment count
            if ((i % X == 0) && (i % Y != 0))
                count++;
        }
        return count;
    }

    // Driver Code
    public static void Main()
    {

        int X = 2, Y = 3, N = 10;
        Console.WriteLine(countNumbers(X, Y, N));
    }
}
      JavaScript 
      // Function to count total numbers divisible by
// x but not y in the range 1 to N
function countNumbers(X, Y, N) {
    let count = 0;
    for (let i = 1; i <= N; i++) {
        // Check if the number is divisible by X but not by Y
        if (i % X === 0 && i % Y !== 0) {
            count++;
        }
    }
    return count;
}

// Driver code
function main() {
    const X = 2;
    const Y = 3;
    const N = 10;

    // Call the countNumbers function and print the result
    console.log(countNumbers(X, Y, N));
}

// Call the main function to start the process
main();
      PHP 
      <?php
//PHP implementation of above approach 

// Function to count total numbers divisible by 
// x but not y in range 1 to N 
function countNumbers($X, $Y, $N) 
{ 
    $count = 0; 
    for ($i = 1; $i <= $N; $i++)
    { 
        // Check if Number is divisible 
        // by x but not Y 
        // if yes, Increment count 
        if (($i % $X == 0) && ($i % $Y != 0)) 
            $count++; 
    } 
    return $count; 
} 

// Driver Code 
$X = 2;
$Y = 3;
$N = 10; 
echo (countNumbers($X, $Y, $N)); 
    
// This code is contributed by Arnab Kundu
?>

    3. Output
      4
    4. Time Complexity : O(N)
    5. Efficient solution:
      1. In range 1 to N, find total numbers divisible by X and total numbers divisible by Y.
      2. Also, Find total numbers divisible by either X or Y
      3. Calculate total number divisible by X but not Y as (total number divisible by X or Y) - (total number divisible by Y)
    7. Below is the implementation of above approach:
    8. C++ 
      // C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

// Function to count total numbers divisible by
// x but not y in range 1 to N
int countNumbers(int X, int Y, int N)
{

    // Count total number divisible by X
    int divisibleByX = N / X;

    // Count total number divisible by Y
    int divisibleByY = N / Y;

    // Count total number divisible by either X or Y
    int LCM = (X * Y) / __gcd(X, Y);
    int divisibleByLCM = N / LCM;
    int divisibleByXorY = divisibleByX + divisibleByY 
                                     - divisibleByLCM;

    // Count total numbers divisible by X but not Y
    int divisibleByXnotY = divisibleByXorY 
                                       - divisibleByY;

    return divisibleByXnotY;
}

// Driver Code
int main()
{

    int X = 2, Y = 3, N = 10;
    cout << countNumbers(X, Y, N);
    return 0;
}
      Java 
      // Java implementation of above approach

class GFG {

    // Function to calculate GCD

    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    // Function to count total numbers divisible by
    // x but not y in range 1 to N

    static int countNumbers(int X, int Y, int N)
    {

        // Count total number divisible by X
        int divisibleByX = N / X;

        // Count total number divisible by Y
        int divisibleByY = N / Y;

        // Count total number divisible by either X or Y
        int LCM = (X * Y) / gcd(X, Y);
        int divisibleByLCM = N / LCM;
        int divisibleByXorY = divisibleByX + divisibleByY
                              - divisibleByLCM;

        // Count total number divisible by X but not Y
        int divisibleByXnotY = divisibleByXorY 
                                          - divisibleByY;

        return divisibleByXnotY;
    }

    // Driver Code
    public static void main(String[] args)
    {

        int X = 2, Y = 3, N = 10;
        System.out.println(countNumbers(X, Y, N));
    }
}
      Python3 
      # Python 3 implementation of above approach
from math import gcd

# Function to count total numbers divisible 
# by x but not y in range 1 to N
def countNumbers(X, Y, N):
    
    # Count total number divisible by X
    divisibleByX = int(N / X)

    # Count total number divisible by Y
    divisibleByY = int(N / Y)

    # Count total number divisible 
    # by either X or Y
    LCM = int((X * Y) / gcd(X, Y))
    divisibleByLCM = int(N / LCM)
    divisibleByXorY = (divisibleByX + 
                       divisibleByY - 
                       divisibleByLCM)

    # Count total numbers divisible by 
    # X but not Y
    divisibleByXnotY = (divisibleByXorY - 
                        divisibleByY)

    return divisibleByXnotY

# Driver Code
if __name__ == '__main__':
    X = 2
    Y = 3
    N = 10
    print(countNumbers(X, Y, N))

# This code is contributed by
# Surendra_Gangwar
      C# 
      // C# implementation of above approach

using System;
class GFG {

    // Function to calculate GCD
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    // Function to count total numbers divisible by
    // x but not y in range 1 to N
    static int countNumbers(int X, int Y, int N)
    {

        // Count total number divisible by X
        int divisibleByX = N / X;

        // Count total number divisible by Y
        int divisibleByY = N / Y;

        // Count total number divisible by either X or Y
        int LCM = (X * Y) / gcd(X, Y);
        int divisibleByLCM = N / LCM;
        int divisibleByXorY = divisibleByX + divisibleByY 
                                        - divisibleByLCM;

        // Count total number divisible by X but not Y
        int divisibleByXnotY = divisibleByXorY 
                                          - divisibleByY;

        return divisibleByXnotY;
    }

    // Driver Code
    public static void Main()
    {

        int X = 2, Y = 3, N = 10;
        Console.WriteLine(countNumbers(X, Y, N));
    }
}
      JavaScript 
      // Function to count total numbers divisible by
// X but not Y in the range 1 to N
function countNumbers(X, Y, N) {
    // Count total numbers divisible by X
    const divisibleByX = Math.floor(N / X);

    // Count total numbers divisible by Y
    const divisibleByY = Math.floor(N / Y);

    // Calculate the least common multiple (LCM) of X and Y
    const LCM = (X * Y) / gcd(X, Y);

    // Count total numbers divisible by either X or Y
    const divisibleByLCM = Math.floor(N / LCM);

    // Count total numbers divisible by either X or Y
    const divisibleByXorY = divisibleByX + divisibleByY - divisibleByLCM;

    // Count total numbers divisible by X but not by Y
    const divisibleByXnotY = divisibleByXorY - divisibleByY;

    return divisibleByXnotY;
}

// Function to calculate the greatest common divisor (GCD) using Euclidean algorithm
function gcd(a, b) {
    if (b === 0) {
        return a;
    }
    return gcd(b, a % b);
}

// Driver code
function main() {
    const X = 2;
    const Y = 3;
    const N = 10;

    // Call the countNumbers function and print the result
    console.log("Count of numbers divisible by " + X + " but not by " + Y + " in the range 1 to " + N + ": " + countNumbers(X, Y, N));
}

// Call the main function to start the process
main();
      PHP 
      <?php
// PHP implementation of above approach

function __gcd($a, $b) 
{ 

    // Everything divides 0 
    if ($a == 0) 
        return $b; 
    if ($b == 0) 
        return $a; 

    // base case 
    if($a == $b) 
        return $a ; 
    
    // a is greater 
    if($a > $b) 
        return __gcd( $a - $b , $b ); 

    return __gcd( $a , $b - $a ); 
} 

// Function to count total numbers divisible 
// by x but not y in range 1 to N
function countNumbers($X, $Y, $N)
{

    // Count total number divisible by X
    $divisibleByX = $N / $X;

    // Count total number divisible by Y
    $divisibleByY = $N /$Y;

    // Count total number divisible by either X or Y
    $LCM = ($X * $Y) / __gcd($X, $Y);
    $divisibleByLCM = $N / $LCM;
    $divisibleByXorY = $divisibleByX + $divisibleByY - 
                                       $divisibleByLCM;

    // Count total numbers divisible by X but not Y
    $divisibleByXnotY = $divisibleByXorY - 
                        $divisibleByY;

    return ceil($divisibleByXnotY);
}

// Driver Code
$X = 2;
$Y = 3;
$N = 10;
echo countNumbers($X, $Y, $N);

// This is code contrubted by inder_verma
?>

    9. Output
      4
    10. Time Complexity:
    11. O(1)

Next Article
Count numbers in range 1 to N which are divisible by X but not by Y

I
ihritik
Improve
Article Tags :
Practice Tags :

Similar Reads

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