const RegExp = struct {
    number: Regex,
    last_number: Regex,
    exp_number: Regex,
};

var reg_exp: RegExp = undefined;

    reg_exp.number = try Regex.compile(arena.allocator(), "(\\d+)");
    reg_exp.last_number = try Regex.compile(arena.allocator(), "(\\d+)[^\\d+]+$");
    reg_exp.exp_number = try Regex.compile(arena.allocator(), "^\\[(\\d+)[^\\d]+(\\d+)");

            const next = try std.fmt.allocPrint(arena.allocator(), "[{s},{s}]", .{ ret, line });

            var buf: [150]u8 = undefined;
            const next = try std.fmt.bufPrint(&buf, "[{s},{s}]", .{ ret, line });

    var buf: [2]u8 = undefined;

    try ret.appendSlice(try std.fmt.allocPrint(a, "{d}", .{split_num / 2}));

    try ret.appendSlice(try std.fmt.bufPrint(&buf, "{d}", .{split_num / 2}));

    try ret.appendSlice(try std.fmt.allocPrint(a, "{d}", .{std.math.ceil(@intToFloat(f32, split_num) / 2)}));

    try ret.appendSlice(try std.fmt.bufPrint(&buf, "{d}", .{std.math.ceil(@intToFloat(f32, split_num) / 2)}));

    var number = try Regex.compile(a, "(\\d+)");
    defer number.deinit();
    var last_number = try Regex.compile(a, "(\\d+)[^\\d+]+$");
    defer last_number.deinit();
    var exp_number = try Regex.compile(a, "^\\[(\\d+)[^\\d]+(\\d+)");
    defer exp_number.deinit();
    const exp_nums = (try exp_number.captures(input.*[pivot..])).?;

    const exp_nums = (try reg_exp.exp_number.captures(input.*[pivot..])).?;

    if (try last_number.captures(input.*[0..pivot])) |lefts| {

    if (try reg_exp.last_number.captures(input.*[0..pivot])) |lefts| {

            try new_string.appendSlice(try std.fmt.allocPrint(a, "{d}", .{left_num + exp_left_num}));

            var buf: [2]u8 = undefined;
            try new_string.appendSlice(try std.fmt.bufPrint(&buf, "{d}", .{left_num + exp_left_num}));

    if (try number.captures(input.*[exp_right[1] + 1 ..])) |rights| {

    if (try reg_exp.number.captures(input.*[exp_right[1] + 1 ..])) |rights| {

            try new_string.appendSlice(try std.fmt.allocPrint(a, "{d}", .{right_num + exp_left_num}));

            var buf: [2]u8 = undefined;
            try new_string.appendSlice(try std.fmt.bufPrint(&buf, "{d}", .{right_num + exp_left_num}));

## Day 15
This one is solved by a Dijksra algorithm. I use a `std.PriorityQueue` for
storing grid points to visit. I can not use `queue.update()` because of some
limitations in the std lib implementation, so I just keep adding the grid
points. It turns out to be faster than updating with `std.meta.eql()`. This
solution is ~240ms for the second part.
## Day 16
I convert from hex to binary as string with `switch`. Not sure if this is good
or bad. The rest if slicing and parsing. Nothing fancy.
## Day 17
This first part is a simple calculation. In second part I just brute force the
solutions with the following optimizations:
 - I keep vx{min, max} and vy{min, max} limited to the interesting part.
 - I also keep the time (steps) within useful range.
 - I break the loop when it has no chance to come up with a hit.
## Day 18
### First solution: day18a_string.zig
My go solution uses strings to solve this with regexes and so. I have tried to
replicate that in zig, but it needs a regex lib (which is not in the `std`) and
turns out to be quite slow. The first part takes ~500ms on my
computer, so I have to find a better way.