循环小数的分数

Question

Working on this problem, and also did a few reference to similar solutions. One thing I am confuse is, why we break the loop as long as there is one repetitive number? Is it possible the number repeat for 2-3 times and then changed to another different number? Thanks.

I mean this part specifically,

        if (map.containsKey(num)) {
            int index = map.get(num);
            res.insert(index, "(");
            res.append(")");
            break;
        }

The problem,

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.

For example,

Given numerator = 1, denominator = 2, return "0.5". Given numerator = 2, denominator = 1, return "2". Given numerator = 2, denominator = 3, return "0.(6)".

public class Solution {
    public String fractionToDecimal(int numerator, int denominator) {
        if (numerator == 0) {
            return "0";
        }
        StringBuilder res = new StringBuilder();
        // "+" or "-"
        res.append(((numerator > 0) ^ (denominator > 0)) ? "-" : "");
        long num = Math.abs((long)numerator);
        long den = Math.abs((long)denominator);

        // integral part
        res.append(num / den);
        num %= den;
        if (num == 0) {
            return res.toString();
        }

        // fractional part
        res.append(".");
        HashMap<Long, Integer> map = new HashMap<Long, Integer>();
        map.put(num, res.length());
        while (num != 0) {
            num *= 10;
            res.append(num / den);
            num %= den;
            if (map.containsKey(num)) {
                int index = map.get(num);
                res.insert(index, "(");
                res.append(")");
                break;
            }
            else {
                map.put(num, res.length());
            }
        }
        return res.toString();
    }
}

thanks in advance, Lin

Answer 1

The code doesn't stop when it sees a digit repeated. It stops when it notes that it has reached a state which it was already in. If it reaches the same state again, it means that we are about to repeat a division that we have already done, which means that the dividend and remainder are going to be the same, and we are going to do the same series of steps we have already done.

When that happens, it means a repetition, and it stops and adds the parentheses.

For example, let's divide 123 by 999. This should give us the repeating decimal 0.123123123..., so the output should be 0.(123) .

• 123 / 999 is 0. The remainder is 123. We start with 0.
• Multiply the remainder by 10. Now we have 1230 / 999. Dividend is 1, remainder is 231. Now we have 0.1
• Multiply the remainder by 10. Now we have 2310 / 999. Dividend is 2, remainder is 312. Now we have 0.12
• Multiply the remainder by 10. Now we have 3120 / 999. Dividend is 3, remainder is 123. Now we have 0.123
• Multiply the remainder by 10. Now we have 1230 / 999... wait, we have already done that! That means that as we continue to divide, we'll get to that number again and again. Stop and put parentheses around the repeating part.

The map is there to tell us which numbers we have already divided, and at which index in the StringBuilder . When we find a number we have already divided, we use that index to know where to insert the parenthesis.

Answer 2

Clearly it's possible to have a decimal number with two or more decimals recurring and then a different decimal. For example 449/1000 = 0.449

Answer 3

This problem is actually very simple to solve if we use the long division technique that we learnt in 4th grade.

Suppose you need to divide 92 by 22. How do you do it using the long division method. How do you detect a repeating pattern?

Simple, you know you have a repeating pattern of decimals when you encounter a previously encountered reminder . You'll need to store the reminders and the corresponding index of the result in a dictionary and using the same you could detect/print repeating decimals. Working python code below.

def divide(numerator, denominator):
    sign, res, lead = '', '', ''
    if (numerator < 0) ^ (denominator < 0) and numerator != 0:
        sign = '-'
    numerator = abs(numerator)
    denominator = abs(denominator)
    remainders = defaultdict(list)

    if numerator < denominator:
        lead = '0'
    _x = str(numerator)
    r = 0
    i = 0
    j = 0
    while True:
        if i < len(_x):
            d = int(str(r)+_x[i])
            q = d // denominator
            if not (q == 0 and len(res) == 0):
                res += str(q)
            r = d - (q * denominator)
            i += 1
        elif i >= len(_x) and j <= 9223372036854775807:
            if r == 0:
                return sign+lead+res
            if j == 0:
                remainders[r] = [True, len(res)+1]
                res += '.'
            d = int(str(r) + '0')
            q = d // denominator
            res += str(q)
            r = d - (q * denominator)
            if remainders[r] and remainders[r][0]:
                res = res[0:remainders[r][1]] + '(' + res[remainders[r][1]:] + ')'
                return sign+lead+res
            remainders[r] = [True, len(res)]
            j += 1
        else:
            return sign+lead+res

Answer 4

Here is my solution in Java to this problem:

/**
 * Given two integers a and b, return the result as a String.
 * Display the repeating part of the fraction in parenthesis.
 *
 * Runs in O(b)
 *
 * @author Raed Shomali
 */
public class Divider {

    private static final String DOT = ".";
    private static final String ERROR = "ERROR";
    private static final String LEFT_PARENTHESIS = "(";
    private static final String RIGHT_PARENTHESIS = ")";

    public static String divide(final int a, final int b){
        if (b == 0) {
            return ERROR;
        }

        int value = a / b;
        int remainder = a % b;
        return String.valueOf(value) + DOT + divider(remainder, b);
    }

    private static String divider(final int a, final int b) {
        final Map<Integer, Integer> remainderIndexMap = new HashMap<>();
        final List<Integer> values = new ArrayList<>();

        int value;
        int remainder = a;
        while (!remainderIndexMap.containsKey(remainder)) {
            remainderIndexMap.put(remainder, values.size());

            remainder *= 10;
            value = remainder / b;
            remainder = remainder % b;
            values.add(value);
        }

        final int index = remainderIndexMap.get(remainder);
        final StringBuilder result = new StringBuilder();
        for (int i = 0; i < index; i++) {
            result.append(values.get(i));
        }
        result.append(LEFT_PARENTHESIS);
        for (int i = index; i < values.size(); i++) {
            result.append(values.get(i));
        }
        result.append(RIGHT_PARENTHESIS);
        return result.toString();
    }
}

Basically, the idea is simple. Using the same long division technique, you know when to stop when you have already seen the same remainder value.

Here are some test cases to show a few different scenarios:

divide(0, 0)     // "ERROR"
divide(1, 2)     // "0.5(0)"
divide(0, 3)     // "0.(0)"
divide(10, 3)    // "3.(3)"
divide(22, 7)    // "3.(142857)"
divide(100, 145) // "0.(6896551724137931034482758620)"

If you are interested in a solution written in Go , you can find it here https://github.com/shomali11/util