08

Author: jamOne-

.idea/workspace.xml

@@ -0,0 +1,92 @@
+fun main() {
+    println(solve08a(readInputLines("08")))
+    println(solve08b(readInputLines("08")))
+}
+
+fun solve08a(lines: List<String>): Int {
+    val (size, antennas) = parseInput(lines)
+    return antennas.values.flatMap { getAntinodeLocations(size, it) }.toSet().size
+}
+
+fun solve08b(lines: List<String>): Int {
+    val (size, antennas) = parseInput(lines)
+    return antennas.values.flatMap { getAntinodeLocations2(size, it) }.toSet().size
+}
+
+private data class City(val size: Vector, val antennas: Map<Char, Set<Point>>)
+
+private fun parseInput(lines: List<String>): City {
+    val antennas = mutableMapOf<Char, Set<Point>>()
+
+    for ((y, line) in lines.withIndex()) {
+        for ((x, c) in line.withIndex()) {
+            if (c == '.') {
+                continue
+            }
+
+            val existing = antennas.getOrDefault(c, setOf())
+            antennas[c] = existing + setOf(Point(x, y))
+        }
+    }
+
+    return City(Vector(lines[0].length, lines.size), antennas)
+}
+
+private fun getAntinodeLocations(size: Vector, antennas: Set<Point>): Set<Point> {
+    val result = mutableSetOf<Point>()
+    val list = antennas.toList()
+
+    for (i in antennas.indices) {
+        for (j in i + 1 until antennas.size) {
+            val delta = Vector(list[j].x - list[i].x, list[j].y - list[i].y)
+            result.add(Point(list[i].x - delta.x, list[i].y - delta.y))
+            result.add(Point(list[j].x + delta.x, list[j].y + delta.y))
+        }
+    }
+
+    return result.filter { isPointInBounds(size, it) }.toSet()
+}
+
+private fun getAntinodeLocations2(size: Vector, antennas: Set<Point>): Set<Point> {
+    val result = mutableSetOf<Point>()
+    val list = antennas.toList()
+
+    for (i in antennas.indices) {
+        for (j in i + 1 until antennas.size) {
+            result.addAll(getPointsInLine(list[i], list[j], size))
+        }
+    }
+
+    return result
+}
+
+private fun getPointsInLine(antenna1: Point, antenna2: Point, size: Vector): Set<Point> {
+    val delta = simplifyDelta(Vector(antenna2.x - antenna1.x, antenna2.y - antenna1.y))
+    val result = mutableSetOf<Point>()
+
+    var current = antenna1
+    while (isPointInBounds(size, current)) {
+        result.add(current)
+        current = Point(current.x - delta.x, current.y - delta.y)
+    }
+    current = antenna1
+    while (isPointInBounds(size, current)) {
+        result.add(current)
+        current = Point(current.x + delta.x, current.y + delta.y)
+    }
+
+    return result
+}
+
+private fun simplifyDelta(delta: Vector): Vector =
+    when {
+        delta.x == 0 -> Vector(0, 1)
+        delta.y == 0 -> Vector(1, 0)
+        else -> {
+            val gcd = delta.x.toBigInteger().gcd(delta.y.toBigInteger()).toInt()
+            Vector(delta.x / gcd, delta.y / gcd)
+        }
+    }
+
+private fun isPointInBounds(size: Vector, point: Point): Boolean =
+    point.x >= 0 && point.x < size.x && point.y >= 0 && point.y < size.y

src/main/kotlin/08.kt

@@ -0,0 +1,50 @@
+..........M..........j.............y.....O........
+...B...............q......m........lGO............
+....................q......2.l.GQ...O.............
+.....X.......................................4....
+.....................q............................
+....M......P...............xl.K.............2.....
+....F.........L.......C.K..............m..........
+..........FM......P....jy......m..........o...r...
+..X.......P.....RL..............G..x..........4...
+............L..........NC.....q...................
+.....C.X...............K....y..........4..........
+........S...R.............j.x.....V...4...........
+.....................R..x.....V..i......m.........
+...........................R.V......N.......X.....
+.....F.........M......N......E....................
+................v................T.......F......O.
+.............................N...V.......Q........
+...v.....................C.....i..................
+......c.....W..n.w........................E.......
+3...................c.....................Q..6....
+...........h......................j...............
+.......n.0......h.................E..............2
+.v.............7.......120.....c..................
+......n.0............w...........D.t.........E...r
+....8..3......0.w.hP....z...D..T...............r..
+.................f........T........G......eQ......
+......f.n.....7..p................................
+.....Y..7.......f......I......D......K............
+............Uf....T..W.....D..r...i...............
+......I...............................Z...........
+....5....B.......b..............s..............Z..
+..........d...W..Uwh.............c..........i.....
+..I.3..Y......................e...................
+.....p.b..........k......7........................
+p...........k....I..b..........s..................
+.....k.......o...........W........................
+.A..Y..........U.................a........6.......
+..A...Y.p...................................6.....
+B......k..........................Z............u..
+...3.....................s..............a.........
+......A.........................g.....a...........
+.......A....8...b.U......H....sS..................
+.........................S1.............t.........
+.....................9z..e.....5..1.g.u...........
+.......................z....d....g....H.J....o.6..
+........B................d.....u....9.J.H.........
+.8........S.................u9.............J.....H
+.....................Z5.............t1...........a
+.....................e..v...................o..t..
+.....8...............L.....z.............J........

src/main/kotlin/input/08.txt

@@ -0,0 +1,12 @@
+............
+........0...
+.....0......
+.......0....
+....0.......
+......A.....
+............
+............
+........A...
+.........A..
+............
+............

src/main/kotlin/input/08_example1.txt

@@ -0,0 +1,18 @@
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class Test08 {
+    @Test
+    fun test_a() {
+        val result = solve08a(readInputLines("08_example1"))
+
+        assertEquals(14, result)
+    }
+
+    @Test
+    fun test_b() {
+        val result = solve08b(readInputLines("08_example1"))
+
+        assertEquals(34, result)
+    }
+}