Convert given Decimal number into an irreducible Fraction

Difficulty Level : Hard
Last Updated : 08 Feb, 2021

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 10⁹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 (10⁹) that is precision value = 1000000000

Calculate GCD(0.50 * 10⁹, 10⁹) = 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 <bits/stdc++.h>
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;
}

C

// C implementation of the above approach
#include <math.h>
#include <stdio.h>
 
int gcfFinder(int a, int b)
{ // gcf finder
    int gcf = 1;
    for (int i = 1; i <= a && i <= b; i++) 
    {
        if (a % i == 0 && b % i == 0) 
        {
            gcf = i;
        }
    }
    return gcf;
}
 
int shortform(int* a, int* b)
{
    for (int i = 2; i <= *a && i <= *b; i++) 
    {
        if (*a % i == 0 && *b % i == 0) 
        {
            *a = *a / i;
            *b = *b / i;
        }
    }
    return 0;
}
 
// Driver Code
int main(void)
{
    // converting decimal into fraction.
    double a = 4.50;
 
    int c = 10000;
    double b = (a - floor(a)) * c;
    int d = (int)floor(a) * c + (int)(b + .5f);
 
    while (1) 
    {
        if (d % 10 == 0) 
        {
            d = d / 10;
            c = c / 10;
        }
        else
            break;
    }
    int* i = &d;
    int* j = &c;
    int t = 0;
    while (t != 1)
    {
        int gcf = gcfFinder(d, c);
        if (gcf == 1) 
        {
            printf("%d/%d\n", d, c);
            t = 1;
        }
        else
        {
            shortform(i, j);
        }
    }
    return 0;
}
// this code is contributed by harsh sinha username-
// harshsinha03

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

Related Articles

C++

C

Java

Python3

C#