Refactored day03 zig to avoid copy and use stack

Author: avokadoen

days/day-03/solutions/day03.zig

@@ -4,79 +4,52 @@ const io = std.io;
 const ArrayList = std.ArrayList;
 const Allocator = std.mem.Allocator;
 
-const max_file_size = 20_000;
-
-const Tile = enum {
-    open,
-    closed
-};
-
-const ParseError = error {
-    UnrecognizedChar
-};
-
-// Zig will support support function definition expressions in 0.8
-// see: https://github.com/ziglang/zig/issues/1717
-inline fn parse(internal_map: *ArrayList(Tile), bytes: ArrayList(u8), pos: usize, exit_on_whitespace: bool) anyerror!usize {
-    var i: usize = pos;
-    
-    parser: while (i < bytes.items.len) : (i += 1) {
-        var tile: Tile = Tile.closed; 
-
-        switch(bytes.items[i]) {
-            '.' => tile = Tile.open,
-            '#' => tile = Tile.closed,
-            '\n', '\r' => if (exit_on_whitespace) break else continue :parser,
-            else => return ParseError.UnrecognizedChar
-        }
-
-        try internal_map.append(tile);
-    }
-
-    return i;
-}
+const MAX_FILE_SIZE = 20_000;
 
 const Map = struct {
-    internal_map: ArrayList(Tile),
-    map_width: usize,
+    bytes: []u8,
+    line_width: usize,
     map_height: usize,
 
-    pub inline fn fromBytesList(bytes: ArrayList(u8), pre_alloc: usize) anyerror!Map {
-        var internal_map = try ArrayList(Tile).initCapacity(bytes.allocator, pre_alloc);
-        var map_width: usize = 0;
+    pub inline fn init(bytes: []u8) Map {
+        var line_width: usize = 0;
+        while (line_width < bytes.len) : (line_width += 1) {
+            switch(bytes[line_width]) {
+                '\n', '\r' => break,
+                else => continue
+            }
+        }
 
-        map_width = try parse(&internal_map, bytes, 0, true);
-        _ = try parse(&internal_map, bytes, map_width, false);
+        line_width += 1;
 
         return Map {
-            .internal_map = internal_map,
-            .map_width = map_width,
-            .map_height = @divFloor(internal_map.items.len, map_width)
+            .bytes = bytes,
+            .line_width = line_width,  // TODO: account for arbitrary line ending format
+            .map_height = @divFloor(bytes.len, line_width)
         };
-    }
+    } 
 
-    pub fn inspectPath(self: Map, right: usize, down: usize) u32 {
+    pub inline fn inspectPath(self: Map, rigth: usize, down: usize) usize {
         var x_pos: usize = 0;
         var y_pos: usize = 0;
-
         var closed: u32 = 0;
+
         while (y_pos < self.map_height) {
-            var wat = self.get(x_pos, y_pos);
-            closed += @boolToInt(self.get(x_pos, y_pos) == Tile.closed);
-            x_pos += right;
+            var n_skipped = @divFloor(x_pos, self.line_width - 1);
+            var real_x = (x_pos + n_skipped) % self.line_width;
+            var real_y = y_pos * self.line_width;
+
+            closed += @boolToInt(self.bytes[real_x + real_y] == '#');
+
+            x_pos += rigth;
             y_pos += down;
-        } 
+        }
 
         return closed;
     }
+};
 
-    pub fn get(self: Map, x: usize, y: usize) Tile {
-        var real_x = x % self.map_width;
-        var real_y = y * self.map_width;
 
-        return self.internal_map.items[real_x + real_y];
-    } 
-};
 
 pub fn main() anyerror!void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
@@ -87,12 +60,10 @@ pub fn main() anyerror!void {
     const in = std.io.getStdIn().reader();
     const stdout = std.io.getStdOut().writer();
 
-    // Lets not do io using the stack this time ... 
-    comptime const pre_alloc = max_file_size * 0.8;
-    var bytes = try ArrayList(u8).initCapacity(allocator, pre_alloc);
-    try in.readAllArrayList(&bytes, max_file_size);
+    var buf: [MAX_FILE_SIZE]u8 = undefined;
+    const length = try in.readAll(&buf);
 
-    var map = try Map.fromBytesList(bytes, pre_alloc);
+    var map = Map.init(buf[0..length]);
 
     var path_3_1 = map.inspectPath(3, 1);
     try stdout.print("{}\n", .{path_3_1});