Find the Kth number which is not divisible by N

Given two integers N and K, the task is to find the K^th 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 K^th non-divisible number by N. Below is the steps to find the K^th 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 K^th number not divisible by N will be:

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