# 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 = 10Output:4

Numbers divisible by 2 but not 3 are : 2, 4, 8, 10

Input :X = 2, Y = 4, N = 20Output :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**

- For every number in range 1 to N, Increment count if the number is divisible by X but not by Y.
- Print the count.
- In range 1 to N, find
**total numbers divisible by X**and**total numbers divisible by Y**. - Also, Find
**total numbers divisible by either X or Y** - Calculate total number divisible by X but not Y as
**(total number divisible by X or Y) – (total number divisible by Y)**

Below is the implementation of above approach:

## 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));`

`}`

`}`

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

`?>`

**Output:**4

**Time Complexity : O(N)****Efficient solution:**Below is the implementation of above approach:

## 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));`

`}`

`}`

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

`?>`

**Output:**4

**Time Complexity:**O(1)Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the

**DSA Self Paced Course**at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer**Complete Interview Preparation Course****.**In case you wish to attend

**live classes**with experts, please refer**DSA Live Classes for Working Professionals**and**Competitive Programming Live for Students**. - In range 1 to N, find