# Kth number from the set of multiples of numbers A, B and C

Given four integers A, B, C and K. Assume that all the multiples of A, B and C are stored in a set in sorted order with no duplicates, now the task is to find the Kth element from that set.

Examples:

Input: A = 1, B = 2, C = 3, K = 4
Output: 4
The required set is {1, 2, 3, 4, 5, …}

Input: A = 2, B = 4, C = 5, K = 5
Output: 8

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

Approach: Binary Search can be used here on K to find the Kth number in the set. Let’s find the Kth number if this was a multiple of A.
Apply Binary search on the multiples of A, starting from 1 to K (as there may be utmost K multiples of A to find the Kth number in the required set).
Now, for a value mid, the required multiple of A will be A * mid (say X). Now the task is to find whether this is the Kth number of the required set. It can be found as shown below:

Find the number of multiples of A less then X say A1
Find the number of multiples of B less than X say B1
Find the number of multiples of C less than X say C1
Find the number of multiples of lcm(A, B) (Divisible by both A and B) less than X say AB1
Find the number of multiples of lcm(B, C) less than X say BC1
Find the number of multiples of lcm(C, A) less than X say CA1
Find the number of multiples of lcm(A, B, C) less than X say ABC1

Now, the count of numbers in the required set less than X will be A1 + B1 + C1 – AB1 – BC1 – CA1 + ABC1 by the principle of Inclusion and Exclusion.
If count = K – 1, then X is the required answer.
If count < K – 1 then that multiple is greater than X implies set start = mid + 1 else set end = mid – 1.

Perform the same steps (if Kth number is not a multiple of A) for B and then for C.
Since the Kth number is bound to be a multiple of either A, B or C, these three Binary Search will definitely return the result.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `#define ll long long int ` `using` `namespace` `std; ` ` `  `// Function to return the ` `// GCD of A and B ` `int` `gcd(``int` `A, ``int` `B) ` `{ ` `    ``if` `(B == 0) ` `        ``return` `A; ` `    ``return` `gcd(B, A % B); ` `} ` ` `  `// Function to return the ` `// LCM of A and B ` `int` `lcm(``int` `A, ``int` `B) ` `{ ` `    ``return` `(A * B) / gcd(A, B); ` `} ` ` `  `// Function to return the Kth element from ` `// the required set if it a multiple of A ` `int` `checkA(``int` `A, ``int` `B, ``int` `C, ``int` `K) ` `{ ` `    ``// Start and End for Binary Search ` `    ``int` `start = 1; ` `    ``int` `end = K; ` ` `  `    ``// If no answer found return -1 ` `    ``int` `ans = -1; ` ` `  `    ``while` `(start <= end) { ` `        ``int` `mid = (start + end) / 2; ` `        ``int` `value = A * mid; ` ` `  `        ``int` `divA = mid - 1; ` `        ``int` `divB = (value % B == 0) ? value / B - 1 ` `                                    ``: value / B; ` `        ``int` `divC = (value % C == 0) ? value / C - 1 ` `                                    ``: value / C; ` `        ``int` `divAB = (value % lcm(A, B) == 0) ` `                        ``? value / lcm(A, B) - 1 ` `                        ``: value / lcm(A, B); ` `        ``int` `divBC = (value % lcm(C, B) == 0) ` `                        ``? value / lcm(C, B) - 1 ` `                        ``: value / lcm(C, B); ` `        ``int` `divAC = (value % lcm(A, C) == 0) ` `                        ``? value / lcm(A, C) - 1 ` `                        ``: value / lcm(A, C); ` `        ``int` `divABC = (value % lcm(A, lcm(B, C)) == 0) ` `                         ``? value / lcm(A, lcm(B, C)) - 1 ` `                         ``: value / lcm(A, lcm(B, C)); ` ` `  `        ``// Inclusion and Exclusion ` `        ``int` `elem = divA + divB + divC - divAC ` `                   ``- divBC - divAB + divABC; ` `        ``if` `(elem == (K - 1)) { ` `            ``ans = value; ` `            ``break``; ` `        ``} ` ` `  `        ``// Multiple should be smaller ` `        ``else` `if` `(elem > (K - 1)) { ` `            ``end = mid - 1; ` `        ``} ` ` `  `        ``// Multiple should be bigger ` `        ``else` `{ ` `            ``start = mid + 1; ` `        ``} ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Function to return the Kth element from ` `// the required set if it a multiple of B ` `int` `checkB(``int` `A, ``int` `B, ``int` `C, ``int` `K) ` `{ ` `    ``// Start and End for Binary Search ` `    ``int` `start = 1; ` `    ``int` `end = K; ` ` `  `    ``// If no answer found return -1 ` `    ``int` `ans = -1; ` ` `  `    ``while` `(start <= end) { ` `        ``int` `mid = (start + end) / 2; ` `        ``int` `value = B * mid; ` ` `  `        ``int` `divB = mid - 1; ` `        ``int` `divA = (value % A == 0) ? value / A - 1 ` `                                    ``: value / A; ` `        ``int` `divC = (value % C == 0) ? value / C - 1 ` `                                    ``: value / C; ` `        ``int` `divAB = (value % lcm(A, B) == 0) ` `                        ``? value / lcm(A, B) - 1 ` `                        ``: value / lcm(A, B); ` `        ``int` `divBC = (value % lcm(C, B) == 0) ` `                        ``? value / lcm(C, B) - 1 ` `                        ``: value / lcm(C, B); ` `        ``int` `divAC = (value % lcm(A, C) == 0) ` `                        ``? value / lcm(A, C) - 1 ` `                        ``: value / lcm(A, C); ` `        ``int` `divABC = (value % lcm(A, lcm(B, C)) == 0) ` `                         ``? value / lcm(A, lcm(B, C)) - 1 ` `                         ``: value / lcm(A, lcm(B, C)); ` ` `  `        ``// Inclusion and Exclusion ` `        ``int` `elem = divA + divB + divC - divAC ` `                   ``- divBC - divAB + divABC; ` `        ``if` `(elem == (K - 1)) { ` `            ``ans = value; ` `            ``break``; ` `        ``} ` ` `  `        ``// Multiple should be smaller ` `        ``else` `if` `(elem > (K - 1)) { ` `            ``end = mid - 1; ` `        ``} ` ` `  `        ``// Multiple should be bigger ` `        ``else` `{ ` `            ``start = mid + 1; ` `        ``} ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Function to return the Kth element from ` `// the required set if it a multiple of C ` `int` `checkC(``int` `A, ``int` `B, ``int` `C, ``int` `K) ` `{ ` `    ``// Start and End for Binary Search ` `    ``int` `start = 1; ` `    ``int` `end = K; ` ` `  `    ``// If no answer found return -1 ` `    ``int` `ans = -1; ` ` `  `    ``while` `(start <= end) { ` `        ``int` `mid = (start + end) / 2; ` `        ``int` `value = C * mid; ` ` `  `        ``int` `divC = mid - 1; ` `        ``int` `divB = (value % B == 0) ? value / B - 1 ` `                                    ``: value / B; ` `        ``int` `divA = (value % A == 0) ? value / A - 1 ` `                                    ``: value / A; ` `        ``int` `divAB = (value % lcm(A, B) == 0) ` `                        ``? value / lcm(A, B) - 1 ` `                        ``: value / lcm(A, B); ` `        ``int` `divBC = (value % lcm(C, B) == 0) ` `                        ``? value / lcm(C, B) - 1 ` `                        ``: value / lcm(C, B); ` `        ``int` `divAC = (value % lcm(A, C) == 0) ` `                        ``? value / lcm(A, C) - 1 ` `                        ``: value / lcm(A, C); ` `        ``int` `divABC = (value % lcm(A, lcm(B, C)) == 0) ` `                         ``? value / lcm(A, lcm(B, C)) - 1 ` `                         ``: value / lcm(A, lcm(B, C)); ` ` `  `        ``// Inclusion and Exclusion ` `        ``int` `elem = divA + divB + divC - divAC ` `                   ``- divBC - divAB + divABC; ` `        ``if` `(elem == (K - 1)) { ` `            ``ans = value; ` `            ``break``; ` `        ``} ` ` `  `        ``// Multiple should be smaller ` `        ``else` `if` `(elem > (K - 1)) { ` `            ``end = mid - 1; ` `        ``} ` ` `  `        ``// Multiple should be bigger ` `        ``else` `{ ` `            ``start = mid + 1; ` `        ``} ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Function to return the Kth element from ` `// the set of multiples of A, B and C ` `int` `findKthMultiple(``int` `A, ``int` `B, ``int` `C, ``int` `K) ` `{ ` ` `  `    ``// Apply binary search on the multiples of A ` `    ``int` `res = checkA(A, B, C, K); ` ` `  `    ``// If the required element is not a ` `    ``// multiple of A then the multiples ` `    ``// of B and C need to be checked ` `    ``if` `(res == -1) ` `        ``res = checkB(A, B, C, K); ` ` `  `    ``// If the required element is neither ` `    ``// a multiple of A nor a multiple ` `    ``// of B then the multiples of C ` `    ``// need to be checked ` `    ``if` `(res == -1) ` `        ``res = checkC(A, B, C, K); ` ` `  `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A = 2, B = 4, C = 5, K = 5; ` ` `  `    ``cout << findKthMultiple(A, B, C, K); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach  ` `class` `GFG  ` `{ ` `     `  `    ``// Function to return the  ` `    ``// GCD of A and B  ` `    ``static` `int` `gcd(``int` `A, ``int` `B)  ` `    ``{  ` `        ``if` `(B == ``0``)  ` `            ``return` `A;  ` `        ``return` `gcd(B, A % B);  ` `    ``}  ` `     `  `    ``// Function to return the  ` `    ``// LCM of A and B  ` `    ``static` `int` `lcm(``int` `A, ``int` `B)  ` `    ``{  ` `        ``return` `(A * B) / gcd(A, B);  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the required set if it a multiple of A  ` `    ``static` `int` `checkA(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `        ``// Start and End for Binary Search  ` `        ``int` `start = ``1``;  ` `        ``int` `end = K;  ` `     `  `        ``// If no answer found return -1  ` `        ``int` `ans = -``1``;  ` `     `  `        ``while` `(start <= end)  ` `        ``{  ` `            ``int` `mid = (start + end) / ``2``;  ` `            ``int` `value = A * mid;  ` `     `  `            ``int` `divA = mid - ``1``;  ` `            ``int` `divB = (value % B == ``0``) ? value / B - ``1` `                                        ``: value / B;  ` `            ``int` `divC = (value % C == ``0``) ? value / C - ``1` `                                        ``: value / C;  ` `            ``int` `divAB = (value % lcm(A, B) == ``0``) ?  ` `                           ``value / lcm(A, B) - ``1` `:  ` `                           ``value / lcm(A, B);  ` `            ``int` `divBC = (value % lcm(C, B) == ``0``) ?  ` `                           ``value / lcm(C, B) - ``1` `:  ` `                           ``value / lcm(C, B);  ` `            ``int` `divAC = (value % lcm(A, C) == ``0``) ?  ` `                           ``value / lcm(A, C) - ``1` `:  ` `                           ``value / lcm(A, C);  ` `            ``int` `divABC = (value % lcm(A, lcm(B, C)) == ``0``) ?  ` `                            ``value / lcm(A, lcm(B, C)) - ``1` `: ` `                            ``value / lcm(A, lcm(B, C));  ` `     `  `            ``// Inclusion and Exclusion  ` `            ``int` `elem = divA + divB + divC - divAC -  ` `                              ``divBC - divAB + divABC;  ` `            ``if` `(elem == (K - ``1``))  ` `            ``{  ` `                ``ans = value;  ` `                ``break``;  ` `            ``}  ` `     `  `            ``// Multiple should be smaller  ` `            ``else` `if` `(elem > (K - ``1``)) ` `            ``{  ` `                ``end = mid - ``1``;  ` `            ``}  ` `     `  `            ``// Multiple should be bigger  ` `            ``else`  `            ``{  ` `                ``start = mid + ``1``;  ` `            ``}  ` `        ``}  ` `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the required set if it a multiple of B  ` `    ``static` `int` `checkB(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `        ``// Start and End for Binary Search  ` `        ``int` `start = ``1``;  ` `        ``int` `end = K;  ` `     `  `        ``// If no answer found return -1  ` `        ``int` `ans = -``1``;  ` `     `  `        ``while` `(start <= end)  ` `        ``{  ` `            ``int` `mid = (start + end) / ``2``;  ` `            ``int` `value = B * mid;  ` `     `  `            ``int` `divB = mid - ``1``;  ` `            ``int` `divA = (value % A == ``0``) ? value / A - ``1` `                                        ``: value / A;  ` `            ``int` `divC = (value % C == ``0``) ? value / C - ``1` `                                        ``: value / C;  ` `            ``int` `divAB = (value % lcm(A, B) == ``0``) ?  ` `                           ``value / lcm(A, B) - ``1` `: ` `                           ``value / lcm(A, B);  ` `            ``int` `divBC = (value % lcm(C, B) == ``0``) ?  ` `                           ``value / lcm(C, B) - ``1` `:  ` `                           ``value / lcm(C, B);  ` `            ``int` `divAC = (value % lcm(A, C) == ``0``) ?  ` `                           ``value / lcm(A, C) - ``1` `:  ` `                           ``value / lcm(A, C);  ` `            ``int` `divABC = (value % lcm(A, lcm(B, C)) == ``0``) ?  ` `                            ``value / lcm(A, lcm(B, C)) - ``1` `:  ` `                            ``value / lcm(A, lcm(B, C));  ` `     `  `            ``// Inclusion and Exclusion  ` `            ``int` `elem = divA + divB + divC - divAC  ` `                    ``- divBC - divAB + divABC;  ` `            ``if` `(elem == (K - ``1``)) ` `            ``{  ` `                ``ans = value;  ` `                ``break``;  ` `            ``}  ` `     `  `            ``// Multiple should be smaller  ` `            ``else` `if` `(elem > (K - ``1``)) ` `            ``{  ` `                ``end = mid - ``1``;  ` `            ``}  ` `     `  `            ``// Multiple should be bigger  ` `            ``else`  `            ``{  ` `                ``start = mid + ``1``;  ` `            ``}  ` `        ``}  ` `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the required set if it a multiple of C  ` `    ``static` `int` `checkC(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `        ``// Start and End for Binary Search  ` `        ``int` `start = ``1``;  ` `        ``int` `end = K;  ` `     `  `        ``// If no answer found return -1  ` `        ``int` `ans = -``1``;  ` `     `  `        ``while` `(start <= end)  ` `        ``{  ` `            ``int` `mid = (start + end) / ``2``;  ` `            ``int` `value = C * mid;  ` `     `  `            ``int` `divC = mid - ``1``;  ` `            ``int` `divB = (value % B == ``0``) ? value / B - ``1` `                                        ``: value / B;  ` `            ``int` `divA = (value % A == ``0``) ? value / A - ``1` `                                        ``: value / A;  ` `            ``int` `divAB = (value % lcm(A, B) == ``0``) ?  ` `                           ``value / lcm(A, B) - ``1` `:  ` `                           ``value / lcm(A, B);  ` `            ``int` `divBC = (value % lcm(C, B) == ``0``) ?  ` `                           ``value / lcm(C, B) - ``1` `:  ` `                           ``value / lcm(C, B);  ` `            ``int` `divAC = (value % lcm(A, C) == ``0``) ?  ` `                           ``value / lcm(A, C) - ``1` `:  ` `                           ``value / lcm(A, C);  ` `            ``int` `divABC = (value % lcm(A, lcm(B, C)) == ``0``) ?  ` `                            ``value / lcm(A, lcm(B, C)) - ``1` `:  ` `                            ``value / lcm(A, lcm(B, C));  ` `     `  `            ``// Inclusion and Exclusion  ` `            ``int` `elem = divA + divB + divC - divAC -  ` `                       ``divBC - divAB + divABC;  ` `            ``if` `(elem == (K - ``1``))  ` `            ``{  ` `                ``ans = value;  ` `                ``break``;  ` `            ``}  ` `     `  `            ``// Multiple should be smaller  ` `            ``else` `if` `(elem > (K - ``1``)) ` `            ``{  ` `                ``end = mid - ``1``;  ` `            ``}  ` `     `  `            ``// Multiple should be bigger  ` `            ``else` `            ``{  ` `                ``start = mid + ``1``;  ` `            ``}  ` `        ``}  ` `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the set of multiples of A, B and C  ` `    ``static` `int` `findKthMultiple(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `     `  `        ``// Apply binary search on the multiples of A  ` `        ``int` `res = checkA(A, B, C, K);  ` `     `  `        ``// If the required element is not a  ` `        ``// multiple of A then the multiples  ` `        ``// of B and C need to be checked  ` `        ``if` `(res == -``1``)  ` `            ``res = checkB(A, B, C, K);  ` `     `  `        ``// If the required element is neither  ` `        ``// a multiple of A nor a multiple  ` `        ``// of B then the multiples of C  ` `        ``// need to be checked  ` `        ``if` `(res == -``1``)  ` `            ``res = checkC(A, B, C, K);  ` `     `  `        ``return` `res;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String args[]) ` `    ``{  ` `        ``int` `A = ``2``, B = ``4``, C = ``5``, K = ``5``;  ` `     `  `        ``System.out.println(findKthMultiple(A, B, C, K));  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to return the GCD of A and B ` `def` `gcd(A, B): ` `    ``if` `(B ``=``=` `0``): ` `        ``return` `A ` `    ``return` `gcd(B, A ``%` `B) ` ` `  `# Function to return the ` `# LCM of A and B ` `def` `lcm(A, B): ` `    ``return` `(A ``*` `B) ``/``/` `gcd(A, B) ` ` `  `# Function to return the Kth element from ` `# the required set if it a multiple of A ` `def` `checkA(A, B, C, K): ` `     `  `    ``# Start and End for Binary Search ` `    ``start ``=` `1` `    ``end ``=` `K ` ` `  `    ``# If no answer found return -1 ` `    ``ans ``=` `-``1` ` `  `    ``while` `(start <``=` `end): ` `        ``mid ``=` `(start ``+` `end) ``/``/` `2` `        ``value ``=` `A ``*` `mid ` ` `  `        ``divA ``=` `mid ``-` `1` ` `  `        ``divB ``=` `value ``/``/` `B ``-` `1` `if` `(value ``%` `B ``=``=` `0``) \ ` `                              ``else` `value ``/``/` `B ` ` `  `        ``divC ``=` `value ``/``/` `C ``-` `1` `if` `(value ``%` `C ``=``=` `0``) \ ` `                              ``else` `value ``/``/` `C ` ` `  `        ``divAB ``=` `value ``/``/` `lcm(A, B) ``-` `1` `\ ` `        ``if` `(value ``%` `lcm(A, B) ``=``=` `0``) \ ` `        ``else` `value ``/``/` `lcm(A, B) ` ` `  `        ``divBC ``=` `value ``/``/` `lcm(C, B) ``-` `1` `\ ` `        ``if` `(value ``%` `lcm(C, B) ``=``=` `0``) \ ` `        ``else` `value ``/``/` `lcm(C, B) ` ` `  `        ``divAC ``=` `value ``/``/` `lcm(A, C) ``-` `1` `\ ` `        ``if` `(value ``%` `lcm(A, C) ``=``=` `0``) \ ` `        ``else` `value ``/``/` `lcm(A, C) ` ` `  `        ``divABC ``=` `value ``/``/` `lcm(A, lcm(B, C)) ``-` `1` `\ ` `        ``if` `(value ``%` `lcm(A, lcm(B, C)) ``=``=` `0``) \ ` `        ``else` `value ``/``/` `lcm(A, lcm(B, C)) ` ` `  `        ``# Inclusion and Exclusion ` `        ``elem ``=` `divA ``+` `divB ``+` `divC ``-` `\ ` `               ``divAC ``-` `divBC ``-` `divAB ``+` `divABC ` `        ``if` `(elem ``=``=` `(K ``-` `1``)): ` `            ``ans ``=` `value ` `            ``break` ` `  `        ``# Multiple should be smaller ` `        ``elif` `(elem > (K ``-` `1``)): ` `            ``end ``=` `mid ``-` `1` ` `  `        ``# Multiple should be bigger ` `        ``else` `: ` `            ``start ``=` `mid ``+` `1` ` `  `    ``return` `ans ` ` `  `# Function to return the Kth element from ` `# the required set if it a multiple of B ` `def` `checkB(A, B, C, K): ` `     `  `    ``# Start and End for Binary Search ` `    ``start ``=` `1` `    ``end ``=` `K ` ` `  `    ``# If no answer found return -1 ` `    ``ans ``=` `-``1` ` `  `    ``while` `(start <``=` `end): ` `        ``mid ``=` `(start ``+` `end) ``/``/` `2` `        ``value ``=` `B ``*` `mid ` ` `  `        ``divB ``=` `mid ``-` `1` ` `  `        ``if` `(value ``%` `A ``=``=` `0``): ` `            ``divA ``=` `value ``/``/` `A ``-` `1`  `        ``else``: value ``/``/` `A ` ` `  `        ``if` `(value ``%` `C ``=``=` `0``): ` `            ``divC ``=` `value ``/``/` `C ``-` `1`  `        ``else``: value ``/``/` `C ` ` `  `        ``if` `(value ``%` `lcm(A, B) ``=``=` `0``):  ` `            ``divAB ``=` `value ``/``/` `lcm(A, B) ``-``1`  `        ``else``: value ``/``/` `lcm(A, B) ` ` `  `        ``if` `(value ``%` `lcm(C, B) ``=``=` `0``): ` `            ``divBC ``=` `value ``/``/` `lcm(C, B) ``-``1`  `        ``else``: value ``/``/` `lcm(C, B) ` ` `  `        ``if` `(value ``%` `lcm(A, C) ``=``=` `0``): ` `            ``divAC ``=` `value ``/``/` `lcm(A, C) ``-``1`  `        ``else``: value ``/``/` `lcm(A, C) ` ` `  `        ``if` `(value ``%` `lcm(A, lcm(B, C)) ``=``=` `0``): ` `            ``divABC ``=` `value ``/``/` `lcm(A, lcm(B, C)) ``-` `1`  `        ``else``: value ``/``/` `lcm(A, lcm(B, C)) ` ` `  `        ``# Inclusion and Exclusion ` `        ``elem ``=` `divA ``+` `divB ``+` `divC ``-` `\ ` `               ``divAC ``-` `divBC ``-` `divAB ``+` `divABC ` `        ``if` `(elem ``=``=` `(K ``-` `1``)): ` `            ``ans ``=` `value ` `            ``break` ` `  `        ``# Multiple should be smaller ` `        ``elif` `(elem > (K ``-` `1``)): ` `            ``end ``=` `mid ``-` `1` ` `  `        ``# Multiple should be bigger ` `        ``else` `: ` `            ``start ``=` `mid ``+` `1` ` `  `    ``return` `ans ` ` `  `# Function to return the Kth element from ` `# the required set if it a multiple of C ` `def` `checkC(A, B, C, K): ` `     `  `    ``# Start and End for Binary Search ` `    ``start ``=` `1` `    ``end ``=` `K ` ` `  `    ``# If no answer found return -1 ` `    ``ans ``=` `-``1` ` `  `    ``while` `(start <``=` `end): ` `        ``mid ``=` `(start ``+` `end) ``/``/` `2` `        ``value ``=` `C ``*` `mid ` ` `  `        ``divC ``=` `mid ``-` `1` ` `  `        ``if` `(value ``%` `B ``=``=` `0``): ` `            ``divB ``=` `value ``/``/` `B ``-` `1`   `        ``else``: value ``/``/` `B ` ` `  `        ``if` `(value ``%` `A ``=``=` `0``): ` `            ``divA ``=` `value ``/``/` `A ``-` `1`   `        ``else``: value ``/``/` `A ` ` `  `        ``if` `(value ``%` `lcm(A, B) ``=``=` `0``):  ` `            ``divAB ``=` `value ``/``/` `lcm(A, B) ``-``1`  `        ``else``: value ``/``/` `lcm(A, B) ` ` `  `        ``if` `(value ``%` `lcm(C, B) ``=``=` `0``): ` `            ``divBC ``=` `value ``/``/` `lcm(C, B) ``-``1`  `        ``else``: value ``/``/` `lcm(C, B) ` ` `  `        ``if` `(value ``%` `lcm(A, C) ``=``=` `0``): ` `            ``divAC ``=` `value ``/``/` `lcm(A, C) ``-``1`   `        ``else``: value ``/``/` `lcm(A, C) ` ` `  `        ``if` `(value ``%` `lcm(A, lcm(B, C)) ``=``=` `0``): ` `            ``divABC ``=` `value ``/``/` `lcm(A, lcm(B, C)) ``-` `1`  `        ``else``: value ``/``/` `lcm(A, lcm(B, C)) ` ` `  `        ``# Inclusion and Exclusion ` `        ``elem ``=` `divA ``+` `divB ``+` `divC ``-` `\ ` `               ``divAC ``-` `divBC ``-` `divAB ``+` `divABC ` `        ``if` `(elem ``=``=` `(K ``-` `1``)): ` `            ``ans ``=` `value ` `            ``break` ` `  `        ``# Multiple should be smaller ` `        ``elif` `(elem > (K ``-` `1``)): ` `            ``end ``=` `mid ``-` `1` ` `  `        ``# Multiple should be bigger ` `        ``else` `: ` `            ``start ``=` `mid ``+` `1` ` `  `    ``return` `ans ` ` `  `# Function to return the Kth element from ` `# the set of multiples of A, B and C ` `def` `findKthMultiple(A, B, C, K): ` ` `  `    ``# Apply binary search on the multiples of A ` `    ``res ``=` `checkA(A, B, C, K) ` ` `  `    ``# If the required element is not a ` `    ``# multiple of A then the multiples ` `    ``# of B and C need to be checked ` `    ``if` `(res ``=``=` `-``1``): ` `        ``res ``=` `checkB(A, B, C, K) ` ` `  `    ``# If the required element is neither ` `    ``# a multiple of A nor a multiple ` `    ``# of B then the multiples of C ` `    ``# need to be checked ` `    ``if` `(res ``=``=` `-``1``): ` `        ``res ``=` `checkC(A, B, C, K) ` ` `  `    ``return` `res ` ` `  `# Driver code ` `A ``=` `2` `B ``=` `4` `C ``=` `5` `K ``=` `5` ` `  `print``(findKthMultiple(A, B, C, K)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# implementation of the above approach  ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `     `  `    ``// Function to return the  ` `    ``// GCD of A and B  ` `    ``static` `int` `gcd(``int` `A, ``int` `B)  ` `    ``{  ` `        ``if` `(B == 0)  ` `            ``return` `A;  ` `        ``return` `gcd(B, A % B);  ` `    ``}  ` `     `  `    ``// Function to return the  ` `    ``// LCM of A and B  ` `    ``static` `int` `lcm(``int` `A, ``int` `B)  ` `    ``{  ` `        ``return` `(A * B) / gcd(A, B);  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the required set if it a multiple of A  ` `    ``static` `int` `checkA(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `        ``// Start and End for Binary Search  ` `        ``int` `start = 1;  ` `        ``int` `end = K;  ` `     `  `        ``// If no answer found return -1  ` `        ``int` `ans = -1;  ` `     `  `        ``while` `(start <= end)  ` `        ``{  ` `            ``int` `mid = (start + end) / 2;  ` `            ``int` `value = A * mid;  ` `     `  `            ``int` `divA = mid - 1;  ` `            ``int` `divB = (value % B == 0) ? value / B - 1 ` `                                        ``: value / B;  ` `            ``int` `divC = (value % C == 0) ? value / C - 1 ` `                                        ``: value / C;  ` `            ``int` `divAB = (value % lcm(A, B) == 0) ?  ` `                           ``value / lcm(A, B) - 1 :  ` `                           ``value / lcm(A, B);  ` `            ``int` `divBC = (value % lcm(C, B) == 0) ?  ` `                           ``value / lcm(C, B) - 1 :  ` `                           ``value / lcm(C, B);  ` `            ``int` `divAC = (value % lcm(A, C) == 0) ?  ` `                        ``value / lcm(A, C) - 1 :  ` `                        ``value / lcm(A, C);  ` `            ``int` `divABC = (value % lcm(A, lcm(B, C)) == 0) ?  ` `                            ``value / lcm(A, lcm(B, C)) - 1 : ` `                            ``value / lcm(A, lcm(B, C));  ` `     `  `            ``// Inclusion and Exclusion  ` `            ``int` `elem = divA + divB + divC - divAC -  ` `                              ``divBC - divAB + divABC;  ` `            ``if` `(elem == (K - 1))  ` `            ``{  ` `                ``ans = value;  ` `                ``break``;  ` `            ``}  ` `     `  `            ``// Multiple should be smaller  ` `            ``else` `if` `(elem > (K - 1)) ` `            ``{  ` `                ``end = mid - 1;  ` `            ``}  ` `     `  `            ``// Multiple should be bigger  ` `            ``else` `            ``{  ` `                ``start = mid + 1;  ` `            ``}  ` `        ``}  ` `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the required set if it a multiple of B  ` `    ``static` `int` `checkB(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `        ``// Start and End for Binary Search  ` `        ``int` `start = 1;  ` `        ``int` `end = K;  ` `     `  `        ``// If no answer found return -1  ` `        ``int` `ans = -1;  ` `     `  `        ``while` `(start <= end)  ` `        ``{  ` `            ``int` `mid = (start + end) / 2;  ` `            ``int` `value = B * mid;  ` `     `  `            ``int` `divB = mid - 1;  ` `            ``int` `divA = (value % A == 0) ? value / A - 1 ` `                                        ``: value / A;  ` `            ``int` `divC = (value % C == 0) ? value / C - 1 ` `                                        ``: value / C;  ` `            ``int` `divAB = (value % lcm(A, B) == 0) ?  ` `                           ``value / lcm(A, B) - 1 : ` `                           ``value / lcm(A, B);  ` `            ``int` `divBC = (value % lcm(C, B) == 0) ?  ` `                           ``value / lcm(C, B) - 1 :  ` `                           ``value / lcm(C, B);  ` `            ``int` `divAC = (value % lcm(A, C) == 0) ?  ` `                           ``value / lcm(A, C) - 1 :  ` `                           ``value / lcm(A, C);  ` `            ``int` `divABC = (value % lcm(A, lcm(B, C)) == 0) ?  ` `                            ``value / lcm(A, lcm(B, C)) - 1 :  ` `                            ``value / lcm(A, lcm(B, C));  ` `     `  `            ``// Inclusion and Exclusion  ` `            ``int` `elem = divA + divB + divC - divAC -  ` `                       ``divBC - divAB + divABC;  ` `            ``if` `(elem == (K - 1)) ` `            ``{  ` `                ``ans = value;  ` `                ``break``;  ` `            ``}  ` `     `  `            ``// Multiple should be smaller  ` `            ``else` `if` `(elem > (K - 1)) ` `            ``{  ` `                ``end = mid - 1;  ` `            ``}  ` `     `  `            ``// Multiple should be bigger  ` `            ``else` `            ``{  ` `                ``start = mid + 1;  ` `            ``}  ` `        ``}  ` `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the required set if it a multiple of C  ` `    ``static` `int` `checkC(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `        ``// Start and End for Binary Search  ` `        ``int` `start = 1;  ` `        ``int` `end = K;  ` `     `  `        ``// If no answer found return -1  ` `        ``int` `ans = -1;  ` `     `  `        ``while` `(start <= end)  ` `        ``{  ` `            ``int` `mid = (start + end) / 2;  ` `            ``int` `value = C * mid;  ` `     `  `            ``int` `divC = mid - 1;  ` `            ``int` `divB = (value % B == 0) ? value / B - 1 ` `                                        ``: value / B;  ` `            ``int` `divA = (value % A == 0) ? value / A - 1 ` `                                        ``: value / A;  ` `            ``int` `divAB = (value % lcm(A, B) == 0) ?  ` `                           ``value / lcm(A, B) - 1 :  ` `                           ``value / lcm(A, B);  ` `            ``int` `divBC = (value % lcm(C, B) == 0) ?  ` `                           ``value / lcm(C, B) - 1 :  ` `                           ``value / lcm(C, B);  ` `            ``int` `divAC = (value % lcm(A, C) == 0) ?  ` `                           ``value / lcm(A, C) - 1 :  ` `                           ``value / lcm(A, C);  ` `            ``int` `divABC = (value % lcm(A, lcm(B, C)) == 0) ?  ` `                            ``value / lcm(A, lcm(B, C)) - 1 :  ` `                            ``value / lcm(A, lcm(B, C));  ` `     `  `            ``// Inclusion and Exclusion  ` `            ``int` `elem = divA + divB + divC - divAC -  ` `                       ``divBC - divAB + divABC;  ` `            ``if` `(elem == (K - 1))  ` `            ``{  ` `                ``ans = value;  ` `                ``break``;  ` `            ``}  ` `     `  `            ``// Multiple should be smaller  ` `            ``else` `if` `(elem > (K - 1)) ` `            ``{  ` `                ``end = mid - 1;  ` `            ``}  ` `     `  `            ``// Multiple should be bigger  ` `            ``else` `            ``{  ` `                ``start = mid + 1;  ` `            ``}  ` `        ``}  ` `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Function to return the Kth element from  ` `    ``// the set of multiples of A, B and C  ` `    ``static` `int` `findKthMultiple(``int` `A, ``int` `B, ``int` `C, ``int` `K)  ` `    ``{  ` `     `  `        ``// Apply binary search on the multiples of A  ` `        ``int` `res = checkA(A, B, C, K);  ` `     `  `        ``// If the required element is not a  ` `        ``// multiple of A then the multiples  ` `        ``// of B and C need to be checked  ` `        ``if` `(res == -1)  ` `            ``res = checkB(A, B, C, K);  ` `     `  `        ``// If the required element is neither  ` `        ``// a multiple of A nor a multiple  ` `        ``// of B then the multiples of C  ` `        ``// need to be checked  ` `        ``if` `(res == -1)  ` `            ``res = checkC(A, B, C, K);  ` `     `  `        ``return` `res;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String []args) ` `    ``{  ` `        ``int` `A = 2, B = 4, C = 5, K = 5;  ` `     `  `        ``Console.WriteLine(findKthMultiple(A, B, C, K));  ` `    ``}  ` `} ` ` `  `// This code is contributed by Arnab Kundu `

Output:

```8
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.