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

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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next