Improve solution 2018-02, part 2's performance

Abort calculating the edit distance as soon as is clear
that it gets larger than the one we search for (which is 1).

This is much faster than the previous caching approach.
(On an MS Surface Pro 8: from 20 seconds down to < 100 ms.)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2018/day02/InventoryManagementSystem.kt

@@ -21,39 +21,35 @@ class InventoryManagementSystem : AdventOfCode<String>(2018, 2) {
     override fun part2(input: List<String>): String {
         val minPair = input
             .combinations()
-            .minBy { lev(it.first, it.second) }
+            .minBy { lev(it.first, it.second, 1) }
 
         return minPair.first.filterIndexed { i, char ->
             minPair.second[i] == char
         }
     }
 }
 
-private val levCache = mutableMapOf<Pair<String, String>, Int>()
-
 /**
- * The Levenshtein distance (an edit distance).
+ * @return The Levenshtein distance (an edit distance) between the Strings [a] and [b].
+ * @param maxDistance Specifies an upper bound for the calculated distance. The function aborts if this value is exceeded
+ * returning the distance calculated so far (which might be much higher than [maxDistance]).
+ * @param distanceSoFar For recursive calls, only. The distance calculated to the current level.
  */
-fun lev(a: String, b: String): Int {
-    levCache[a to b]?.let { return it }
-
+fun lev(a: String, b: String, maxDistance: Int = Int.MAX_VALUE, distanceSoFar: Int = 0): Int {
     if (b.isEmpty()) return a.length
     if (a.isEmpty()) return b.length
+    if (distanceSoFar > maxDistance) return 0
 
     val aTail = a.substring(1)
     val bTail = b.substring(1)
 
-    val tailResult = lev(aTail, bTail)
-    levCache[aTail to bTail] = tailResult
-
     if (a.first() == b.first()) {
-        return tailResult
+        return lev(aTail, bTail, maxDistance, distanceSoFar)
     }
 
-    val aTailResult = lev(aTail, b)
-    val bTailResult = lev(a, bTail)
-    levCache[aTail to b] = aTailResult
-    levCache[a to bTail] = bTailResult
+    val aTailResult = lev(aTail, b, maxDistance, distanceSoFar + 1)
+    val bTailResult = lev(a, bTail, maxDistance, distanceSoFar + 1)
+    val tailResult = lev(aTail, bTail, maxDistance, distanceSoFar + 1)
 
     return 1 + min(min(aTailResult, bTailResult), tailResult)
 }

src/test/kotlin/de/ronny_h/aoc/year2018/day02/InventoryManagementSystemTest.kt

@@ -48,4 +48,20 @@ class InventoryManagementSystemTest : StringSpec({
             lev(a, b) shouldBe distance
         }
     }
+
+    "The Levenshtein distance with an upper bound" {
+        forAll(
+            row("", "", 1, 0),
+            row("", "a", 1, 1),
+            row("a", "", 1, 1),
+            row("abc", "abc", 1, 0),
+            row("abc", "a_c", 1, 1),
+            row("abc", "axbyc", 1, 2),
+            row("abc", "axbycz", 1, 2),
+            row("abc", "xyz", 1, 2),
+            row("abc", "abcxyz", 1, 3),
+        ) { a, b, maxDistance, distance ->
+            lev(a, b, maxDistance) shouldBe distance
+        }
+    }
 })