Fraction to Recurring Decimal - Practice Coding Problems

Fraction to Recurring Decimal - Problem

Given two integers representing the numerator and denominator of a fraction, return the fraction in string format.

The challenge is that some fractions have repeating decimal parts. For example, 1/3 = 0.333... where 3 repeats infinitely. When this happens, you must enclose the repeating part in parentheses.

Examples:

1/2 = "0.5" (finite decimal)
1/3 = "0.(3)" (repeating decimal)
22/7 = "3.(142857)" (repeating cycle)

If the fraction can be represented as a finite decimal, return it without parentheses. The key insight is detecting when remainders start repeating during long division - that's when the decimal cycle begins!

Input & Output

example_1.py — Simple Fraction

$ Input: numerator = 1, denominator = 2

› Output: "0.5"

💡 Note: 1/2 = 0.5, which is a finite decimal, so no parentheses are needed.

example_2.py — Repeating Single Digit

$ Input: numerator = 1, denominator = 3

› Output: "0.(3)"

💡 Note: 1/3 = 0.333..., where 3 repeats indefinitely, so we enclose it in parentheses.

example_3.py — Longer Repeating Cycle

$ Input: numerator = 22, denominator = 7

› Output: "3.(142857)"

💡 Note: 22/7 = 3.142857142857..., where 142857 repeats, forming a 6-digit cycle.

Constraints

-2³¹ ≤ numerator, denominator ≤ 2³¹ - 1
denominator ≠ 0
The length of the answer string is less than 10⁴

Visualization

Tap to expand

Understanding the Visualization

Setup Investigation

Handle the sign and calculate the integer part. Start tracking remainders with a hash map.

Follow the Trail

For each remainder in long division, check if we've seen it before. If not, record it with its position.

Catch the Repeat

The moment we see a repeated remainder, we've found our cycle! Insert parentheses around the repeating part.

Case Closed

Return the properly formatted decimal string with repeating parts in parentheses.

Key Takeaway

🎯 Key Insight: In long division, when the same remainder appears twice, the sequence of digits will repeat exactly from that point forward. Using a hash map to track remainder positions allows us to detect this cycle instantly and format the result correctly.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a hash map to track remainders during long division. When we encounter a remainder we've seen before, we know the decimal will repeat from that point. This allows us to detect cycles in O(k) time where k is the length of the result, making it much more efficient than generating many digits and searching for patterns.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map for Remainder Tracking (Optimal)	O(k)	O(k)	Track remainder positions during division to detect cycles instantly
Naive String Pattern Detection	O(k²)	O(k)	Generate many decimal digits then search for repeating patterns

Hash Map for Remainder Tracking (Optimal) — Algorithm Steps

Handle edge cases (numerator = 0) and determine sign
Calculate integer part and get initial remainder
Use hash map to track remainder -> position mapping
For each remainder: check if seen before, if yes = cycle found
If new remainder: add digit to result, store remainder position
When cycle detected: insert opening parenthesis at cycle start, close at end

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Division

Begin long division, storing each remainder and its position

Check Remainder

For each new remainder, check if we've seen it before

Cycle Detected

When remainder repeats, insert parentheses around the cycle

Return Result

Complete formatted string with proper repeating notation

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 10000

typedef struct {
    long long remainder;
    int position;
} RemainderEntry;

char* fractionToDecimal(int numerator, int denominator) {
    if (numerator == 0) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char* result = malloc(MAX_SIZE);
    int pos = 0;
    
    // Handle sign
    if ((numerator < 0) ^ (denominator < 0)) {
        result[pos++] = '-';
    }
    
    // Work with absolute values
    long long num = llabs((long long)numerator);
    long long den = llabs((long long)denominator);
    
    // Integer part
    pos += sprintf(result + pos, "%lld", num / den);
    num %= den;
    
    if (num == 0) {
        return result;
    }
    
    // Decimal part
    result[pos++] = '.';
    
    // Simple hash table for remainders
    RemainderEntry remainders[1000];
    int remainderCount = 0;
    
    while (num != 0) {
        // Check if remainder already seen
        int cycleStart = -1;
        for (int i = 0; i < remainderCount; i++) {
            if (remainders[i].remainder == num) {
                cycleStart = remainders[i].position;
                break;
            }
        }
        
        if (cycleStart != -1) {
            // Found cycle - insert parentheses
            int len = pos;
            for (int i = len; i > cycleStart; i--) {
                result[i + 1] = result[i];
            }
            result[cycleStart] = '(';
            result[len + 1] = ')';
            result[len + 2] = '\0';
            return result;
        }
        
        // Store remainder and position
        remainders[remainderCount].remainder = num;
        remainders[remainderCount].position = pos;
        remainderCount++;
        
        // Continue division
        num *= 10;
        result[pos++] = '0' + (num / den);
        num %= den;
    }
    
    result[pos] = '\0';
    return result;
}

int main() {
    printf("%s\n", fractionToDecimal(1, 2));   // "0.5"
    printf("%s\n", fractionToDecimal(1, 3));   // "0.(3)"
    printf("%s\n", fractionToDecimal(22, 7));  // "3.(142857)"
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k)

k is the length of the decimal representation, each remainder processed once

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k remainder-position pairs

✓ Linear Space

73.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Map for Remainder Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler