thảo luận Leetcode mỗi ngày

class Fraction:
    def __init__(self, numerator: int, denominator: int):
        self.numerator = numerator
        self.denominator = denominator
        self.__simplify()

    def add(self, f: 'Fraction') -> 'Fraction':
        return Fraction(
            self.numerator * f.denominator + f.numerator * self.denominator,
            self.denominator * f.denominator
        )

    def __str__(self) -> str:
        return '{}/{}'.format(self.numerator, self.denominator)

    def __simplify(self) -> None:
        gcd_num = gcd(self.numerator, self.denominator)
        self.numerator //= gcd_num
        self.denominator //= gcd_num

class Solution:
    def fractionAddition(self, expression: str) -> str:
        ans = None
        sign = 1
        sub_expression = str()

        for c in (expression + '+'):
            if c in ['-', '+']:
                if sub_expression:
                    numerator, denominator = sub_expression.split('/')
                    fraction = Fraction(sign * int(numerator), int(denominator))
                    ans = fraction if not ans else ans.add(fraction)
                sign = -1 if c == '-' else 1
                sub_expression = str()
            else:
                sub_expression += c

        return str(ans)

class Solution:
    def fractionAddition(self, expression: str) -> str:
        n = len(expression)
        def evaluate(aOperation, firstNum, bOperation, secondNum):
            a,b =  firstNum.split("/")
            a,b = int(a), int(b)
            c,d = secondNum.split("/")
            c,d = int(c), int(d)
            fraction = lcm(b, d)
            a*= fraction//b
            c*= fraction//d
            a*= aOperation
            c*= bOperation
            e = a + c
            if e == 0:
                return (1, "0/1")
            f = gcd(fraction, e)
            fraction//=f
            e//=f
            ans = str(abs(e)) + "/" + str(fraction)
            if e < 0:
                return (-1, ans)
        
            return (1, ans)
        last = None
        i = 0
        
        while i < n:
            if i == 0:
                if expression[i] == '-':
                    operation = -1
                else:
                    operation = 1
                    i -=1
            else:
                operation = 1 if expression[i] == "+" else -1
            currentExpression = ""
            i+=1
            if i + 1 < n and expression[i + 1] == "0":
                currentExpression = "10"
                i += 1
            else:
                currentExpression = expression[i]
            
            i += 1
            currentExpression += expression[i]
            i += 1
            if i + 1 < n and expression[i + 1] == "0":
                currentExpression += "10"
                i += 1
            else:
                currentExpression += expression[i]
            
            i += 1
            if not last:
                last = (operation, currentExpression)
            else:
                result = evaluate(last[0], last[1], operation, currentExpression)
                last = result
        ans = ""
        if last[0] == -1:
            ans += '-'
        
        ans += str(last[1])
        return ans

class Solution {
    func fractionAddition(_ expression: String) -> String {
        var resultUp = 0
        var resultDown = 0

        var upNum = 0
        var downNum = 0
        var isPos = true
        var isUp = true
        func addNum() {
            guard downNum != 0 else { return }
            if resultUp == 0 {
                resultUp = isPos ? upNum : -upNum
                resultDown = downNum
            } else {
                //
                resultUp = resultDown*(isPos ? upNum : -upNum)+resultUp*downNum
                resultDown = resultDown*downNum
            }
            //
            upNum = 0
            downNum = 0
            isUp = true
        }
        for c in expression {
            if c == "-" {
                addNum()
                isPos = false
            } else if c == "+" {
                addNum()
                isPos = true
            } else if c == "/" {
                isUp = false
            } else {
                let num = Int(String(c)) ?? 0
                if isUp {
                    upNum = upNum*10 + num
                } else {
                    downNum = downNum*10 + num
                }
            }
        }

        addNum()

        func simplify(top:Int, bottom:Int) -> (newTop:Int, newBottom:Int) {
            guard bottom != 0 else {
                return (0, 0)
            }
            
            var x = top
            var y = bottom
            while (y != 0) {
                let buffer = y
                y = x % y
                x = buffer
            }
            let hcfVal = abs(x)
            let newTopVal = top/hcfVal
            let newBottomVal = bottom/hcfVal
            return(newTopVal, newBottomVal)
        }

        let (rUp, rDown) = simplify(top:resultUp, bottom:resultDown)
        return "\(rUp)/\(rDown != 0 ? rDown : 1)"
    }
}

class Solution {
    public String fractionAddition(String expression) {
        String prefix = "";
        Queue<Character> queue = new ArrayDeque<>();
        for (char c : expression.toCharArray()) {
            if (c == '-' && queue.isEmpty()) {
                queue.offer(c);
                continue;
            }
            if (c == '+' || c == '-') {
                StringBuilder fraction = new StringBuilder();
                while (!queue.isEmpty()) {
                    fraction.append(queue.poll());
                }
                prefix = addFriction(prefix, fraction.toString());
            }
            queue.offer(c);
        }
        StringBuilder last = new StringBuilder();
        while (!queue.isEmpty()) {
            last.append(queue.poll());
        }
        return addFriction(prefix, last.toString());
    }

    private String addFriction(String f1, String f2) {
        if (Objects.equals(f1, "")) {
            return f2;
        }
        int in1 = Integer.parseInt(f1.split("/")[0]);
        int de1 = Integer.parseInt(f1.split("/")[1]);
        int in2 = Integer.parseInt(f2.split("/")[0]);
        int de2 = Integer.parseInt(f2.split("/")[1]);
        int numerator = in1 * de2 + in2 * de1;
        int denominator = de1 * de2;
        return reduce(numerator, denominator);
    }

    private String reduce(int numerator, int denominator) {
        if (numerator == 0) {
            return "0/1";
        }
        int n = 1;
        int result = 1;
        while (n <= Math.abs(numerator) && n <= Math.abs(denominator)) {
            if (numerator % n == 0 && denominator % n == 0) {
                result = n;
            }
            n++;
        }
        return numerator / result + "/" + denominator / result;
    }
}

class Solution {
    public String fractionAddition(String expression) {
        String[] danhSachPhanSo = expression.split("(?=[-+])");
        PhanSo phanso = new PhanSo(danhSachPhanSo[0]);

        for (int i = 1; i < danhSachPhanSo.length; i++) {
            phanso.cong(danhSachPhanSo[i]);
        }

        return phanso.toString();
    }

    class PhanSo {
        int tu;
        int mau;

        public PhanSo(String phanso) {
            String[] tuVaMau = phanso.split("/");
            this.tu = Integer.parseInt(tuVaMau[0]);
            this.mau = Integer.parseInt(tuVaMau[1]);
        }

        public void cong(String phanso) {
            String[] tuVaMau = phanso.split("/");
            int tu1 = Integer.parseInt(tuVaMau[0]);
            int mau1 = Integer.parseInt(tuVaMau[1]);

            if (tu == 0) {
                tu = tu1;
                mau = mau1;
            } else {
                tu = tu * mau1 + tu1 * mau;
                mau = mau * mau1;
            }
            toiGianPhanSo();
        }

        private void toiGianPhanSo() {
            if (tu == 0) {
                mau = 1;
                return;
            }

            int ucln = timUCLN(tu, mau);

            tu = tu/ucln;
            mau = mau/ucln;

            if ((mau < 0 && tu > 0) || (mau < 0 && tu < 0)) {
                mau = -mau;
                tu = -tu;
            }
        }

        private int timUCLN(int a, int b) {
            while (b != 0) {
                int temp = b;
                b = a % b;
                a = temp;
            }
            return a;
        }

        @Override
        public String toString() {
            return tu + "/" + mau;
        }
    }
}

class Solution:
    def fractionAddition(self, E: str) -> str:
        d = defaultdict(list)
        for i,e in enumerate(E):
            if e == "/":
                n1 = ""
                j = i - 1
                while j >= 0 and E[j] != "-" and E[j] != "+":
                    n1 = E[j] + n1
                    j -= 1
                n1 = int(n1)
                n2 = -1 if j >= 0 and E[j] == "-" else 1
                n3 = ""
                k = i + 1
                while k < len(E) and E[k] != "-" and E[k] != "+":
                    n3 += E[k]
                    k += 1
                n3 = int(n3)
                d[n3].append(n1 * n2)

        def gcd(a, b):
            while b != 0:
                a, b = b, a % b
            return a
        denomirator = 1
        for k in d:
            denomirator *= k
        numerator = 0
        for k,v in d.items():
            for n in v:
                numerator += n * (denomirator // k)
        if numerator == 0:
            return "0/1"
        divisor = gcd(abs(numerator), denomirator)
        return f"{str(numerator // divisor)}/{denomirator//divisor}"

class Solution {
    public String fractionAddition(String s) {
        double sum = 0;
        StringBuilder sb = new StringBuilder();
        char[] cArr = s.toCharArray();
        char preOperator = '+';
        String sign = "";
        sb.append(s.charAt(0));
        int lcm = 1;
        for(int i = 1;i<cArr.length;i++){
            if(cArr[i]!='+' && cArr[i]!='-')
                sb.append(cArr[i]);
            if(cArr[i]=='+'||cArr[i]=='-'||i==s.length()-1){
                    String fraction = sb.toString();
                    String[] arr = fraction.split("/");
                    int numerator = Integer.parseInt(arr[0]);
                    int denominator = Integer.parseInt(arr[1]);
                    if(preOperator == '+')
                        sum+= (double) numerator/denominator;
                    else
                        sum-= (double) numerator/denominator;
                    lcm = lcm(lcm,denominator);
                    sb.delete(0,sb.length());
                    preOperator = cArr[i];
            }
        }
        if(sum == (int) sum){
            sb.append((int)sum);
            sb.append("/1");
            return sb.toString();
        }else{
            if(sum<0){
                sign = "-";
                sum*=-1;
            }
            int newNumerator = (int) (Math.round(sum*lcm));
            int gcd = gcd(newNumerator,lcm);
            lcm/=gcd;
            newNumerator/=gcd;
            sb.append(sign);
            sb.append(newNumerator);
            sb.append('/');
            sb.append(lcm);
            return sb.toString();
        }
    }

    public int gcd(int a, int b){
        if(b==0) return a;
        return gcd(b,a%b);
    }

    public int lcm(int a,int b){
        return a*b/gcd(a,b);
    }
}

class Solution {
    public String fractionAddition(String expression) {

        expression = expression.replace("-", "+-");
        String[] fractions = expression.split("\\+");
        
        int numerator = 0, denominator = 1;
        
        for (String fraction : fractions) {
            if (!fraction.isEmpty()) {
                String[] parts = fraction.split("/");
                int num = Integer.parseInt(parts[0]);
                int den = Integer.parseInt(parts[1]);
                
                numerator = numerator * den + num * denominator;
                denominator *= den;
                
                int gcd = gcd(Math.abs(numerator), Math.abs(denominator));
                numerator /= gcd;
                denominator /= gcd;
            }
        }
        
        return numerator + "/" + denominator;
    }
    
    private static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
}

class Solution {
    class Fraction {
        int numerator;
        int denominator;

        public Fraction() {
            this.numerator = 0;
            this.denominator = 1;
        }

        public Fraction(int numerator, int denom) {
            this.numerator = numerator;
            this.denominator = denom;
        }

        public Fraction(int num) {
            this.numerator = num;
            this.denominator = 1;
        }

        int getNumerator() {
            return this.numerator;
        }

        int getDenominator() {
            return this.denominator;
        }

        void setNumerator(int num) {
            this.numerator = num;
        }

        void setDenominator(int num) {
            this.denominator = num;
        }

        public void simplify() {
            int a = this.numerator;
            int b = this.denominator;
            int gcd = gcd(Math.abs(a), Math.abs(b));
            this.numerator = a / gcd;
            this.denominator = b / gcd;
        }

        public Fraction plus(Fraction f2) {
            int a = this.numerator;
            int b = this.denominator;
            int c = f2.getNumerator();
            int d = f2.getDenominator();
            this.setNumerator(a * d + b * c);
            this.setDenominator(b * d);
            this.simplify();
            return this;
        }

        public Fraction substract(Fraction f2) {
            int a = this.numerator;
            int b = this.denominator;
            int c = f2.getNumerator();
            int d = f2.getDenominator();
            this.setNumerator(a * d - b * c);
            this.setDenominator(b * d);
            this.simplify();
            return this;
        }
    }

    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    public String fractionAddition(String expression) {
        expression = expression.replace("-", "+-");
        String[] fractions = expression.split("\\+");
        Fraction res = new Fraction(0);
        for (String fraction : fractions) {
            if (!fraction.isEmpty()) {
                String[] parts = fraction.split("/");
                int num = Integer.parseInt(parts[0]);
                int den = Integer.parseInt(parts[1]);
                res.plus(new Fraction(num, den));

            }
        }
        return res.getNumerator() + "/" + res.getDenominator();
    }
}

class Solution:
    def fractionAddition(self, expression: str) -> str:
        d = defaultdict(list)
        for i , v in enumerate(expression):
            if v == '/':
                n1 = ""
                j = i - 1
                while j >= 0 and expression[j] != '+' and expression[j] != '-':
                    n1 = expression[j] + n1
                    j -= 1
                n1 = int(n1)
                n2 = -1 if expression[j] == '-' else 1

                k = i + 1
                n3 = ""
                while k < len(expression) and expression[k] != '+' and expression[k] != '-':
                    n3 += expression[k]
                    k += 1
                n3 = int(n3)
                d[n3].append(n1 * n2)
        denominator = 1
        for k in d: denominator *= k
        
        numerator = 0
        for k , v in d.items():
            for n in v: numerator += (denominator // k) * n
        
        if numerator == 0: return "0/1"
        common = gcd(denominator , numerator)

        return f"{numerator // common}/{denominator // common}"

function fractionAddition(expression: string): string {
    let totalNumerator = 0;
    let totalDenominator = 1;
    let subExpression = '';
    let index = 0;
    while (index < expression.length) {
        while (((expression[index] !== '-') || index === 0) && expression[index] !== '+' && index < expression.length) {
            subExpression += expression[index];
            index+=1
        }
        const [num, denom] = subExpression.split('/').map(Number);
        totalNumerator = totalNumerator * denom + totalDenominator * num;
        totalDenominator *= denom;
        subExpression = expression[index];
        index +=1
    }

    const resultSimple = simpleFraction(totalNumerator, totalDenominator);
    return resultSimple.join('/');
}

function simpleFraction(numerator, denominator) {
    var gcd = function gcd(a, b) {
        return b ? gcd(b, a % b) : a;
    };
    const gcdVal = Math.abs(gcd(numerator, denominator));
    return [numerator / gcdVal, denominator / gcdVal];
}

class Solution {
public:
    int gcd(int a, int b){
        while (a > 0 && b > 0) {
            if (a > b) {
                a = a % b;
            }
            else {
                b = b % a;
            }
        }
        if (a == 0) {
            return b;
        }
        return a;
    }
    string fractionAddition(string expression) {
        int numL = 0, deL= 1;
        int numR = 0, deR= 1;
        int i=0;
        string tmpNumL = "", tmpDeL= "";
        int isNeg = 1;
        while(expression[i] != '/') {
            if(expression[i] == '-') {
                isNeg = -1;
                i++;
                continue;
            }
            tmpNumL += expression[i];
            i++;   
        }
        i++;
        while(i < expression.size() && (expression[i] != '+' && expression[i] != '-')) {
            tmpDeL += expression[i];
            i++;
        }
        numL = stoi(tmpNumL) * isNeg;
        deL  = stoi(tmpDeL);
        if(expression[i] == '-'){
            isNeg = -1;
        }else{
            isNeg = 1;
        }
        i++;
        for(;i< expression.size();i++){
            string tmpNumR = "", tmpDeR= "";
            bool sign = true;
            while(expression[i] != '/') {
                tmpNumR += expression[i];
                i++;   
            }
            i++;
            while(i < expression.size() && (expression[i] != '+' && expression[i] != '-')) {
                tmpDeR += expression[i];
                i++;
            }
            numR = stoi(tmpNumR);
            deR  = stoi(tmpDeR);
            numL = numL * deR + deL * numR * isNeg;
            deL = deR * deL;
            if(i < expression.size() && expression[i] == '-'){
                isNeg = -1;
            }else{
                isNeg = 1;
            }
        }
        cout << numL << " " << deL << endl;
        string res = "";
        if(numL < 0){
            res += '-';
            numL *= -1;
        }
        int divisor = gcd(numL, deL);
        res += to_string(numL/divisor);
        res += "/";
        res += to_string(deL/divisor);
        return res;
    }
};