分类计算

分数的运算
描述

给你两个分数，要求你设计程序算出他们的和，差，积，且要求使用最简整数比表示(分子分母不能再约分)

注意，对于运算后为整数的，只输出一个整数。

输入项
一行两个分数a/b 和c/d，各自由用分数线隔开

输出量
分三行输出:(均仍用分数线隔开分子分母)

第一行为两个分数相加的和 第二行为两个分数相减的差(可能为负) 第三行为两个分数的乘积(保证分母分子长度小于18)

样本输入1

1/6 5/6
样本输出1

1
-2/3
5/36

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String a = scanner.next();
        String b = scanner.next();

        String[] ad = a.split("/");
        String[] bd = b.split("/");

        Long cd;

        Long result_m = Long.parseLong(ad[0]) * Long.parseLong(bd[1]) + Long.parseLong(bd[0]) * Long.parseLong(ad[1]);
        Long result_d = Long.parseLong(ad[1]) * Long.parseLong(bd[1]);
        Long result_m_add = result_m;
        Long result_d_add = result_d;

        if (result_m_add == 0 || result_d_add == 1) {
            System.out.println(result_m_add);
        } else {
            if (result_m > result_d) {
                Long re = result_m % result_d;
                while (re != 0) {
                    result_m = result_d;
                    result_d = re;
                    re = result_m % result_d;
                }
                cd = Math.abs(result_d);
                result_m = result_m_add / cd;
                result_d = result_d_add / cd;
                if (result_d == 1){
                    System.out.println(result_m);
                }else {
                    System.out.println(result_m + "/" + result_d);
                }
            } else {
                Long re = result_d % result_m;
                while (re != 0) {
                    result_d = result_m;
                    result_m = re;
                    re = result_d % result_m;
                }
                cd = Math.abs(result_d);

                result_m = result_m_add / cd;
                result_d = result_d_add / cd;

                if (result_d == 1){
                    System.out.println(result_m);
                }else {
                    System.out.println(result_m + "/" + result_d);
                }
            }
        }


        Long result_jm = Long.parseLong(ad[0]) * Long.parseLong(bd[1]) - Long.parseLong(bd[0]) * Long.parseLong(ad[1]);
        Long result_jd = Long.parseLong(ad[1]) * Long.parseLong(bd[1]);
        Long result_jm_jian = result_jm;
        Long result_jd_jian = result_jd;

        if (result_jm_jian == 0 || result_jd_jian == 1) {
            System.out.println(result_jm_jian);
        } else {
            if (result_jm > result_jd) {
                Long re = result_jm % result_jd;
                while (re != 0) {
                    result_jm = result_jd;
                    result_jd = re;
                    re = result_jm % result_jd;
                }
                cd = Math.abs(result_jd);

                result_jm = result_jm_jian / cd;
                result_jd = result_jd_jian / cd;
                if (result_jd == 1){
                    System.out.println(result_jm);
                }else {
                    System.out.println(result_jm + "/" + result_jd);
                }
            } else {
                Long re = result_jd % result_jm;
                while (re != 0) {
                    result_jd = result_jm;
                    result_jm = re;
                    re = result_jd % result_jm;
                }
                cd = Math.abs(result_jm);

                result_jm = result_jm_jian / cd;
                result_jd = result_jd_jian / cd;

                if (result_jd == 1){
                    System.out.println(result_jm);
                }else {
                    System.out.println(result_jm + "/" + result_jd);
                }
            }
        }


        Long result_cm = Long.parseLong(ad[0]) * Long.parseLong(bd[0]);
        Long result_cd = Long.parseLong(ad[1]) * Long.parseLong(bd[1]);
        Long result_cm_cheng = result_cm;
        Long result_cd_cheng = result_cd;

        if (result_cm_cheng == 0 || result_cd_cheng == 1) {
            System.out.println(result_cm_cheng);
        } else {
            if (result_cm > result_cd) {
                Long re = result_cm % result_cd;
                while (re != 0) {
                    result_cm = result_cd;
                    result_cd = re;
                    re = result_cm % result_cd;
                }
                cd = Math.abs(result_cd);

                result_cm = result_cm_cheng / cd;
                result_cd = result_cd_cheng / cd;
                System.out.println(result_cm + "/" + result_cd);

            } else {
                Long re = result_cd % result_cm;
                while (re != 0) {
                    result_cd = result_cm;
                    result_cm = re;
                    re = result_cd % result_cm;
                }
                cd = Math.abs(result_cm);

                result_cm = result_cm_cheng / cd;
                result_cd = result_cd_cheng / cd;

                if (result_cd == 1){
                    System.out.println(result_cm);
                }else {
                    System.out.println(result_cm + "/" + result_cd);
                }
            }
        }
    }
}

最大公约数计算