GFG App
Open App
Browser
Continue

Find the largest co-prime fraction less than the given fraction

Consider the set of irreducible fractions A = {n/d | n≤d and d ≤ 10000 and gcd(n, d) = 1}. You are given a member of this set and your task is to find the largest fraction in this set less than the given fraction.

Note: This is a set and all the members are unique.

Examples:

Input: n = 1, d = 4
Output: {2499, 9997}
Explanation: 2499/9997 is the largest fraction.

Input: n = 2, d = 4
Output: {4999, 9999}
Explanation: 4999/9999 is the largest fraction.

Approach: The solution to the problem is based on the following mathematical concept:

Say the desired fraction is p/q. So,

p/q < n/d
p < (n*q)/d
As we want p/q to be smaller than n/d, start to iterate over q from q = d+1.
Then for each value of q, the value of p will be floor((n*q)/d).

Follow the below steps to implement the above idea:

• Create two variables num and den to store the final answer. Initialize them as num =- 1 and den =1.
• Now, loop i from d+1 to 10000:
• Calculate the value of the fraction with denominator as i using the above observation.
• The numerator will be (n*i)/d [this is integer division here, i.e., it gives the floor value] and denominator = i+1
• If the fraction is greater than num/den, then update num and den accordingly.
• After all the iterations num and den will store the required numerator and denominator.

Below is the implementation of the above approach:

C++

 `// C++ code to implement the approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to find the required fraction ` `vector<``int``> numAndDen(``int` `n, ``int` `d) ` `{ ` `    ``int` `num = -1, den = 1; ` `    ``vector<``int``> ans; ` ` `  `    ``// Loop to find the fraction ` `    ``for` `(``int` `i = d + 1; i <= 10000; i++) { ` `        ``int` `x = (n * i) / d; ` `        ``if` `(1.0 * x / i > 1.0 * num / den ` `            ``and __gcd(x, i) == 1) ` `            ``num = x, den = i; ` `    ``} ` `    ``ans.push_back(num); ` `    ``ans.push_back(den); ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 1, d = 4; ` ` `  `    ``// Function call ` `    ``vector<``int``> ans = numAndDen(n, d); ` `    ``for` `(``auto` `i : ans) ` `        ``cout << i << ``" "``; ` `    ``return` `0; ` `}`

Java

 `// Java code to implement the approach ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG { ` `    ``public` `static` `int` `gcd(``int` `a, ``int` `b) ` `    ``{ ` `        ``if` `(b == ``0``) ` `            ``return` `a; ` `        ``return` `gcd(b, a % b); ` `    ``} ` ` `  `    ``// Function to find the required fraction ` `    ``public` `static` `ArrayList numAndDen(``int` `n, ``int` `d) ` `    ``{ ` `        ``int` `num = -``1``; ` `        ``int` `den = ``1``; ` `        ``ArrayList ans = ``new` `ArrayList(); ` ` `  `        ``// Loop to find the fraction ` `        ``for` `(``int` `i = d + ``1``; i <= ``10000``; i++) { ` `            ``int` `x = (n * i) / d; ` `            ``if` `(``1.0` `* x / i > ``1.0` `* num / den ` `                ``&& gcd(x, i) == ``1``) { ` `                ``num = x; ` `                ``den = i; ` `            ``} ` `        ``} ` `        ``ans.add(num); ` `        ``ans.add(den); ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `n = ``1``, d = ``4``; ` ` `  `        ``// Function call ` `        ``ArrayList ans = numAndDen(n, d); ` `        ``for` `(Integer i : ans) ` `            ``System.out.print(i + ``" "``); ` `    ``} ` `} ` ` `  `// This code is contributed by Rohit Pradhan`

Python3

 `# Python3 code to implement the approach ` ` `  `from` `math ``import` `gcd ` ` `  `# Function to find the required fraction ` `def` `numAndDen(n, d) : ` ` `  `    ``num ``=` `-``1``; den ``=` `1``; ` `    ``ans ``=` `[]; ` ` `  `    ``# Loop to find the fraction ` `    ``for` `i ``in` `range``(d ``+` `1``, ``10001``) : ` `        ``x ``=` `(n ``*` `i) ``/``/` `d; ` `        ``if` `((``1.0` `*` `x ``/` `i) > (``1.0` `*` `num ``/` `den) ``and` `gcd(x, i) ``=``=` `1``) : ` `            ``num ``=` `x; ` `            ``den ``=` `i; ` `             `  `    ``ans.append(num); ` `    ``ans.append(den); ` `     `  `    ``return` `ans; ` ` `  `# Driver code ` `if` `__name__ ``=``=`  `"__main__"` `: ` ` `  `    ``n ``=` `1``; d ``=` `4``; ` ` `  `    ``# Function call ` `    ``ans ``=` `numAndDen(n, d); ` `     `  `    ``for` `i ``in` `ans: ` `        ``print``(i,end``=``" "``); ` ` `  `    ``# This code is contributed by AnkThon`

C#

 `// C# code to implement the approach ` `using` `System; ` `using` `System.Collections; ` `public` `class` `GFG{ ` `  ``static` `int` `gcd(``int` `a, ``int` `b) ` `  ``{ ` `    ``if` `(b == 0) ` `      ``return` `a; ` `    ``return` `gcd(b, a % b); ` `  ``} ` ` `  `  ``// Function to find the required fraction ` `  ``static` `ArrayList numAndDen(``int` `n, ``int` `d) ` `  ``{ ` `    ``int` `num = -1; ` `    ``int` `den = 1; ` `    ``ArrayList ans = ``new` `ArrayList();  ` ` `  `    ``// Loop to find the fraction ` `    ``for` `(``int` `i = d + 1; i <= 10000; i++) { ` `      ``int` `x = (n * i) / d; ` `      ``if` `(1.0 * x / i > 1.0 * num / den ` `          ``&& gcd(x, i) == 1) { ` `        ``num = x; ` `        ``den = i; ` `      ``} ` `    ``} ` `    ``ans.Add(num); ` `    ``ans.Add(den); ` `    ``return` `ans; ` `  ``} ` ` `  `  ``// Driver Code ` `  ``static` `public` `void` `Main (){ ` `    ``int` `n = 1, d = 4; ` ` `  `    ``// Function call ` `    ``ArrayList ans = numAndDen(n, d); ` `    ``foreach``(``var` `i ``in` `ans) ` `      ``Console.Write(i + ``" "``); ` `  ``} ` `} ` ` `  `// This code is contributed by hrithikgarg03188.`

Javascript

 ``

Output

`2499 9997 `

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

My Personal Notes arrow_drop_up