fix: day 1 part 1 tests and upper lower limits

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

Author: markkovari

2025/zig/src/day01/day01.zig

@@ -16,6 +16,35 @@ fn Rotation(comptime T: type) type {
     };
 }
 
+fn Dial(comptime T: type) type {
+    return struct {
+        const Self = @This();
+
+        initial: T,
+        position: T,
+
+        pub fn init(initial_position: T) Self {
+            return .{
+                .initial = initial_position,
+                .position = initial_position,
+            };
+        }
+        pub fn rotate(self: *Self, rotation: Rotation(T)) void {
+            switch (rotation.dir) {
+                .Left => {
+                    self.position = @mod(self.position - rotation.amount, 100);
+                },
+                .Right => {
+                    self.position = @mod(self.position + rotation.amount, 100);
+                },
+            }
+        }
+        pub fn getCurrentPosition(self: Self) T {
+            return self.position;
+        }
+    };
+}
+
 fn parseFromString(comptime T: type, input: []const u8) RotationParseError!Rotation(T) {
     if (input.len < 2) {
         return RotationParseError.InvalidLength;
@@ -49,10 +78,24 @@ pub fn parseAllLines(comptime T: type, allocator: std.mem.Allocator, input: []co
     return try results.toOwnedSlice(allocator);
 }
 
-pub fn part1(input: []const u8) !i32 {
-    // Parse and solve part 1
-    _ = input;
-    return 0;
+pub fn part1(input: []const u8) !u32 {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+    var amount: u32 = 0;
+
+    const rotations = try parseAllLines(i32, allocator, input);
+    defer allocator.free(rotations);
+
+    var dial = Dial(i32).init(50);
+    for (rotations) |rotation| {
+        dial.rotate(rotation);
+        if (dial.getCurrentPosition() == 0) {
+            amount += 1;
+        }
+    }
+
+    return amount;
 }
 
 pub fn part2(input: []const u8) !i32 {
@@ -104,3 +147,48 @@ test "parse with invalid length" {
     const asText = "G";
     try std.testing.expectError(RotationParseError.InvalidLength, parseFromString(u32, asText));
 }
+
+test "dial initialization" {
+    var dial = Dial(i32).init(100);
+    try std.testing.expectEqual(@as(i32, 100), dial.initial);
+    try std.testing.expectEqual(@as(i32, 100), dial.getCurrentPosition());
+}
+
+test "dial rotation right" {
+    var dial = Dial(i32).init(0);
+    const rotation = Rotation(i32){ .dir = .Right, .amount = 10 };
+    dial.rotate(rotation);
+    try std.testing.expectEqual(@as(i32, 0), dial.initial); // initial unchanged
+    try std.testing.expectEqual(@as(i32, 10), dial.getCurrentPosition());
+}
+
+test "dial rotation left" {
+    var dial = Dial(i32).init(50);
+    const rotation = Rotation(i32){ .dir = .Left, .amount = 20 };
+    dial.rotate(rotation);
+    try std.testing.expectEqual(@as(i32, 50), dial.initial); // initial unchanged
+    try std.testing.expectEqual(@as(i32, 30), dial.getCurrentPosition());
+}
+
+test "dial multiple rotations" {
+    var dial = Dial(i32).init(0);
+    dial.rotate(.{ .dir = .Right, .amount = 10 });
+    dial.rotate(.{ .dir = .Left, .amount = 5 });
+    dial.rotate(.{ .dir = .Right, .amount = 15 });
+    try std.testing.expectEqual(@as(i32, 0), dial.initial); // initial always unchanged
+    try std.testing.expectEqual(@as(i32, 20), dial.getCurrentPosition());
+}
+
+test "first part example" {
+    const example_input = @embedFile("example.txt");
+    const result = try part1(example_input);
+
+    try std.testing.expectEqual(3, result);
+}
+
+test "first part input" {
+    const example_input = @embedFile("input.txt");
+    const result = try part1(example_input);
+
+    try std.testing.expectEqual(1071, result);
+}