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

Last Updated : 16 Oct, 2023

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 ` `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

 ``

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)
6. Below is the implementation of above approach:
7. ## C++

 `// C++ implementation of above approach` `#include ` `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

 ` ``\$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` `?>`

8. Output

```4

```
9. Time Complexity:
10. O(1)

Previous
Next