Related Articles
Convert given Decimal number into an irreducible Fraction
• Difficulty Level : Hard
• Last Updated : 31 Jul, 2020

Given a decimal number as N, the task is to convert N into an equivalent irreducible fraction.

An irreducible fraction is a fraction in which numerator and denominator are co-primes i.e., they have no other common divisor other than 1.

Examples:

Input: N = 4.50
Output: 9/2
Explanation:
9/2 in decimal is written as 4.5

Input: N = 0.75
Output: 3/4
Explanation:
3/4 in decimal is written as 0.75

Approach: Follow the steps given below to solve the problem.

• Fetch integral value and fractional part of the decimal number ‘n’.
• Consider the precision value to be 109 to convert the fractional part of the decimal to an integral equivalent.
• Calculate GCD of the integral equivalent of fractional part and precision value.
• Calculate numerator by dividing the integral equivalent of fractional part by GCD value. Calculate the denominator by dividing the precision value by GCD value.
• From the obtained mixed fraction, convert it into an improper fraction.

For example N = 4.50, integral value = 4  and  fractional part = 0.50

Consider precision value to be (109) that is precision value = 1000000000

Calculate GCD(0.50 *  109, 109) = 500000000

Calculate numerator = (0.50 * 10^9) / 500000000 = 1 and denominator = 10^9/ 500000000 = 2

Convert mixed fraction into improper fraction that is fraction = ((4 * 2) + 1) / 2 = 9/2

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Recursive function to ` `// return GCD of a and b ` `long` `long` `gcd(``long` `long` `a, ``long` `long` `b) ` `{ ` `    ``if` `(a == 0) ` `        ``return` `b; ` `    ``else` `if` `(b == 0) ` `        ``return` `a; ` `    ``if` `(a < b) ` `        ``return` `gcd(a, b % a); ` `    ``else` `        ``return` `gcd(b, a % b); ` `} ` ` `  `// Function to convert decimal to fraction ` `void` `decimalToFraction(``double` `number) ` `{ ` `    ``// Fetch integral value of the decimal ` `    ``double` `intVal = ``floor``(number); ` ` `  `    ``// Fetch fractional part of the decimal ` `    ``double` `fVal = number - intVal; ` ` `  `    ``// Consider precision value to ` `    ``// convert fractional part to ` `    ``// integral equivalent ` `    ``const` `long` `pVal = 1000000000; ` ` `  `    ``// Calculate GCD of integral ` `    ``// equivalent of fractional ` `    ``// part and precision value ` `    ``long` `long` `gcdVal ` `        ``= gcd(round(fVal * pVal), pVal); ` ` `  `    ``// Calculate num and deno ` `    ``long` `long` `num ` `        ``= round(fVal * pVal) / gcdVal; ` `    ``long` `long` `deno = pVal / gcdVal; ` ` `  `    ``// Print the fraction ` `    ``cout << (intVal * deno) + num ` `         ``<< ``"/"` `<< deno << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``double` `N = 4.5; ` ` `  `    ``decimalToFraction(N); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `     `  `// Recursive function to ` `// return GCD of a and b ` `static` `long` `gcd(``long` `a, ``long` `b) ` `{ ` `    ``if` `(a == ``0``) ` `        ``return` `b; ` `    ``else` `if` `(b == ``0``) ` `        ``return` `a; ` `    ``if` `(a < b) ` `        ``return` `gcd(a, b % a); ` `    ``else` `        ``return` `gcd(b, a % b); ` `} ` `     `  `// Function to convert decimal to fraction ` `static` `void` `decimalToFraction(``double` `number) ` `{ ` `   `  `    ``// Fetch integral value of the decimal ` `    ``double` `intVal = Math.floor(number); ` `  `  `    ``// Fetch fractional part of the decimal ` `    ``double` `fVal = number - intVal; ` `  `  `    ``// Consider precision value to ` `    ``// convert fractional part to ` `    ``// integral equivalent ` `    ``final` `long` `pVal = ``1000000000``; ` `  `  `    ``// Calculate GCD of integral ` `    ``// equivalent of fractional ` `    ``// part and precision value ` `    ``long` `gcdVal = gcd(Math.round( ` `                      ``fVal * pVal), pVal); ` `   `  `    ``// Calculate num and deno ` `    ``long` `num = Math.round(fVal * pVal) / gcdVal; ` `    ``long` `deno = pVal / gcdVal; ` `  `  `    ``// Print the fraction ` `    ``System.out.println((``long``)(intVal * deno) +  ` `                           ``num + ``"/"` `+ deno); ` `} ` `   `  `// Driver Code ` `public` `static` `void` `main(String s[]) ` `{ ` `    ``double` `N = ``4.5``; ` `    ``decimalToFraction(N); ` `}     ` `} ` ` `  `// This code is contributed by rutvik_56`

## Python3

 `# Python3 program for the above approach ` `from` `math ``import` `floor ` ` `  `# Recursive function to ` `# return GCD of a and b ` `def` `gcd(a, b): ` `     `  `    ``if` `(a ``=``=` `0``): ` `        ``return` `b ` `    ``elif` `(b ``=``=` `0``): ` `        ``return` `a ` `    ``if` `(a < b): ` `        ``return` `gcd(a, b ``%` `a) ` `    ``else``: ` `        ``return` `gcd(b, a ``%` `b) ` ` `  `# Function to convert decimal to fraction ` `def` `decimalToFraction(number): ` `     `  `    ``# Fetch integral value of the decimal ` `    ``intVal ``=` `floor(number) ` ` `  `    ``# Fetch fractional part of the decimal ` `    ``fVal ``=` `number ``-` `intVal ` ` `  `    ``# Consider precision value to ` `    ``# convert fractional part to ` `    ``# integral equivalent ` `    ``pVal ``=` `1000000000` ` `  `    ``# Calculate GCD of integral ` `    ``# equivalent of fractional ` `    ``# part and precision value ` `    ``gcdVal ``=` `gcd(``round``(fVal ``*` `pVal), pVal) ` ` `  `    ``# Calculate num and deno ` `    ``num``=` `round``(fVal ``*` `pVal) ``/``/` `gcdVal ` `    ``deno ``=` `pVal ``/``/` `gcdVal ` ` `  `    ``# Print the fraction ` `    ``print``((intVal ``*` `deno) ``+` `num, ``"/"``, deno) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``N ``=` `4.5` ` `  `    ``decimalToFraction(N) ` ` `  `# This code is contributed by mohit kumar 29 `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `// Recursive function to ` `// return GCD of a and b ` `static` `long` `gcd(``long` `a, ``long` `b) ` `{ ` `    ``if` `(a == 0) ` `        ``return` `b; ` `    ``else` `if` `(b == 0) ` `        ``return` `a; ` `    ``if` `(a < b) ` `        ``return` `gcd(a, b % a); ` `    ``else` `        ``return` `gcd(b, a % b); ` `} ` `     `  `// Function to convert decimal to fraction ` `static` `void` `decimalToFraction(``double` `number) ` `{ ` ` `  `    ``// Fetch integral value of the decimal ` `    ``double` `intVal = Math.Floor(number); ` ` `  `    ``// Fetch fractional part of the decimal ` `    ``double` `fVal = number - intVal; ` ` `  `    ``// Consider precision value to ` `    ``// convert fractional part to ` `    ``// integral equivalent ` `    ``long` `pVal = 1000000000; ` ` `  `    ``// Calculate GCD of integral ` `    ``// equivalent of fractional ` `    ``// part and precision value ` `    ``long` `gcdVal = gcd((``long``)Math.Round( ` `                    ``fVal * pVal), pVal); ` ` `  `    ``// Calculate num and deno ` `    ``long` `num = (``long``)Math.Round(fVal * pVal) / gcdVal; ` `    ``long` `deno = pVal / gcdVal; ` ` `  `    ``// Print the fraction ` `    ``Console.WriteLine((``long``)(intVal * deno) +  ` `                          ``num + ``"/"` `+ deno); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String []s) ` `{ ` `    ``double` `N = 4.5; ` `     `  `    ``decimalToFraction(N); ` `}  ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```9/2
```

Time complexity: O(log min(a, b))
Auxiliary space: O(1)

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
Recommended Articles
Page :