# Binary Search for Rational Numbers without using floating point arithmetic

• Difficulty Level : Medium
• Last Updated : 21 Jul, 2022

A rational is represented as p/qb, for example 2/3. Given a sorted array of rational numbers, how to search an element using Binary Search. Use of floating-point arithmetic is not allowed.

Example:

```Input:  arr[] = {1/5, 2/3, 3/2, 13/2}
x = 3/2
Output: Found at index 2```

We strongly recommend you to minimize your browser and try this yourself first.
To compare two rational numbers p/q and r/s, we can compare p*s with q*r.

## C++

 `// C++ program for Binary Search for ` `// Rational Numbers without using` `// floating point arithmetic` `#include ` `using` `namespace` `std;`   `struct` `Rational` `{` `    ``int` `p;` `    ``int` `q;` `};`   `// Utility function to compare two ` `// Rational numbers 'a' and 'b'.` `// It returns` `// 0 --> When 'a' and 'b' are same` `// 1 --> When 'a' is greater` `//-1 --> When 'b' is greater` `int` `compare(``struct` `Rational a, ``struct` `Rational b)` `{` `    `  `    ``// If a/b == c/d then a*d = b*c:` `    ``// method to ignore division` `    ``if` `(a.p * b.q == a.q * b.p)` `        ``return` `0;` `    ``if` `(a.p * b.q > a.q * b.p)` `        ``return` `1;` `        `  `    ``return` `-1;` `}`   `// Returns index of x in arr[l..r] if ` `// it is present, else returns -1. It` `// mainly uses Binary Search.` `int` `binarySearch(``struct` `Rational arr[], ``int` `l, ``int` `r,` `                 ``struct` `Rational x)` `{` `    ``if` `(r >= l)` `    ``{` `        ``int` `mid = l + (r - l) / 2;` `        `  `        ``// If the element is present at the middle itself` `        ``if` `(compare(arr[mid], x) == 0) ` `            ``return` `mid;` `        `  `        ``// If element is smaller than mid, then it can` `        ``// only be present in left subarray` `        ``if` `(compare(arr[mid], x) > 0)` `            ``return` `binarySearch(arr, l, mid - 1, x);` `        `  `        ``// Else the element can only be present in right` `        ``// subarray` `        ``return` `binarySearch(arr, mid + 1, r, x);` `    ``}` `    ``return` `-1;` `}`   `// Driver code` `int` `main()` `{` `    ``struct` `Rational arr[] = { { 1, 5 }, { 2, 3 }, ` `                              ``{ 3, 2 }, { 13, 2 } };` `    ``struct` `Rational x = { 3, 2 };` `    `  `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    `  `    ``cout << ``"Element found at index "` `         ``<< binarySearch(arr, 0, n - 1, x);` `}`   `// This code is contributed by shivanisinghss2110`

## C

 `// C program for Binary Search for Rational Numbers` `// without using floating point arithmetic` `#include `   `struct` `Rational` `{` `    ``int` `p;` `    ``int` `q;` `};`   `// Utility function to compare two Rational numbers` `// 'a' and 'b'. It returns` `// 0 --> When 'a' and 'b' are same` `// 1 --> When 'a' is greater` `//-1 --> When 'b' is greater` `int` `compare(``struct` `Rational a, ``struct` `Rational b)` `{` `    ``// If a/b == c/d  then  a*d = b*c:` `    ``// method to ignore division` `    ``if` `(a.p * b.q == a.q * b.p)` `        ``return` `0;` `    ``if` `(a.p * b.q > a.q * b.p)` `        ``return` `1;` `    ``return` `-1;` `}`   `// Returns index of x in arr[l..r] if it is present, else` `// returns -1. It mainly uses Binary Search.` `int` `binarySearch(``struct` `Rational arr[], ``int` `l, ``int` `r,` `                 ``struct` `Rational x)` `{` `   ``if` `(r >= l)` `   ``{` `        ``int` `mid = l + (r - l)/2;`   `        ``// If the element is present at the middle itself` `        ``if` `(compare(arr[mid], x) == 0)  ``return` `mid;`   `        ``// If element is smaller than mid, then it can` `        ``// only be present in left subarray` `        ``if` `(compare(arr[mid], x) > 0)` `            ``return` `binarySearch(arr, l, mid-1, x);`   `        ``// Else the element can only be present in right` `        ``// subarray` `        ``return` `binarySearch(arr, mid+1, r, x);` `   ``}`   `   ``return` `-1;` `}`   `// Driver method` `int` `main()` `{` `    ``struct` `Rational arr[] = {{1, 5}, {2, 3}, {3, 2}, {13, 2}};` `    ``struct` `Rational x = {3, 2};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);` `    ``printf``(``"Element found at index %d"``,` `            ``binarySearch(arr, 0, n-1, x));` `}`

## Java

 `// Java program for Binary Search for Rational Numbers` `// without using floating point arithmetic` `class` `GFG` `{`   `static` `class` `Rational` `{` `    ``int` `p;` `    ``int` `q;`   `    ``public` `Rational(``int` `p, ``int` `q)` `    ``{` `        ``this``.p = p;` `        ``this``.q = q;` `    ``}` `    `  `};`   `// Utility function to compare two Rational numbers` `// 'a' and 'b'. It returns` `// 0 -. When 'a' and 'b' are same` `// 1 -. When 'a' is greater` `//-1 -. When 'b' is greater` `static` `int` `compare(Rational a, Rational b)` `{` `    ``// If a/b == c/d then a*d = b*c:` `    ``// method to ignore division` `    ``if` `(a.p * b.q == a.q * b.p)` `        ``return` `0``;` `    ``if` `(a.p * b.q > a.q * b.p)` `        ``return` `1``;` `    ``return` `-``1``;` `}`   `// Returns index of x in arr[l..r] if it is present, else` `// returns -1. It mainly uses Binary Search.` `static` `int` `binarySearch(Rational arr[], ``int` `l, ``int` `r,` `                ``Rational x)` `{` `    `  `    ``if` `(r >= l)` `    ``{` `        ``int` `mid = l + (r - l)/``2``;`   `        ``// If the element is present at the middle itself` `        ``if` `(compare(arr[mid], x) == ``0``) ``return` `mid;`   `        ``// If element is smaller than mid, then it can` `        ``// only be present in left subarray` `        ``if` `(compare(arr[mid], x) > ``0``)` `            ``return` `binarySearch(arr, l, mid - ``1``, x);`   `        ``// Else the element can only be present in right` `        ``// subarray` `        ``return` `binarySearch(arr, mid + ``1``, r, x);` `    ``}`   `return` `-``1``;` `}`   `// Driver method` `public` `static` `void` `main(String[] args)` `{` `    ``Rational arr[] = {``new` `Rational(``1``, ``5``), ` `                        ``new` `Rational(``2``, ``3``), ` `                        ``new` `Rational(``3``, ``2``), ` `                        ``new` `Rational(``13``, ``2``)};` `    ``Rational x = ``new` `Rational(``3``, ``2``);` `    ``int` `n = arr.length;` `    ``System.out.printf(``"Element found at index %d"``,` `            ``binarySearch(arr, ``0``, n - ``1``, x));` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for Binary Search ` `# for Rational Numbers without ` `# using floating point arithmetic` `class` `Rational:` `    `  `    ``def` `__init__(``self``, a ``=` `0``, b ``=` `0``):` `        `  `        ``self``.p ``=` `a` `        ``self``.q ``=` `b`   `# Utility function to compare two ` `# Rational numbers 'a' and 'b'.` `# It returns` `# 0 --> When 'a' and 'b' are same` `# 1 --> When 'a' is greater` `#-1 --> When 'b' is greater` `def` `compare(a: Rational, b: Rational) ``-``> ``int``:`   `    ``# If a/b == c/d  then  a*d = b*c:` `    ``# method to ignore division` `    ``if` `(a.p ``*` `b.q ``=``=` `a.q ``*` `b.p):` `        ``return` `0` `    ``if` `(a.p ``*` `b.q > a.q ``*` `b.p):` `        ``return` `1` `        `  `    ``return` `-``1`   `# Returns index of x in arr[l..r] if ` `# it is present, else returns -1. It` `# mainly uses Binary Search.` `def` `binarySearch(arr: ``list``, l: ``int``, ` `                   ``r: ``int``, x: Rational) ``-``> ``int``:`   `    ``if` `(r >``=` `l):`   `        ``mid ``=` `l ``+` `(r ``-` `l) ``/``/` `2`   `        ``# If the element is present at the` `        ``# middle itself` `        ``if` `(compare(arr[mid], x) ``=``=` `0``):` `            ``return` `mid`   `        ``# If element is smaller than mid, then ` `        ``# it can only be present in left subarray` `        ``if` `(compare(arr[mid], x) > ``0``):` `            ``return` `binarySearch(arr, l, mid ``-` `1``, x)`   `        ``# Else the element can only be present` `        ``# in right subarray` `        ``return` `binarySearch(arr, mid ``+` `1``, r, x)`   `    ``return` `-``1`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``arr ``=` `[ Rational(``1``, ``5``), Rational(``2``, ``3``),` `            ``Rational(``3``, ``2``), Rational(``13``, ``2``) ]` `    ``x ``=` `Rational(``3``, ``2``)` `    ``n ``=` `len``(arr)` `    `  `    ``print``(``"Element found at index %d"` `%` `(` `        ``binarySearch(arr, ``0``, n ``-` `1``, x)))`   `# This code is contributed by sanjeev2552`

## C#

 `// C# program for Binary Search for Rational Numbers` `// without using floating point arithmetic` `using` `System;`   `class` `GFG` `{`   `class` `Rational` `{` `    ``public` `int` `p;` `    ``public` `int` `q;`   `    ``public` `Rational(``int` `p, ``int` `q)` `    ``{` `        ``this``.p = p;` `        ``this``.q = q;` `    ``}` `    `  `};`   `// Utility function to compare two Rational numbers` `// 'a' and 'b'. It returns` `// 0 -. When 'a' and 'b' are same` `// 1 -. When 'a' is greater` `//-1 -. When 'b' is greater` `static` `int` `compare(Rational a, Rational b)` `{` `    ``// If a/b == c/d then a*d = b*c:` `    ``// method to ignore division` `    ``if` `(a.p * b.q == a.q * b.p)` `        ``return` `0;` `    ``if` `(a.p * b.q > a.q * b.p)` `        ``return` `1;` `    ``return` `-1;` `}`   `// Returns index of x in arr[l..r] if it is present, else` `// returns -1. It mainly uses Binary Search.` `static` `int` `binarySearch(Rational []arr, ``int` `l, ``int` `r,` `                ``Rational x)` `{` `    ``if` `(r >= l)` `    ``{` `        ``int` `mid = l + (r - l)/2;`   `        ``// If the element is present at the middle itself` `        ``if` `(compare(arr[mid], x) == 0) ``return` `mid;`   `        ``// If element is smaller than mid, then it can` `        ``// only be present in left subarray` `        ``if` `(compare(arr[mid], x) > 0)` `            ``return` `binarySearch(arr, l, mid - 1, x);`   `        ``// Else the element can only be present in right` `        ``// subarray` `        ``return` `binarySearch(arr, mid + 1, r, x);` `    ``}` `return` `-1;` `}`   `// Driver method` `public` `static` `void` `Main(String[] args)` `{` `    ``Rational []arr = {``new` `Rational(1, 5), ` `                        ``new` `Rational(2, 3), ` `                        ``new` `Rational(3, 2), ` `                        ``new` `Rational(13, 2)};` `    ``Rational x = ``new` `Rational(3, 2);` `    ``int` `n = arr.Length;` `    ``Console.Write(``"Element found at index {0}"``,` `            ``binarySearch(arr, 0, n - 1, x));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`Element found at index 2`

Time Complexity: O(log n)

Auxiliary Space: O(1),  since no extra space has been taken.

Thanks to Utkarsh Trivedi for suggesting above solution.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes arrow_drop_up
Recommended Articles
Page :