Fraction to Recurring Decimal

You're given two integers, numerator and denominator. Return the value of numerator / denominator written as a decimal string.

Formatting rules:

• If the division is exact, write it with no decimal point when it is a whole number ("3"), or with exactly the digits needed otherwise ("1.75").
• If the fractional part repeats forever, write the digits before the repeat as usual and put the repeating block in parentheses, starting at the earliest position where the repetition begins. For example 1/6 is "0.1(6)", not "0.(16)" or "0.16(6)".
• A negative result starts with "-". Zero is always "0", never "-0".

The answer is unique under these rules, and it is guaranteed to be shorter than 10⁴ characters.

Do the division the way you would on paper. After the integer part, each step multiplies the remainder by 10, writes one digit (remainder * 10 // d), and keeps the new remainder (remainder * 10 % d).

The next digit depends only on the current remainder. So the moment a remainder shows up a second time, everything from its first appearance onward will repeat forever. Remember, for each remainder, the position in the digit list where it first appeared. When you see it again, insert ( at that position and ) at the end. If the remainder reaches 0 instead, the decimal terminates.

Because every remainder is between 1 and d - 1, a repeat is guaranteed within d steps.

def fraction_to_decimal(numerator: int, denominator: int) -> str:
    if numerator == 0:
        return "0"
    parts = []
    if (numerator < 0) != (denominator < 0):
        parts.append("-")
    n, d = abs(numerator), abs(denominator)
    parts.append(str(n // d))
    remainder = n % d
    if remainder == 0:
        return "".join(parts)

    parts.append(".")
    digits = []
    seen = {}  # remainder -> index in digits where it first appeared
    while remainder and remainder not in seen:
        seen[remainder] = len(digits)
        remainder *= 10
        digits.append(str(remainder // d))
        remainder %= d
    if remainder:
        start = seen[remainder]
        digits.insert(start, "(")
        digits.append(")")
    return "".join(parts) + "".join(digits)

function fractionToDecimal(numerator, denominator) {
  if (numerator === 0) return '0';
  let result = (numerator < 0) !== (denominator < 0) ? '-' : '';
  const n = Math.abs(numerator);
  const d = Math.abs(denominator);
  result += Math.floor(n / d);
  let remainder = n % d;
  if (remainder === 0) return result;

  result += '.';
  const digits = [];
  const seen = new Map(); // remainder -> index in digits where it first appeared
  while (remainder !== 0 && !seen.has(remainder)) {
    seen.set(remainder, digits.length);
    remainder *= 10;
    digits.push(Math.floor(remainder / d));
    remainder %= d;
  }
  if (remainder !== 0) {
    digits.splice(seen.get(remainder), 0, '(');
    digits.push(')');
  }
  return result + digits.join('');
}

Start with the key observation: "the next digit depends only on the remainder, so a repeated remainder means a repeating cycle." That sentence is what the interviewer is waiting for.

Then list the edge cases before coding: zero numerator, negative signs on either side, the -2³¹ overflow, and whole-number results with no decimal point. Trace 1/6 to show the parenthesis lands after the 1.