Represent the fraction of two numbers in the string format

Given two integers representing the Numerator and Denominator of a fraction, return the fraction in string format. If the fractional part is repeating, enclose the repeating part in parentheses.

Examples:

Input: Numerator = 1, Denominator = 2
Output: "0.5"
1/2 = 0.5 with no repeating part.

Input: Numerator = 50, Denominator = 22
Output: "2.(27)"
50/22 = 2.27272727... Since fractional part (27) 
is repeating, it is enclosed in parentheses.

Prerequisites: Recurring Sequence in a Fraction

Approach: The idea is to first calculate the integral quotient (absolute part before decimal point) and then calculate the fractional part. To check if the fractional part is repeating, insert the remainder (numerator % denominator) in a map with key as remainder and value as the index position at which this remainder occurs. If at any point of time, the remainder becomes zero, then there doesn’t exist a repeating fraction otherwise if the remainder is already found in the map, then there exists a repeating fraction.

Below is the implementation of above approach.  

C++

// C++ program to calculate
// fraction of two numbers
#include <bits/stdc++.h>
using namespace std;

// Function to return the required fraction
// in string format
string calculateFraction(int num, int den)
{
    // If the numerator is zero, answer is 0
    if (num == 0)
        return "0";

    // If any one (out of numerator and denominator)
    // is -ve, sign of resultant answer -ve.
    int sign = (num < 0) ^ (den < 0) ? -1 : 1;

    num = abs(num);
    den = abs(den);

    // Calculate the absolute part
    // (before decimal point).
    int initial = num / den;

    // Output string to store the answer
    string res;

    // Append sign
    if (sign == -1)
        res += "-";

    // Append the initial part
    res += to_string(initial);

    // If completely divisible, return answer.
    if (num % den == 0)
        return res;

    res += ".";

    // Initialize Remainder
    int rem = num % den;
    map<int, int> mp;

    // Position at which fraction starts repeating
    // if it exists
    int index;
    bool repeating = false;
    while (rem > 0 && !repeating) {

        // If this remainder is already seen,
        // then there exists a repeating fraction.
        if (mp.find(rem) != mp.end()) {

            // Index to insert parentheses
            index = mp[rem];
            repeating = true;
            break;
        }
        else
            mp[rem] = res.size();

        rem = rem * 10;

        // Calculate quotient, append
        // it to result and
        // calculate next remainder
        int temp = rem / den;
        res += to_string(temp);
        rem = rem % den;
    }

    // If repeating fraction exists,
    // insert parentheses.
    if (repeating) {
        res += ")";
        res.insert(index, "(");
    }

    // Return result.
    return res;
}

// Drivers Code
int main()
{
    int num = 50, den = 22;
    cout << calculateFraction(num, den) << endl;

    num = -1, den = 2;
    cout << calculateFraction(num, den) << endl;
    return 0;
}

Java

// Java program to calculate fraction
// of two numbers
import java.util.*;

class GFG {

    // Function to return the required fraction
    // in string format

    public static String calculateFraction(int num, int den)
    {
        if (num == 0)
            return "0"; // if numerator is zero
        if (den == 0)
            return ""; // if denominator is zero

        // result StringBuilder

        StringBuilder result = new StringBuilder();
        if ((num < 0) ^ (den < 0))
            result.append("-"); // check -ve sign

        // absolute values of num and den

        num = Math.abs(num);
        den = Math.abs(den);

        long quo = num / den; // Quotient
        long rem = num % den * 10; // calculating remainder

        result.append(
            String.valueOf(quo)); // appending quotient
        if (rem == 0)
            return result
                .toString(); // return if remainder is 0

        // if remainder is not zero, continue

        result.append(".");
        Map<Long, Integer> m
            = new HashMap<>(); // map for storing remainder
                               // and the indexes of the
                               // appropriate decimal in
                               // stringbuilder

        while (rem != 0) {

            if (m.containsKey(rem)) {

                // if the rem is already present, find the
                // index and append ( )

                int index = m.get(rem);
                String part1 = result.substring(0, index);
                String part2 = "("
                               + result.substring(
                                   index, result.length())
                               + ")";
                return part1 + part2;
            }

            // continue updating the map and appending quo
            // which was generated by dividing rem with den

            m.put(rem, result.length());
            quo = rem / den;
            result.append(String.valueOf(quo));

            // update rem
            rem = (rem % den) * 10;
        }
        return result.toString();
    }

    // Driver code
    public static void main(String[] args)
    {
        int num = 113;
        int den = 56;

        String resString1 = calculateFraction(num, den);

        num = -1;
        den = 2;

        String resString2 = calculateFraction(num, den);

        System.out.println(resString1);
        System.out.println(resString2);
    }
}

// This code is contributed by Saiteja Marisetti

Python3

# Python3 program to calculate fraction
# of two numbers

# Function to return the required
# fraction in string format
def calculateFraction(num, den) :

    # If the numerator is zero, answer is 0
    if (num == 0):
        return "0"

    # If any one (out of numerator and denominator)
    # is -ve, sign of resultant answer -ve.
    sign = -1 if (num < 0) ^ (den < 0) else 1

    num = abs(num)
    den = abs(den)

    # Calculate the absolute part
    # (before decimal point).
    initial = num // den

    # Output string to store the answer
    res = ""

    # Append sign
    if (sign == -1):
        res += "-"

    # Append the initial part
    res += str(initial)

    # If completely divisible, return answer.
    if (num % den == 0):
        return res

    res += "."

    # Initialize Remainder
    rem = num % den
    mp = {}

    # Position at which fraction starts
    # repeating if it exists
    index = 0
    repeating = False
    while (rem > 0 and not repeating) :

        # If this remainder is already seen,
        # then there exists a repeating fraction.
        if ( rem in mp):

            # Index to insert parentheses
            index = mp[rem]
            repeating = True
            break

        else:
            mp[rem] = len(res)

        rem = rem * 10

        # Calculate quotient, append it to result
        # and calculate next remainder
        temp = rem // den
        res += str(temp )
        rem = rem % den

    # If repeating fraction exists,
    # insert parentheses.
    if (repeating) :
        res += ")"
        x = res[:index]
        x += "("
        x += res[index:]
        res = x

    # Return result.
    return res

# Driver code
if __name__ =="__main__":
    num = 50
    den = 22
    print(calculateFraction(num, den))
    num = -1
    den = 2
    print(calculateFraction(num, den))

# This code is contributed
# Shubham Singh(SHUBHAMSINGH10)

C#

// C# program to calculate fraction
// of two numbers
using System;
using System.Text;
using System.Collections.Generic;

class GFG {

    // Function to return the required fraction
    // in string format
    public static string calculateFraction(int num, int den)
    {
        if (num == 0)
            return "0"; // if numerator is zero
        if (den == 0)
            return ""; // if denominator is zero

        // result StringBuilder

        StringBuilder result = new StringBuilder();
        if ((num < 0) ^ (den < 0))
            result.Append("-"); // check -ve sign

        // absolute values of num and den

        num = Math.Abs(num);
        den = Math.Abs(den);

        int quo = num / den; // Quotient
        int rem = num % den * 10; // calculating remainder

        result.Append(
            Convert.ToString(quo)); // appending quotient
        if (rem == 0)
            return result
                .ToString(); // return if remainder is 0

        // if remainder is not zero, continue

        result.Append(".");
        Dictionary<long, int> m
            = new Dictionary<long, int>(); // map for storing remainder
                               // and the indexes of the
                               // appropriate decimal in
                               // stringbuilder

        while (rem != 0) {

            if (m.ContainsKey(rem)) {

                // if the rem is already present, find the
                // index and append ( )

                int index = m[rem];
                string part1 = result.ToString(0, index);
                string part2 = "("
                               + result.ToString(index, result.Length - index)
                               + ")";
                return part1 + part2;
            }

            // continue updating the map and appending quo
            // which was generated by dividing rem with den

            m[rem] = result.Length;
            quo = rem / den;
            result.Append(Convert.ToString(quo));

            // update rem
            rem = (rem % den) * 10;
        }
        return result.ToString();
    }

    // Driver code
    public static void Main(string[] args)
    {
        int num = 50;
        int den = 22;

        string resString1 = calculateFraction(num, den);

        num = -1;
        den = 2;

        string resString2 = calculateFraction(num, den);

        Console.WriteLine(resString1);
        Console.WriteLine(resString2);
    }
}

// This code is contributed by phasing17

Javascript

<script>

// JavaScript program to calculate
// fraction of two numbers

// Function to return the required fraction
// in string format
function calculateFraction(num, den)
{
    // If the numerator is zero, answer is 0
    if (num == 0)
        return "0";

    // If any one (out of numerator and denominator)
    // is -ve, sign of resultant answer -ve.
    var sign = (num < 0) ^ (den < 0) ? -1 : 1;

    num = Math.abs(num);
    den = Math.abs(den);

    // Calculate the absolute part
    // (before decimal point).
    var initial = parseInt(num / den);

    // Output string to store the answer
    var res = [];

    // Append sign
    if (sign == -1)
        res.push("-");

    // Append the initial part
    res.push(initial.toString());

    // If completely divisible, return answer.
    if (num % den == 0)
        return res;

    res.push(".");

    // Initialize Remainder
    var rem = num % den;
    var mp = new Map();

    // Position at which fraction starts repeating
    // if it exists
    var index;
    var repeating = false;
    while (rem > 0 && !repeating) {

        // If this remainder is already seen,
        // then there exists a repeating fraction.
        if (mp.has(rem)) {

            // Index to insert parentheses
            index = mp.get(rem);
            repeating = true;
            break;
        }
        else
            mp.set(rem, res.length);

        rem = rem * 10;

        // Calculate quotient, append
        // it to result and
        // calculate next remainder
        var temp = parseInt(rem / den);
        res.push(temp.toString());
        rem = rem % den;
    }

    // If repeating fraction exists,
    // insert parentheses.
    if (repeating) {
        res.push(")");
        res.splice(index,0, "(");
    }

    // Return result.
    return res.join('');
}

// Drivers Code
var num = 50, den = 22;
document.write( calculateFraction(num, den) + "<br>");
num = -1, den = 2;
document.write( calculateFraction(num, den));


</script>

Output:

2.(27)
-0.5

Time Complexity: O(n),  where n is the length of the string representation of the output fraction.
Space Complexity: O(n), where n is the length of the string and output string res can store up to n characters, and the map mp can store up to n entries in the worst case where the fraction is repeating.