清华大学分数计算器

雨点打透心脏的1/2处 2022-02-23 16:56 239阅读 0赞

编写一个python程序（[假设python文件名为exam01.py][python_exam01.py]），程序接收一个参数，该参数为一个文件名。使用命令python [exam01.py][] test.txt执行命令。该程序需满足以下要求：  
（1）如果该文件不存在，则输出错误信息并结束程序。（5分）  
（2）如果文件存在，该文件包括若干行文本，其中每一行是一个数学算式，算式中只包括正整数以及四则运算符号（±*/），程序计算该行算式，以最简分数形式输出结果，输出到命令行，每行一个。根据支持的算式格式评分。具体要求如下：  
（2.1）支持格式如“a+b”或“a-b”的数学算式计算，其中a和b的格式分别为一个正整数或者一个分数（即以“/”分隔的两个正整数）。例如：“3/5+1/2”、“12/7-3/15”、“123+23/6”。（10分）  
（2.2）支持格式如“a±b±c±……±g”的数学算式计算，其中a,b,…,g的格式也为一个正整数或者一个分数。例如：“1+2/5-3/12+123/456+76+12/34”.（10分）  
（2.3）【加分项】支持任意合法格式的数学算式计算（只包括正整数和四则运算，不含括号）。例如：“1*2/3+4-5/6+7\*8-9/10”。（10分）（建议：没有把握的同学建议先做后面的题目。）  
（3）该程序也可以接收两个参数，第一个参数作用不变，第二个参数传入另外一个文件名：如果传入一个参数，则程序结果输出到命令行；如果传入两个参数，则程序结果输出到第二个参数的文件中。（5分）

【注意问题】  
（a）只能使用Python自带的标准库，不允许使用第三方库。  
（b）最后结果输出为最简分数形式（分子分母不可约分，假分数不要化为带分数）。如果结果可以化简为整数，则直接输出为整数。  
（c）不需要考虑输入文件格式不合法的情况。  
（d）只编写一个.py文件解决上述所有要求。

【样例】  
（2.1输入样例）  
9/15+1/2  
23/6-4  
1/6+13/6  
（2.1输出样例）  
11/10  
\-1/6  
2

## 解决方法如下（python）： ##

**利用Python，解决这个问题，不言自明**

# -*- coding: utf-8 -*-
    import os
    import sys
    
    
    class Calculation:
        def __init__(self, expression: str):
            self.expression = list(expression)
            self.simple_expression = []
    
        def calculation(self):
            """
            计算，[[int, '/', int], ......]
            :return:
            """
            index = 0
            self.split_plus_less()
            for i in self.simple_expression:
                # 分数表达式的个数
                if i == '+' or i == '-':
                    continue
                index += 1
            for i in range(index - 1):
                # 依次计算各个分数项
                value = self.general_source(self.simple_expression[0:3])
                del self.simple_expression[0:3]
                self.simple_expression.insert(0, value)
            return self.approximate(self.simple_expression[0])
    
        def split_plus_less(self):
            """
            以+，-，为分隔符
            :return:
            """
            index_list = []
            for i in self.expression:
                if i == '+' or i == '-':
                    self.simple_expression.append(self.split_multiply_except(index_list))
                    self.simple_expression.append(i)
                    index_list = []
                    continue
                index_list.append(i)
            self.simple_expression.append(self.split_multiply_except(index_list))
    
        def split_multiply_except(self, expression: list):
            """
            以*，/，为分隔符，字符串转化为数字
            :param expression:
            :return:
            """
            index_list = []
            multiply_except_list = []
            for i in expression:
                if i == '*' or i == '/':
                    multiply_except_list.append(int(''.join(index_list)))
                    multiply_except_list.append(i)
                    index_list = []
                    continue
                index_list.append(i)
            try:
                # 表达式以运算符结尾
                multiply_except_list.append(int(''.join(index_list)))
                return self.simplification(multiply_except_list)
            except ValueError:
                print('Incoming expression error')
    
        def simplification(self, exception: list):
            """
            计算*
            :param exception:
            :return: [[int, '/', int], ......]
            """
            if len(exception) == 1:
                # 只含常数项
                return self.is_list(exception[0])
    
            index = 0
            value = ''
            for i in exception:
                if i == '*' or i == '/':
                    continue
                index += 1
            for i in range(index - 1):
                if exception[1] == '*' or exception[1] == '/':
                    value = self.multiply_except(exception[0:3])
                else:
                    raise TypeError('Incoming expression error')
                del exception[0:3]
                exception.insert(0, value)
            return value
    
        def multiply_except(self, exception: list):
            """
            分式乘法
            :param exception:
            :return:
            """
            first = self.is_list(exception[0])
            second = self.is_list(exception[2])
            if exception[1] == '*':
                return [first[0] * second[0], '/', first[2] * second[2]]
            elif exception[1] == '/':
                return [first[0] * second[2], '/', first[2] * second[0]]
            else:
                raise TypeError('Incoming expression error')
    
        @staticmethod
        def is_list(value):
            """
            将数字转换为[int, '/', int]
            :param value:
            :return: [int, '/', int]
            """
            if isinstance(value, list):
                return value
            return [value, '/', 1]
    
        @staticmethod
        def general_source(expression: list):
            """
            general source
            :param expression: [[int, '/', int], '+', [int, '/', int]]
            :return:[int, '/', int]
            """
            expression = [expression[0][0] * expression[2][2], expression[2][0] * expression[0][2],
                          expression[0][2] * expression[2][2], expression[1]]
            if expression[-1] == '+':
                return [expression[0] + expression[1], '/', expression[2]]
            elif expression[-1] == '-':
                return [expression[0] - expression[1], '/', expression[2]]
            else:
                raise TypeError('Incoming expression error')
    
        @staticmethod
        def approximate(expression: list):
            index = gcd(expression[0], expression[2])
            expression[0] = str(int(expression[0] / index))
            expression[2] = str(int(expression[2] / index))
            return ''.join(expression)
    
    
    def main():
        file_path, save_file = sys.argv[1:3]
        if not os.path.exists(file_path):
            print('path is not exists, please check it')
            raise ValueError
        with open(file_path, 'r') as file:
            for line in file.readlines():
                if line == '\n':
                    continue
                with open(save_file, 'a') as f:
                    f.write('\n' + ''.join(Calculation(line).calculation()) + '\n')
    
    
    def gcd(x, y):
        """
        最大公约数
        """
        if y == 0:
            return x
        else:
            return gcd(y, x % y)
    
    
    main()

[python_exam01.py]: http://xn--pythonexam01-4f5sh6fish27rbn6ec05h.py
[exam01.py]: http://exam01.py