Solution 2015-11 (Corporate Policy)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2015/day11/CorporatePolicy.kt

@@ -0,0 +1,86 @@
+package de.ronny_h.aoc.year2015.day11
+
+import de.ronny_h.aoc.AdventOfCode
+
+fun main() = CorporatePolicy().run("vzbxxyzz", "vzcaabcc")
+
+class CorporatePolicy : AdventOfCode<String>(2015, 11) {
+    override fun part1(input: List<String>) = input.first().rotate()
+
+    override fun part2(input: List<String>) = input.first().rotate().rotate()
+
+    fun rule0AppliesTo(password: String) = password.matches("[a-z]{8}".toRegex())
+
+    // must include one increasing straight of at least three letters
+    fun rule1Applies(password: String): Boolean {
+        var applies = false
+        password.windowed(3) {
+            if (it[2] == it[1].inc() && it[1] == it[0].inc()) {
+                applies = true
+            }
+        }
+        return applies
+    }
+
+    private val lettersToSkip = listOf('i', 'o', 'l')
+    private val ambiguousLettersRegex = lettersToSkip.joinToString("|").toRegex()
+
+    // may not contain the letters i, o, or l
+    fun rule2Applies(password: String) = !password.contains(ambiguousLettersRegex)
+
+    // must contain at least two different, non-overlapping pairs of letters
+    fun rule3Applies(password: String): Boolean {
+        var pairs = 0
+        var lastWasAPair = false
+        password.windowed(2) {
+            if (lastWasAPair) {
+                // no overlappings
+                lastWasAPair = false
+            } else {
+                if (it[0] == it[1]) {
+                    pairs++
+                    lastWasAPair = true
+                }
+            }
+        }
+        return pairs >= 2
+    }
+
+    private fun String.rotate(): String {
+        require(rule0AppliesTo(this)) { "a password has to be exactly 8 lowercase letters: '${this}" }
+
+        var newPassword = this
+        do {
+            newPassword = newPassword.inc(lettersToSkip)
+        } while (newPassword.notAllRulesApply())
+
+        check(rule0AppliesTo(newPassword)) { "a password has to be exactly 8 lowercase letters: '$newPassword" }
+        return newPassword
+    }
+
+    private fun String.notAllRulesApply() = !rule1Applies(this) || !rule2Applies(this) || !rule3Applies(this)
+}
+
+fun String.inc(toSkip: List<Char> = emptyList()): String {
+    val highestChar = 'z'
+    require(highestChar !in toSkip) { "incrementation only works correct if the highest char is not to skip" }
+
+    var suffix = ""
+    var incIndex = lastIndex
+    while (incIndex >= 0) {
+        val prefix = substring(0..<incIndex)
+        if (get(incIndex) == highestChar) {
+            suffix = "a$suffix"
+            incIndex--
+        } else {
+            var incChar = get(incIndex).inc()
+            while (incChar in toSkip) {
+                incChar = incChar.inc()
+            }
+            return prefix + incChar + suffix
+        }
+    }
+    throw StringOverflowException("String '$this' cannot be incremented without making it longer.")
+}
+
+class StringOverflowException(message: String) : Exception(message)

src/test/kotlin/de/ronny_h/aoc/year2015/day11/CorporatePolicyTest.kt

@@ -0,0 +1,104 @@
+package de.ronny_h.aoc.year2015.day11
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
+import io.kotest.matchers.shouldBe
+
+class CorporatePolicyTest : StringSpec({
+
+    val day11 = CorporatePolicy()
+
+    "Passwords must be exactly eight lowercase letters" {
+        forAll(
+            row("abcdefgh", true),
+            row("abcdefg", false),
+            row("aBcdefgh", false),
+            row("abcdefghi", false),
+        ) { password, expected ->
+            day11.rule0AppliesTo(password) shouldBe expected
+        }
+    }
+
+    "Passwords must include one increasing straight of at least three letters" {
+        forAll(
+            row("abc", true),
+            row("abbcdde", true),
+            row("aaa", false),
+            row("aabc", true),
+            row("abcc", true),
+            row("aabcc", true),
+            row("aabbcc", false),
+        ) { password, expected ->
+            day11.rule1Applies(password) shouldBe expected
+        }
+    }
+
+    "Passwords may not contain the letters i, o, or l" {
+        forAll(
+            row("abc", true),
+            row("hij", false),
+            row("mno", false),
+            row("lmn", false),
+        ) { password, expected ->
+            day11.rule2Applies(password) shouldBe expected
+        }
+    }
+
+    "Passwords must contain at least two different, non-overlapping pairs of letters" {
+        forAll(
+            row("abcd", false),
+            row("aabb", true),
+            row("aabbcc", true),
+            row("aaaa", true),
+            row("aaab", false),
+        ) { password, expected ->
+            day11.rule3Applies(password) shouldBe expected
+        }
+    }
+
+    "hijklmmn" {
+        val password = "hijklmmn"
+        day11.rule1Applies(password) shouldBe true
+        day11.rule2Applies(password) shouldBe false
+    }
+
+    "abbceffg" {
+        val password = "abbceffg"
+        day11.rule3Applies(password) shouldBe true
+        day11.rule1Applies(password) shouldBe false
+    }
+
+    "increment a" {
+        "a".inc() shouldBe "b"
+    }
+
+    "increment az with carry-over" {
+        "az".inc() shouldBe "ba"
+    }
+
+    "increment aaazzz with carry-over" {
+        "aaazzz".inc() shouldBe "aabaaa"
+    }
+
+    "zzzz cannot be incremented without making the String longer" {
+        val exception = shouldThrow<StringOverflowException> {
+            "zzzz".inc()
+        }
+        exception.message shouldBe "String 'zzzz' cannot be incremented without making it longer."
+    }
+
+    "part 1: The next password after abcdefgh is abcdffaa" {
+        day11.part1(listOf("abcdefgh")) shouldBe "abcdffaa"
+    }
+
+    "part 1: The next password after ghijklmn is ghjaabcc" {
+        day11.part1(listOf("ghijklmn")) shouldBe "ghjaabcc"
+    }
+
+    "part 2 is two times part 1" {
+        val input = listOf("ghijklmn")
+        day11.part2(input) shouldBe "ghjbbcdd"
+    }
+})