voroskoi/aoc2021-zig - Change NBWIQLPZIFZRXGCDMIFXQAAWWVQEOJDP6KIALLI2NJE4YSNCCNOAC

Rework the build system, use separate file for first and second part

Created by voroskoi on January 15, 2022

NBWIQLPZIFZRXGCDMIFXQAAWWVQEOJDP6KIALLI2NJE4YSNCCNOAC

Dependencies

In channels

main

Change contents

Replacement in src/main.zig at line 2 [6.50]

B:BD[6.58] → [6.58:88]

B:BD[6.88] → [7.0:30]

B:BD[7.30] → [8.0:30]

B:BD[8.30] → [9.0:60]

    _ = @import("day01.zig");
    _ = @import("day02.zig");
    _ = @import("day03.zig");
    _ = @import("day04.zig");
    _ = @import("day05.zig");

[6.58]

[6.88]

    _ = @import("day01a.zig");
    _ = @import("day01b.zig");
    _ = @import("day02a.zig");
    _ = @import("day02b.zig");
    _ = @import("day03a.zig");
    _ = @import("day03b.zig");
    _ = @import("day04a.zig");
    _ = @import("day04b.zig");
    _ = @import("day05a.zig");
    _ = @import("day05b.zig");
    _ = @import("day06a.zig");
    _ = @import("day06b.zig");
    _ = @import("day07a.zig");
    _ = @import("day07b.zig");

File addition: day07b.zig (----------)

[6.15]

const std = @import("std");
const path = "../data/day07/input.txt";
const crabs = 1000;
const CrabType = u11;
const P2 = struct {
    crs: [crabs]CrabType = undefined,
    sum: usize,
};
fn parseInput() anyerror!P2 {
    const in = @embedFile(path);
    const input = std.mem.trimRight(u8, in, "\r\n");
    var crbs = std.mem.tokenize(u8, input, ",");
    var ret = P2{ .sum = 0 };
    var idx: usize = 0;
    while (crbs.next()) |crab| : (idx += 1) {
        const crab_pos = try std.fmt.parseUnsigned(CrabType, crab, 10);
        ret.crs[idx] = crab_pos;
        ret.sum += crab_pos;
    }
    ret.sum = @floatToInt(usize, std.math.floor(@intToFloat(f32, ret.sum) / crabs));
    return ret;
}
fn second() anyerror!usize {
    const crbs = try parseInput();
    var fuel: usize = 0;
    for (crbs.crs) |c| {
        var diff: usize = undefined;
        if (c > crbs.sum) {
            diff = c - crbs.sum;
        } else {
            diff = crbs.sum - c;
        }
        fuel += (diff * (diff + 1)) / 2;
    }
    return fuel;
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.lap() / 1000;
    std.debug.print("Day 7 \tsecond: {d}µs\n", .{s});
}
test "day07b" {
    try std.testing.expectEqual(@as(usize, 95851339), try second());
}

File move: day07.zig → day07a.zig
BF:BFD[6.15] → [5.0:33]
BF:BF[5.33] → [5.34:34]
[6.15]
[5.34]

Deletion in src/day07a.zig at line 39 [5.34]

B:BD[5.924] → [5.924:1516]

}
const P2 = struct {
    crs: [crabs]CrabType = undefined,
    sum: usize,
};
fn parseInput2() anyerror!P2 {
    const in = @embedFile(path);
    const input = std.mem.trimRight(u8, in, "\r\n");
    var crbs = std.mem.tokenize(u8, input, ",");
    var ret = P2{ .sum = 0 };
    var idx: usize = 0;
    while (crbs.next()) |crab| : (idx += 1) {
        const crab_pos = try std.fmt.parseUnsigned(CrabType, crab, 10);
        ret.crs[idx] = crab_pos;
        ret.sum += crab_pos;
    }
    ret.sum = @floatToInt(usize, std.math.floor(@intToFloat(f32, ret.sum) / crabs));
    return ret;

Deletion in src/day07a.zig at line 41 [5.34]

B:BD[5.1519] → [5.1519:1860]

fn second() anyerror!usize {
    const crbs = try parseInput2();
    var fuel: usize = 0;
    for (crbs.crs) |c| {
        var diff: usize = undefined;
        if (c > crbs.sum) {
            diff = c - crbs.sum;
        } else {
            diff = crbs.sum - c;
        }
        fuel += (diff * (diff + 1)) / 2;
    }
    return fuel;
}

Deletion in src/day07a.zig at line 43 [5.34]
B:BD[5.1934] → [5.1934:1935]
Deletion in src/day07a.zig at line 45 [5.34]
B:BD[5.1990] → [5.1990:2046]
```
    _ = try second();
    const s = timer.lap() / 1000;
```

Replacement in src/day07a.zig at line 46 [5.34]

B:BD[5.2047] → [5.2047:2127]

    std.debug.print("Day 7 \t\tfirst: {d}µs \t\tsecond: {d}µs\n", .{ f, s });

[5.2047]

[5.2127]

    std.debug.print("Day 7 \tfirst: {d}µs\t", .{f});

Replacement in src/day07a.zig at line 49 [5.34]
B:BD[5.2130] → [5.2130:2145]
```
test "first" {
```
[5.2130]
[5.2145]
```
test "day07a" {
```

Deletion in src/day07a.zig at line 51 [5.34]

B:BD[5.2211] → [5.2211:2299]

}
test "second" {
    try std.testing.expectEqual(@as(usize, 95851339), try second());

File addition: day06b.zig (----------)

[6.15]

const std = @import("std");
const path = "../data/day06/input.txt";
const ages = 9;
const AgeType = u4;
fn parseInput() anyerror![ages]usize {
    const in = @embedFile(path);
    const input = std.mem.trimRight(u8, in, "\r\n");
    var ltrs = std.mem.tokenize(u8, input, ",");
    var ret = [_]usize{0} ** ages;
    while (ltrs.next()) |lantern_age| {
        const age = try std.fmt.parseUnsigned(AgeType, lantern_age, 10);
        ret[age] += 1;
    }
    return ret;
}
fn sum(ageArray: [ages]usize) usize {
    var s: usize = 0;
    for (ageArray) |value| {
        s += value;
    }
    return s;
}
fn countFish(days: u9) anyerror![ages]usize {
    var age = try parseInput();
    var i: @TypeOf(days) = 0;
    while (i < days) : (i += 1) {
        const new = age[0];
        age[0] = age[1];
        age[1] = age[2];
        age[2] = age[3];
        age[3] = age[4];
        age[4] = age[5];
        age[5] = age[6];
        age[6] = age[7] + new;
        age[7] = age[8];
        age[8] = new;
    }
    return age;
}
fn second() anyerror!usize {
    return sum(try countFish(256));
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.lap() / 1000;
    std.debug.print("Day 6 \tsecond: {d}µs\n", .{s});
}
test "day06b" {
    try std.testing.expectEqual(@as(usize, 1590327954513), try second());
}

File move: day06.zig → day06a.zig
BF:BFD[6.15] → [10.0:33]
BF:BF[10.33] → [10.34:34]
[6.15]
[10.34]
Deletion in src/day06a.zig at line 53 [10.34]
B:BD[10.1135] → [10.1135:1203]
```
}
fn second() anyerror!usize {
    return sum(try countFish(256));
```
Deletion in src/day06a.zig at line 57 [10.34]
B:BD[10.1280] → [10.1280:1281]
Deletion in src/day06a.zig at line 59 [10.34]
B:BD[10.1336] → [10.1336:1392]
```
    _ = try second();
    const s = timer.lap() / 1000;
```

Replacement in src/day06a.zig at line 60 [10.34]

B:BD[10.1393] → [10.1393:1473]

    std.debug.print("Day 6 \t\tfirst: {d}µs \t\tsecond: {d}µs\n", .{ f, s });

[10.1393]

[10.1473]

    std.debug.print("Day 6 \tfirst: {d}µs\t", .{f});

Replacement in src/day06a.zig at line 63 [10.34]
B:BD[10.1476] → [10.1476:1491]
```
test "first" {
```
[10.1476]
[10.1491]
```
test "day06a" {
```

Deletion in src/day06a.zig at line 66 [10.34]

B:BD[10.1559] → [10.1559:1652]


test "second" {
    try std.testing.expectEqual(@as(usize, 1590327954513), try second());
}

File addition: day05b.zig (----------)

[6.15]

const std = @import("std");
const path = "../data/day05/input.txt";
const RetType = u16;
const grid_size = 1000;
const max_grid_value = u2;
const Vents = [grid_size][grid_size]max_grid_value;
const CoordType = i20;
const Coord = struct { x: CoordType, y: CoordType };
fn countVents(directions: []const Coord, nodiag: bool) anyerror!RetType {
    const input = @embedFile(path);
    var lines = std.mem.split(u8, input, "\n");
    var vts: Vents = [_][grid_size]max_grid_value{[_]max_grid_value{0} ** grid_size} ** grid_size;
    var counter: RetType = 0;
    while (lines.next()) |line| {
        if (line.len == 0) continue;
        var crop_line = std.mem.tokenize(u8, line, " -> ");
        // parse coordinates
        var l: [2]Coord = undefined;
        var idx: usize = 0;
        while (crop_line.next()) |cl| : (idx += 1) {
            var coords = std.mem.tokenize(u8, cl, ",");
            l[idx].x = try std.fmt.parseUnsigned(CoordType, coords.next().?, 10);
            l[idx].y = try std.fmt.parseUnsigned(CoordType, coords.next().?, 10);
        }
        // check if diagonal lines count or not
        if (nodiag and !((l[0].x == l[1].x) or (l[0].y == l[1].y))) continue;
        // setup lines
        const dir = try getDirection(l, directions);
        while ((l[0].x != l[1].x + dir.x) or (l[0].y != l[1].y + dir.y)) : ({
            l[0].x += dir.x;
            l[0].y += dir.y;
        }) {
            var v = vts[@intCast(usize, l[0].x)][@intCast(usize, l[0].y)];
            if (v == 1) {
                counter += 1;
            }
            v +|= 1;
            vts[@intCast(usize, l[0].x)][@intCast(usize, l[0].y)] = v;
        }
    }
    return counter;
}
fn getDirection(c: [2]Coord, directions: []const Coord) !Coord {
    var min = try manhattan(c[0], c[1]);
    for (directions) |d| {
        if ((try manhattan(Coord{ .x = c[0].x + d.x, .y = c[0].y + d.y }, c[1])) < min) {
            return d;
        }
    }
    unreachable;
}
fn manhattan(f: Coord, s: Coord) !CoordType {
    const xdiff = try std.math.absInt(f.x - s.x);
    const ydiff = try std.math.absInt(f.y - s.y);
    return xdiff + ydiff;
}
fn second() anyerror!RetType {
    const directions = [_]Coord{
        // Diagonal manhattan distance can decrease by 2, so these must be
        // tried first otherwise getDirection() will not return proper direction.
        .{ .x = -1, .y = -1 },
        .{ .x = -1, .y = 1 },
        .{ .x = 1, .y = -1 },
        .{ .x = 1, .y = 1 },
        .{ .x = -1, .y = 0 },
        .{ .x = 1, .y = 0 },
        .{ .x = 0, .y = -1 },
        .{ .x = 0, .y = 1 },
    };
    return try countVents(directions[0..], false);
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.lap() / 1000;
    std.debug.print("Day 5 \tsecond: {d}µs\n", .{s});
}
test "day05b" {
    try std.testing.expectEqual(@as(RetType, 21577), try second());
}

File move: day05.zig → day05a.zig
BF:BFD[6.15] → [9.61:94]
BF:BF[9.94] → [9.95:95]
[6.15]
[9.95]

Deletion in src/day05a.zig at line 79 [9.95]

B:BD[9.2698] → [9.2698:2765]

B:BD[9.2765] → [4.266:544]

∅:D[4.544] → [9.2765:2883]

B:BD[9.2765] → [9.2765:2883]

B:BD[9.3003] → [9.3003:3061]

}
fn second() anyerror!RetType {
    const directions = [_]Coord{
        // Diagonal manhattan distance can decrease by 2, so these must be
        // tried first otherwise getDirection() will not return proper direction.
        .{ .x = -1, .y = -1 },
        .{ .x = -1, .y = 1 },
        .{ .x = 1, .y = -1 },
        .{ .x = 1, .y = 1 },
        .{ .x = -1, .y = 0 },
        .{ .x = 1, .y = 0 },
        .{ .x = 0, .y = -1 },
        .{ .x = 0, .y = 1 },
    };
    return try countVents(directions[0..], false);

Deletion in src/day05a.zig at line 83 [9.95]
B:BD[9.3138] → [9.3138:3139]
Deletion in src/day05a.zig at line 85 [9.95]
B:BD[9.3194] → [9.3194:3250]
```
    _ = try second();
    const s = timer.lap() / 1000;
```

Replacement in src/day05a.zig at line 86 [9.95]

B:BD[9.3251] → [9.3251:3331]

    std.debug.print("Day 5 \t\tfirst: {d}µs \t\tsecond: {d}µs\n", .{ f, s });

[9.3251]

[9.3331]

    std.debug.print("Day 5 \tfirst: {d}µs\t", .{f});

Replacement in src/day05a.zig at line 89 [9.95]
B:BD[9.3334] → [9.3334:3349]
```
test "first" {
```
[9.3334]
[9.3349]
```
test "day05a" {
```

Deletion in src/day05a.zig at line 92 [9.95]

B:BD[9.3417] → [9.3417:3504]


test "second" {
    try std.testing.expectEqual(@as(RetType, 21577), try second());
}

File addition: day04b.zig (----------)

[6.15]

const std = @import("std");
const path = "../data/day04/input.txt";
const retSize = u16;
const grid_size = 5;
const grid_item_size = u7;
const Board = struct {
    items: [grid_size][grid_size]grid_item_size,
    row: [grid_size]u5 = [_]u5{0} ** grid_size,
    col: [grid_size]u5 = [_]u5{0} ** grid_size,
    pub fn value(self: @This()) retSize {
        var ret: retSize = 0;
        for (self.items) |row, rowID| {
            for (row) |item, col| {
                if (self.row[rowID] & (@as(u5, 1) <<| col) == 0) {
                    ret += item;
                }
            }
        }
        return ret;
    }
};
const Bingo = struct {
    numbers: std.ArrayList(grid_item_size),
    boards: std.ArrayList(Board),
};
fn parseInput(allocator: std.mem.Allocator) anyerror!Bingo {
    const input = @embedFile(path);
    var lines = std.mem.split(u8, input, "\n");
    var ret = Bingo{
        .numbers = std.ArrayList(grid_item_size).init(allocator),
        .boards = std.ArrayList(Board).init(allocator),
    };
    var gridRow: u3 = 0;
    var gridCol: u3 = 0;
    var g = Board{ .items = undefined };
    var idx: usize = 0;
    while (lines.next()) |line| : (idx += 1) {
        // read in numbers
        if (idx == 0) {
            var nums = std.mem.tokenize(u8, line, ",");
            while (nums.next()) |num| {
                try ret.numbers.append(try std.fmt.parseUnsigned(grid_item_size, num, 10));
            }
            continue;
        }
        // read in Grids
        var items = std.mem.tokenize(u8, line, " ");
        while (items.next()) |item| {
            const value = try std.fmt.parseUnsigned(grid_item_size, item, 10);
            g.items[gridRow][gridCol] = value;
            gridCol += 1;
        }
        gridCol = 0;
        if (line.len != 0) gridRow += 1;
        // append grid
        if (gridRow == 5) {
            try ret.boards.append(g);
            gridRow = 0;
            gridCol = 0;
            // create new grid
            g = Board{ .items = undefined };
        }
    }
    return ret;
}
fn second() anyerror!retSize {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var bg = try parseInput(allocator);
    defer { // cleanup code
        bg.boards.deinit();
        bg.numbers.deinit();
    }
    var to_remove = std.ArrayList(usize).init(allocator);
    defer to_remove.deinit();
    for (bg.numbers.items) |num| {
        boards_loop: for (bg.boards.items) |_, idx| {
            var grid = &bg.boards.items[idx];
            for (grid.items) |row, i| {
                for (row) |item, j| {
                    if (item == num) {
                        // increase row, col counter
                        grid.row[i] += @as(u5, 1) <<| j;
                        grid.col[j] += @as(u5, 1) <<| i;
                        // check if row or grid equals to 11111, return when true
                        if ((grid.row[i] == 0b11111) or (grid.col[j] == 0b11111)) {
                            if (bg.boards.items.len == 1) {
                                return num * grid.value();
                            } else {
                                try to_remove.append(idx);
                            }
                        }
                        // break out to grid loop
                        continue :boards_loop;
                    }
                }
            }
        }
        std.sort.sort(usize, to_remove.items, {}, comptime std.sort.desc(usize));
        for (to_remove.items) |idx| {
            _ = bg.boards.swapRemove(idx);
        }
        try to_remove.resize(0);
    }
    unreachable;
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.lap() / 1000;
    std.debug.print("Day 4 \tsecond: {d}µs\n", .{s});
}
test "day04b" {
    try std.testing.expectEqual(@as(retSize, 1284), try second());
}

File move: day04.zig → day04a.zig
BF:BFD[6.15] → [11.25:58]
BF:BF[11.58] → [11.59:59]
[6.15]
[11.59]

Deletion in src/day04a.zig at line 101 [11.59]

B:BD[11.3029] → [11.3029:4420]

                        }
                        // break out to grid loop
                        continue :boards_loop;
                    }
                }
            }
        }
    }
    unreachable;
}
fn second() anyerror!retSize {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var bg = try parseInput(allocator);
    defer { // cleanup code
        bg.boards.deinit();
        bg.numbers.deinit();
    }
    var to_remove = std.ArrayList(usize).init(allocator);
    defer to_remove.deinit();
    for (bg.numbers.items) |num| {
        boards_loop: for (bg.boards.items) |_, idx| {
            var grid = &bg.boards.items[idx];
            for (grid.items) |row, i| {
                for (row) |item, j| {
                    if (item == num) {
                        // increase row, col counter
                        grid.row[i] += @as(u5, 1) <<| j;
                        grid.col[j] += @as(u5, 1) <<| i;
                        // check if row or grid equals to 11111, return when true
                        if ((grid.row[i] == 0b11111) or (grid.col[j] == 0b11111)) {
                            if (bg.boards.items.len == 1) {
                                return num * grid.value();
                            } else {
                                try to_remove.append(idx);
                            }

Deletion in src/day04a.zig at line 108 [11.59]

B:BD[11.4607] → [11.4607:4814]


        std.sort.sort(usize, to_remove.items, {}, comptime std.sort.desc(usize));
        for (to_remove.items) |idx| {
            _ = bg.boards.swapRemove(idx);
        }
        try to_remove.resize(0);

Deletion in src/day04a.zig at line 115 [11.59]
B:BD[11.4915] → [11.4915:4916]
Deletion in src/day04a.zig at line 117 [11.59]
B:BD[11.4971] → [11.4971:5027]
```
    _ = try second();
    const s = timer.lap() / 1000;
```

Replacement in src/day04a.zig at line 118 [11.59]

B:BD[11.5028] → [11.5028:5108]

    std.debug.print("Day 4 \t\tfirst: {d}µs \t\tsecond: {d}µs\n", .{ f, s });

[11.5028]

[11.5108]

    std.debug.print("Day 4 \tfirst: {d}µs\t", .{f});

Replacement in src/day04a.zig at line 121 [11.59]
B:BD[11.5111] → [11.5111:5126]
```
test "first" {
```
[11.5111]
[11.5126]
```
test "day04a" {
```

Deletion in src/day04a.zig at line 124 [11.59]

B:BD[11.5195] → [11.5195:5281]


test "second" {
    try std.testing.expectEqual(@as(retSize, 1284), try second());
}

File addition: day03b.zig (----------)

[6.15]

const std = @import("std");
const path = "../data/day03/input.txt";
const retSize = u24;
const lineSize = getLineSize();
fn second() anyerror!retSize {
    const input = @embedFile(path);
    var lines = std.mem.tokenize(u8, input, "\n");
    var buffer: [1000 * lineSize * 100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    const allocator = fba.allocator();
    var lines_array = std.ArrayList(retSize).init(allocator);
    defer lines_array.deinit();
    var lines_array2 = std.ArrayList(retSize).init(allocator);
    defer lines_array2.deinit();
    while (lines.next()) |line| {
        try lines_array.append(try std.fmt.parseUnsigned(retSize, line, 2));
        try lines_array2.append(try std.fmt.parseUnsigned(retSize, line, 2));
    }
    const ox = try getOxigenRating(allocator, &lines_array);
    const co = try getCO2Rating(allocator, &lines_array2);
    return ox * co;
}
fn getOxigenRating(allocator: std.mem.Allocator, oxigen: *std.ArrayList(retSize)) anyerror!retSize {
    var to_remove = std.ArrayList(usize).init(allocator);
    defer to_remove.deinit();
    var idx: usize = lineSize;
    while (oxigen.items.len > 1) : (idx -= 1) {
        var ones: retSize = 0;
        var zeros: retSize = 0;
        // count ones and zeros
        for (oxigen.items) |line| {
            if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                ones += 1;
            } else {
                zeros += 1;
            }
        }
        // std.debug.print("{d} {d} {d}", .{ones, zeros, idx-1});
        for (oxigen.items) |line, i| {
            if (ones >= zeros) {
                if ((line & (@as(retSize, 1) <<| idx - 1)) == 0) {
                    try to_remove.append(i);
                }
            } else {
                if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                    try to_remove.append(i);
                }
            }
        }
        std.sort.sort(usize, to_remove.items, {}, comptime std.sort.desc(usize));
        for (to_remove.items) |i| {
            _ = oxigen.swapRemove(i);
        }
        try to_remove.resize(0);
        // std.debug.print("{d}\n", .{oxigen.items.len});
    }
    return oxigen.items[0];
}
fn getCO2Rating(allocator: std.mem.Allocator, co2: *std.ArrayList(retSize)) anyerror!retSize {
    var to_remove = std.ArrayList(usize).init(allocator);
    defer to_remove.deinit();
    var idx: usize = lineSize;
    while (co2.items.len > 1) : (idx -= 1) {
        var ones: retSize = 0;
        var zeros: retSize = 0;
        // count ones and zeros
        for (co2.items) |line| {
            if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                ones += 1;
            } else {
                zeros += 1;
            }
        }
        // std.debug.print("{d} {d} {d}", .{ones, zeros, idx-1});
        for (co2.items) |line, i| {
            if (zeros <= ones) {
                if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                    try to_remove.append(i);
                }
            } else {
                if ((line & (@as(retSize, 1) <<| idx - 1)) == 0) {
                    try to_remove.append(i);
                }
            }
        }
        std.sort.sort(usize, to_remove.items, {}, comptime std.sort.desc(usize));
        for (to_remove.items) |i| {
            _ = co2.swapRemove(i);
        }
        try to_remove.resize(0);
        // std.debug.print("{d}\n", .{co2.items.len});
    }
    return co2.items[0];
}
fn getLineSize() usize {
    const input = @embedFile(path);
    var ret: usize = 0;
    for (input) |bit, idx| {
        if (bit == '\n') {
            ret = idx;
            break;
        }
    }
    return ret;
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.lap() / 1000;
    std.debug.print("Day 3 \tsecond: {d}µs\n", .{s});
}
test "day03b" {
    try std.testing.expectEqual(@as(retSize, 4105235), try second());
}

File move: day03.zig → day03a.zig
BF:BFD[6.15] → [12.28:61]
BF:BF[12.61] → [12.62:62]
[6.15]
[12.62]

Deletion in src/day03a.zig at line 43 [12.62]

B:BD[12.1079] → [12.1079:2515]


fn second() anyerror!retSize {
    const input = @embedFile(path);
    var lines = std.mem.tokenize(u8, input, "\n");
    var buffer: [1000 * lineSize * 100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    const allocator = fba.allocator();
    var lines_array = std.ArrayList(retSize).init(allocator);
    defer lines_array.deinit();
    var lines_array2 = std.ArrayList(retSize).init(allocator);
    defer lines_array2.deinit();
    while (lines.next()) |line| {
        try lines_array.append(try std.fmt.parseUnsigned(retSize, line, 2));
        try lines_array2.append(try std.fmt.parseUnsigned(retSize, line, 2));
    }
    const ox = try getOxigenRating(allocator, &lines_array);
    const co = try getCO2Rating(allocator, &lines_array2);
    return ox * co;
}
fn getOxigenRating(allocator: std.mem.Allocator, oxigen: *std.ArrayList(retSize)) anyerror!retSize {
    var to_remove = std.ArrayList(usize).init(allocator);
    defer to_remove.deinit();
    var idx: usize = lineSize;
    while (oxigen.items.len > 1) : (idx -= 1) {
        var ones: retSize = 0;
        var zeros: retSize = 0;
        // count ones and zeros
        for (oxigen.items) |line| {
            if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                ones += 1;
            } else {
                zeros += 1;
            }
        }
        // std.debug.print("{d} {d} {d}", .{ones, zeros, idx-1});

Deletion in src/day03a.zig at line 44 [12.62]

B:BD[12.2516] → [12.2516:4472]

        for (oxigen.items) |line, i| {
            if (ones >= zeros) {
                if ((line & (@as(retSize, 1) <<| idx - 1)) == 0) {
                    try to_remove.append(i);
                }
            } else {
                if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                    try to_remove.append(i);
                }
            }
        }
        std.sort.sort(usize, to_remove.items, {}, comptime std.sort.desc(usize));
        for (to_remove.items) |i| {
            _ = oxigen.swapRemove(i);
        }
        try to_remove.resize(0);
        // std.debug.print("{d}\n", .{oxigen.items.len});
    }
    return oxigen.items[0];
}
fn getCO2Rating(allocator: std.mem.Allocator, co2: *std.ArrayList(retSize)) anyerror!retSize {
    var to_remove = std.ArrayList(usize).init(allocator);
    defer to_remove.deinit();
    var idx: usize = lineSize;
    while (co2.items.len > 1) : (idx -= 1) {
        var ones: retSize = 0;
        var zeros: retSize = 0;
        // count ones and zeros
        for (co2.items) |line| {
            if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                ones += 1;
            } else {
                zeros += 1;
            }
        }
        // std.debug.print("{d} {d} {d}", .{ones, zeros, idx-1});
        for (co2.items) |line, i| {
            if (zeros <= ones) {
                if ((line & (@as(retSize, 1) <<| idx - 1)) != 0) {
                    try to_remove.append(i);
                }
            } else {
                if ((line & (@as(retSize, 1) <<| idx - 1)) == 0) {
                    try to_remove.append(i);
                }
            }
        }
        std.sort.sort(usize, to_remove.items, {}, comptime std.sort.desc(usize));
        for (to_remove.items) |i| {
            _ = co2.swapRemove(i);
        }
        try to_remove.resize(0);
        // std.debug.print("{d}\n", .{co2.items.len});
    }
    return co2.items[0];
}

Deletion in src/day03a.zig at line 60 [12.62]
B:BD[12.4766] → [12.4766:4767]
Deletion in src/day03a.zig at line 62 [12.62]
B:BD[12.4822] → [12.4822:4878]
```
    _ = try second();
    const s = timer.lap() / 1000;
```

Replacement in src/day03a.zig at line 63 [12.62]

B:BD[12.4879] → [12.4879:4959]

    std.debug.print("Day 3 \t\tfirst: {d}µs \t\tsecond: {d}µs\n", .{ f, s });

[12.4879]

[12.4959]

    std.debug.print("Day 3 \tfirst: {d}µs\t", .{f});

Replacement in src/day03a.zig at line 66 [12.62]
B:BD[12.4962] → [12.4962:4977]
```
test "first" {
```
[12.4962]
[12.4977]
```
test "day03a" {
```

Deletion in src/day03a.zig at line 69 [12.62]

B:BD[12.5048] → [12.5048:5137]


test "second" {
    try std.testing.expectEqual(@as(retSize, 4105235), try second());
}

File addition: day02b.zig (----------)

[6.15]

const std = @import("std");
const path = "../data/day02/input.txt";
const intType = u32;
fn second() anyerror!intType {
    const input = @embedFile(path);
    var commands = std.mem.tokenize(u8, input, "\n");
    const Postition = struct {
        forward: intType = 0,
        depth: intType = 0,
        aim: intType = 0,
    };
    var pos: Postition = .{};
    while (commands.next()) |c| {
        // example: commands = forward 8
        var comm_parts = std.mem.tokenize(u8, c, " ");
        const direction = comm_parts.next().?;
        const value = try std.fmt.parseUnsigned(intType, comm_parts.next().?, 10);
        if (std.mem.eql(u8, direction, "forward")) {
            pos.forward += value;
            pos.depth += value * pos.aim;
        }
        if (std.mem.eql(u8, direction, "down")) {
            pos.aim += value;
        }
        if (std.mem.eql(u8, direction, "up")) {
            pos.aim -= value;
        }
    }
    return pos.forward * pos.depth;
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.lap() / 1000;
    std.debug.print("Day 2 \tsecond: {d}µs\n", .{s});
}
test "day02b" {
    try std.testing.expectEqual(@as(u32, 2120734350), try second());
}

File move: day02.zig → day02a.zig
BF:BFD[6.15] → [7.31:64]
BF:BF[7.64] → [7.65:65]
[6.15]
[7.65]

Deletion in src/day02a.zig at line 37 [7.65]

B:BD[7.990] → [7.990:1235]


fn second() anyerror!intType {
    const input = @embedFile(path);
    var commands = std.mem.tokenize(u8, input, "\n");
    const Postition = struct {
        forward: intType = 0,
        depth: intType = 0,
        aim: intType = 0,
    };

Deletion in src/day02a.zig at line 38 [7.65]

B:BD[7.1236] → [7.1236:1892]

    var pos: Postition = .{};
    while (commands.next()) |c| {
        // example: commands = forward 8
        var comm_parts = std.mem.tokenize(u8, c, " ");
        const direction = comm_parts.next().?;
        const value = try std.fmt.parseUnsigned(intType, comm_parts.next().?, 10);
        if (std.mem.eql(u8, direction, "forward")) {
            pos.forward += value;
            pos.depth += value * pos.aim;
        }
        if (std.mem.eql(u8, direction, "down")) {
            pos.aim += value;
        }
        if (std.mem.eql(u8, direction, "up")) {
            pos.aim -= value;
        }
    }
    return pos.forward * pos.depth;
}

Deletion in src/day02a.zig at line 40 [7.65]
B:BD[7.1966] → [7.1966:1967]
Deletion in src/day02a.zig at line 42 [7.65]
B:BD[7.2022] → [7.2022:2078]
```
    _ = try second();
    const s = timer.lap() / 1000;
```

Replacement in src/day02a.zig at line 43 [7.65]

B:BD[7.2079] → [7.2079:2159]

    std.debug.print("Day 2 \t\tfirst: {d}µs \t\tsecond: {d}µs\n", .{ f, s });

[7.2079]

[7.2159]

    std.debug.print("Day 2 \tfirst: {d}µs\t", .{f});

Replacement in src/day02a.zig at line 46 [7.65]
B:BD[7.2162] → [7.2162:2177]
```
test "first" {
```
[7.2162]
[7.2177]
```
test "day02a" {
```

Deletion in src/day02a.zig at line 49 [7.65]

B:BD[7.2244] → [7.2244:2332]


test "second" {
    try std.testing.expectEqual(@as(u32, 2120734350), try second());
}

File addition: day01b.zig (----------)

[6.15]

const std = @import("std");
const lineLength = 4; // maximum line length (digits)
const decimalSize = u13; // every num in input is < 2^13
const maxItems = 2000; // number of items in input file
const path = "../data/day01/input.txt";
fn second() anyerror!decimalSize {
    const values = try parseValues();
    var inc: decimalSize = 0;
    for (values) |_, idx| {
        if (idx >= 3) {
            // as idx-2 and idx-1 are in a and b too, this can be simplified
            // const a = @intCast(u15, values[idx - 3]) + values[idx - 2] + values[idx - 1];
            // const b = @intCast(u15, values[idx - 2]) + values[idx - 1] + values[idx];
            const a = values[idx - 3];
            const b = values[idx];
            if (a < b) {
                inc += 1;
            }
        }
    }
    return inc;
}
fn parseValues() anyerror![maxItems]decimalSize {
    const file = @embedFile(path);
    var lines = std.mem.tokenize(u8, file, "\n");
    var values: [maxItems]decimalSize = undefined;
    var i: decimalSize = 0;
    while (lines.next()) |v| : (i += 1) {
        values[i] = try std.fmt.parseUnsigned(decimalSize, v, 10);
    }
    return values;
}
pub fn main() anyerror!void {
    var timer = try std.time.Timer.start();
    _ = try second();
    const s = timer.read() / 1000;
    std.debug.print("Day 1 \tsecond: {d}μs\n", .{s});
}
test "day01b" {
    try std.testing.expectEqual(@as(decimalSize, 1429), try second());
}

File move: day01.zig → day01a.zig
BF:BFD[6.15] → [6.91:124]
BF:BF[6.124] → [6.125:125]
[6.15]
[6.125]
Deletion in src/day01a.zig at line 22 [6.125]
B:BD[6.902] → [6.902:938]
B:BD[6.938] → [3.39:77]
```
fn second() anyerror!decimalSize {
    const values = try parseValues();
```

Deletion in src/day01a.zig at line 23 [6.125]

B:BD[6.1216] → [6.1216:1298]

B:BD[6.1298] → [2.0:333]

∅:D[2.333] → [6.1474:1572]

B:BD[6.1474] → [6.1474:1572]

B:BD[6.1572] → [3.78:81]

    var inc: decimalSize = 0;
    for (values) |_, idx| {
        if (idx >= 3) {
            // as idx-2 and idx-1 are in a and b too, this can be simplified
            // const a = @intCast(u15, values[idx - 3]) + values[idx - 2] + values[idx - 1];
            // const b = @intCast(u15, values[idx - 2]) + values[idx - 1] + values[idx];
            const a = values[idx - 3];
            const b = values[idx];
            if (a < b) {
                inc += 1;
            }
        }
    }
    return inc;
}

Deletion in src/day01a.zig at line 39 [6.125]
B:BD[6.1649] → [6.1649:1650]
Deletion in src/day01a.zig at line 41 [6.125]
B:BD[6.1705] → [6.1705:1762]
```
    _ = try second();
    const s = timer.read() / 1000;
```

Replacement in src/day01a.zig at line 42 [6.125]

B:BD[6.1763] → [2.334:414]

    std.debug.print("Day 1 \t\tfirst: {d}μs \t\tsecond: {d}μs\n", .{ f, s });

[6.1763]

[6.1839]

    std.debug.print("Day 1 \tfirst: {d}μs\t", .{f});

Deletion in src/day01a.zig at line 48 [6.125]

B:BD[6.1930] → [6.1930:2020]


test "day01b" {
    try std.testing.expectEqual(@as(decimalSize, 1429), try second());
}

Replacement in build.zig at line 21 [6.2055]

B:BD[6.2821] → [6.2821:2935]

        const dayString = b.fmt("day{:0>2}", .{day});
        const zigFile = b.fmt("src/{s}.zig", .{dayString});

[6.2821]

[6.2935]

        for ("ab") |part| {
            const dayString = b.fmt("day{:0>2}{c}", .{ day, part });
            const zigFile = b.fmt("src/{s}.zig", .{dayString});

Replacement in build.zig at line 25 [6.2055]

B:BD[6.2936] → [6.2936:3079]

        const exe = b.addExecutable(dayString, zigFile);
        exe.setTarget(target);
        exe.setBuildMode(mode);
        exe.install();

[6.2936]

[6.3079]

            const exe = b.addExecutable(dayString, zigFile);
            exe.setTarget(target);
            exe.setBuildMode(mode);
            exe.install();

Replacement in build.zig at line 30 [6.2055]

B:BD[6.3080] → [6.3080:3240]

        const run_cmd = exe.run();
        run_cmd.step.dependOn(b.getInstallStep());
        if (b.args) |args| {
            run_cmd.addArgs(args);
        }

[6.3080]

[6.3240]

            const run_cmd = exe.run();
            run_cmd.step.dependOn(b.getInstallStep());
            if (b.args) |args| {
                run_cmd.addArgs(args);
            }

Replacement in build.zig at line 36 [6.2055]

B:BD[6.3241] → [6.3241:3329]

        const run_day = b.step(dayString, "");
        run_day.dependOn(&run_cmd.step);

[6.3241]

[6.3329]

            const run_day = b.step(dayString, "");
            run_day.dependOn(&run_cmd.step);

Replacement in build.zig at line 39 [6.2055]

B:BD[6.3330] → [6.3330:3408]

        // add to main run step too
        run_step.dependOn(&run_cmd.step);

[6.3330]

[6.3408]

            // add to main run step too
            run_step.dependOn(&run_cmd.step);
        }

Rework the build system, use separate file for first and second part

Dependencies

In channels

Change contents

Replacement in src/main.zig at line 2 [6.50]

File addition: day07b.zig (----------)

File move: day07.zig → day07a.zig

Deletion in src/day07a.zig at line 39 [5.34]

Deletion in src/day07a.zig at line 41 [5.34]

Deletion in src/day07a.zig at line 43 [5.34]

Deletion in src/day07a.zig at line 45 [5.34]

Replacement in src/day07a.zig at line 46 [5.34]

Replacement in src/day07a.zig at line 49 [5.34]

Deletion in src/day07a.zig at line 51 [5.34]

File addition: day06b.zig (----------)

File move: day06.zig → day06a.zig

Deletion in src/day06a.zig at line 53 [10.34]

Deletion in src/day06a.zig at line 57 [10.34]

Deletion in src/day06a.zig at line 59 [10.34]

Replacement in src/day06a.zig at line 60 [10.34]

Replacement in src/day06a.zig at line 63 [10.34]

Deletion in src/day06a.zig at line 66 [10.34]

File addition: day05b.zig (----------)

File move: day05.zig → day05a.zig

Deletion in src/day05a.zig at line 79 [9.95]

Deletion in src/day05a.zig at line 83 [9.95]

Deletion in src/day05a.zig at line 85 [9.95]

Replacement in src/day05a.zig at line 86 [9.95]

Replacement in src/day05a.zig at line 89 [9.95]

Deletion in src/day05a.zig at line 92 [9.95]

File addition: day04b.zig (----------)

File move: day04.zig → day04a.zig

Deletion in src/day04a.zig at line 101 [11.59]

Deletion in src/day04a.zig at line 108 [11.59]

Deletion in src/day04a.zig at line 115 [11.59]

Deletion in src/day04a.zig at line 117 [11.59]

Replacement in src/day04a.zig at line 118 [11.59]

Replacement in src/day04a.zig at line 121 [11.59]

Deletion in src/day04a.zig at line 124 [11.59]

File addition: day03b.zig (----------)

File move: day03.zig → day03a.zig

Deletion in src/day03a.zig at line 43 [12.62]

Deletion in src/day03a.zig at line 44 [12.62]

Deletion in src/day03a.zig at line 60 [12.62]

Deletion in src/day03a.zig at line 62 [12.62]

Replacement in src/day03a.zig at line 63 [12.62]

Replacement in src/day03a.zig at line 66 [12.62]

Deletion in src/day03a.zig at line 69 [12.62]

File addition: day02b.zig (----------)

File move: day02.zig → day02a.zig

Deletion in src/day02a.zig at line 37 [7.65]

Deletion in src/day02a.zig at line 38 [7.65]

Deletion in src/day02a.zig at line 40 [7.65]

Deletion in src/day02a.zig at line 42 [7.65]

Replacement in src/day02a.zig at line 43 [7.65]

Replacement in src/day02a.zig at line 46 [7.65]

Deletion in src/day02a.zig at line 49 [7.65]

File addition: day01b.zig (----------)

File move: day01.zig → day01a.zig

Deletion in src/day01a.zig at line 22 [6.125]

Deletion in src/day01a.zig at line 23 [6.125]

Deletion in src/day01a.zig at line 39 [6.125]

Deletion in src/day01a.zig at line 41 [6.125]

Replacement in src/day01a.zig at line 42 [6.125]

Deletion in src/day01a.zig at line 48 [6.125]

Replacement in build.zig at line 21 [6.2055]

Replacement in build.zig at line 25 [6.2055]

Replacement in build.zig at line 30 [6.2055]

Replacement in build.zig at line 36 [6.2055]

Replacement in build.zig at line 39 [6.2055]