Add day 8 part 1

Author: jvgrootveld

2015/src/main/kotlin/day08/Day08.kt

@@ -0,0 +1,140 @@
+package day08
+
+import shared.DebugLogger
+
+class Day08 {
+    companion object {
+
+        val log = DebugLogger(false)
+
+        fun part1(input: ByteArray): Day08Result {
+
+            val stateMachine = StateMachine()
+
+            input.forEach(stateMachine::addChar)
+
+            stateMachine.newLine() // Add last result to the results
+            return Day08Result(stateMachine.lineResults)
+        }
+
+        fun part2(input: List<String>): Int {
+            TODO("IMPLEMENT")
+        }
+
+        class Day08Result(val lineResults: List<LineResult>) {
+            fun countTotal() = lineResults.sumOf {
+                it.codeCount - it.memoryCount
+            }
+        }
+
+
+        enum class CharBytes(private val char: Char) {
+            NEW_LINE('\n'),
+            ZERO('0'),
+            NINE('9'),
+            SLASH('\\'),
+            QUOTE('"'),
+            X('x');
+
+            val code: Int
+                get() = char.code
+
+            val byte: Byte
+                get() = code.toByte()
+        }
+
+        data class LineResult(var codeCount: Int = 0, var memoryCount: Int = 0) {
+            fun clear() {
+                codeCount = 0
+                memoryCount = 0
+            }
+        }
+
+        interface CharState {
+            fun addChar(stateMachine: StateMachine, charByte: Byte)
+        }
+
+        class StateMachine {
+            private var currentState: CharState = NormalState()
+
+            val lineResults = mutableListOf<LineResult>()
+            var currentLineResult = LineResult(0, 0)
+
+            fun addChar(charByte: Byte) {
+                currentLineResult.codeCount++ // Always increase code count
+                log.debugln("\naddChar: '${charByte.toInt().toChar()}' codeCount: ${currentLineResult.codeCount}")
+                currentState.addChar(this, charByte)
+            }
+
+            fun addMemoryCount() {
+                currentLineResult.memoryCount++
+                log.debugln("addMemoryCount: ${currentLineResult.memoryCount}")
+            }
+
+            fun newLine() {
+                currentLineResult.memoryCount -= 2 // Remove start and end quotes
+                log.debugln("newLine code '${currentLineResult.codeCount}' memory '${currentLineResult.memoryCount}'")
+                log.debugln("=".repeat(20))
+                lineResults.add(currentLineResult)
+
+                // Reset line and state
+                currentLineResult = LineResult(0, 0)
+                setNewState(NormalState())
+            }
+
+            fun setNewState(newState: CharState) {
+                log.debugln("setNewState: $currentState > $newState")
+                currentState = newState
+            }
+        }
+
+        // ""          =  2 code, 0 memory
+        // "abc"       =  5 code, 3 memory
+        // "aaa\"aaa"  = 10 code, 7 memory
+        // "\x27"      =  6 code, 1 memory
+        class NormalState() : CharState {
+            override fun addChar(stateMachine: StateMachine, charByte: Byte) {
+                log.debugln("--- NormalState")
+
+                when(charByte) {
+                    CharBytes.SLASH.byte -> stateMachine.setNewState(SlashState())
+                    CharBytes.NEW_LINE.byte -> {
+                        stateMachine.currentLineResult.codeCount -= 1 // Remove new line
+                        stateMachine.newLine()
+                    }
+                    else -> stateMachine.addMemoryCount()
+                }
+            }
+        }
+
+        class SlashState() : CharState {
+            override fun addChar(stateMachine: StateMachine, charByte: Byte) {
+                log.debugln("--- SlashState")
+                when(charByte) {
+                    CharBytes.X.byte -> stateMachine.setNewState(HexState())
+                    else -> { // Like '\\' or '\"'
+                        stateMachine.addMemoryCount()
+                        stateMachine.setNewState(NormalState())
+                    }
+                }
+            }
+        }
+
+        class HexState() : CharState {
+            var hexadecimalCount = 0;
+
+            override fun addChar(stateMachine: StateMachine, charByte: Byte) {
+                log.debugln("--- HexState")
+
+                hexadecimalCount++
+
+                // Like '\x27' or '\x3d'
+                if (hexadecimalCount == 2) {
+                    stateMachine.addMemoryCount()
+                    stateMachine.setNewState(NormalState())
+                }
+            }
+        }
+
+    }
+}

2015/src/test/kotlin/Day08Test.kt

@@ -0,0 +1,45 @@
+import day08.Day08
+import day08.Day08.Companion.LineResult
+import org.junit.jupiter.api.Test
+
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+internal class Day08Test {
+
+    @Test
+    fun `part1 examples`() {
+        val input = Resource.readFileAsBytes("day08_test")
+        val result = Day08.part1(input)
+        assertLineResult(result.lineResults[0], 2, 0)  // ""          =  2 code, 0 memory
+        assertLineResult(result.lineResults[1], 5, 3)  // "abc"       =  5 code, 3 memory
+        assertLineResult(result.lineResults[2], 10, 7) // "aaa\"aaa"  = 10 code, 7 memory
+        assertLineResult(result.lineResults[3], 6, 1)  // "\x27"      =  6 code, 1 memory
+    }
+
+    private fun assertLineResult(lineResult: LineResult, codeCount: Int, memoryCount: Int) {
+        assertEquals(codeCount, lineResult.codeCount)
+        assertEquals(memoryCount, lineResult.memoryCount)
+    }
+
+    @Test
+    fun `part1 puzzel input`() {
+        val input = Resource.readFileAsBytes("day08")
+        assertEquals(1333, Day08.part1(input).countTotal())
+    }
+
+    @ParameterizedTest
+    @CsvSource(
+        "input, 0",
+    )
+    fun `part2 examples`(input: String, expectedResult: Int) {
+        assertEquals(expectedResult, Day08.part2(listOf(input)))
+    }
+
+    @Test
+    fun `part2 puzzel input`() {
+        val input = Resource.readFileLines("day08")
+        assertEquals(0, Day08.part2(input))
+    }
+}

2015/src/test/kotlin/FileUtils.kt

@@ -15,6 +15,10 @@ class Resource {
         fun readFileLines(fileName: String): List<String> {
             return Resource::class.java.getResource("$fileName.txt").readText(Charsets.UTF_8).split("\n")
         }
+
+        fun readFileAsBytes(fileName: String): ByteArray {
+            return Resource::class.java.getResource("$fileName.txt").readBytes()
+        }
     }
 }