voroskoi/aoc2021-zig - Change KHVGYFXXJZY762NIUJXIMLYMKIZC3IKKAVLTA3A6FO2LWEIW26KQC

Day18 WIP

Created by voroskoi on April 19, 2022

KHVGYFXXJZY762NIUJXIMLYMKIZC3IKKAVLTA3A6FO2LWEIW26KQC

Dependencies

In discussions

#1 Day18 methods and comptime

Change contents

Deletion in src/day18a.zig at line 7 [4.35]

B:BD[4.155] → [4.155:257]

B:BD[4.257] → [4.257:258]

B:BD[4.258] → [4.258:545]

const SnailType = u6;
const SnailItem = union(enum) {
    num: SnailType,
    pair: *SnailNumber,
};
const SnailNumber = struct {
    left: ?SnailItem = null,
    right: ?SnailItem = null,
    parent: ?*SnailNumber = null,
    fn add(self: *@This(), a: std.mem.Allocator, input: *Str) !*SnailNumber {
        var pos: usize = 1;
        const next = try parseSnail(a, input, null, &pos);

Deletion in src/day18a.zig at line 8 [4.35]

B:BD[4.546] → [4.546:752]

B:BD[4.752] → [4.752:753]

B:BD[4.753] → [4.753:841]

        const root = try a.create(SnailNumber);
        root.left = SnailItem{ .pair = self };
        root.right = SnailItem{ .pair = next };
        root.parent = null; // segfaults without this line :-(
        self.parent = root;
        next.parent = root;
        return root;
    }
};

Replacement in src/day18a.zig at line 31 [4.35]

B:BD[4.1540] → [3.5155:5232]

            ret = try parseSnail(arena.allocator(), &line[0..], null, &pos);

[4.1540]

[4.1609]

            ret = try SnailNumber.parse(arena.allocator(), &line[0..], null, &pos);

Replacement in src/day18a.zig at line 34 [4.35]

B:BD[3.5295] → [3.5295:5343]

            try reduce(arena.allocator(), ret);

[3.5295]

[4.1720]

            try ret.reduce(arena.allocator());

Replacement in src/day18a.zig at line 38 [4.35]
B:BD[4.1737] → [4.1737:1764]
```
    return magnitude(ret);
```
[4.1737]
[4.1764]
```
    return ret.magnitude();
```

Replacement in src/day18a.zig at line 41 [4.35]

B:BD[4.1767] → [4.1767:1833]

B:BD[4.1898] → [4.1898:2098]

fn reduce(a: std.mem.Allocator, sn: *SnailNumber) anyerror!void {
    if (checkExplode(a, sn, 0)) |node| {
        explode(a, node);
        try reduce(a, sn);
    } else if (checkSplit(a, sn)) |node| {
        try split(a, node);
        try reduce(a, sn);
    }
}

[4.1767]

[4.2098]

const SnailType = u6;

Replacement in src/day18a.zig at line 43 [4.35]

B:BD[4.2099] → [4.2099:2159]

B:BD[4.2277] → [4.2277:2330]

fn explode(a: std.mem.Allocator, node: *SnailNumber) void {
    defer a.destroy(node); // free up abandoned node

[4.2099]

[4.2330]

const SnailItem = union(enum) {
    num: SnailType,
    pair: *SnailNumber,
};

Replacement in src/day18a.zig at line 48 [4.35]

B:BD[4.2331] → [4.2331:2378]

    explodeLeft(node);
    explodeRight(node);

[4.2331]

[4.2378]

const SnailNumber = struct {
    left: ?SnailItem = null,
    right: ?SnailItem = null,
    parent: ?*SnailNumber = null,
    fn parse(a: std.mem.Allocator, in: *Str, parent: ?*SnailNumber, pos: *usize) anyerror!*@This() {
        // allocate and set up new node
        const node = try a.create(SnailNumber);
        node.parent = parent;
        var right: bool = false;

Replacement in src/day18a.zig at line 60 [4.35]

B:BD[4.2379] → [4.2379:2567]

    const par = node.parent.?;
    if (par.left.? == .pair and par.left.?.pair == node) {
        par.left = SnailItem{ .num = 0 };
    } else {
        par.right = SnailItem{ .num = 0 };

[4.2379]

[4.2567]

        while (pos.* < in.len) : (pos.* += 1) {
            var ch = in.*[pos.*];
            switch (ch) {
                ']' => {
                    break;
                },
                '[' => {
                    pos.* += 1;
                    if (right) {
                        node.right = SnailItem{ .pair = try parse(a, in, node, pos) };
                    } else {
                        node.left = SnailItem{ .pair = try parse(a, in, node, pos) };
                    }
                },
                ',' => {
                    right = true;
                },
                else => {
                    if (right) {
                        node.right = SnailItem{ .num = try std.fmt.parseUnsigned(SnailType, in.*[pos.* .. pos.* + 1], 10) };
                    } else {
                        node.left = SnailItem{ .num = try std.fmt.parseUnsigned(SnailType, in.*[pos.* .. pos.* + 1], 10) };
                    }
                },
            }
        }
        return node;

Replacement in src/day18a.zig at line 89 [4.35]

B:BD[4.2573] → [4.2573:2575]

[4.2573]

[4.2575]


    fn add(self: *@This(), a: std.mem.Allocator, input: *Str) !*SnailNumber {
        var pos: usize = 1;
        const next = try parse(a, input, null, &pos);
        const root = try a.create(SnailNumber);
        root.left = SnailItem{ .pair = self };
        root.right = SnailItem{ .pair = next };
        root.parent = null; // segfaults without this line :-(

Replacement in src/day18a.zig at line 99 [4.35]

B:BD[4.2576] → [4.2576:2652]

fn explodeLeft(node: *SnailNumber) void {
    const left = node.left.?.num;

[4.2576]

[4.2652]

        self.parent = root;
        next.parent = root;

Replacement in src/day18a.zig at line 102 [4.35]

B:BD[4.2653] → [4.2653:2808]

B:BD[4.2808] → [2.0:129]

∅:D[2.129] → [4.2995:3005]

B:BD[4.2995] → [4.2995:3005]

    var prev = node;
    var it = node.parent;
    while (it) |par| : ({
        prev = par;
        it = par.parent;
    }) {
        if (par.left) |l| {
            // check if it is not the exploding node
            if (l == .pair and l.pair == prev) continue;
            break;
        }

[4.2653]

[4.3005]

        return root;

Replacement in src/day18a.zig at line 105 [4.35]

B:BD[4.3012] → [4.3012:3677]

B:BD[4.3677] → [4.3677:3691]

    target: while (it) |target| {
        // These must be _pointers_! Removing the & makes them local, so the changes
        // do not happen when they should.
        for ([2]*?SnailItem{ &target.right, &target.left }) |t| {
            if (t.*) |*child| {
                switch (child.*) {
                    SnailItem.pair => |c| {
                        if (c != prev) {
                            it = c;
                            continue :target;
                        }
                    },
                    SnailItem.num => |*c| {
                        c.* += left;
                        return;
                    },
                }
            }

[4.3012]

[4.3691]

    fn reduce(self: *@This(), a: std.mem.Allocator) anyerror!void {
        if (self.checkExplode(a, 0)) |node| {
            node.explode(a);
            try self.reduce(a);
        } else if (self.checkSplit(a)) |node| {
            try node.split(a);
            try self.reduce(a);

Deletion in src/day18a.zig at line 114 [4.35]
B:BD[4.3707] → [4.3707:3709]
```
}
```

Replacement in src/day18a.zig at line 115 [4.35]

B:BD[4.3710] → [4.3710:3789]

fn explodeRight(node: *SnailNumber) void {
    const right = node.right.?.num;

[4.3710]

[4.3789]

    fn checkExplode(self: *@This(), a: std.mem.Allocator, depth: u3) ?*SnailNumber {
        if (depth == explode_limit) return self;

Replacement in src/day18a.zig at line 118 [4.35]

B:BD[4.3790] → [4.3790:3946]

B:BD[4.3946] → [2.130:259]

    var prev = node;
    var it = node.parent;
    while (it) |par| : ({
        prev = par;
        it = par.parent;
    }) {
        if (par.right) |r| {
            // check if it is not the exploding node
            if (r == .pair and r.pair == prev) continue;
            break;

[4.3790]

[4.4133]

        if (self.left) |l| {
            if (l == .pair) {
                const ret = l.pair.checkExplode(a, depth + 1);
                if (ret != null) return ret;
            }

Deletion in src/day18a.zig at line 124 [4.35]
B:BD[4.4143] → [4.4143:4149]
```
    }
```

Replacement in src/day18a.zig at line 125 [4.35]

B:BD[4.4150] → [4.4150:4798]

B:BD[4.4798] → [4.4798:4816]

    target: while (it) |target| {
        // These must be _pointers_! Removing the & makes them local, so the changes
        // do not happen when they should.
        for ([2]*?SnailItem{ &target.left, &target.right }) |t| {
            if (t.*) |*child| {
                switch (child.*) {
                    SnailItem.pair => |c| {
                        if (c != prev) {
                            it = c;
                            continue :target;
                        }
                    },
                    SnailItem.num => |*c| {
                        c.* += right;
                        return;
                    },
                }

[4.4150]

[4.4816]

        if (self.right) |r| {
            if (r == .pair) {
                const ret = r.pair.checkExplode(a, depth + 1);
                if (ret != null) return ret;

Insertion in src/day18a.zig at line 131 [4.35]
[4.4840]
[4.4840]
```
        return null;
```
Deletion in src/day18a.zig at line 134 [4.35]
B:BD[4.4846] → [4.4846:4848]
```
}
```

Replacement in src/day18a.zig at line 135 [4.35]

B:BD[4.4849] → [4.4849:4934]

B:BD[4.5038] → [4.5038:5083]

B:BD[4.5083] → [4.5083:5084]

B:BD[4.5084] → [4.5084:5109]

B:BD[4.5109] → [2.260:387]

fn checkExplode(a: std.mem.Allocator, node: *SnailNumber, depth: u3) ?*SnailNumber {
    if (depth == explode_limit) return node;
    if (node.left) |l| {
        if (l == .pair) {
            const ret = checkExplode(a, l.pair, depth + 1);
            if (ret != null) return ret;

[4.4849]

[4.5349]

    fn checkSplit(self: *@This(), a: std.mem.Allocator) ?*SnailNumber {
        if (self.left) |l| {
            switch (l) {
                SnailItem.pair => |n| {
                    const ret = n.checkSplit(a);
                    if (ret != null) return ret;
                },
                SnailItem.num => |val| if (val > 9) return self,
            }

Deletion in src/day18a.zig at line 145 [4.35]
B:BD[4.5359] → [4.5359:5365]
```
    }
```

Replacement in src/day18a.zig at line 146 [4.35]

B:BD[4.5366] → [4.5366:5392]

B:BD[4.5392] → [2.388:515]

    if (node.right) |r| {
        if (r == .pair) {
            const ret = checkExplode(a, r.pair, depth + 1);
            if (ret != null) return ret;

[4.5366]

[4.5632]

        if (self.right) |r| {
            switch (r) {
                SnailItem.pair => |n| {
                    const ret = n.checkSplit(a);
                    if (ret != null) return ret;
                },
                SnailItem.num => |val| if (val > 9) return self,
            }

Insertion in src/day18a.zig at line 155 [4.35]
[4.5642]
[4.5642]
```
        return null;
```

Replacement in src/day18a.zig at line 159 [4.35]

B:BD[4.5649] → [4.5649:5668]

    return null;
}

[4.5649]

[4.5668]

    fn explode(self: *@This(), a: std.mem.Allocator) void {
        defer a.destroy(self); // free up abandoned node

Replacement in src/day18a.zig at line 162 [4.35]

B:BD[4.5669] → [4.5669:5881]

fn parseSnail(a: std.mem.Allocator, in: *Str, parent: ?*SnailNumber, pos: *usize) anyerror!*SnailNumber {
    // allocate and set up new node
    const node = try a.create(SnailNumber);
    node.parent = parent;

[4.5669]

[4.5881]

        // explode the left side first, then the right too
        inline for ([_]Str{ "left", "right" }) |child_str| {
            const lr = @field(self, child_str).?.num;

Replacement in src/day18a.zig at line 166 [4.35]

B:BD[4.5882] → [4.5882:5911]

B:BD[4.5911] → [4.5911:5912]

B:BD[4.5912] → [4.5912:6029]

B:BD[4.6029] → [4.6029:6052]

B:BD[4.6052] → [4.6052:6345]

    var right: bool = false;
    while (pos.* < in.len) : (pos.* += 1) {
        var ch = in.*[pos.*];
        switch (ch) {
            ']' => {
                break;
            },
            '[' => {
                pos.* += 1;
                if (right) {
                    node.right = SnailItem{ .pair = try parseSnail(a, in, node, pos) };
                } else {
                    node.left = SnailItem{ .pair = try parseSnail(a, in, node, pos) };

[4.5882]

[4.6345]

            // Check parents of the exploding SnailNumber.
            var prev = self;
            var it = self.parent;
            while (it) |par| : ({
                prev = par;
                it = par.parent;
            }) {
                if (@field(par, child_str)) |kid| {
                    // check if it is not the exploding node
                    if (kid == .pair and kid.pair == prev) continue;
                    break;

Replacement in src/day18a.zig at line 178 [4.35]

B:BD[4.6363] → [4.6363:6761]

B:BD[4.6761] → [4.6761:6779]

B:BD[4.6779] → [4.6779:6794]

B:BD[4.6794] → [4.6794:6810]

            },
            ',' => {
                right = true;
            },
            else => {
                if (right) {
                    node.right = SnailItem{ .num = try std.fmt.parseUnsigned(SnailType, in.*[pos.* .. pos.* + 1], 10) };
                } else {
                    node.left = SnailItem{ .num = try std.fmt.parseUnsigned(SnailType, in.*[pos.* .. pos.* + 1], 10) };
                }
            },
        }
    }

[4.6363]

[4.6810]

Replacement in src/day18a.zig at line 180 [4.35]

B:BD[4.6811] → [4.6811:6830]

    return node;
}

[4.6811]

[4.6830]

            const target_str = comptime if (std.mem.eql(u8, child_str, "left"))
                [_]Str{ "right", "left" }
            else
                [_]Str{ "left", "right" };

Replacement in src/day18a.zig at line 185 [4.35]

B:BD[4.6831] → [4.6831:6915]

B:BD[4.6915] → [2.516:754]

fn split(a: std.mem.Allocator, node: *SnailNumber) !void {
    if (node.left) |l| {
        if (l == .num and l.num > 9) {
            const new = try a.create(SnailNumber);
            new.left = SnailItem{ .num = l.num / 2 };
            new.right = SnailItem{ .num = l.num - l.num / 2 };
            new.parent = node;

[4.6831]

[4.7229]

            target: while (it) |target| {
                // These must be _pointers_! Removing the & makes them local, so the changes
                // do not happen when they should.
                for ([2]*?SnailItem{ &@field(target, target_str[0]), &@field(target, target_str[1]) }) |t| {
                    if (t.*) |*child| {
                        switch (child.*) {
                            .pair => |c| {
                                if (c != prev) {
                                    it = c;
                                    continue :target;
                                }
                            },
                            .num => |*c| {
                                c.* += lr;
                                break :target;
                            },
                        }
                    }
                }
            }
        }

Replacement in src/day18a.zig at line 207 [4.35]

B:BD[4.7230] → [2.755:825]

            node.left = SnailItem{ .pair = new };
            return;

[4.7230]

[4.7373]

        const par = self.parent.?;
        if (par.left.? == .pair and par.left.?.pair == self) {
            par.left = SnailItem{ .num = 0 };
        } else {
            par.right = SnailItem{ .num = 0 };

Deletion in src/day18a.zig at line 214 [4.35]

B:BD[4.7389] → [4.7389:7415]

B:BD[4.7415] → [2.826:1064]

    if (node.right) |r| {
        if (r == .num and r.num > 9) {
            const new = try a.create(SnailNumber);
            new.left = SnailItem{ .num = r.num / 2 };
            new.right = SnailItem{ .num = r.num - r.num / 2 };
            new.parent = node;

Replacement in src/day18a.zig at line 215 [4.35]

B:BD[4.7730] → [2.1065:1136]

∅:D[2.1136] → [4.7874:7890]

B:BD[4.7874] → [4.7874:7890]

B:BD[4.7890] → [4.7890:7892]

            node.right = SnailItem{ .pair = new };
            return;
        }
    }
}

[4.7730]

[4.7892]

    fn split(self: *@This(), a: std.mem.Allocator) !void {
        if (self.left) |l| {
            if (l == .num and l.num > 9) {
                const new = try a.create(SnailNumber);
                new.left = SnailItem{ .num = l.num / 2 };
                new.right = SnailItem{ .num = l.num - l.num / 2 };
                new.parent = self;

Replacement in src/day18a.zig at line 223 [4.35]

B:BD[4.7893] → [4.7893:7965]

B:BD[4.8044] → [4.8044:8293]

fn checkSplit(a: std.mem.Allocator, node: *SnailNumber) ?*SnailNumber {
    if (node.left) |l| {
        switch (l) {
            SnailItem.pair => |n| {
                const ret = checkSplit(a, n);
                if (ret != null) return ret;
            },
            SnailItem.num => |val| if (val > 9) return node,

[4.7893]

[4.8293]

                self.left = SnailItem{ .pair = new };
                return;
            }

Replacement in src/day18a.zig at line 227 [4.35]

B:BD[4.8303] → [4.8303:8309]

[4.8303]

[4.8309]

        if (self.right) |r| {
            if (r == .num and r.num > 9) {
                const new = try a.create(SnailNumber);
                new.left = SnailItem{ .num = r.num / 2 };
                new.right = SnailItem{ .num = r.num - r.num / 2 };
                new.parent = self;

Replacement in src/day18a.zig at line 234 [4.35]

B:BD[4.8310] → [4.8310:8560]

    if (node.right) |r| {
        switch (r) {
            SnailItem.pair => |n| {
                const ret = checkSplit(a, n);
                if (ret != null) return ret;
            },
            SnailItem.num => |val| if (val > 9) return node,

[4.8310]

[4.8560]

                self.right = SnailItem{ .pair = new };
                return;
            }

Replacement in src/day18a.zig at line 240 [4.35]

B:BD[4.8577] → [4.8577:8594]

B:BD[4.8594] → [4.8594:8596]

B:BD[4.8596] → [4.8596:8597]

B:BD[4.8597] → [4.8597:8847]

    return null;
}
fn printSnailNumber(node: *SnailNumber) void {
    std.debug.print("[", .{});
    if (node.left) |l| {
        switch (l) {
            SnailItem.num => |value| std.debug.print("{d}", .{value}),
            SnailItem.pair => |n| printSnailNumber(n),

[4.8577]

[4.8847]

    fn print(self: @This()) void {
        std.debug.print("[", .{});
        if (self.left) |l| {
            switch (l) {
                SnailItem.num => |value| std.debug.print("{d}", .{value}),
                SnailItem.pair => |n| n.print(),
            }

Replacement in src/day18a.zig at line 248 [4.35]

B:BD[4.8857] → [4.8857:9067]

    }
    std.debug.print(",", .{});
    if (node.right) |r| {
        switch (r) {
            SnailItem.num => |value| std.debug.print("{d}", .{value}),
            SnailItem.pair => |n| printSnailNumber(n),

[4.8857]

[4.9067]

        std.debug.print(",", .{});
        if (self.right) |r| {
            switch (r) {
                SnailItem.num => |value| std.debug.print("{d}", .{value}),
                SnailItem.pair => |n| n.print(),
            }

Insertion in src/day18a.zig at line 255 [4.35]
[4.9077]
[4.9077]
```
        std.debug.print("]", .{});
```
Deletion in src/day18a.zig at line 257 [4.35]
B:BD[4.9083] → [4.9083:9116]
```
    std.debug.print("]", .{});
}
```

Replacement in src/day18a.zig at line 258 [4.35]

B:BD[4.9117] → [4.9117:9217]

fn magnitude(node: *SnailNumber) usize {
    var left: ?usize = null;
    var right: ?usize = null;

[4.9117]

[4.9217]

    fn magnitude(self: @This()) usize {
        var left: ?usize = null;
        var right: ?usize = null;

Replacement in src/day18a.zig at line 262 [4.35]

B:BD[4.9218] → [4.9218:9370]

    if (node.left) |l| {
        switch (l) {
            SnailItem.num => |value| left = value,
            SnailItem.pair => |n| left = magnitude(n),

[4.9218]

[4.9370]

        if (self.left) |l| {
            switch (l) {
                SnailItem.num => |value| left = value,
                SnailItem.pair => |n| left = n.magnitude(),
            }

Replacement in src/day18a.zig at line 268 [4.35]

B:BD[4.9380] → [4.9380:9541]

    }
    if (node.right) |r| {
        switch (r) {
            SnailItem.num => |value| right = value,
            SnailItem.pair => |n| right = magnitude(n),

[4.9380]

[4.9541]

        if (self.right) |r| {
            switch (r) {
                SnailItem.num => |value| right = value,
                SnailItem.pair => |n| right = n.magnitude(),
            }

Deletion in src/day18a.zig at line 274 [4.35]
B:BD[4.9551] → [4.9551:9557]
```
    }
```

Replacement in src/day18a.zig at line 275 [4.35]

B:BD[4.9558] → [4.9558:9676]

    if (left) |l| {
        if (right) |r| {
            return 3 * l + 2 * r;
        } else {
            return l;

[4.9558]

[4.9676]

        if (left) |l| {
            if (right) |r| {
                return 3 * l + 2 * r;
            } else {
                return l;
            }

Insertion in src/day18a.zig at line 282 [4.35]
[4.9686]
[4.9686]
```
        return right.?;
```
Replacement in src/day18a.zig at line 284 [4.35]
B:BD[4.9692] → [4.9692:9714]
```
    return right.?;
}
```
[4.9692]
[4.9714]
```
};
```