day18

2 files changed, 137 insertions, 0 deletions

diff --git a/day18/example.txt b/day18/example.txt
new file mode 100644
index 0000000..fc7612e
--- /dev/null
+++ b/day18/example.txt
@@ -0,0 +1,14 @@
+R 6 (#70c710)
+D 5 (#0dc571)
+L 2 (#5713f0)
+D 2 (#d2c081)
+R 2 (#59c680)
+D 2 (#411b91)
+L 5 (#8ceee2)
+U 2 (#caa173)
+L 1 (#1b58a2)
+U 2 (#caa171)
+R 2 (#7807d2)
+U 3 (#a77fa3)
+L 2 (#015232)
+U 2 (#7a21e3)
diff --git a/day18/solution.zig b/day18/solution.zig
new file mode 100644
index 0000000..11da2a1
--- /dev/null
+++ b/day18/solution.zig
@@ -0,0 +1,123 @@
+const std = @import("std");
+const print = std.debug.print;
+const assert = std.debug.assert;
+const ArrayList = std.ArrayList;
+const HashMap = std.HashMap;
+const mem = std.mem;
+
+const fin = mem.trim(u8, @embedFile("./example.txt"), &std.ascii.whitespace);
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+const Direction = [_][2]u64{
+    [_]i64{ -1, 0 },
+    [_]i64{ 0, 1 },
+    [_]i64{ 1, 0 },
+    [_]i64{ 0, -1 },
+};
+
+const Move = struct {
+    dir: usize,
+    dist: isize,
+    color: []const u8,
+};
+
+fn abs(a: i64, b: i64) u64 {
+    return @as(u64, @bitCast(@max(a, b) - @min(a, b)));
+}
+
+fn evaluate(moves: []const Move) !u64 {
+    var polygon = ArrayList([2]i64).init(allocator);
+    defer polygon.deinit();
+
+    var curr = [_]i64{ 0, 0 };
+    var bl: u64 = 0;
+
+    for (moves) |m| {
+        const next = switch (m.dir) {
+            'U' => .{
+                curr[0] - m.dist,
+                curr[1],
+            },
+            'R' => .{
+                curr[0],
+                curr[1] + m.dist,
+            },
+            'D' => .{
+                curr[0] + m.dist,
+                curr[1],
+            },
+            'L' => .{
+                curr[0],
+                curr[1] - m.dist,
+            },
+            else => unreachable,
+        };
+
+        bl += abs(curr[0], next[0]) + abs(curr[1], next[1]);
+        try polygon.append(next);
+        curr = next;
+    }
+
+    const points = polygon.items;
+    const nPoints = points.len;
+    var a2: i64 = 0;
+
+    for (points, 1..) |f, j| {
+        const s = points[j % nPoints];
+
+        a2 += f[0] * s[1] - f[1] * s[0];
+    }
+
+    const a: usize = @bitCast(@divTrunc(if (a2 > 0) a2 else -a2, 2));
+
+    return a + 1 + bl / 2;
+}
+
+pub fn solve(moves: []const Move) !void {
+    const part1 = try evaluate(moves);
+
+    print("{d}\n", .{part1});
+
+    var movespt2 = ArrayList(Move).init(allocator);
+    defer movespt2.deinit();
+
+    for (moves) |m| {
+        const dist = try std.fmt.parseInt(i64, m.color[0..5], 16);
+        const dir: u8 = switch (m.color[5]) {
+            '0' => 'R',
+            '1' => 'D',
+            '2' => 'L',
+            '3' => 'U',
+            else => unreachable,
+        };
+        try movespt2.append(Move{
+            .dist = dist,
+            .dir = dir,
+            .color = m.color,
+        });
+    }
+
+    const part2 = try evaluate(movespt2.items);
+
+    print("{d}\n", .{part2});
+}
+
+pub fn main() !void {
+    var splitLines = mem.splitScalar(u8, fin, '\n');
+    var moves = ArrayList(Move).init(allocator);
+
+    while (splitLines.next()) |line| {
+        var toks = mem.tokenizeAny(u8, line, " (#)");
+        const dir = toks.next().?[0];
+        const dist = try std.fmt.parseInt(i64, toks.next().?, 10);
+        const color = toks.next().?;
+
+        try moves.append(Move{
+            .dir = dir,
+            .dist = dist,
+            .color = color,
+        });
+    }
+    try solve(moves.items);
+}