Tidy up and increase performance a bit

README.md

@@ -1,19 +1,15 @@
 # Advent of Code 2018
 
 This repository contains my solution to 2018's [Advent of Code](https://adventofcode.com/2018) puzzles. The solutions
-are all written in Python 3; one or two may require the [NumPy](http://www.numpy.org/) package, but the rest should
-work out-of-the-box.
+are a mixture of Python 3 and Nim.
 
-If you have docker installed, simply execute `run.sh` to build a docker image and execute the latest solution
-using pypy3. You can specify other days by passing the script names as arguments (e.g. `run.sh 03.py`).
-
-I tend to focus on short, functional solutions where possible, so they may be a bit hard to read. Some solutions are
-commented to some degree to help with that.
+The easiest way to run these is using docker -- simply execute `run.sh <day>` to build a docker image and execute the
+specific day.
 
 I have separate repositories for solutions from previous years:
-  - [2017](https://g.c5h.io/archive/aoc-2017)
-  - [2016](https://g.c5h.io/archive/aoc-2016)
-  - [2015](https://g.c5h.io/archive/aoc-2015)
+  - [2017](https://g.c5h.io/archive/aoc-2017) (All python)
+  - [2016](https://g.c5h.io/archive/aoc-2016) (All python)
+  - [2015](https://g.c5h.io/archive/aoc-2015) (All python)
 
 ---
 

day06.nim

@@ -14,74 +14,76 @@ func bounds(coords: seq[Point]): array[4, int] =
         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 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
+    let
+        distances = coords.map(proc(coord: Point): int = coord.distance(point))
+        lowest = min(distances)
+        lowest_count = distances.filter(proc (distance: int): bool = distance == lowest).len
+    if lowest_count == 1: distances.find(lowest) else: -1
 
-    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
 
-func inrange(coords: seq[Point], point: Point): bool = coords.map(proc (coord: Point): int = coord.distance(point)).sum < 10000
+func part1(coords: seq[Point], extents: array[4, int]): int =
+    var
+        counts = newSeqWith(coords.len, 0)
+        excluded = newSeqWith(coords.len, false)
 
-let
-    coords = read_coords(readFile("data/06.txt"))
-    extents = coords.bounds
+    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 the area reaches the edge of the grid, it will continue infinitely.
+                # Mark that area as excluded.
+                if x == extents[0] or x == extents[1] or y == extents[2] or y == extents[3]:
+                    excluded[coord] = true
 
-var
-    counts = newSeqWith(coords.len, 0)
-    excluded = newSeqWith(coords.len, false)
+    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
+
+func part2(coords: seq[Point], extents: array[4, int]): int =
+    var
+        size = 0
+        found = false
+    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] .. 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
+    # The region we're in is going to be contiguous so once we've found some
+    # 'safe' areas and subsequently hit a row/column with none in, we can abort
+    for x in extents[0] - extension .. extents[1] + extension:
+        var
+            min_y = int.high
+            max_y = int.high
 
-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
+        for y in extents[2] - extension .. extents[3] + extension:
+            if coords.inrange([x,y]):
+                if min_y == int.high:
+                    min_y = y
+                max_y = y
+            elif max_y != int.high:
+                break
+        
+        if min_y != int.high:
+            size += abs(max_y - min_y) + 1
+            found = true
+        elif found:
+            break
 
+    size
 
-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)
+    coords = read_coords(readFile("data/06.txt"))
+    extents = coords.bounds
 
-echo size
+echo part1(coords, extents)
+echo part2(coords, extents)