小学生四则运算(-) 递归实现
小学生四则运算(-) 递归实现
题目见邹欣老师的博客,简单地说是实现一个小学生四则运算的生成及求解程序。
花二十分钟写一个能自动生成小学四则运算题目的命令行 “软件”, 分别满足下面的各种需求
问题困难在对分数的处理上,在有真分数时更加麻烦了一点。
说实话,我真的没法在二十分钟内写完,目前简单的算一下至少也是有了五六个小时 -- 一个小时左右自己写了一个 Fraction
类及其运算,然后觉得可能使用成熟的库更加方便(如果本程序主要是要让自己独立完成库的设计的话,我的选择也许就是有悖于要求了,但要是按照张老师的说法,最终呈现给用户的形式多样,可以是网页应用等,那么,选取他人的库进行修改肯定是很不错的想法,毕竟整个项目有许多工作要做),所以在 github 上寻找了半个小时的库,发现计算分数的并不多。这里选取了一个捷克友人的库进行扩展。在写这篇文档的时候又考虑了一下使用“逆波兰式”实现的可能性,发现也许使用逆波兰式更加方便简单一些,会另开一篇文章介绍。
分析
1.给定一个表达式字符串进行求解,首先最好是对输入进行一些处理(可以很有效地降低后续处理的难度),比如说将“减号”与“负号”,“除号”与“分号”区分对待,可能省略的“乘号”,过多的“正负号”,可能拥有的扩展运算 **
(或 ^
)、!
、带分数等。(当然,如果真的是小学生四则运算可能没这么麻烦,但是需求的不确定性确实存在,比如说,“来来来,加个阶乘运算吧 ...”),对于减法我们将其视为加法(2-1
=> 2+(-1)
)。
举些例子(为不引起混淆,使用 #
表示“除号”,/
表示 “分号”,'
表示带分数):
+1*2 => (1)*2 //正号
-1+2 => (-1)+2 //负号
3*-2 => 3*(-2) //负号
3+-2 => 3+(-2) //两个或多个加减号
(1+2)(3+4) => (1+2)*(3+4) //省略的乘号
2**3 => 2^3 //求幂
2!3 => (2!)*3 //阶乘
3#1/2 => 3#(1/2) //除去分数
1'1/2 => (1+1/2) //带分数
...
2.将处理过的表达式进行求值,这里就可以使用“逆波兰式”了,但目前的实现是使用“递归”:
基本想法:按运算符优先级依次进行处理,()
> !
> /
> ^
> *#
> +
(我们没有减号),其中我们将 /
(分号)优先级定义地很高,比如说 2^1/2 => 2^(1/2)
。
/* 伪代码 */
parse(s:String) {
// 1. Extract all parentheses into TokenLists
extractParentheses();
// 2. Convert operator tokens to operators, including their arguments
// in the correct order ^ * / + -
extractOperator(TokenOperatorFactorial.class);
extractOperator(TokenOperatorPower.class);
extractOperator(TokenOperatorDivideFraction.class); //addby miaodx to first deal with fraction
extractOperator(TokenOperatorMultiply.class);
extractOperator(TokenOperatorDivide.class);
extractOperator(TokenOperatorModulo.class);
extractOperator(TokenOperatorAdd.class);
extractOperator(TokenOperatorSubtract.class);
}
详细的代码可以参见 TokenList.java,其中,处理括号以及处理操作符都包含了对 parse
的递归调用,很明显的是递归存在栈溢出的可能,但当算式不至于太长时还是比较安全的。
举例(以字符串表示的 SyntaxTree 的形式给出,更加直观一些,其实另一个主要原因是原库给出了实现):
2*(3+4)#1/2+3'2/3-5#(6-2)
。在预处理后变为,
2*(3+4)#(1/2)+(3+(2/3))+(-5#(6+(-2)))
,先处理 ()
->
取出带有()
的部分:(3+4)
,(1/2)
,(3+(2/3))
,(6+(-2))
,对这几部分分别处理:
(3+4) => ADD{3,4}
(1/2) => FRACTION{1,2}
(3+(2/3)) => (3+FRACTION{2,3}) => ADD{3,FRACTION{2,3}}
(-5#(6+(-2))) => (-5#ADD{6,-2}) => DIV{-5,ADD{6,-2}}
所以原式变为 2*ADD{3,4}#FRACTION{1,2}+ADD{3,FRACTION{2,3}}+DIV{-5,ADD{6,-2}}
,处理 *
=>
2*ADD{3,4} => MUL{2,ADD{3,4}}
所以原式变为 MUL{2,ADD{3,4}}#FRACTION{1,2}+ADD{3,FRACTION{2,3}}+DIV{-5,ADD{6,-2}}
,处理 #
=>
MUL{2,ADD{3,4}}#FRACTION{1,2} => DIV{MUL{2,ADD{3,4}},FRACTION{1,2}}
所以原式变为 DIV{MUL{2,ADD{3,4}},FRACTION{1,2} }+ADD{3,FRACTION{2,3}}+DIV{-5,ADD{6,-2}}
,处理 +
最终得到:
ADD{ADD{DIV{MUL{2,ADD{3,4}},FRACTION{1,2}}, ADD{3,FRACTION{2,3}}}, DIV{-5,ADD{6,-2}}
。
计算求值的话可以同步进行。这样有些乱,我们给出一张图来看:
<<<< 这里需要张图
小结
1.对输入的预处理非常重要,处理好的规整的输入可以有效地减少后续的工作量,举个例子 (1+2)(3+4)
和 3++-+2
进行预处理后变为 (1+2)*(3+4)
和 3+(-2)
,这比在 parse
中判断 (
前面是不是 )
,+-
前面是不是还有运算符能有效地降低编码难度和出错率。
当然,输入的预处理也是有代价的,多趟对字符串的操作特别是配合着正则表达式(应该只能使用正则表达式)会比较费时,如果对时间要求过高也许会出现一些瓶颈。
2.“递归”方法,因为选用的库就是使用的递归实现,所以就先这样吧,至少没有太多需求说计算长达上百个字符长度的四则运算。
3.SyntaxTree,得到语法树除了使结果看着“很科学”之外,还能顺便解决程序一次运行生成的题目不能重复,即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目的问题。
举例:
不进行处理的语法树:
1+2+3 => ADD{ADD{1,2},3}
2+1+3 => ADD{ADD{2,1},3}
3+(2+1) => ADD{3,ADD{2,1}}
1+3+2 => ADD{ADD{1,3},2}
我们想让三者相同且与第四个区分开来,只需对语法树进行简单的处理即可,比如生成语法树时左右内容按照字符串大小排序(我们的语法树是用字符串表示的)。
那么 1+2
与 2+1
都将变为 ADD{1,2}
同理,其余也是如此,这样便可保证相同的题目生成的语法树是相同的。
TODO
1.1.3^1/2
=>
MATH ERROR:
Can't calculate fractional power.
这个问题是可以理解的。
2.运行时间,由于使用的是递归的方式进行计算,当算式过长时效率会很有问题,举个例子,在我的机子上计算
"53*7+1-54*441-9+33/4+4/32-6*31/4/3/6-5-9-5-6-9/84-9-58+5/2/2-7-5-9/5+63/3/1*6/3*4-1-2/8/1+4/114/8*3/6/5-2*9*2-635/2/9-2*8*3*88"
(字符串长度为 126,其实计算没有太多)的结果:
Token list:
[53, *, 7, +, 1, +, -54, *, 441, +, -9, +, (, (, 33, ), /, (, 4, ), ), +, (, (, 4, ), /, (, 32, ), ), +, -6, *, (, (, 31, ), /, (, 4, ), ), /, (, (, 3, ), /, (, 6, ), ), +, -5, +, -9, +, -5, +, -6, +, -1, *, (, (, 9, ), /, (, 84, ), ), +, -9, +, -58, +, (, (, 5, ), /, (, 2, ), ), /, 2, +, -7, +, -5, +, -1, *, (, (, 9, ), /, (, 5, ), ), +, (, (, 63, ), /, (, 3, ), ), /, 1, *, (, (, 6, ), /, (, 3, ), ), *, 4, +, -1, +, -1, *, (, (, 2, ), /, (, 8, ), ), /, 1, +, (, (, 4, ), /, (, 114, ), ), /, 8, *, (, (, 3, ), /, (, 6, ), ), /, 5, +, -2, *, 9, *, 2, +, -1, *, (, (, 635, ), /, (, 2, ), ), /, 9, +, -2, *, 8, *, 3, *, 88]
Building syntax tree...
Syntax tree:
ADD{ADD{ADD{ADD{ADD{ADD{-1,ADD{ADD{ADD{-5,ADD{-7,ADD{ADD{-58,ADD{-9,ADD{ADD{-6,ADD{-5,ADD{-9,ADD{-5,ADD{ADD{ADD{ADD{-9,ADD{ADD{1,MUL{53,7}},MUL{-54,441}}},FRACTION{33,4}},FRACTION{4,32}},MUL{-6,FRACTION{FRACTION{31,4},FRACTION{3,6}}}}}}}},MUL{-1,FRACTION{9,84}}}}},FRACTION{FRACTION{5,2},2}}}},MUL{-1,FRACTION{9,5}}},MUL{4,MUL{FRACTION{6,3},FRACTION{FRACTION{63,3},1}}}}},MUL{-1,FRACTION{FRACTION{2,8},1}}},MUL{FRACTION{FRACTION{3,6},5},FRACTION{FRACTION{4,114},8}}},MUL{2,MUL{-2,9}}},MUL{-1,FRACTION{FRACTION{635,2},9}}},MUL{88,MUL{3,MUL{-2,8}}}}
耗时:33077毫秒
330 秒,这是无法忍受的,所以,最好是转化为“逆波兰式”进行计算处理。
Good Luck & Have Fun