voroskoi/aoc2021-zig - Change GOJWG2LPR326XY6GYYLPXQ4OU5FKA5KH5LH2GNDEKC62TRPFIA3AC

day22b: use mem.indexOfScalar instead of getIndex, cleanups

Created by voroskoi on February 9, 2022

GOJWG2LPR326XY6GYYLPXQ4OU5FKA5KH5LH2GNDEKC62TRPFIA3AC

Dependencies

[2] KKSI6N3U7RYMJAN2NQ5T6QKIUOQ4GQQK53Q4HZEB3PJ6HVKVHUVQC

In channels

main

Change contents

Insertion in src/day22b.zig at line 2 [2.35]
[2.64]
[2.64]
```
const mem = std.mem;
```

Insertion in src/day22b.zig at line 6 [2.35]

[2.106]

const Cuboid = struct {
    state: bool,
    xmin: isize,
    xmax: isize,
    ymin: isize,
    ymax: isize,
    zmin: isize,
    zmax: isize,
};
const Cubes = []Cuboid;
const CoordList = std.ArrayList(isize);

Replacement in src/day22b.zig at line 22 [2.35]
B:BD[2.172] → [2.172:201]
```
    const ret = try first();
```
[2.172]
[2.201]
```
    const ret = try second();
```

Replacement in src/day22b.zig at line 27 [2.35]

B:BD[2.305] → [2.305:381]

    std.debug.print("Day 22b result: {d} \t\ttime: {d}µs\n", .{ ret, t });

[2.305]

[2.381]

    std.debug.print("Day 22b result: {d}time: {d}µs\n", .{ ret, t });

Replacement in src/day22b.zig at line 30 [2.35]

B:BD[2.384] → [2.384:494]

const CoordList = std.ArrayList(isize);
pub fn first() !usize {
    const allocator = std.testing.allocator;

[2.384]

[2.494]

pub fn second() !usize {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

Replacement in src/day22b.zig at line 48 [2.35]
B:BD[2.978] → [2.978:1010]
```
    var N: usize = X.items.len;
```
[2.978]
[2.1010]
```
    const N: usize = X.items.len;
```

Replacement in src/day22b.zig at line 57 [2.35]

B:BD[2.1338] → [2.1338:1602]

        const x0 = getIndex(&X, cube.xmin);
        const x1 = getIndex(&X, cube.xmax);
        const y0 = getIndex(&Y, cube.ymin);
        const y1 = getIndex(&Y, cube.ymax);
        const z0 = getIndex(&Z, cube.zmin);
        const z1 = getIndex(&Z, cube.zmax);

[2.1338]

[2.1602]

        const x0 = mem.indexOfScalar(isize, X.items, cube.xmin).?;
        const x1 = mem.indexOfScalar(isize, X.items, cube.xmax).?;
        const y0 = mem.indexOfScalar(isize, Y.items, cube.ymin).?;
        const y1 = mem.indexOfScalar(isize, Y.items, cube.ymax).?;
        const z0 = mem.indexOfScalar(isize, Z.items, cube.zmin).?;
        const z1 = mem.indexOfScalar(isize, Z.items, cube.zmax).?;

Deletion in src/day22b.zig at line 95 [2.35]

B:BD[2.2445] → [2.2445:2766]


fn getIndex(list: *CoordList, value: isize) usize {
    for (list.items) |val, idx| {
        if (val == value) {
            return idx;
        }
    }
    unreachable;
}
const Cuboid = struct {
    state: bool,
    xmin: isize,
    xmax: isize,
    ymin: isize,
    ymax: isize,
    zmin: isize,
    zmax: isize,
};

Replacement in src/day22b.zig at line 96 [2.35]

B:BD[2.2767] → [2.2767:2882]

const Cubes = []Cuboid;
fn parseInput(a: std.mem.Allocator, X: *CoordList, Y: *CoordList, Z: *CoordList) !Cubes {

[2.2767]

[2.2882]

fn parseInput(a: mem.Allocator, X: *CoordList, Y: *CoordList, Z: *CoordList) !Cubes {

Replacement in src/day22b.zig at line 98 [2.35]

B:BD[2.2918] → [2.2918:2966]

    var lines = std.mem.split(u8, input, "\n");

[2.2918]

[2.2966]

    var lines = mem.split(u8, input, "\n");

Replacement in src/day22b.zig at line 105 [2.35]

B:BD[2.3119] → [2.3119:3175]

        var st_coord = std.mem.tokenize(u8, line, " ");

[2.3119]

[2.3175]

        var st_coord = mem.tokenize(u8, line, " ");

Replacement in src/day22b.zig at line 108 [2.35]

B:BD[2.3204] → [2.3204:3301]

        if (std.mem.eql(u8, st_coord.next().?, "on")) cube.state = true else cube.state = false;

[2.3204]

[2.3301]

        if (mem.eql(u8, st_coord.next().?, "on")) cube.state = true else cube.state = false;

Replacement in src/day22b.zig at line 110 [2.35]

B:BD[2.3302] → [2.3302:3367]

        var axes = std.mem.tokenize(u8, st_coord.next().?, ",");

[2.3302]

[2.3367]

        var axes = mem.tokenize(u8, st_coord.next().?, ",");

Replacement in src/day22b.zig at line 114 [2.35]

B:BD[2.3496] → [2.3496:3596]

            std.debug.assert(cntr < 3);
            var min_max = std.mem.tokenize(u8, axis, "..");

[2.3496]

[2.3596]

            var min_max = mem.tokenize(u8, axis, "..");

Replacement in src/day22b.zig at line 147 [2.35]

B:BD[2.4667] → [2.4667:4743]

    try std.testing.expectEqual(@as(usize, 1267133912086024), try first());

[2.4667]

[2.4743]

    try std.testing.expectEqual(@as(usize, 1267133912086024), try second());