Open In App

Find the Kth number which is not divisible by N

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: 

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.

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

Article Tags :