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
- For every number in range 1 to N, Increment count if the number is divisible by X but not by Y.
- Print the count.
-
- 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));
}
}
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
?>
-
Output
4
- Time Complexity : O(N)
- Efficient solution:
-
- 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)
{
// 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
?>
-
Output
4
- Time Complexity:
- O(1)