Given two integers N and K, the task is to find the Kth number which is not divisible by N.
Note: The value of N is greater than 1, because every number is divisible by 1.
Examples:
Input: N = 3, K = 6
Output: 8
Explanation:
Numbers which is not divisible by N = 3 – {1, 2, 4, 5, 7, 8, 10}
6th non-divisible number by 3 is 8.Input: N = 7, K = 97
Output: 113
Explanation:
Numbers which is not divisible by N = 7 – {1, 2, 4, 5, 6, ….}
97th non-divisible number by 7 is 113.
Naive Approach: A simple solution is to iterate over a loop to find the Kth non-divisible number by N. Below is the steps to find the Kth number:
- Initialize the count of non-divisible number and current number to 0.
- Iterate using a while loop until the count of the non-divisible number is not equal to K.
- Increment the count of the non-divisible number by 1, If the current number is not divisible by N.
Below is the implementation of the above approach:
// C++ implementation to find // the K'th non divisible // number by N #include <bits/stdc++.h> using namespace std;
// Function to find // the K'th non divisible // number by N int kthNonDivisible( int N, int K)
{ int find = 0;
int j = 0;
// Loop to find the K non
// divisible number by N
while (find != K) {
j++;
if (j % N != 0)
find++;
}
return j;
} // Driver Code int main()
{ int N = 3;
int K = 6;
cout << kthNonDivisible(N, K);
return 0;
} |
// Java implementation to find // the K'th non divisible // number by N class GFG{
// Function to find // the K'th non divisible // number by N static int kthNonDivisible( int N, int K)
{ int find = 0 ;
int j = 0 ;
// Loop to find the K non
// divisible number by N
while (find != K)
{
j++;
if (j % N != 0 )
find++;
}
return j;
} // Driver code public static void main(String[] args)
{ int N = 3 ;
int K = 6 ;
System.out.print(kthNonDivisible(N, K));
} } // This code is contributed by shivanisinghss2110 |
# Python3 implementation to find # the K'th non divisible # number of N import math
# Function to find the Kth # not divisible by N def kthNonDivisible(n, K):
find = 0
j = 0
# Loop to find the K non
# divisible number by N
while find ! = K:
j = j + 1
if j % N ! = 0 :
find = find + 1
return j
# Driver Code N = 3
K = 6
# Function Call print (kthNonDivisible(N, K))
# This code is contributed by ishayadav181 |
// C# implementation to find the // K'th non-divisible number by N using System;
class GFG {
// Function to find the K'th // non divisible number by N static int kthNonDivisible( int N, int K)
{ int find = 0;
int j = 0;
// Loop to find the K non
// divisible number by N
while (find != K)
{
j++;
if (j % N != 0)
find++;
}
return j;
} // Driver code public static void Main(String[] args)
{ int N = 3;
int K = 6;
Console.Write(kthNonDivisible(N, K));
} } // This code is contributed by shivanisinghss2110 |
<script> // Javascript implementation to find the
// K'th non-divisible number by N
// Function to find the K'th
// non divisible number by N
function kthNonDivisible(N, K)
{
let find = 0;
let j = 0;
// Loop to find the K non
// divisible number by N
while (find != K)
{
j++;
if (j % N != 0)
find++;
}
return j;
}
let N = 3;
let K = 6;
document.write(kthNonDivisible(N, K));
// This code is contributed by decode2207.
</script> |
Output
8
Another Approach – Using Binary Search The idea is to use Binary Search to solve this problem. The search space for this problem will be from 1 to the maximum integer value and the middle value is computed as the difference of the middle of search space and multiples of the N.
- If the middle value is greater than K, then update the value of the H as middle-1.
- Otherwise, If the middle value is greater than K, then update the value of the L as middle – 1.
Below is the implementation of the above approach:
// C++ implementation for // above approach #include <bits/stdc++.h> using namespace std;
// Function to find the Kth // not divisible by N void kthNonDivisible( int N, int K)
{ // Lowest possible value
int L = 1;
// Highest possible value
int H = INT_MAX;
// To store the Kth non
// divisible number of N
int ans = 0;
// Using binary search
while (L <= H)
{
// Calculating mid value
int mid = (L + H) / 2;
// Sol would have the value
// by subtracting all
// multiples of n till mid
int sol = mid - mid / N;
// Check if sol is greater than k
if (sol > K)
{
// H should be reduced to find
// minimum possible value
H = mid - 1;
}
// Check if sol is less than k
// then L will be mid+1
else if (sol < K)
{
L = mid + 1;
}
// Check if sol is equal to k
else
{
// ans will be mid
ans = mid;
// H would be reduced to find any
// more possible value
H = mid - 1;
}
}
// Print the answer
cout << ans;
} // Driver Code int main()
{ int N = 3;
int K = 7;
// Function Call
kthNonDivisible(N, K);
return 0;
} |
// Java implementation for // above approach class GFG{
// Function to find the Kth // not divisible by N public static void kthNonDivisible( int N,
int K)
{ // Lowest possible value
int L = 1 ;
// Highest possible value
int H = Integer.MAX_VALUE;
// To store the Kth non
// divisible number of N
int ans = 0 ;
// Using binary search
while (L <= H)
{
// Calculating mid value
int mid = (L + H) / 2 ;
// Sol would have the value
// by subtracting all
// multiples of n till mid
int sol = mid - mid / N;
// Check if sol is greater than k
if (sol > K)
{
// H should be reduced to find
// minimum possible value
H = mid - 1 ;
}
// Check if sol is less than k
// then L will be mid+1
else if (sol < K)
{
L = mid + 1 ;
}
// Check if sol is equal to k
else
{
// ans will be mid
ans = mid;
// H would be reduced to find any
// more possible value
H = mid - 1 ;
}
}
// Print the answer
System.out.print(ans);
} // Driver code public static void main(String[] args)
{ int N = 3 ;
int K = 7 ;
// Function Call
kthNonDivisible(N, K);
} } // This code is contributed by divyeshrabadiya07 |
# Python3 implementation for # above approach import sys
# Function to find the Kth # not divisible by N def kthNonDivisible(N, K):
# Lowest possible value
L = 1
# Highest possible value
H = sys.maxsize
# To store the Kth non
# divisible number of N
ans = 0
# Using binary search
while (L < = H):
# Calculating mid value
mid = (L + H) / / 2
# Sol would have the value
# by subtracting all
# multiples of n till mid
sol = mid - mid / / N
# Check if sol is greater than k
if (sol > K):
# H should be reduced to find
# minimum possible value
H = mid - 1
# Check if sol is less than k
# then L will be mid+1
elif (sol < K):
L = mid + 1
# Check if sol is equal to k
else :
# ans will be mid
ans = mid
# H would be reduced to find any
# more possible value
H = mid - 1
# Print the answer
print (ans)
# Driver Code N = 3
K = 7
# Function call kthNonDivisible(N, K) # This code is contributed by ANKITKUMAR34 |
// C# implementation for // above approach using System;
class GFG{
// Function to find the Kth // not divisible by N static void kthNonDivisible( int N, int K)
{ // Lowest possible value
int L = 1;
// Highest possible value
int H = Int32.MaxValue;
// To store the Kth non
// divisible number of N
int ans = 0;
// Using binary search
while (L <= H)
{
// Calculating mid value
int mid = (L + H) / 2;
// Sol would have the value
// by subtracting all
// multiples of n till mid
int sol = mid - mid / N;
// Check if sol is greater than k
if (sol > K)
{
// H should be reduced to find
// minimum possible value
H = mid - 1;
}
// Check if sol is less than k
// then L will be mid+1
else if (sol < K)
{
L = mid + 1;
}
// Check if sol is equal to k
else
{
// ans will be mid
ans = mid;
// H would be reduced to find
// any more possible value
H = mid - 1;
}
}
// Print the answer
Console.Write(ans);
} // Driver code static void Main()
{ int N = 3;
int K = 7;
// Function Call
kthNonDivisible(N, K);
} } // This code is contributed by divyesh072019 |
<script> // Javascript implementation for above approach
// Function to find the Kth
// not divisible by N
function kthNonDivisible(N, K)
{
// Lowest possible value
let L = 1;
// Highest possible value
let H = 2147483647;
// To store the Kth non
// divisible number of N
let ans = 0;
// Using binary search
while (L <= H)
{
// Calculating mid value
let mid = parseInt((L + H) / 2, 10);
// Sol would have the value
// by subtracting all
// multiples of n till mid
let sol = mid - parseInt(mid / N, 10);
// Check if sol is greater than k
if (sol > K)
{
// H should be reduced to find
// minimum possible value
H = mid - 1;
}
// Check if sol is less than k
// then L will be mid+1
else if (sol < K)
{
L = mid + 1;
}
// Check if sol is equal to k
else
{
// ans will be mid
ans = mid;
// H would be reduced to find
// any more possible value
H = mid - 1;
}
}
// Print the answer
document.write(ans);
}
let N = 3;
let K = 7;
// Function Call
kthNonDivisible(N, K);
// This code is contributed by mukesh07. </script> |
Output
10
Time Complexity: O(logN)
Efficient Approach: The key observation in the problem is that every number from 1 to N-1 is not divisible by N and then Similarly, N + 1 to 2*N – 1 is also not divisible by N. Keeping this in mind, the Kth number not divisible by N will be:
Below is the implementation of the above approach:
// C++ implementation to find // the K'th non-divisible // number of N #include <bits/stdc++.h> using namespace std;
// Function to find the Kth // not divisible by N int kthNonDivisible( int N, int K)
{ return K + floor ((K - 1) / (N - 1));
} // Driver Code int main()
{ int N = 3;
int K = 6;
// Function Call
cout << kthNonDivisible(N, K);
return 0;
} |
// Java implementation to find the // K'th non-divisible number of N class GFG{
// Function to find the Kth // not divisible by N static int kthNonDivisible( int N, int K)
{ return ( int ) (K + Math.floor((K - 1 ) / (N - 1 )));
} // Driver Code public static void main(String[] args)
{ int N = 3 ;
int K = 6 ;
// Function Call
System.out.print(kthNonDivisible(N, K));
} } // This code is contributed by amal kumar choubey |
# Python3 implementation to find # the K'th non-divisible # number of N import math
# Function to find the Kth # not divisible by N def kthNonDivisible(N, K):
return K + math.floor((K - 1 ) / (N - 1 ))
# Driver Code N = 3
K = 6
# Function Call print (kthNonDivisible(N, K))
# This code is contributed by ishayadav181 |
// C# implementation to find the // K'th non-divisible number of N using System;
class GFG{
// Function to find the Kth // not divisible by N static int kthNonDivisible( int N, int K)
{ return ( int ) (K + Math.Floor(( double )(K - 1) /
(N - 1)));
} // Driver Code public static void Main(String[] args)
{ int N = 3;
int K = 6;
// Function Call
Console.Write(kthNonDivisible(N, K));
} } // This code is contributed by amal kumar choubey |
<script> // Javascript implementation to find // the K'th non-divisible // number of N // Function to find the Kth // not divisible by N function kthNonDivisible(N, K)
{ return K + parseInt(
Math.floor((K - 1) / (N - 1)), 10);
} // Driver code let N = 3; let K = 6; // Function Call document.write(kthNonDivisible(N, K)); // This code is contributed by suresh07 </script> |
Output
8