春节刷题计划（二）| 一题三解，搞定版本号判断

方法三有点一言难尽吧... 尝试写一个python的版本： ```python class Solution: def compareVersion(self, ver1: str, ver2: str) -> int: to_nums = lambda ver: map(int, ver.split('.')) zipped = zip_longest(*map(to_nums, [ver1, ver2]), fillvalue=0) cmp = lambda a, b: (a > b) - (a < b) return next((i for i in starmap(cmp, zipped) if i != 0), 0) # return next(filter(lambda x: x != 0, starmap(cmp, zipped)), 0) ``` 文中的zipLongest实现接受Iterable<String>，返回List<Pair<Int, Int>>。这意味： 1. 输入是Iterable，输出成了List。这样就不适用于输入长度无限的情况，或是可以惰性求值的情况。在本题中，因为只要遇到第一个不相同的子版本号就可以返回，所以可以不用生成完整的List，正好是可以利用惰性求值的情况； 2. 输入Iterable的基类型是String，输出Pair的基类型是Int，这就把类型转换写死在了实现里，让实现失去了通用性，即便沉淀出来可能用途也有限吧； 3. 文中的实现只支持一个Iterable与另一个Iterable进行zip，而python的实现支持任意多个。 这里不是要抬杠，只是想说各种语言的不同特性会形成不同的惯用法，强行使用另一种语言的惯用法可能会显得不伦不类。如有冒犯还请见谅。

这样写也算比较简洁把： val list1 = version1.split(".") val list2 = version2.split(".") val result = list1.zip(list2) { v1, v2 -> Pair(v1.toInt(), v2.toInt()) } .onEach { if (it.first != it.second) { return it.first.compareTo(it.second) } }.run { return list1.size - list2.size }

工作中谁敢用方法三，我保准让他默写十遍！

解法二稍加封装了一下 fun compareVersion(version1: String, version2: String): Int { val v1 = Version(0, 0, version1) val v2 = Version(0, 0, version2) while (v1.index < version1.length || v2.index < version2.length) { v1.dealVersion() v2.dealVersion() if (v1.subValue != v2.subValue) { return v1.subValue.compareTo(v2.subValue) } } return 0 } data class Version(var index: Int, var subValue: Int, var text: String) { fun dealVersion(): Version { subValue = 0 while (index < text.length && text[index] != '.') { subValue = subValue * 10 + text[index].toInt() - '0'.toInt() index++ } index++ return this } }

class Solution { // ax+b // symbol 和 tmp 都是处理表达式临时变量 data class Expr(var a: Int, var b: Int, var symbol: Int, var tmp: String) fun solveEquation(equation: String): String { return equation .split("=")// 1、分成前后两个部分 .map {// 2、处理表达式为 ax+b "$it+"//骚操作加"+"：防止表达式最后一点丢失处理 .fold(Expr(0, 0, 1, "")) { acc, c -> when (c) { '+', '-' -> { if (acc.tmp.contains("x")) { acc.a += acc.symbol * acc.tmp.replace("x", "").ifBlank { "1" }.toInt() } else { acc.b += acc.symbol * acc.tmp.ifBlank { "0" }.toInt() } acc.symbol = if (c == '+') 1 else -1 acc.tmp = "" } else -> { acc.tmp += c } } acc } }.reduce { acc, expr -> // 3、前段 减 后段 acc.a -= expr.a acc.b -= expr.b acc }.run { when { a == 0 && b != 0 -> "No solution" a == 0 -> "Infinite solutions" else -> "x=${-1 * b / a}" } } } }

class Solution { fun solveEquation(equation: String): String { val eq = equation.replace("-", "+-").split("=") val (lx, ln) = parse(eq[0]) val (rx, rn) = parse(eq[1]) val x = lx - rx val n = rn - ln return if (x == 0 && n != 0) { "No solution" } else if (x == 0 && n == 0) { "Infinite solutions" } else { "x=${ n / x }" } } fun parse(eq: String): Pair<Int, Int> { val exp = eq.split("+") var (x, n) = 0 to 0 exp.filter { !it.contains("x") && it != "" } .forEach { n += it.toInt() } exp.filter { it.contains("x") } .forEach { x += if (it.length == 1 || it.length == 2 && it[0] == '-') it.replace("x", "1").toInt() else it.replace("x", "").toInt() } return x to n } }

```Kotlin fun solveEquation(equation: String): String { val (left, right) = equation.split("=").take(2) val (lx, ln) = parse(left) val (rx, rn) = parse(right) if (lx == rx) return if (ln == rn) "Infinite solutions" else "No solution" if ((rn - ln) % (lx - rx) != 0) return "No solution" return "x=" + (rn - ln) / (lx - rx) } @OptIn(ExperimentalStdlibApi::class) fun parse(exp: String): Pair<Int, Int> { // Split operands and operators val operands = exp.split("[+-]".toRegex()) val operators = buildList<Int> { add(1) // Add leading + to align with operands addAll(exp.filter { it == '+' || it == '-' }.map { if (it == '+') 1 else -1 }) } var (x, n) = 0 to 0 // Calculate x and n for (i in operands.indices) { if (operands[i].isEmpty()) continue if (operands[i].last() == 'x') { x += operators[i] * (operands[i].dropLast(1).toIntOrNull() ?: 1) } else { n += operators[i] * operands[i].toInt() } } return x to n } ```

fun solveEquation(equation: String) { var sumX = 0 var numEq = 0 equation.replace("-", "+-").split('=').forEachIndexed { index, s -> s.split('+').forEach { if (it.contains('x')) { val count = if (it == "x") 1 else it.removeSuffix("x").toInt() sumX += if (index == 0) count else -count } else { numEq += if (index == 0) -it.toInt() else it.toInt() } } } println(when { sumX == 0 -> "Infinite solutions" numEq.mod(sumX) == 0 -> "x = ${numEq.div(sumX)}" else -> "no solution" }) }