# Find Nth number in a sequence which is not a multiple of a given number

Given four integers A, N, L and R, the task is to find the N th number in a sequence of consecutive integers from L to R which is not a multiple of A. It is given that the sequence contain at least N numbers which are not divisible by A and the integer A is always greater than 1.
Examples:

Input: A = 2, N = 3, L = 1, R = 10
Output:
Explanation:
The sequence is 1, 2, 3, 4, 5, 6, 7, 8, 9 and 10. Here 5 is the third number which is not a multiple of 2 in the sequence.
Input: A = 3, N = 6, L = 4, R = 20
Output: 11
Explanation :
11 is the 6th number which is not a multiple of 3 in the sequence.

Naive Approach: The naive approach is to iterate over the range [L, R] in a loop to find the Nth number. The steps are:

1. Intialize the count of non-multiple number and current number to 0.
2. Iterate over the range [L, R] until the count of the non-multiple number is not equal to N.
3. Increment the count of the non-multiple number by 1, If the current number is not divisible by A.

Below is the implementation of the above approach:

 // C++ program for the above approach  #include  using namespace std;    // Function to find Nth number not a  // multiple of A in the range [L, R]  void count_no (int A, int N, int L, int R)  {            // To store the count      int count = 0;      int i = 0;        // To check all the nos in range      for(i = L; i < R + 1; i++)      {      if (i % A != 0)          count += 1;                if (count == N)          break;      }      cout << i;  }    // Driver code  int main()  {            // Given values of A, N, L, R      int A = 3, N = 6, L = 4, R = 20;            // Function Call      count_no (A, N, L, R);      return 0;  }    // This code is contributed by mohit kumar 29

 // Java program for the above approach  import java.util.*; import java.io.*;   class GFG{       // Function to find Nth number not a  // multiple of A in the range [L, R]  static void count_no (int A, int N,                        int L, int R) {        // To store the count      int count = 0;      int i = 0;        // To check all the nos in range      for(i = L; i < R + 1; i++)      {          if (i % A != 0)              count += 1;                if (count == N)              break;      }      System.out.println(i);  }    // Driver code  public static void main(String[] args)  {           // Given values of A, N, L, R      int A = 3, N = 6, L = 4, R = 20;        // Function call      count_no (A, N, L, R);  } }   // This code is contributed by sanjoy_62

 # Python3 program for the above approach    # Function to find Nth number not a  # multiple of A in the range [L, R]  def count_no (A, N, L, R):        # To store the count      count = 0       # To check all the nos in range      for i in range ( L, R + 1 ):          if ( i % A != 0 ):              count += 1           if ( count == N ):              break     print ( i )        # Given values of A, N, L, R  A, N, L, R = 3, 6, 4, 20   # Function Call  count_no (A, N, L, R)

 // C# program for the above approach  using System;   class GFG{       // Function to find Nth number not a  // multiple of A in the range [L, R]  static void count_no (int A, int N,                        int L, int R) {            // To store the count      int count = 0;      int i = 0;        // To check all the nos in range      for(i = L; i < R + 1; i++)      {          if (i % A != 0)              count += 1;                if (count == N)              break;      }      Console.WriteLine(i);  }    // Driver code  public static void Main()  {           // Given values of A, N, L, R      int A = 3, N = 6, L = 4, R = 20;        // Function call      count_no (A, N, L, R);  } }   // This code is contributed by sanjoy_62

Output:
11



Time Complexity: O(R – L)
Auxiliary Space: O(1)

Efficient Approach:
The key observation is that there are A – 1 numbers that are not divisible by A in the range [1, A – 1]. Similarly, there are A – 1 numbers not divisible by A in range [A + 1, 2 * A – 1], [2 * A + 1, 3 * A – 1] and so on.
With the help of this observation, the Nth number which is not divisible by A will be:

To find the value in the range [ L, R ], we need to shift the origin from ‘0’ to ‘L – 1’, thus we can say that the Nth number which is not divisible by A in the range will be :

However there is an edge case, when the value of ( L – 1 ) + N + floor( ( N – 1 ) / ( A – 1 ) ) itself turns out to be multiple of a ‘A’, in that case Nth number will be :

Below is the implementation of the above approach:

 # Python3 program for the above approach import math   # Function to find Nth number # not a multiple of A in range [L, R] def countNo (A, N, L, R):       # Calculate the Nth no     ans = L - 1 + N \           + math.floor( ( N - 1 ) / ( A - 1 ) )           # Check for the edge case     if ans % A == 0:         ans = ans + 1;     print(ans)   # Input parameters  A, N, L, R = 5, 10, 4, 20   # Function Call countNo(A, N, L, R)

Output:
16



Time Complexity: O(1)
Auxiliary Space: O(1)

Never give up

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :