Skip to content
Related Articles

Related Articles

Improve Article

Find the Kth number which is not divisible by N

  • Difficulty Level : Hard
  • Last Updated : 14 Jun, 2021
Geek Week

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:
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++




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




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




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




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

Javascript




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




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




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




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




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

Javascript




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

floor((K - 1) / (N - 1)) + K

Below is the implementation of the above approach:

C++




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




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




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




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

Javascript




<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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :