Added benchmark

day1/part1.zig

@@ -4,7 +4,6 @@ const print = std.debug.print;
 var file_buf: [1024 * 1024]u8 = undefined; // The file do 20kB, I give it 1MB
 
 pub fn main() !void {
-    const time_start = std.time.microTimestamp();
     var left: [1000]i32 = undefined;
     var right: [1000]i32 = undefined;
 
@@ -24,16 +23,7 @@ pub fn main() !void {
     std.mem.sort(i32, &left, {}, comptime std.sort.asc(i32));
     std.mem.sort(i32, &right, {}, comptime std.sort.asc(i32));
 
-    const time_parsing = std.time.microTimestamp();
-    print("Parsing time: {d}μs\n", .{time_parsing - time_start});
-
-    const total_distance = distance(left, right);
-    const total_similarity = try similarity(left, right);
-
-    const time_end = std.time.microTimestamp();
-    print("Compute time: {d}μs\n", .{time_end - time_parsing});
-    print("\tDistance: {d}\n", .{total_distance});
-    print("\tSimilarity: {d}\n", .{total_similarity});
+    try std.testing.expectEqual(1110981, distance(left, right));
 }
 
 fn distance(left: [1000]i32, right: [1000]i32) u32 {

day1/part2.zig

@@ -0,0 +1,56 @@
+const std = @import("std");
+const print = std.debug.print;
+
+var file_buf: [1024 * 1024]u8 = undefined; // The file do 20kB, I give it 1MB
+
+pub fn main() !void {
+    var left: [1000]i32 = undefined;
+    var right: [1000]i32 = undefined;
+
+    const file = try std.fs.cwd().openFile("day1/input", .{});
+    defer file.close();
+    const len = try file.readAll(&file_buf);
+
+    var i: u32 = 0;
+    var iter = std.mem.split(u8, file_buf[0..len], "\n");
+    while (iter.next()) |line| {
+        if (i == 1000) continue;
+        left[i] = try std.fmt.parseInt(i32, line[0..5], 10);
+        right[i] = try std.fmt.parseInt(i32, line[8..13], 10);
+        i += 1;
+    }
+
+    try std.testing.expectEqual(24869388, similarity(left, right));
+}
+
+fn distance(left: [1000]i32, right: [1000]i32) u32 {
+    var total_distance: u32 = 0;
+    for (left, right) |l, r| {
+        total_distance += @abs(r - l);
+    }
+    return total_distance;
+}
+
+fn similarity(left: [1000]i32, right: [1000]i32) !i32 {
+    // Make a map with value -> occurence
+    var buff: [1024 * 100]u8 = undefined;
+    var fbuf = std.heap.FixedBufferAllocator.init(&buff);
+    const allocator = fbuf.allocator();
+
+    var map = std.AutoHashMap(i32, u8).init(allocator);
+    defer map.deinit();
+
+    for (right) |r| {
+        if (map.get(r)) |r_count| {
+            try map.put(r, r_count + 1);
+        } else {
+            try map.put(r, 1);
+        }
+    }
+
+    var total_similarity: i32 = 0;
+    for (left) |l| {
+        if (map.get(l)) |r_count| total_similarity += l * r_count;
+    }
+    return total_similarity;
+}