2022-08 in zig

1 files changed, 101 insertions, 0 deletions

diff --git a/2022/08-treetop-tree-house/second.zig b/2022/08-treetop-tree-house/second.zig
new file mode 100644
index 0000000..3582143
--- /dev/null
+++ b/2022/08-treetop-tree-house/second.zig
@@ -0,0 +1,101 @@
+const std = @import("std");
+
+const example = @embedFile("example");
+const input = @embedFile("input");
+
+pub fn main() anyerror!void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    try std.testing.expectEqual(try solve(example, allocator), 8);
+    const result = try solve(input, allocator);
+    try std.io.getStdOut().writer().print("{}\n", .{result});
+}
+
+fn solve(puzzle: []const u8, allocator: std.mem.Allocator) !u64 {
+    var it = std.mem.tokenize(u8, puzzle, "\n");
+    var heights = std.ArrayList(std.ArrayList(u8)).init(allocator);
+    var scenic = std.ArrayList(std.ArrayList(u64)).init(allocator);
+    // process input
+    var line = it.next() orelse unreachable;
+    const width = line.len;
+    while (true) {
+        var h = try heights.addOne();
+        var v = try scenic.addOne();
+        h.* = try std.ArrayList(u8).initCapacity(allocator, width);
+        v.* = try std.ArrayList(u64).initCapacity(allocator, width);
+        try h.*.writer().writeAll(line);
+        var i: usize = 0;
+        while (i < width) : (i += 1) {
+            v.*.appendAssumeCapacity(0);
+        }
+        if (it.next()) |l| {
+            line = l;
+        } else {
+            break;
+        }
+    }
+    const lastX = width - 1;
+    const lastY = heights.items.len - 1;
+    // init first and last lines edges
+    var x: usize = 1;
+    while (x < width - 1) : (x += 1) {
+        scenic.items[0].items[x] = 0;
+        scenic.items[lastY].items[x] = 0;
+    }
+    // calculate scenic scores tree by tree
+    var tot: usize = 0;
+    var y: usize = 1;
+    while (y < lastY) : (y += 1) {
+        x = 1;
+        while (x < lastX) : (x += 1) {
+            const max = heights.items[y].items[x];
+            // look right
+            var sr: usize = 1; // scenic score to the right
+            var i: usize = x + 1;
+            while (i < lastX) : (i += 1) {
+                if (heights.items[y].items[i] < max) {
+                    sr += 1;
+                } else {
+                    break;
+                }
+            }
+            // look left
+            var sl: usize = 1;
+            i = x - 1;
+            while (i > 0) : (i -= 1) {
+                if (heights.items[y].items[i] < max) {
+                    sl += 1;
+                } else {
+                    break;
+                }
+            }
+            // look down
+            var sd: usize = 1;
+            i = y + 1;
+            while (i < lastY) : (i += 1) {
+                if (heights.items[i].items[x] < max) {
+                    sd += 1;
+                } else {
+                    break;
+                }
+            }
+            // look up
+            var su: usize = 1;
+            i = y - 1;
+            while (i > 0) : (i -= 1) {
+                if (heights.items[i].items[x] < max) {
+                    su += 1;
+                } else {
+                    break;
+                }
+            }
+            const score = sr * sl * sd * su;
+            if (score > tot) {
+                tot = score;
+            }
+        }
+    }
+    return tot;
+}