转换前缀表示法中给出的表达式，识别公共子表达式和依赖项
我在ANSI文本文件中的前缀表示法中给出了一堆表达式。我想生成另一个ANSI文本文件，其中包含对这些表达式的逐步评估。例如：
- + ^ x 2 ^ y 2 1
t1 = x^2
t2 = y^2
t3 = t1 + t2
t4 = t3 - 1
t4 is the result
expression_1: z = ^ x 2
expression_2: - + z ^ y 2 1
expression_3: - z y
exp
sum
没有找到相关结果
已邀请:
7 个回复
矾醒忻
operators = "+-*/^" def parse(it, count=1): token = next(it) if token in operators: op1, count = parse(it, count) op2, count = parse(it, count) tmp = "t%s" % count print tmp, "=", op1, token, op2 return tmp, count + 1 return token, count s = "- + ^ x 2 ^ y 2 1" a = s.split() res, dummy = parse(iter(a)) print res, "is the result"到街客核
python包执行符号代数，包括公共子表达式消除和生成一组表达式的评估步骤。 请参阅：http：//docs.sympy.org/dev/modules/rewriting.html（请参阅页面底部的方法）。结乳
object OpParser { private def estr(oe: Option[Expr]) = oe.map(_.toString).getOrElse("_") case class Expr(text: String, left: Option[Expr] = None, right: Option[Expr] = None) { import Expr._ def varsUsed: Set[String] = text match { case Variable(v) => Set(v) case Op(o) => left.map(_.varsUsed).getOrElse(Set()) ++ right.map(_.varsUsed).getOrElse(Set()) case _ => Set() } def printTemp(n: Int = 0, depth: Int = 0): (String,Int) = text match { case Op(o) => val (tl,nl) = left.map(_.printTemp(n,depth+1)).getOrElse(("_",n)) val (tr,nr) = right.map(_.printTemp(nl,depth+1)).getOrElse(("_",n)) val t = "t"+(nr+1) println(t + " = " + tl + " " + text + " " + tr) if (depth==0) println(t + " is the result") (t, nr+1) case _ => (text, n) } override def toString: String = { if (left.isDefined || right.isDefined) { "(" + estr(left) + " " + text + " " + estr(right) + ")" } else text } } object Expr { val Digit = "([0-9]+)"r val Variable = "([a-z])"r val Op = """([+-*/^])"""r def parse(s: String) = { val bits = s.split(" ") val parsed = ( if (bits.length > 2 && Variable.unapplySeq(bits(0)).isDefined && bits(1)=="=") { parseParts(bits,2) } else parseParts(bits) ) parsed.flatMap(p => if (p._2<bits.length) None else Some(p._1)) } def parseParts(as: Array[String], from: Int = 0): Option[(Expr,Int)] = { if (from >= as.length) None else as(from) match { case Digit(n) => Some(Expr(n), from+1) case Variable(v) => Some(Expr(v), from+1) case Op(o) => parseParts(as, from+1).flatMap(lhs => parseParts(as, lhs._2).map(rhs => (Expr(o,Some(lhs._1),Some(rhs._1)), rhs._2)) ) case _ => None } } } }结果可能会失败）。如果你扔垃圾，它将返回。 （通过更多的工作，你可以让它以一个信息丰富的方式抱怨问题 - 基本上然后嵌套两次可以存储结果并打印出一个信息性的错误消息，如果操作没有得到两个同样，可能会抱怨拖尾价值而不是仅仅扔掉。） 其次，当你完成它时，你有一个完整的表达式树。请注意，打印出您想要的临时变量，列出特定表达式中使用的变量，一旦解析多行，您可以使用它们扩展为完整列表。 （如果你的变量不仅仅是到，你可能需要稍微摆弄正则表达式。）另请注意，表达式树以正常的中缀表示法打印出来。我们来看一些例子：scala> OpParser.Expr.parse("4") res0: Option[OpParser.Expr] = Some(4) scala> OpParser.Expr.parse("+ + + + + 1 2 3 4 5 6") res1: Option[OpParser.Expr] = Some((((((1 + 2) + 3) + 4) + 5) + 6)) scala> OpParser.Expr.parse("- + ^ x 2 ^ y 2 1") res2: Option[OpParser.Expr] = Some((((x ^ 2) + (y ^ 2)) - 1)) scala> OpParser.Expr.parse("+ + 4 4 4 4") // Too many 4s! res3: Option[OpParser.Expr] = None scala> OpParser.Expr.parse("Q#$S!M$#!*)000") // Garbage! res4: Option[OpParser.Expr] = None scala> OpParser.Expr.parse("z =") // Assigned nothing?! res5: Option[OpParser.Expr] = None scala> res2.foreach(_.printTemp()) t1 = x ^ 2 t2 = y ^ 2 t3 = t1 + t2 t4 = t3 - 1 t4 is the result scala> res2.map(_.varsUsed) res10: Option[Set[String]] = Some(Set(x, y))席酱
object Parser { val Subexprs = collection.mutable.Map[String, String]() val Dependencies = collection.mutable.Map[String, Set[String]]().withDefaultValue(Set.empty) val TwoArgsOp = "([-+*/^])".r // - at the beginning, ^ at the end val Ident = "(\p{Alpha}\w*)".r val Literal = "(\d+)".r var counter = 1 def getIdent = { val ident = "t" + counter counter += 1 ident } def makeOp(op: String) = { val op1 = expr val op2 = expr val ident = getIdent val subexpr = op1 + " " + op + " " + op2 Subexprs(ident) = subexpr Dependencies(ident) = Dependencies(op1) ++ Dependencies(op2) + op1 + op2 ident } def expr: String = nextToken match { case TwoArgsOp(op) => makeOp(op) case Ident(id) => id case Literal(lit) => lit case x => error("Unknown token "+x) } def nextToken = tokens.next var tokens: Iterator[String] = _ def parse(input: String) = { tokens = input.trim split "\s+" toIterator; counter = 1 expr if (tokens.hasNext) error("Input not fully parsed: "+tokens.mkString(" ")) (Subexprs, Dependencies) } }scala> val (subexpressions, dependencies) = Parser.parse("- + ^ x 2 ^ y 2 1") subexpressions: scala.collection.mutable.Map[String,String] = Map(t3 -> t1 + t2, t4 -> t3 - 1, t1 -> x ^ 2, t2 -> y ^ 2) dependencies: scala.collection.mutable.Map[String,Set[String]] = Map(t3 -> Set(x, y, t2, 2, t1), t4 -> Set(x, y, t3, t2, 1, 2, t1), t1 -> Set(x, 2), t 2 -> Set(y, 2)) scala> subexpressions.toSeq.sorted foreach println (t1,x ^ 2) (t2,y ^ 2) (t3,t1 + t2) (t4,t3 - 1) scala> dependencies.toSeq.sortBy(_._1) foreach println (t1,Set(x, 2)) (t2,Set(y, 2)) (t3,Set(x, y, t2, 2, t1)) (t4,Set(x, y, t3, t2, 1, 2, t1))object Parser { val Subexprs = collection.mutable.Map[String, String]() val Dependencies = collection.mutable.Map[String, Set[String]]().withDefaultValue(Set.empty) val TwoArgsOp = "([-+*/^])".r // - at the beginning, ^ at the end val Ident = "(\p{Alpha}\w*)".r val Literal = "(\d+)".r var counter = 1 def getIdent = { val ident = "t" + counter counter += 1 ident } def makeOp(op: String) = { val op1 = expr val op2 = expr val ident = getIdent val subexpr = op1 + " " + op + " " + op2 Subexprs(ident) = subexpr Dependencies(ident) = Dependencies(op1) ++ Dependencies(op2) + op1 + op2 ident } def expr: String = nextToken match { case TwoArgsOp(op) => makeOp(op) case Ident(id) => id case Literal(lit) => lit case x => error("Unknown token "+x) } def assignment: Unit = { val ident = nextToken nextToken match { case "=" => val tmpIdent = expr Dependencies(ident) = Dependencies(tmpIdent) Subexprs(ident) = Subexprs(tmpIdent) Dependencies.remove(tmpIdent) Subexprs.remove(tmpIdent) case x => error("Expected assignment, got "+x) } } def stmts: Unit = while(tokens.hasNext) tokens.head match { case TwoArgsOp(_) => expr case Ident(_) => assignment case x => error("Unknown statement starting with "+x) } def nextToken = tokens.next var tokens: BufferedIterator[String] = _ def parse(input: String) = { tokens = (input.trim split "\s+" toIterator).buffered counter = 1 stmts if (tokens.hasNext) error("Input not fully parsed: "+tokens.mkString(" ")) (Subexprs, Dependencies) } }scala> val (subexpressions, dependencies) = Parser.parse(""" | z = ^ x 2 | - + z ^ y 2 1 | - z y | """) subexpressions: scala.collection.mutable.Map[String,String] = Map(t3 -> z + t2, t5 -> z - y, t4 -> t3 - 1, z -> x ^ 2, t2 -> y ^ 2) dependencies: scala.collection.mutable.Map[String,Set[String]] = Map(t3 -> Set(x, y, t2, 2, z), t5 -> Set(x, 2, z, y), t4 -> Set(x, y, t3, t2, 1, 2, z ), z -> Set(x, 2), t2 -> Set(y, 2)) scala> subexpressions.toSeq.sorted foreach println (t2,y ^ 2) (t3,z + t2) (t4,t3 - 1) (t5,z - y) (z,x ^ 2) scala> dependencies.toSeq.sortBy(_._1) foreach println (t2,Set(y, 2)) (t3,Set(x, y, t2, 2, z)) (t4,Set(x, y, t3, t2, 1, 2, z)) (t5,Set(x, 2, z, y)) (z,Set(x, 2))唤副埂侧壬
object PrefixParser extends JavaTokenParsers { import scala.collection.mutable // Maps generated through parsing val Subexprs = mutable.Map[String, String]() val Dependencies = mutable.Map[String, Set[String]]().withDefaultValue(Set.empty) // Initialize, read, parse & evaluate string def read(input: String) = { counter = 1 Subexprs.clear Dependencies.clear parseAll(stmts, input) } // Grammar def stmts = stmt+ def stmt = assignment | expr def assignment = (ident <~ "=") ~ expr ^^ assignOp def expr: P = subexpr | identifier | number def subexpr: P = twoArgs | nArgs def twoArgs: P = operator ~ expr ~ expr ^^ twoArgsOp def nArgs: P = "sum" ~ ("\d+".r >> args) ^^ nArgsOp def args(n: String): Ps = repN(n.toInt, expr) def operator = "[-+*/^]".r def identifier = ident ^^ (id => Result(id, Set(id))) def number = wholeNumber ^^ (Result(_, Set.empty)) // Evaluation helper class and types case class Result(ident: String, dependencies: Set[String]) type P = Parser[Result] type Ps = Parser[List[Result]] // Evaluation methods def assignOp: (String ~ Result) => Result = { case ident ~ result => val value = assign(ident, Subexprs(result.ident), result.dependencies - result.ident) Subexprs.remove(result.ident) Dependencies.remove(result.ident) value } def assign(ident: String, value: String, dependencies: Set[String]): Result = { Subexprs(ident) = value Dependencies(ident) = dependencies Result(ident, dependencies) } def twoArgsOp: (String ~ Result ~ Result) => Result = { case op ~ op1 ~ op2 => makeOp(op, op1, op2) } def makeOp(op: String, op1: Result, op2: Result): Result = { val ident = getIdent assign(ident, "%s %s %s" format (op1.ident, op, op2.ident), op1.dependencies ++ op2.dependencies + ident) } def nArgsOp: (String ~ List[Result]) => Result = { case op ~ ops => makeNOp(op, ops) } def makeNOp(op: String, ops: List[Result]): Result = { val ident = getIdent assign(ident, "%s(%s)" format (op, ops map (_.ident) mkString ", "), ops.foldLeft(Set(ident))(_ ++ _.dependencies)) } var counter = 1 def getIdent = { val ident = "t" + counter counter += 1 ident } // Debugging helper methods def printAssignments = Subexprs.toSeq.sorted foreach println def printDependencies = Dependencies.toSeq.sortBy(_._1) map { case (id, dependencies) => (id, dependencies - id) } foreach println }scala> PrefixParser.read(""" | z = ^ x 2 | - + z ^ y 2 1 | - z y | """) res77: PrefixParser.ParseResult[List[PrefixParser.Result]] = [5.1] parsed: List(Result(z,Set(x)), Result(t4,Set(t4, y, t3, t2, z)), Result(t5,Set(z, y , t5))) scala> PrefixParser.printAssignments (t2,y ^ 2) (t3,z + t2) (t4,t3 - 1) (t5,z - y) (z,x ^ 2) scala> PrefixParser.printDependencies (t2,Set(y)) (t3,Set(z, y, t2)) (t4,Set(y, t3, t2, z)) (t5,Set(z, y)) (z,Set(x))scala> PrefixParser.read(""" | x = sum 3 + 1 2 * 3 4 5 | * x x | """) res93: PrefixParser.ParseResult[List[PrefixParser.Result]] = [4.1] parsed: List(Result(x,Set(t1, t2)), Result(t4,Set(x, t4))) scala> PrefixParser.printAssignments (t1,1 + 2) (t2,3 * 4) (t4,x * x) (x,sum(t1, t2, 5)) scala> PrefixParser.printDependencies (t1,Set()) (t2,Set()) (t4,Set(x)) (x,Set(t1, t2))旗低饶彤
表达式的打印对我没用，你已经有几个Scala例子，所以我会跳过它。） 首先，我们需要提取语言的各个部分。我会选择正则表达式，但也可以使用解析器组合器：object OpParser { val Natural = "([0-9]+)"r val Number = """((?:-)?[0-9]+(?:.[0-9]+)?(?:[eE](?:-)?[0-9]+)?)"""r val Variable = "([a-z])"r val Unary = "(exp|sin|cos|tan|sqrt)"r val Binary = "([-+*/^])"r val Nary = "(sum|prod|list)"r函数，这些数字可以是浮点数。）最后的表示这是一个正则表达式，它会给出我们在括号中的东西。 现在我们需要代表我们的树。有很多方法可以做到这一点，但我会选择一个带有特定表达式作为案例类的抽象基类，因为这样可以简化模式匹配。此外，我们可能想要很好的打印，所以我们将覆盖。但是，大多数情况下，我们将使用递归函数来完成繁重的工作。abstract class Expr { def text: String def args: List[Expr] override def toString = args match { case l :: r :: Nil => "(" + l + " " + text + " " + r + ")" case Nil => text case _ => args.mkString(text+"(", ",", ")") } } case class Num(text: String, args: List[Expr]) extends Expr { val quantity = text.toDouble } case class Var(text: String, args: List[Expr]) extends Expr { override def toString = args match { case arg :: Nil => "(" + text + " <- " + arg + ")" case _ => text } } case class Una(text: String, args: List[Expr]) extends Expr case class Bin(text: String, args: List[Expr]) extends Expr case class Nar(text: String, args: List[Expr]) extends Expr { override def toString = text match { case "list" => (for ((a,i) <- args.zipWithIndex) yield { "%3d: %s".format(i+1,a.toString) }).mkString("List[n","n","n]") case _ => super.toString } }和会自动填入。请注意，我已经确定是一个可能的n-ary函数，并且它将打印出行号。 （原因是如果您有多行输入，有时将它们作为一个表达式一起使用会更方便;这使它们成为一个函数。） 一旦定义了我们的数据结构，我们就需要解析表达式。将要解析的东西表示为令牌列表很方便;当我们解析时，我们将返回一个表达式和我们尚未解析的剩余标记 - 这对于递归解析来说是一个特别有用的结构。当然，我们可能无法解析任何东西，所以最好还包括在中。def parse(tokens: List[String]): Option[(Expr,List[String])] = tokens match { case Variable(x) :: "=" :: rest => for ((expr,remains) <- parse(rest)) yield (Var(x,List(expr)), remains) case Variable(x) :: rest => Some(Var(x,Nil), rest) case Number(n) :: rest => Some(Num(n,Nil), rest) case Unary(u) :: rest => for ((expr,remains) <- parse(rest)) yield (Una(u,List(expr)), remains) case Binary(b) :: rest => for ((lexp,lrem) <- parse(rest); (rexp,rrem) <- parse(lrem)) yield (Bin(b,List(lexp,rexp)), rrem) case Nary(a) :: Natural(b) :: rest => val buffer = new collection.mutable.ArrayBuffer[Expr] def parseN(tok: List[String], n: Int = b.toInt): List[String] = { if (n <= 0) tok else { for ((expr,remains) <- parse(tok)) yield { buffer += expr; parseN(remains, n-1) } }.getOrElse(tok) } val remains = parseN(rest) if (buffer.length == b.toInt) Some( Nar(a,buffer.toList), remains ) else None case _ => None }def parse(s: String): Option[Expr] = parse(s.split(" ").toList).flatMap(x => { if (x._2.isEmpty) Some(x._1) else None }) def parseLines(ls: List[String]): Option[Expr] = { val attempt = ls.map(parse).flatten if (attempt.length<ls.length) None else if (attempt.length==1) attempt.headOption else Some(Nar("list",attempt)) }def calc(n: Num, f: Double => Double): Num = Num(f(n.quantity).toString, Nil) def calc(n: Num, m: Num, f: (Double,Double) => Double): Num = Num(f(n.quantity,m.quantity).toString, Nil) def calc(ln: List[Num], f: (Double,Double) => Double): Num = Num(ln.map(_.quantity).reduceLeft(f).toString, Nil)def numericSimplify(expr: Expr): Expr = expr match { case Una(t,List(e)) => numericSimplify(e) match { case n @ Num(_,_) => t match { case "exp" => calc(n, math.exp _) case "sin" => calc(n, math.sin _) case "cos" => calc(n, math.cos _) case "tan" => calc(n, math.tan _) case "sqrt" => calc(n, math.sqrt _) } case a => Una(t,List(a)) } case Bin(t,List(l,r)) => (numericSimplify(l), numericSimplify(r)) match { case (n @ Num(_,_), m @ Num(_,_)) => t match { case "+" => calc(n, m, _ + _) case "-" => calc(n, m, _ - _) case "*" => calc(n, m, _ * _) case "/" => calc(n, m, _ / _) case "^" => calc(n, m, math.pow) } case (a,b) => Bin(t,List(a,b)) } case Nar("list",list) => Nar("list",list.map(numericSimplify)) case Nar(t,list) => val simple = list.map(numericSimplify) val nums = simple.collect { case n @ Num(_,_) => n } if (simple.length == 0) t match { case "sum" => Num("0",Nil) case "prod" => Num("1",Nil) } else if (nums.length == simple.length) t match { case "sum" => calc(nums, _ + _) case "prod" => calc(nums, _ * _) } else Nar(t, simple) case Var(t,List(e)) => Var(t, List(numericSimplify(e))) case _ => expr }def algebraicSimplify(expr: Expr): Expr = { val all, dup, used = new collection.mutable.HashSet[Expr] val made = new collection.mutable.HashMap[Expr,Int] val user = new collection.mutable.HashMap[Expr,Expr] def findExpr(e: Expr) { e match { case Var(t,List(v)) => user += v -> e if (all contains e) dup += e else all += e case Var(_,_) | Num(_,_) => // Do nothing in these cases case _ => if (all contains e) dup += e else all += e } e.args.foreach(findExpr) } findExpr(expr) def replaceDup(e: Expr): Expr = { if (made contains e) Var("x"+made(e),Nil) else if (used contains e) Var(user(e).text,Nil) else if (dup contains e) { val fixed = replaceDupChildren(e) made += e -> made.size Var("x"+made(e),List(fixed)) } else replaceDupChildren(e) } def replaceDupChildren(e: Expr): Expr = e match { case Una(t,List(u)) => Una(t,List(replaceDup(u))) case Bin(t,List(l,r)) => Bin(t,List(replaceDup(l),replaceDup(r))) case Nar(t,list) => Nar(t,list.map(replaceDup)) case Var(t,List(v)) => used += v Var(t,List(if (made contains v) replaceDup(v) else replaceDupChildren(v))) case _ => e } replaceDup(expr) }def main(args: Array[String]) { val test1 = "- + ^ x 2 ^ y 2 1" val test2 = "+ + +" // Bad! val test3 = "exp sin cos sum 5" // Bad! val test4 = "+ * 2 3 ^ 3 2" val test5 = List(test1, test4, "^ y 2").mkString("list 3 "," ","") val test6 = "+ + x y + + * + x y + 4 5 * + x y + 4 y + + x y + 4 y" def performTest(test: String) = { println("Start with: " + test) val p = OpParser.parse(test) if (p.isEmpty) println(" Parsing failed") else { println("Parsed: " + p.get) val q = OpParser.numericSimplify(p.get) println("Numeric: " + q) val r = OpParser.algebraicSimplify(q) println("Algebraic: " + r) } println } List(test1,test2,test3,test4,test5,test6).foreach(performTest) } }所以我不知道这对你有用，但结果证明对我有用。这就是我在C ++中非常犹豫不决的事情，因为应该很容易的各种事情最终会变得痛苦。 编辑：以下是使用此结构打印临时分配的示例，只是为了证明此结构完全可以执行此类操作。 码：def useTempVars(expr: Expr): Expr = { var n = 0 def temp = { n += 1; "t"+n } def replaceTemp(e: Expr, exempt: Boolean = false): Expr = { def varify(x: Expr) = if (exempt) x else Var(temp,List(x)) e match { case Var(t,List(e)) => Var(t,List(replaceTemp(e, exempt = true))) case Una(t,List(u)) => varify( Una(t, List(replaceTemp(u,false))) ) case Bin(t,lr) => varify( Bin(t, lr.map(replaceTemp(_,false))) ) case Nar(t,ls) => varify( Nar(t, ls.map(replaceTemp(_,false))) ) case _ => e } } replaceTemp(expr) } def varCut(expr: Expr): Expr = expr match { case Var(t,_) => Var(t,Nil) case Una(t,List(u)) => Una(t,List(varCut(u))) case Bin(t,lr) => Bin(t, lr.map(varCut)) case Nar(t,ls) => Nar(t, ls.map(varCut)) case _ => expr } def getAssignments(expr: Expr): List[Expr] = { val children = expr.args.flatMap(getAssignments) expr match { case Var(t,List(e)) => children :+ expr case _ => children } } def listAssignments(expr: Expr): List[String] = { getAssignments(expr).collect(e => e match { case Var(t,List(v)) => t + " = " + varCut(v) }) :+ (expr.text + " is the answer") }listAssignments(useTempVars(r)).foreach(printf(" %sn",_))第二次编辑：找到依赖关系也不算太糟糕。 码：def directDepends(expr: Expr): Set[Expr] = expr match { case Var(t,_) => Set(expr) case _ => expr.args.flatMap(directDepends).toSet } def indirectDepends(expr: Expr) = { val depend = getAssignments(expr).map(e => e -> e.args.flatMap(directDepends).toSet ).toMap val tagged = for ((k,v) <- depend) yield (k.text -> v.map(_.text)) def percolate(tags: Map[String,Set[String]]): Option[Map[String,Set[String]]] = { val expand = for ((k,v) <- tags) yield ( k -> (v union v.flatMap(x => tags.get(x).getOrElse(Set()))) ) if (tags.exists(kv => expand(kv._1) contains kv._1)) None // Cyclic dependency! else if (tags == expand) Some(tags) else percolate(expand) } percolate(tagged) } def listDependents(expr: Expr): List[(String,String)] = { def sayNothing(s: String) = if (s=="") "nothing" else s val e = expr match { case Var(_,_) => expr case _ => Var("result",List(expr)) } indirectDepends(e).map(_.toList.map(x => (x._1, sayNothing(x._2.toList.sorted.mkString(" "))) )).getOrElse(List((e.text,"cyclic"))) }和并用for ((v,d) <- listDependents(r)) println(" "+v+" requires "+d)所以我认为除了这种结构之外，所有的个性化需求都可以通过一到两行Scala代码来满足。 编辑：这里是表达式评估，如果你给出了从变量到值的映射：def numericEvaluate(expr: Expr, initialValues: Map[String,Double]) = { val chain = new collection.mutable.ArrayBuffer[(String,Double)] val evaluated = new collection.mutable.HashMap[String,Double] def note(xv: (String,Double)) { chain += xv; evaluated += xv } evaluated ++= initialValues def substitute(expr: Expr): Expr = expr match { case Var(t,List(n @ Num(v,_))) => { note(t -> v.toDouble); n } case Var(t,_) if (evaluated contains t) => Num(evaluated(t).toString,Nil) case Var(t,ls) => Var(t,ls.map(substitute)) case Una(t,List(u)) => Una(t,List(substitute(u))) case Bin(t,ls) => Bin(t,ls.map(substitute)) case Nar(t,ls) => Nar(t,ls.map(substitute)) case _ => expr } def recurse(e: Expr): Expr = { val sub = numericSimplify(substitute(e)) if (sub == e) e else recurse(sub) } (recurse(expr), chain.toList) }val (num,ops) = numericEvaluate(r,Map("x"->3,"y"->1.5)) println("Evaluated:") for ((v,n) <- ops) println(" "+v+" = "+n) println(" result = " + num)和）：另一个挑战 - 选择尚未使用的变量 - 只是从依赖项ѭ58ѭ列表中减去。是集合减法的名称。剑哎