Messy day 6

data/06.txt

@@ -0,0 +1,50 @@
+183, 157
+331, 86
+347, 286
+291, 273
+285, 152
+63, 100
+47, 80
+70, 88
+333, 86
+72, 238
+158, 80
+256, 140
+93, 325
+343, 44
+89, 248
+93, 261
+292, 250
+240, 243
+342, 214
+192, 51
+71, 92
+219, 63
+240, 183
+293, 55
+316, 268
+264, 151
+68, 98
+190, 288
+85, 120
+261, 59
+84, 222
+268, 171
+205, 134
+80, 161
+337, 326
+125, 176
+228, 122
+278, 151
+129, 287
+293, 271
+57, 278
+104, 171
+330, 69
+141, 141
+112, 127
+201, 151
+331, 268
+95, 68
+289, 282
+221, 359

day01.nim

@@ -1,13 +1,14 @@
 import intsets, math, sequtils, strutils
 
-let input = readFile("data/01.txt").splitLines.filter(proc(x: string): bool = x != "").map(parseInt)
+let input = readFile("data/01.txt").strip.splitLines.map(parseInt)
 
 proc part1(freqs: seq[int]): int =
     freqs.sum
 
 proc part2(freqs: seq[int]): int =
-    var seen = initIntSet()
-    var talley: int
+    var
+        seen = initIntSet()
+        talley: int
 
     while true:
         for n in freqs:

day06.nim

@@ -0,0 +1,87 @@
+import math, sequtils, strutils
+
+type
+    Point = array[2, int]
+
+func read_coords(text: string): seq[Point] =
+    for line in text.strip.splitlines:
+        let parts = line.split(", ").map(parseInt)
+        result &= [parts[0], parts[1]]
+
+func bounds(coords: seq[Point]): array[4, int] =
+    let
+        xs = coords.map(proc(coord: Point): int = coord[0])
+        ys = coords.map(proc(coord: Point): int = coord[1])
+    result = [min(xs), max(xs), min(ys), max(ys)]
+
+func distance(point1: Point, point2: Point): int = abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])
+
+func nearest(coords: seq[Point], point: Point): int =
+    var
+        min = -1
+        best = -1
+        dupe = false
+        i = 0
+
+    for coord in coords:
+        let distance = coord.distance(point)
+        if min == -1 or distance < min:
+            min = distance
+            best = i
+            dupe = false
+        elif min == distance:
+            dupe = true
+        i += 1
+    
+    if dupe:
+        result = -1
+    else:
+        result = best
+
+func inrange(coords: seq[Point], point: Point): bool = coords.map(proc (coord: Point): int = coord.distance(point)).sum < 10000
+
+let
+    coords = read_coords(readFile("data/06.txt"))
+    extents = coords.bounds
+
+var
+    counts = newSeqWith(coords.len, 0)
+    excluded = newSeqWith(coords.len, false)
+
+for x in extents[0] .. extents[1]:
+    for y in extents[2] .. extents[3]:
+        let coord = coords.nearest([x, y])
+        if coord != -1:
+            counts[coord] += 1
+            if x == extents[0] or x == extents[1] or y == extents[2] or y == extents[3]:
+                excluded[coord] = true
+
+echo zip(counts, excluded)
+        .filter(proc(x: tuple[a: int, b: bool]): bool = not x.b)
+        .map(proc(x: tuple[a: int, b: bool]): int = x.a)
+        .max
+
+
+var size = 0
+let
+    extension = int(10000 / coords.len)
+    y_start = extents[2] - extension
+    y_finish = extents[3] + extension
+    y_range = y_finish - y_start
+
+for x in extents[0] - extension .. extents[1] + extension:
+    var
+        min_y = 0
+        max_y = 0
+    for y in extents[2] - extension .. extents[3] + extension:
+        if coords.inrange([x,y]):
+            min_y = y
+            break
+    for dy in 0 .. y_range:
+        var y = y_finish - dy
+        if coords.inrange([x,y]):
+            max_y = y + 1
+            break
+    size += abs(max_y - min_y)
+
+echo size