g0501_0600.s0592_fraction_addition_and_subtraction.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0501_0600.s0592_fraction_addition_and_subtraction;

// #Medium #String #Math #Simulation #2022_08_25_Time_6_ms_(91.33%)_Space_40.8_MB_(97.33%)

import java.util.ArrayList;
import java.util.List;

/**
 * 592 - Fraction Addition and Subtraction\.
 *
 * Medium
 *
 * Given a string `expression` representing an expression of fraction addition and subtraction, return the calculation result in string format.
 *
 * The final result should be an [irreducible fraction](https://en.wikipedia.org/wiki/Irreducible_fraction). If your final result is an integer, change it to the format of a fraction that has a denominator `1`. So in this case, `2` should be converted to `2/1`.
 *
 * **Example 1:**
 *
 * **Input:** expression = "-1/2+1/2"
 *
 * **Output:** "0/1" 
 *
 * **Example 2:**
 *
 * **Input:** expression = "-1/2+1/2+1/3"
 *
 * **Output:** "1/3" 
 *
 * **Example 3:**
 *
 * **Input:** expression = "1/3-1/2"
 *
 * **Output:** "-1/6" 
 *
 * **Constraints:**
 *
 * *   The input string only contains `'0'` to `'9'`, `'/'`, `'+'` and `'-'`. So does the output.
 * *   Each fraction (input and output) has the format `±numerator/denominator`. If the first input fraction or the output is positive, then `'+'` will be omitted.
 * *   The input only contains valid **irreducible fractions** , where the **numerator** and **denominator** of each fraction will always be in the range `[1, 10]`. If the denominator is `1`, it means this fraction is actually an integer in a fraction format defined above.
 * *   The number of given fractions will be in the range `[1, 10]`.
 * *   The numerator and denominator of the **final result** are guaranteed to be valid and in the range of **32-bit** int.
**/
public class Solution {
    private int gcd(int a, int b) {
        return a % b == 0 ? b : gcd(b, a % b);
    }

    private String format(int a, int b) {
        int gcd = Math.abs(gcd(a, b));
        return a / gcd + "/" + (b / gcd);
    }

    private int[] parse(String s) {
        int idx = s.indexOf("/");
        return new int[] {
            Integer.parseInt(s.substring(0, idx)), Integer.parseInt(s.substring(idx + 1))
        };
    }

    public String fractionAddition(String expression) {
        int[] rst = {0, 1};
        List list = new ArrayList<>();
        StringBuilder sb = new StringBuilder().append(expression.charAt(0));
        for (int i = 1; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == '+' || c == '-') {
                list.add(parse(sb.toString()));
                sb = new StringBuilder().append(c);
            } else {
                sb.append(c);
            }
        }
        list.add(parse(sb.toString()));
        for (int[] num : list) {
            rst = new int[] {rst[0] * num[1] + rst[1] * num[0], rst[1] * num[1]};
        }
        return format(rst[0], rst[1]);
    }
}