Convert given Decimal number into an irreducible Fraction

Last Updated : 23 Dec, 2023

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 <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
JavaScript
<script>

// Javascript program to implement
// the above approach

// Recursive function to
// return GCD of a and b
function gcd(a, 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
function decimalToFraction(number)
{
   
    // Fetch letegral value of the decimal
    let letVal = Math.floor(number);
  
    // Fetch fractional part of the decimal
    let fVal = number - letVal;
  
    // Consider precision value to
    // convert fractional part to
    // letegral equivalent
    let pVal = 1000000000;
  
    // Calculate GCD of letegral
    // equivalent of fractional
    // part and precision value
    let gcdVal = gcd(Math.round(
                      fVal * pVal), pVal);
   
    // Calculate num and deno
    let num = Math.round(fVal * pVal) / gcdVal;
    let deno = pVal / gcdVal;
  
    // Print the fraction
    document.write((letVal * deno) +
                           num + "/" + deno);
}
   
   
    // Driver Code
          
    let N = 4.5;
    decimalToFraction(N);

</script>

Output
9/2

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

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

For larger decimal values the float function automatically rounds off the input resulting in an incorrect response 
Using inbuilt python libraries doesn't round off the input for example for the below input the decimal value the code above rounds off the input

  • Import library Decimal to convert a string input into decimal
  • Import library Fraction to convert a Decimal input into a fraction
  • Now convert the fraction into the string and give the output

For example N = "123456789.25252525"

Decimal(N) takes string input and converts it into decimal value = 123456789.25252525
         
Now we convert the fraction into string using type casting str(493827157010101/4000000)

result "493827157010101/4000000"

Below is the implementation of the above approach:

C++
#include <iostream>
#include <string>
#include <cmath>

// Function to calculate the greatest common divisor (GCD)
long long gcd(long long a, long long b) {
    return b == 0 ? a : gcd(b, a % b);
}

void decimalToFraction(const std::string &number) {
    // Convert the decimal string to a double
    double decimal = std::stod(number);

    // Calculate the denominator (e.g., 100 for two decimal places)
    int scale = std::to_string(decimal).length() - number.find('.') - 1;
    long long denominator = std::pow(10, scale);

    // Calculate the numerator by multiplying the decimal by the denominator
    long long numerator = decimal * denominator;

    // Calculate the greatest common divisor (GCD) of the numerator and denominator
    long long commonDivisor = gcd(numerator, denominator);

    // Simplify the fraction by dividing both the numerator and denominator by the GCD
    numerator /= commonDivisor;
    denominator /= commonDivisor;

    // Print the simplified fraction
    std::cout << numerator << "/" << denominator << std::endl;
}

int main() {
    // Input decimal as a string
    std::string N = "123456789.25252525";

    // Convert the decimal to a fraction and print the result
    decimalToFraction(N);

    return 0;
}
Java
import java.math.BigDecimal;
import java.math.BigInteger;

public class DecimalToFraction {
    public static void main(String[] args) {
        String N = "123456789.25252525";
        decimalToFraction(N);
    }

    public static void decimalToFraction(String number) {
        BigDecimal decimal = new BigDecimal(number);
        BigInteger numerator = decimal.unscaledValue();
        int scale = decimal.scale();
        BigInteger denominator = BigInteger.TEN.pow(scale);
        BigInteger gcd = numerator.gcd(denominator);
        numerator = numerator.divide(gcd);
        denominator = denominator.divide(gcd);

        System.out.println(numerator + "/" + denominator);
    }
}
Python3
from decimal import Decimal
from fractions import Fraction


def decimalToFraction(number):
    f = Fraction(Decimal(str(number)))
    print(str(f))


if __name__ == '__main__':

    N = "123456789.25252525"
    decimalToFraction(N)

# This code is contributed by sonusahu050502
C#
using System;

class DecimalToFraction {
    // Function to calculate the greatest common divisor
    // (GCD)
    static long Gcd(long a, long b)
    {
        return b == 0 ? a : Gcd(b, a % b);
    }

    static void ConvertDecimalToFraction(string number)
    {
        // Convert the decimal string to a decimal
        decimal decimalNumber = decimal.Parse(number);

        // Calculate the denominator (e.g., 100 for two
        // decimal places)
        int scale = number.Length - number.IndexOf('.') - 1;
        long denominator = (long)Math.Pow(10, scale);

        // Calculate the numerator by multiplying the
        // decimal by the denominator
        long numerator
            = (long)(decimalNumber * denominator);

        // Calculate the greatest common divisor (GCD) of
        // the numerator and denominator
        long commonDivisor = Gcd(numerator, denominator);

        // Simplify the fraction by dividing both the
        // numerator and denominator by the GCD
        numerator /= commonDivisor;
        denominator /= commonDivisor;

        // Print the simplified fraction
        Console.WriteLine(numerator + "/" + denominator);
    }

    static void Main()
    {
        // Input decimal as a string
        string N = "123456789.25252525";

        // Convert the decimal to a fraction and print the
        // result
        ConvertDecimalToFraction(N);
    }
}
JavaScript
// JavaScript program for the above approach

const Decimal = require('decimal.js');
const { Fraction } = require('fractions');

function decimalToFraction(number) {
    const f = new Fraction(new Decimal(String(number)));
    console.log(String(f));
}

const N = "123456789.25252525";
decimalToFraction(N);

// This code is contributed by codebraxnzt

Output
493827157010101/4000000

Time complexity: O(k + log n)
Auxiliary space: O(1)

Explanation:
The time complexity of the decimalToFraction function depends on the length of the input number and the efficiency of the Fraction constructor. In this case, the input number is converted to a Decimal object using the Decimal constructor, which has a time complexity of O(k), where k is the number of digits in the input number. Then, the Fraction constructor is called with the Decimal object, which has a time complexity of O(log n), where n is the value of the input Decimal object. Therefore, the overall time complexity of decimalToFraction is O(k + log n).

The auxiliary space complexity of the decimalToFraction function is O(1), as it only uses a constant amount of additional memory to store the Fraction object and its string representation of it.

Comment
Article Tags:
DSA
GCD-LCM
Fraction

Explore