1  const std = @import("std");
 2  const mem = std.mem;
 3  
 4  const input = @embedFile("inputs/day01.txt");
 5  
 6  pub fn run(alloc: mem.Allocator, progress: *std.Progress.Node) !void {
 7      const n1 = progress.start("Parsing", 0);
 8  
 9      const parsed = try parse(alloc, input);
10      defer parsed.deinit();
11  
12      n1.end();
13  
14      const n2 = progress.start("Running", 0);
15      defer n2.end();
16  
17      std.mem.sort(u64, parsed.items, .{}, BiggerThan(u64).sort);
18  
19      std.log.info("Result Part 1: {}", .{parsed.items[0]});
20      std.log.info("Result Part 2: {}", .{parsed.items[0] + parsed.items[1] + parsed.items[2]});
21  }
22  
23  pub fn parse(alloc: mem.Allocator, buffer: []const u8) !std.ArrayList(u64) {
24      var ret = std.ArrayList(u64).init(alloc);
25  
26      var idx: usize = 0;
27      var block_iter = std.mem.splitSequence(u8, buffer, "\n");
28      while (block_iter.next()) |block| {
29          if (std.mem.eql(u8, block, "")) {
30              idx += 1;
31              try ret.append(0);
32              continue;
33          }
34  
35          const cal = try std.fmt.parseUnsigned(u64, block, 0);
36          if (ret.popOrNull()) |current| {
37              try ret.insert(idx, current + cal);
38          } else {
39              try ret.insert(idx, cal);
40          }
41      }
42  
43      return ret;
44  }
45  
46  fn BiggerThan(comptime T: type) type {
47      return struct {
48          fn sort(_: @TypeOf(.{}), lhs: T, rhs: T) bool {
49              return lhs > rhs;
50          }
51      };
52  }
53  
54  test "test" {
55      const testing = std.testing;
56  
57      const test_input =
58          \\1000
59          \\2000
60          \\3000
61          \\
62          \\4000
63          \\
64          \\5000
65          \\6000
66          \\
67          \\7000
68          \\8000
69          \\9000
70          \\
71          \\10000
72      ;
73  
74      const parsed = try parse(testing.allocator, test_input);
75      defer parsed.deinit();
76  
77      std.mem.sort(u64, parsed.items, .{}, BiggerThan(u64).sort);
78  
79      try testing.expectEqual(parsed.items[0], 24000);
80  }