Related Articles
Nth number in a set of multiples of A , B or C
• Last Updated : 25 Feb, 2020

Given four integers N, A, B and C. The task is to print the Nth number in the set containing the multiples of A, B or C.

Examples:

Input: A = 2, B = 3, C = 5, N = 8
Output: 10
2, 3, 4, 5, 6, 8, 9, 10, 12, 14, …

Input: A = 2, B = 3, C = 5, N = 100
Output: 136

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive approach: Start traversing from 1 until we find the Nth element which is divisible by either A, B or C.

Efficient approach: Given a number we can find the count of the divisors of either A, B or C. Now, binary search can be used to find the Nth number which is divisible by either A, B or C.

So, if the number is num then
count = (num/A) + (num/B) + (num/C) – (num/lcm(A, B)) – (num/lcm(C, B)) – (num/lcm(A, C)) – (num/lcm(A, B, C))

Below is the implementation of the above approach:

## C++

 `// C++ program to find nth term``// divisible by a, b or c`` ` `#include ``using` `namespace` `std;`` ` `// Function to return``// gcd of a and b``int` `gcd(``int` `a, ``int` `b)``{``    ``if` `(a == 0)``        ``return` `b;`` ` `    ``return` `gcd(b % a, a);``}`` ` `// Function to return the count of integers``// from the range [1, num] which are``// divisible by either a, b or c``long` `divTermCount(``long` `a, ``long` `b, ``long` `c, ``long` `num)``{``    ``// Calculate the number of terms divisible by a, b``    ``// and c then remove the terms which are divisible``    ``// by both (a, b) or (b, c) or (c, a) and then``    ``// add the numbers which are divisible by a, b and c``    ``return` `((num / a) + (num / b) + (num / c)``            ``- (num / ((a * b) / gcd(a, b)))``            ``- (num / ((c * b) / gcd(c, b)))``            ``- (num / ((a * c) / gcd(a, c)))``            ``+ (num / ((((a*b)/gcd(a, b))* c) / gcd(((a*b)/gcd(a, b)), c))));``}`` ` `// Function for binary search to find the``// nth term divisible by a, b or c``int` `findNthTerm(``int` `a, ``int` `b, ``int` `c, ``long` `n)``{``    ``// Set low to 1 and high to LONG_MAX``    ``long` `low = 1, high = LONG_MAX, mid;`` ` `    ``while` `(low < high) {``        ``mid = low + (high - low) / 2;`` ` `        ``// If the current term is less than``        ``// n then we need to increase low``        ``// to mid + 1``        ``if` `(divTermCount(a, b, c, mid) < n)``            ``low = mid + 1;`` ` `        ``// If current term is greater than equal to``        ``// n then high = mid``        ``else``            ``high = mid;``    ``}`` ` `    ``return` `low;``}`` ` `// Driver code``int` `main()``{``    ``long` `a = 2, b = 3, c = 5, n = 100;`` ` `    ``cout << findNthTerm(a, b, c, n);`` ` `    ``return` `0;``}`

## Java

 `// Java program to find nth term``// divisible by a, b or c``class` `GFG``{`` ` `    ``// Function to return``    ``// gcd of a and b``    ``static` `long` `gcd(``long` `a, ``long` `b)``    ``{``        ``if` `(a == ``0``)``        ``{``            ``return` `b;``        ``}``        ``return` `gcd(b % a, a);``    ``}`` ` `    ``// Function to return the count of integers``    ``// from the range [1, num] which are``    ``// divisible by either a, b or c``    ``static` `long` `divTermCount(``long` `a, ``long` `b, ``                             ``long` `c, ``long` `num) ``    ``{``        ``// Calculate the number of terms divisible by a, b``        ``// and c then remove the terms which are divisible``        ``// by both (a, b) or (b, c) or (c, a) and then``        ``// add the numbers which are divisible by a, b and c``        ``return` `((num / a) + (num / b) + (num / c) - ``                ``(num / ((a * b) / gcd(a, b))) - ``                ``(num / ((c * b) / gcd(c, b))) - ``                ``(num / ((a * c) / gcd(a, c))) + ``                ``(num / ((a * b * c) / gcd(gcd(a, b), c))));``    ``}`` ` `    ``// Function for binary search to find the``    ``// nth term divisible by a, b or c``    ``static` `long` `findNthTerm(``int` `a, ``int` `b, ``int` `c, ``long` `n) ``    ``{``         ` `        ``// Set low to 1 and high to LONG_MAX``        ``long` `low = ``1``, high = Long.MAX_VALUE, mid;`` ` `        ``while` `(low < high)``        ``{``            ``mid = low + (high - low) / ``2``;`` ` `            ``// If the current term is less than``            ``// n then we need to increase low``            ``// to mid + 1``            ``if` `(divTermCount(a, b, c, mid) < n) ``            ``{``                ``low = mid + ``1``;``            ``}``             ` `            ``// If current term is greater than equal to``            ``// n then high = mid``            ``else``            ``{``                ``high = mid;``            ``}``        ``}``        ``return` `low;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[]) ``    ``{``        ``int` `a = ``2``, b = ``3``, c = ``5``, n = ``100``;`` ` `        ``System.out.println(findNthTerm(a, b, c, n));``    ``}``}`` ` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find nth term``# divisible by a, b or c``import` `sys`` ` `# Function to return gcd of a and b``def` `gcd(a, b):`` ` `    ``if` `(a ``=``=` `0``):``        ``return` `b;`` ` `    ``return` `gcd(b ``%` `a, a);`` ` `# Function to return the count of integers``# from the range [1, num] which are``# divisible by either a, b or c``def` `divTermCount(a, b, c, num):``     ` `    ``# Calculate the number of terms divisible by a, b``    ``# and c then remove the terms which are divisible``    ``# by both (a, b) or (b, c) or (c, a) and then``    ``# add the numbers which are divisible by a, b and c``    ``return` `((num ``/` `a) ``+` `(num ``/` `b) ``+` `(num ``/` `c) ``-` `                ``(num ``/` `((a ``*` `b) ``/` `gcd(a, b))) ``-` `                ``(num ``/` `((c ``*` `b) ``/` `gcd(c, b))) ``-` `                ``(num ``/` `((a ``*` `c) ``/` `gcd(a, c))) ``+` `                ``(num ``/` `((a ``*` `b ``*` `c) ``/` `gcd(gcd(a, b), c))));`` ` `# Function for binary search to find the``# nth term divisible by a, b or c``def` `findNthTerm(a, b, c, n):`` ` `    ``# Set low to 1 and high to LONG_MAX``    ``low ``=` `1``; high ``=` `sys.maxsize; mid ``=` `0``;`` ` `    ``while` `(low < high):``        ``mid ``=` `low ``+` `(high ``-` `low) ``/` `2``;`` ` `        ``# If the current term is less than``        ``# n then we need to increase low``        ``# to mid + 1``        ``if` `(divTermCount(a, b, c, mid) < n):``            ``low ``=` `mid ``+` `1``;`` ` `        ``# If current term is greater than equal to``        ``# n then high = mid``        ``else``:``            ``high ``=` `mid;``     ` `    ``return` `int``(low);`` ` `# Driver code``a ``=` `2``; b ``=` `3``; c ``=` `5``; n ``=` `100``;`` ` `print``(findNthTerm(a, b, c, n));`` ` `# This code is contributed by 29AjayKumar`

## C#

 `// C# program to find nth term``// divisible by a, b or c``using` `System;`` ` `class` `GFG``{`` ` `    ``// Function to return``    ``// gcd of a and b``    ``static` `long` `gcd(``long` `a, ``long` `b)``    ``{``        ``if` `(a == 0)``        ``{``            ``return` `b;``        ``}``        ``return` `gcd(b % a, a);``    ``}`` ` `    ``// Function to return the count of integers``    ``// from the range [1, num] which are``    ``// divisible by either a, b or c``    ``static` `long` `divTermCount(``long` `a, ``long` `b, ``                             ``long` `c, ``long` `num) ``    ``{``        ``// Calculate the number of terms divisible by a, b``        ``// and c then remove the terms which are divisible``        ``// by both (a, b) or (b, c) or (c, a) and then``        ``// add the numbers which are divisible by a, b and c``        ``return` `((num / a) + (num / b) + (num / c) - ``                ``(num / ((a * b) / gcd(a, b))) - ``                ``(num / ((c * b) / gcd(c, b))) - ``                ``(num / ((a * c) / gcd(a, c))) + ``                ``(num / ((a * b * c) / gcd(gcd(a, b), c))));``    ``}`` ` `    ``// Function for binary search to find the``    ``// nth term divisible by a, b or c``    ``static` `long` `findNthTerm(``int` `a, ``int` `b, ``                            ``int` `c, ``long` `n) ``    ``{``         ` `        ``// Set low to 1 and high to LONG_MAX``        ``long` `low = 1, high = ``long``.MaxValue, mid;`` ` `        ``while` `(low < high)``        ``{``            ``mid = low + (high - low) / 2;`` ` `            ``// If the current term is less than``            ``// n then we need to increase low``            ``// to mid + 1``            ``if` `(divTermCount(a, b, c, mid) < n) ``            ``{``                ``low = mid + 1;``            ``}``             ` `            ``// If current term is greater than equal to``            ``// n then high = mid``            ``else``            ``{``                ``high = mid;``            ``}``        ``}``        ``return` `low;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main(String []args) ``    ``{``        ``int` `a = 2, b = 3, c = 5, n = 100;`` ` `        ``Console.WriteLine(findNthTerm(a, b, c, n));``    ``}``}`` ` `// This code is contributed by PrinciRaj1992`
Output:
```136
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up