Rational Arithmetic (20)

#include <iostream>
#include <algorithm>
//long long是两个关键字拼起来的，用起来很不方便，重命名一下
typedef long long ll;
//有理数类的声明
class RationalNumber
{
    bool m_infinate; //处理除数为零
    bool m_negative; //处理负数
    
    ll m_numerator; //分子，方便输出
    ll m_denominator; //分母
    ll m_integer; //整数部分
    ll m_numeratorAll; //记录无整数分数的分子，方便进行运算
    
    ll calcGCD(ll a, ll b); //求最大公约数的函数
public:
    //构造函数
    RationalNumber(ll numerator, ll denominator);
    //四则运算重载
    RationalNumber operator+(RationalNumber const& o) const;
    RationalNumber operator-(RationalNumber const& o) const;
    RationalNumber operator*(RationalNumber const& o) const;
    RationalNumber operator/(RationalNumber const& o) const;
    //输出流运算符重载
    friend std::ostream &operator<<(std::ostream &os, RationalNumber const& o);
};
//有理数类每个方法的实现
ll RationalNumber::calcGCD(ll a, ll b){
    if (b == 0){
        return a;
    }
    //辗转相除法
    return calcGCD(b, a % b);
}
RationalNumber::RationalNumber(ll numerator, ll denominator){
    m_negative = false;
    m_infinate = false;
    //处理分母为零的情况
    if (denominator == 0){
        m_infinate = true;
        return;
    }
    //这里这样写，是因为在通过计算结果进行构造过程中，有可能出现分子分母均为负的情况。
    if (numerator < 0){
        m_negative = !m_negative;
    }
    if (denominator < 0){
        m_negative = !m_negative;
    }
    //计算整数、分子、分母。其中分母要参与下面的运算，所以不能是负的，用abs取绝对值，分子要保留 原值
    m_integer = numerator / denominator;
    m_numerator = numerator - m_integer * denominator;
    m_denominator = abs(denominator);
    //约分，注意传给子函数的分子必须是正的，分母上面处理过了
    if (m_numerator){
        ll maxtmp = calcGCD(abs(m_numerator), m_denominator);
        if (maxtmp){
            m_numerator /= maxtmp; m_denominator /= maxtmp;
        }
    }
    //计算约分后假分数版的分子，因为后续运算是不需要整数部分的，所以必须用假分数的分子算。
    m_numeratorAll = m_numerator + m_integer * m_denominator;
}
//以下为分数的加减乘除，统统使用m_numeratorAll（假分数的分子）进行运算。
RationalNumber RationalNumber::operator+(RationalNumber const& o) const {
    ll numerator = (m_numeratorAll * o.m_denominator) + (o.m_numeratorAll * m_denominator);
    ll denominator = m_denominator * o.m_denominator;
    return RationalNumber(numerator, denominator);
}
RationalNumber RationalNumber::operator-(RationalNumber const& o) const {
    ll numerator = (m_numeratorAll * o.m_denominator) - (o.m_numeratorAll * m_denominator);
    ll denominator = m_denominator * o.m_denominator;
    return RationalNumber(numerator, denominator);
}
RationalNumber RationalNumber::operator*(RationalNumber const& o) const {
    ll numerator = m_numeratorAll * o.m_numeratorAll;
    ll denominator = m_denominator * o.m_denominator;
    return RationalNumber(numerator, denominator);
}
RationalNumber RationalNumber::operator/(RationalNumber const& o) const {
    ll numerator = m_numeratorAll * o.m_denominator;
    ll denominator = m_denominator * o.m_numeratorAll;
    return RationalNumber(numerator, denominator);
}
std::ostream &operator<<(std::ostream &os, RationalNumber const& o){
    //分母为0的情况就不用继续了
    if (o.m_infinate){
        os << "Inf"; return os;
    }
    //整数和分子为0那干脆就是0了
    if (o.m_numerator == 0 && o.m_integer == 0){
        os << "0"; return os;
    }
    //负数打印括号和负号
    if (o.m_negative){
        os << "(-";
    }
    //有整数就打整数
    if (o.m_integer){
        os << abs(o.m_integer);
        if (o.m_numerator) //整数小数都有就打个空格隔开
        { os << " "; }
    }
    //有分数就打分数，分母已经abs过了，这里可以不用
    if (o.m_numerator){
        os << abs(o.m_numerator) << '/' << o.m_denominator;
    }
    //负数的后半边括号
    if (o.m_negative){
        os << ")";
    }
    return os;
}
int main(){
    ll n1, d1, n2, d2;
    scanf("%lld/%lld %lld/%lld", &n1, &d1, &n2, &d2);
    RationalNumber rn1(n1, d1), rn2(n2, d2); //轻松+愉快的使用函数时间
    std::cout << rn1 << " + " << rn2 << " = " << rn1 + rn2 << '\n';
    std::cout << rn1 << " - " << rn2 << " = " << rn1 - rn2 << '\n';
    std::cout << rn1 << " * " << rn2 << " = " << rn1 * rn2 << '\n';
    std::cout << rn1 << " / " << rn2 << " = " << rn1 / rn2 << '\n';
    return 0;
}

#include<cstdio>
struct rational{
	long long up,down;
};
long long gcd(long long a,long long b){
	return b==0?a:gcd(b,a%b);
}
rational add(rational a,rational b){
	rational c;
	c.down=a.down*b.down;
	c.up=a.up*b.down+b.up*a.down;
	return c;
}
rational minus(rational a,rational b){
	rational c;
	c.down=a.down*b.down;
	c.up=a.up*b.down-b.up*a.down;
	return c;
}
rational multiply(rational a,rational b){
	rational c;
	c.down=a.down*b.down;
	c.up=a.up*b.up;
	return c;
}
rational divide(rational a,rational b){
	rational c;
	c.down=a.down*b.up;
	c.up=a.up*b.down;
	return c;
}
void show(rational a){
	bool flag=false;
	long long x,y,z=0;
	x=a.up,y=a.down;
	if(y<0)y=-y,x=-x;
	if(y==0){
		printf("Inf");
		return;
	}
	else if(x==0){
		printf("0");
		return;
	}
	else{
		if(x<0){
			flag=true;
			x=-x;
		}
		if(flag)printf("(-");
		long long temp=gcd(x,y);
		x/=temp,y/=temp;
		z=x/y,x=x%y;
		if(z>0)printf("%lld",z);
		if(z>0&&x!=0)printf(" ");//注意空格问题
		if(x!=0)printf("%lld/%lld",x,y);
		if(flag)printf(")");
		return;
	}
}
int main(){
	//freopen("A1088.txt","r",stdin);
	rational a,b;
	scanf("%lld/%lld %lld/%lld",&a.up,&a.down,&b.up,&b.down);
	show(a);printf(" + ");show(b);printf(" = ");show(add(a,b));printf("\n");
	show(a);printf(" - ");show(b);printf(" = ");show(minus(a,b));printf("\n");
	show(a);printf(" * ");show(b);printf(" = ");show(multiply(a,b));printf("\n");
	show(a);printf(" / ");show(b);printf(" = ");show(divide(a,b));printf("\n");
	return 0;
}

#include <iostream>
#include <math.h>
using namespace std;
struct fraction{                                            //分数
    long long up,down;
};
long long gcd(long long a,long long b){                     //求最大公约数
    if(b==0) return a;
    else return gcd(b,a%b);
}
fraction reduction(fraction result){                        //化简
    if(result.down<0){                                      //使分母非负
        result.up=-result.up;
        result.down=-result.down;
    }
    if(result.up==0) result.down=1;
    else{
        long long d=gcd(abs(result.up),abs(result.down));   //约分
        result.up/=d;result.down/=d;
    }
    return result;
}
fraction add(fraction a,fraction b){                        //分数加法运算
    fraction result;
    result.up=a.up*b.down+b.up*a.down;
    result.down=a.down*b.down;
    return result;
}
fraction minu(fraction a,fraction b){
    fraction result;
    result.up=a.up*b.down-b.up*a.down;
    result.down=a.down*b.down;
    return result;
}
fraction multi(fraction a,fraction b){
    fraction result;
    result.up=a.up*b.up;
    result.down=a.down*b.down;
    return result;
}
fraction divide(fraction a,fraction b){
    fraction result;
    result.up=a.up*b.down;
    result.down=a.down*b.up;
    return result;
}
void printresult(fraction a){                               //输出
    a=reduction(a);
    if(a.up<0) cout<<"(";
    if(a.down==1) cout<<a.up;  //整数                        
    else if(abs(a.up)>a.down)  //假分数化为带分数
        cout<<a.up/a.down<<" "<<abs(a.up)%a.down<<"/"<<a.down;
    else cout<<a.up<<"/"<<a.down; //真分数
    if(a.up<0) cout<<")";
}
int main(){
    fraction a,b;
    scanf("%lld/%lld %lld/%lld",&a.up,&a.down,&b.up,&b.down);
    printresult(a);cout<<" + ";printresult(b);cout<<" = ";printresult(add(a,b));cout<<'\n';
    printresult(a);cout<<" - ";printresult(b);cout<<" = ";printresult(minu(a,b));cout<<'\n';
    printresult(a);cout<<" * ";printresult(b);cout<<" = ";printresult(multi(a,b));cout<<'\n';
    printresult(a);cout<<" / ";printresult(b);cout<<" = ";
    if(b.up==0) cout<<"Inf"<<'\n';
    else{printresult(divide(a,b));cout<<'\n';}    
    return 0;
}

import java.util.Scanner;

public class Main {
    static void pr(long a, long b) {
        long x = gcd(a, b);
        a /= x;
        b /= x;
        if (b < 0) {
            a *= -1;
            b *= -1;
        }
        if (a < 0) {
            if (-a % b == 0) {
                System.out.print("(" + a / b + ")");
            } else if (-a < b) {
                System.out.print("("+a + "/" + b+")");
            } else {
                System.out.print("(" + a / b + " " + (-a + (b * (a / b))) + "/" + b + ")");
            }
        } else {
            if (a % b == 0) {
                System.out.print(a / b);
            } else if (a < b) {
                System.out.print(a + "/" + b);
            } else {
                System.out.print(a / b + " " + (a - (b * (a / b))) + "/" + b );
            }
        }
    }
    static long  gcd(long a, long b) { //辗转相除法求最大公约数
        if (b == 0) {
            return a;
        }
        long r = a % b;
        return gcd(b, r);
    }
    static void add(long a, long b, long c, long d) {
        pr(a, b);
        System.out.print(" + ");
        pr(c, d);
        System.out.print(" = ");
        pr(a * d + b * c, b * d);
    }
    static void minus(long a, long b, long c, long d) {
        pr(a, b);
        System.out.print(" - ");
        pr(c, d);
        System.out.print(" = ");
        pr(a * d - b * c, b * d);
    }
    static void multiply(long a, long b, long c, long d) {
        pr(a, b);
        System.out.print(" * ");
        pr(c, d);
        System.out.print(" = ");
        pr(a * c, b * d);
    }
    static void division(long a, long b, long c, long d) {
        long m = a * d;
        long n = b * c;
        pr(a, b);
        System.out.print(" / ");
        pr(c, d);
        System.out.print(" = ");
        if (c == 0) {
            System.out.print("Inf");
        } else {
            if (n < 0) {
                m = m * -1; //把负号调整到分子上
                n = n * -1;
            }
            pr(m, n);
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s = sc.nextLine();
            String[] split = s.split(" ");
            String[] s1 = split[0].split("/");
            String[] s2 = split[1].split("/");
            long a = Long.parseLong(s1[0]);
            long b = Long.parseLong(s1[1]);
            long c = Long.parseLong(s2[0]);
            long d = Long.parseLong(s2[1]);
            add(a, b, c, d);
            System.out.println();
            minus(a, b, c, d);
            System.out.println();
            multiply(a, b, c, d);
            System.out.println();
            division(a, b, c, d);
        }
    }
}

#include <iostream>
using namespace std;

void parser(string& s, int& a, int& b) {
    bool symbol = true;
    int i = 0;
    if (s[i] == '-') {
        symbol = false;
        i++;
    }
    while (s[i] != '/') {
        a = a * 10 + s[i] - '0';
        i++;
    }
    while (s[++i] != '/') {
        b = b * 10 + s[i] - '0';
    }
    a *= symbol ? 1 : -1;
}

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

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

void FormatPrint(int n, int d) {
    if (d == 0) {
        cout << "Inf";
        return;
    }
    if (n == 0) {
        cout << "0 ";
        return;
    }
    bool flag = false;
    if (n < 0) {
        cout << "(-";
        n = -n;
        flag = true;
    }
    int g = gcd(n % d, d);
    if (n / d) {
        cout << n / d;
        if (n % d / g) cout << " " << n % d / g << "/" << d / g;
    } else {
        if (n % d / g) cout << n % d / g << "/" << d / g;
    }

    if (flag) cout << ") ";
    else cout << " ";
}

void calc(int n1, int d1, int n2, int d2, char op) {
    int n, d;
    if (n1 && n2) {
        d = lcm(d1, d2);
        switch (op) {
            case '+':
                n = d / d1 * n1 + d / d2 * n2;
                break;
            case '-':
                n = d / d1 * n1 - d / d2 * n2;
                break;
            case '*':
                d = d1 * d2;
                n = n1 * n2;
                break;
            case '/':
                d = d1 * n2;
                n = d2 * n1;
                if (d < 0 && n > 0) {
                    d = -d;
                    n = -n;
                }
                break;
        }

    } else if (n1 || n2) {
        d = n1 ? d1 : d2;
        switch (op) {
            case '+':
                n = n1 + n2;
                break;
            case '-':
                n = n1 + n2;
                n *= n1 ? 1 : -1;
                break;
            case '*':
                n = 0;
                break;
            case '/':
                n = 0;
                if (n2 == 0) d = 0;
        }
    } else {
        n = 0;
    }
    FormatPrint(n1, d1);
    cout << op << " ";
    FormatPrint(n2, d2);
    cout << "= ";
    FormatPrint(n, d);
    cout << endl;
}

void compute(string& s1, string& s2) {
    int n1 = 0, d1 = 0, n2 = 0, d2 = 0;
    parser(s1, n1, d1);
    parser(s2, n2, d2);

    calc(n1, d1, n2, d2, '+');
    calc(n1, d1, n2, d2, '-');
    calc(n1, d1, n2, d2, '*');
    calc(n1, d1, n2, d2, '/');
}

int main() {
    string s1, s2;
    while (cin >> s1 >> s2) {
        s1 += '/';
        s2 += '/';
        compute(s1, s2);
    }
    return 0;
}

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String str1 = in.next();
            String str2 = in.next();
            long a1 = Long.parseLong(str1.split("/")[0]);
            long b1 = Long.parseLong(str1.split("/")[1]);
            long a2 = Long.parseLong(str2.split("/")[0]);
            long b2 = Long.parseLong(str2.split("/")[1]);
            System.out.println(sum(a1, b1, a2, b2));
            System.out.println(sub(a1, b1, a2, b2));
            System.out.println(mul(a1, b1, a2, b2));
            System.out.println(div(a1, b1, a2, b2));
        }
    }
    public static boolean isZero(long a) {
        if (a == 0) {
            return true;
        }
        return false;
    }
    public static boolean isPositive(long a) {
        if (a > 0) {
            return true;
        }
        return false;
    }
    public static String finalNum(long a, long b) {
        if (a == 0) {
            return "0";
        }
        long integer = a / b;
        StringBuilder sb = new StringBuilder();
        if (integer != 0) {
            if ((isPositive(a) && isPositive(b))) {
                sb.append(integer);
                long maxNum = maxNum(a, b);
                if (maxNum != b) {
                    sb.append(" ");
                    sb.append((a - b * integer) / maxNum);
                    sb.append("/");
                    sb.append(b / maxNum);
                }
            } else if ((!isPositive(a) && isPositive(b))) {
                sb.append("(");
                sb.append(integer);
                long maxNum = maxNum(-a, b);
                if (maxNum != b) {
                    sb.append(" ");
                    sb.append(-(a + b * (-integer)) / maxNum);
                    sb.append("/");
                    sb.append(b / maxNum);
                }
                sb.append(")");
            } else if ((isPositive(a) && !isPositive(b))) {
                sb.append("(");
                sb.append(integer);
                long maxNum = maxNum(a, -b);
                if (maxNum != -b) {
                    sb.append(" ");
                    sb.append((a - b * integer) / maxNum);
                    sb.append("/");
                    sb.append(-b / maxNum);
                }
                sb.append(")");
            } else if ((!isPositive(a) && !isPositive(b))) {
                sb.append(integer);
                long maxNum = maxNum(-a, -b);
                if (maxNum != -b) {
                    sb.append(" ");
                    sb.append((-a + b * integer) / maxNum);
                    sb.append("/");
                    sb.append(-b / maxNum);
                }
            }
        } else {
            if ((isPositive(a) && isPositive(b))) {
                long maxNum = maxNum(a, b);
                if (maxNum != b) {
                    sb.append(a / maxNum);
                    sb.append("/");
                    sb.append(b / maxNum);
                }
            } else if ((!isPositive(a) && isPositive(b))) {
                sb.append("(");
                long maxNum = maxNum(-a, b);
                if (maxNum != b) {
                    sb.append(a / maxNum);
                    sb.append("/");
                    sb.append(b / maxNum);
                }
                sb.append(")");
            } else if ((isPositive(a) && !isPositive(b))) {
                sb.append("(");
                long maxNum = maxNum(a, -b);
                if (maxNum != -b) {
                    sb.append(-(a ) / maxNum);
                    sb.append("/");
                    sb.append(-b / maxNum);
                }
                sb.append(")");
            } else if ((!isPositive(a) && !isPositive(b))) {
                long maxNum = maxNum(-a, -b);
                if (maxNum != -b) {
                    sb.append((-a ) / maxNum);
                    sb.append("/");
                    sb.append(-b / maxNum);
                }
            }
        }
        return sb.toString();
    }
    /**
     * 最大公约数
     *
     * @return
     */
    public static long maxNum(long a, long b) {
        while (b != 0) {
            long tmp = a;
            a = b;
            b = tmp % b;
        }
        return a;
    }
    public static String sum(long a1, long b1, long a2, long b2) {
        if (isZero(a2)) {
            return finalNum(a1, b1) + " + " + finalNum(a2, b2) + " = " + finalNum(a1, b1);
        } else {
            long newA1 = a1 * b2;
            long newB = b1 * b2;
            long newA2 = a2 * b1;
            return finalNum(a1, b1) + " + " + finalNum(a2, b2) + " = " + finalNum(newA1 + newA2, newB);
        }
    }
    public static String sub(long a1, long b1, long a2, long b2) {
        if (isZero(a2)) {
            return finalNum(a1, b1) + " - " + finalNum(a2, b2) + " = " + finalNum(a1, b1);
        } else {
            long newA1 = a1 * b2;
            long newB = b1 * b2;
            long newA2 = a2 * b1;
            return finalNum(a1, b1) + " - " + finalNum(a2, b2) + " = " + finalNum(newA1 - newA2, newB);
        }
    }
    public static String mul(long a1, long b1, long a2, long b2) {
        if (isZero(a2)) {
            return finalNum(a1, b1) + " * " + finalNum(a2, b2) + " = " + 0;
        } else {
            long newA = a1 * a2;
            long newB = b1 * b2;
            return finalNum(a1, b1) + " * " + finalNum(a2, b2) + " = " + finalNum(newA, newB);
        }
    }
    public static String div(long a1, long b1, long a2, long b2) {
        if (isZero(a2)) {
            return finalNum(a1, b1) + " / " + finalNum(a2, b2) + " = " + "Inf";
        } else {
            long newA = a1 * b2;
            long newB = b1 * a2;
            return finalNum(a1, b1) + " / " + finalNum(a2, b2) + " = " + finalNum(newA, newB);
        }
    }

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String str1 = in.next();
            String str2 = in.next();
            String[] s1 = str1.split("/");
            String[] s2 = str2.split("/");
            int num1 = Integer.parseInt(s1[0]) * Integer.parseInt(s2[1]);
            int demo1 = Integer.parseInt(s1[1]) * Integer.parseInt(s2[1]);
            int num2 = Integer.parseInt(s2[0]) * Integer.parseInt(s1[1]);
            int demo2 = Integer.parseInt(s2[1]) * Integer.parseInt(s1[1]);
            String befor = func(num1, demo1);
            String after = func(num2, demo2);
            System.out.println(befor + " + " + after + " = " + func(num1 + num2, demo1));
            System.out.println(befor + " - " + after + " = " + func(num1 - num2, demo1));
            System.out.println(befor + " * " + after + " = " + func(num1 * num2,
                               demo1 * demo2));
            System.out.println(befor + " / " + after + " = " + func(num1 * demo2,
                                demo1 * num2));
        }
    }
    public static String func(int num, int demo) {
        if (num == 0) {
            return "0";
        }
        if (demo == 0) {
            return "Inf";
        }

        int coe = maxCoe(num, demo);
        num /= coe;
        demo /= coe;
        String ret = fake(num, demo);
        return ret;
    }
    public static int maxCoe(int num, int demo) {
        int i = num % demo;
        while (i != 0) {
            num = demo;
            demo = i;
            i = num % demo;
        }
        return demo;
    }
    public static String fake(int num, int demo) {
        boolean flag = true;
        if (demo == 0) {
            return "Inf";
        }
        if (num < 0) {
            flag = !flag;
            num *= (-1);
        }
        if (demo < 0) {
            flag = !flag;
            demo *= (-1);
        }
        String frac = "";
        if (num < demo) {
            frac = num + "/" + demo;
        } else if (num == demo) {
            frac = "1";
        } else {
            int inte = num / demo;
            num = num - inte * demo;
            if (num != 0) {
                frac = inte + " " + num + "/" + demo;
            } else {
                frac = inte + "";
            }
        }
        if (flag) {
            return frac;
        } else {
            return "(-" + frac + ")";
        }
    }
}

/*
输入描述：
    每个输入文件包含一个测试用例，在一行中以“a1/b1 a2/b2”格式给出两个有理数。
分子和分母都在长整数的范围内。如果有负号，它只能出现在
分子前面。分母保证是非零数。

输出描述：
    对于每个测试用例，分别在4行中打印两个有理数的和、差、积和商。每个的格式
行是“number1 operator number2=result”。注意，所有有理数都必须是最简单的形式“k a/b”，
其中k是整数部分，a/b是最简单的分数部分。如果数字为负数，则必须包含在一对括号中。如果
除法中的分母为零，输出“Inf”作为结果。保证所有输出整数都在长整数的范围内。
*/

#include<iostream>
using namespace std;
typedef long long int64;  //分子 分母都在长整数范围内

class Rational
{
public:
    Rational(int64 n,int64 d)
    {
        negetive = false;  //初始化为false
        isZero = false;
        
        //在输入时(输入要求中有)分母永远不可能为0，但是经过运算之后分母可能会小于0
        if(0 == d){
            isZero = true;
            return;
        }
        
        //分子小于0，表示为负数
        if(n < 0){
            negetive = !negetive;
        }
        
        //在输入时，分母一定不会小于0，但经过计算之后分母也可能会小于0
        if(d < 0){
            negetive = !negetive;
        }
        
        //如果分数是假分数，必须要将其化简为真分数例如5 / 3 --> 1 2/3
        integer = n / d;
        numerator = n - integer*d;
        denominator = abs(d);  //输出的结果中分母不为0
        
        //如果不是最简的分数，还需要将其化简为最简的分数 10 / 15 --> 2 / 3
        //方法：只需要给分子和分母除分子和分母的最大公约数
        if(numerator < -1 || numerator > 1){
            int gcd = CalcGCD(abs(numerator),denominator);
            if(gcd){  //如果最大公约数存在
                numerator /= gcd;
                denominator /= gcd;
            }
        }
        
        //运算时分子 = 整数部分*分母+化简后的真分数的分子
        totalnumerator = integer*denominator + numerator; 
    }
    
    //+运算符重载
    Rational operator+(const Rational& r)const
    {
        int64 n = totalnumerator*r.denominator + r.totalnumerator*denominator;
        int64 d = denominator*r.denominator;
        return Rational(n,d);
    }
    
    Rational operator-(const Rational& r)const
    {
        int64 n = totalnumerator*r.denominator - r.totalnumerator*denominator;
        int64 d = denominator*r.denominator;
        return Rational(n,d);
    }
    
    Rational operator*(const Rational& r)const
    {
        int64 n = totalnumerator*r.totalnumerator;
        int64 d = denominator*r.denominator;
        return Rational(n,d);
    }
    
    Rational operator/(const Rational& r)const
    {
        int64 n = totalnumerator*r.denominator;
        int64 d = denominator*r.totalnumerator;
        return Rational(n,d);
    }
    
    //输出流重载，且必须为友元函数
    friend ostream& operator<<(ostream& _cout,const Rational& r)
    {
        if(r.isZero){
            _cout << "Inf";
            return _cout;
        }
        
        if(0 == r.integer && 0 == r.numerator){
            _cout << "0";
            return _cout;
        }
        
        //如果是负数，需要用()括起来
        if(r.negetive){
            _cout << "(-";
        }
        
        //输出有理数：整数+分数
        if(r.integer){
            _cout << abs(r.integer);
            //如果分数部分存在，整数与分数部分之间有一个空格
            if(r.numerator){
                _cout << " ";
            }
        }
        
        //分数可能存在也可能不存在
        if(r.numerator){
            _cout << abs(r.numerator) << "/" << r.denominator;
        }
        
        if(r.negetive){
            _cout << ")";
        }
        return _cout;
    }
private:
    int64 CalcGCD(int64 a,int64 b)
    {
        if(b == 0){
            return a;
        }
        return CalcGCD(b,a%b);
    }
    
    
private:
    int64 numerator;  //分子
    int64 denominator;  //分母
    int64 integer;  //整数部分 例如5/3 --> 1 2/3,其中1就是整数部分
    bool negetive;  //负数
    bool isZero;   //分母是否为0
    int64 totalnumerator;  //参与运算的分子，原分子+整数部分
};

int main()
{
    int64 n1,d1,n2,d2; //n1第一个有理数的分子，d1第一个有理数的分母；n2第二个有理数的分子，d2第二个有理数的分母
    while(scanf("%lld/%lld %lld/%lld",&n1,&d1,&n2,&d2)!=EOF)
    {
        Rational r1(n1,d1);  //描述有理数的类Rational
        Rational r2(n2,d2);
        cout << r1 << " + " << r2 << " = " << r1 + r2 << endl; //此处需要输出流重载，+运算符重载
        cout << r1 << " - " << r2 << " = " << r1 - r2 << endl;
        cout << r1 << " * " << r2 << " = " << r1 * r2 << endl;
        cout << r1 << " / " << r2 << " = " << r1 / r2 << endl;
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;

struct Fraction {
	LL up,down;
} ans1,ans2,ans3,ans4,x,y;

LL gcd(LL a,LL b) {
	return b==0?a:gcd(b,a%b);
}

Fraction reduction(Fraction a) {
	if(a.down<0) {
		a.up=-a.up;
		a.down=-a.down;
	}
	if(a.up==0) {
		a.down=1;
	} else {
		LL d=gcd(abs(a.up),a.down);
		a.up/=d;
		a.down/=d;
	}
	return a;
}

Fraction Add(Fraction a,Fraction b) {
	Fraction c;
	c.up=a.up*b.down+b.up*a.down;
	c.down=a.down*b.down;
	return reduction(c);
}

Fraction Sub(Fraction a,Fraction b) {
	Fraction c;
	c.up=a.up*b.down-b.up*a.down;
	c.down=a.down*b.down;
	return reduction(c);
}

Fraction Mul(Fraction a,Fraction b) {
	Fraction c;
	c.up=a.up*b.up;
	c.down=a.down*b.down;
	return reduction(c);
}

Fraction Div(Fraction a,Fraction b) {
	Fraction c;
	c.up=a.up*b.down;
	c.down=a.down*b.up;
	return reduction(c);
}

void Printf(Fraction a) {
	a=reduction(a);
	if(a.up<0) cout<<'(';
	if(a.down==1) {
		cout<<a.up;
	} else if(abs(a.up)>a.down) {
		cout<<a.up/a.down<<" "<<abs(a.up)%a.down<<'/'<<a.down;
	} else {
		cout<<a.up<<'/'<<a.down;
	}
	if(a.up<0) cout<<')';
}

int main() {
	scanf("%lld/%lld %lld/%lld",&x.up,&x.down,&y.up,&y.down);
	ans1=Add(x,y);
	ans2=Sub(x,y);
	ans3=Mul(x,y);
	Printf(x);cout<<" + ";Printf(y);cout<<" = ";Printf(ans1);cout<<endl;
    Printf(x);cout<<" - ";Printf(y);cout<<" = ";Printf(ans2);cout<<endl;
	Printf(x);cout<<" * ";Printf(y);cout<<" = ";Printf(ans3);cout<<endl;
	Printf(x);cout<<" / ";Printf(y);cout<<" = ";if(y.up==0) printf("Inf");else Printf(Div(x,y));
	return 0;
}

import java.util.*;
class Rational{
    private long numerator;// 分子
    private long denominator;// 分母
    private long integer;// 整数部分
    private boolean negetive;// 负数帕努单
    private boolean isZero;// 分母为零
    private long totalNumerator;// 最终参与运算的分子
    public static long paraseNumerator(String s){
        // 提取 分数的 分子
        return Long.parseLong(s.substring(0,s.indexOf('/')));
    }
    public static long paraseDenominator(String s){
        // 提取 分数的 分子
        return Long.parseLong(s.substring(s.indexOf('/')+1));
    }
    Rational(long n,long d){
        if(0 == d){
            isZero = true;
            return;
        }
        if(n < 0){
            negetive = true;
        }
        if(d < 0){
            negetive = !negetive;
        }
        // 如果输入的是假分数，需要将其调整为真分数，比如 5/3 == 1 2/3
        integer = n/d;
        numerator = n - integer * d;
        denominator = Math.abs(d);
        
        // 如果分数不是最简的形式，需要将其你约分为最简的形式，比如 10/15 == 2/3
        // 在分子和分母的基础之上，分别处以分子和分母的最大公约数
        if(numerator > 1 || numerator < -1){
            long gcd = calcGCD(Math.abs(numerator),denominator);
            if(gcd > 0){
                numerator /= gcd;
                denominator /= gcd;
            }
        }
        totalNumerator = numerator + integer * denominator;
    }
    private long calcGCD(long a,long b){
        if(b == 0){
            return a;
        }
        return calcGCD(b,a%b);
    }
    public Rational add(Rational r){
        long n = totalNumerator * r.denominator + denominator * r.totalNumerator;
        long d = denominator * r.denominator;
        return new Rational(n,d);
    }
    public Rational sub(Rational r){
        long n = totalNumerator * r.denominator - denominator * r.totalNumerator;
        long d = denominator * r.denominator;
        return new Rational(n,d);
    }
    public Rational mul(Rational r){
        long n = totalNumerator * r.totalNumerator;
        long d = denominator * r.denominator;
        return new Rational(n,d);
    }
    public Rational div(Rational r){
        long n = totalNumerator * r.denominator;
        long d = denominator * r.totalNumerator;
        return new Rational(n,d);
    }
    public String toString(){
        StringBuffer s = new StringBuffer();
        
        if(isZero){
            s.append("Inf");
        }else if(integer == 0 && numerator == 0){
            s.append("0");
            return new String(s);
        }
        else{
            if(negetive){
                s.append("(-");
            }
            if(0 != integer){
                s.append(Math.abs(integer));
                if(numerator != 0){
                    s.append(" ");
                }
            }
            if(0 != numerator){
                s.append(Math.abs(numerator));
                s.append('/');
                s.append(denominator);
            }
        }
        if(negetive){
            s.append(')');
        }
        return new String(s);
    }
}
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String s = sc.next();// 第一个分数
            Rational r1 = new Rational(Rational.paraseNumerator(s),Rational.paraseDenominator(s));
            s = sc.next();// 第一个分数
            Rational r2 = new Rational(Rational.paraseNumerator(s),Rational.paraseDenominator(s));
            System.out.println(r1 + " + " + r2 + " = " + r1.add(r2));
            System.out.println(r1 + " - " + r2 + " = " + r1.sub(r2));
            System.out.println(r1 + " * " + r2 + " = " + r1.mul(r2));
            System.out.println(r1 + " / " + r2 + " = " + r1.div(r2));
        }
        sc.close();
    }
}

想的简单，写得多

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;
class Solution {
public:
    //对外接口
    void Calculate(vector<string>& n) {
        //划分数据
        int index = 0, idx = 0;
        Split(n[0], index, idx);
        idx = 0;
        Split(n[1], index, idx);
        //为避免两有理数被多次计算字符串，此处进行计算
        Head(num[0], num[1], n1);
        Head(num[2], num[3], n2);
        // +
        int s = num[0] * num[3] + num[2] * num[1];
        int p = num[1] * num[3];
        Show(s, p, '+');
        // -
        s = num[0] * num[3] - num[2] * num[1];
        Show(s, p, '-');
        // *
        s = num[0] * num[2];
        p = num[1] * num[3];
        Show(s, p, '*');
        // /
        s = num[0] * num[3];
        p = num[1] * num[2];
        if (p < 0 && s>0)//若分母为负数，交换负号
            s *= -1, p *= -1;
        Show(s, p, '/');
    }
    Solution() :num(4) {}
private:
    //更相减损术
    int GDC(int m1, int m2) {
        m1 *= m1 < 0 ? -1 : 1;
        m2 *= m2 < 0 ? -1 : 1;
        while (m1 != m2) {
            if (m1 > m2)
                m1 -= m2;
            else if (m1 < m2)
                m2 -= m1;
            else
                return m1;
        }
        return m1;
    }
    //格式控制及输出
    void Show(const int& s, const int& p, const char& sys) {
        string head;
        //拼接第一个有理数
        head += n1;
        head += ' ';
        head += sys;
        head += ' ';
        //拼接第二个有理数
        head += n2;
        head += " = ";
        //拼接结果
        if (!p)
            head += "Inf";
        else if (!s)
            head += '0';
        else
            Head(s, p, head);
        cout << head << endl;
    }
    //输出字符串拼接
    void Head(const int& s, const int& p, string& head) {
        if (s == 0) {
            head += '0';
        }
        else if (abs(s) > p) {//存在整数部分
            bool flag = s < 0;//负数为真
            if (flag)
                head += "(-";
            head += to_string(abs(s / p));//整数部分
            if (s/p*p != s) {//存在小数部分
                head += ' ';
                 CalFraction(s,p,head);
            }
            if (flag)
                head += ")";
        }
        else if (s == p)
            head += '1';
        else {//不存在整数部分
            bool flag = s < 0;//负数为真
            if (flag)
            head += "(-";
            CalFraction(s,p,head);
            if (flag)
                head += ")";
        }
    }
    //计算分数部分
    void CalFraction(const int& s,const int& p,string& head){
        int fac = GDC(abs(s) % p, p);//最大公因数
        head += to_string((abs(s) - abs(s) / p * p) / fac);
        head += '/';
        head += to_string(p / fac);
    }
    //数字切割
    void Split(string& n,int& index,int& idx) {
        int sys = n[0] == '-' ? -1 : 1;//正负判断
        idx += sys == -1 ? 1 : 0;//确定因符号引起的偏移
        int pos = n.find('/', idx);//找出完整数字
        for (int j = idx; j < pos; ++j)
            num[index] = num[index] * 10 + (n[j] - '0');
        num[index++] *= sys;
        idx = pos + 1;
        pos = n.size();
        for (int j = idx; j < pos; ++j)
            num[index] = num[index] * 10 + (n[j] - '0');
        ++index;
    }
private:
    vector<int> num;//[a1,b1,a2,b2]
    string n1;//数1的输出格式
    string n2;//数2的输出格式
};

int main() {
    Solution S;
    vector<string> n(2);
    while (cin >> n[0] >> n[1])
        S.Calculate(n);
    return 0;
}

import fractions


def getStr(x: fractions.Fraction):
    ret = ''
    up = x.numerator
    down = x.denominator
    if up < 0:
        ret += '('
    if abs(up) < down&nbs***bsp;up % down == 0:
        ret += str(x)
    else:
        left = int(abs(up)//down*(abs(up)//up))
        up1 = abs(up) % down
        ret += '{} {}/{}'.format(left, up1, down)
    if up < 0:
        ret += ')'
    return ret


lst = input().split()
a, b = fractions.Fraction(lst[0]), fractions.Fraction(lst[1])
opera = ['+', '-', '*']
num = [a+b, a-b, a*b]
for i in range(3):
    res = getStr(a) + ' ' + opera[i] + ' ' + getStr(b) + ' ' + '=' + ' ' + getStr(num[i])
    print(str(res).strip())
res = getStr(a) + ' ' +  '/'  + ' ' + getStr(b) + ' ' + '=' + ' '
if abs(b.numerator) < 0.00001:
    res += "Inf"
else:
    res += getStr(a/b)
print(res)