···

       
3
       
3
       
 
       
const State = struct { turn: i32, zeroes: u32 };

     

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
pub fn main() !void {

     

       
6
       
6
       
-
       
    const turns: []i32 = blk: {

     

       
7
       
7
       
-
       
        const allocator = std.heap.page_allocator;

     

       
6
       
6
       
+
       
    const allocator = std.heap.page_allocator;

     

       
8
       
7
       
 
       


     

       
9
       
9
       
-
       
        const input_raw = @embedFile("./input.txt");

     

       
10
       
10
       
-
       
        const input_str = std.mem.trim(u8, input_raw, "\t\r\n");

     

       
11
       
11
       
-
       
        var turns_str = std.mem.splitScalar(u8, input_str, '\n');

     

       
8
       
8
       
+
       
    const input_raw = @embedFile("./input.txt");

     

       
9
       
9
       
+
       
    const input_str = std.mem.trim(u8, input_raw, "\t\r\n");

     

       
10
       
10
       
+
       
    var turns_str = std.mem.splitScalar(u8, input_str, '\n');

     

       
12
       
11
       
 
       


     

       
13
       
13
       
-
       
        const turns_len =

     

       
14
       
14
       
-
       
            std.mem.count(u8, input_str, "\n") + 1;

     

       
15
       
15
       
-
       
        const turns = try allocator.alloc(i32, turns_len);

     

       
12
       
12
       
+
       
    const turns_len =

     

       
13
       
13
       
+
       
        std.mem.count(u8, input_str, "\n") + 1;

     

       
14
       
14
       
+
       
    const turns = try allocator.alloc(i32, turns_len);

     

       
15
       
15
       
+
       
    defer allocator.free(turns);

     

       
16
       
16
       
 
       


     

       
17
       
17
       
-
       
        var i: u32 = 0;

     

       
18
       
18
       
-
       
        while (turns_str.next()) |turn_str| {

     

       
19
       
19
       
-
       
            const mult: i32 = if (turn_str[0] == 'L') -1 else 1;

     

       
20
       
20
       
-
       
            turns[i] = try std.fmt.parseInt(i32, turn_str[1..], 10) * mult;

     

       
21
       
21
       
-
       
            i += 1;

     

       
22
       
22
       
-
       
        }

     

       
23
       
23
       
-
       
        break :blk turns;

     

       
24
       
24
       
-
       
    };

     

       
17
       
17
       
+
       
    var i: u32 = 0;

     

       
18
       
18
       
+
       
    while (turns_str.next()) |turn_str| {

     

       
19
       
19
       
+
       
        const mult: i32 = if (turn_str[0] == 'L') -1 else 1;

     

       
20
       
20
       
+
       
        turns[i] = try std.fmt.parseInt(i32, turn_str[1..], 10) * mult;

     

       
21
       
21
       
+
       
        i += 1;

     

       
22
       
22
       
+
       
    }

     

       
25
       
23
       
 
       


     

       
26
       
24
       
 
       
    var part_1 = State{ .turn = 50, .zeroes = 0 };

     

       
27
       
25
       
 
       
    for (turns) |turn| {

     

       
28
       
28
       
-
       
        const iturn: i32 = @intCast(part_1.turn);

     

       
29
       
29
       
-
       
        part_1.turn = @mod(iturn + turn, 100);

     

       
26
       
26
       
+
       
        part_1.turn = @mod(part_1.turn + turn, 100);

     

       
30
       
27
       
 
       
        part_1.zeroes += @intFromBool(part_1.turn == 0);

     

       
31
       
28
       
 
       
    }

     

       
32
       
29
       
 
       
    std.debug.print("Part 1: {}\n", .{part_1.zeroes});

     

       
33
       
30
       
 
       


     

       
34
       
31
       
 
       
    var part_2 = State{ .turn = 50, .zeroes = 0 };

     

       
35
       
32
       
 
       
    for (turns) |turn| {

     

       
36
       
36
       
-
       
        const iturn: i32 = @intCast(part_2.turn);

     

       
37
       
37
       
-
       
        const raw_turn: i32 = iturn + turn;

     

       
33
       
33
       
+
       
        const raw_turn: i32 = part_2.turn + turn;

     

       
38
       
34
       
 
       
        // if it is below zero before being moduloed and the original number itself wasn't zero it means that it did touch zero but the division thing wouldn't count it, so we give this extra support.

     

       
39
       
35
       
 
       
        // of course, there is no need to deal with a negative to positive situation because the acc.turn will never be negative!!!

     

       
40
       
36
       
 
       
        part_2.zeroes += @abs(raw_turn) / 100 + @intFromBool(part_2.turn != 0 and raw_turn <= 0);