Advent Of Code 2025 Day 5

const std = @import("std");
const parseInt = std.fmt.parseInt;

const ID_Ranges = struct {
    min: u64,
    max: u64,
};

fn checkFreshness(id: u64, ranges: []ID_Ranges) bool {
    for (ranges) |range| {
        const min = range.min;
        const max = range.max;
        if (id >= min and id <= max) return true;
    }

    return false;
}

fn dayFiveBothParts(stdout: *std.Io.Writer, allocator: std.mem.Allocator) !void {
    const file = try std.fs.cwd().openFile("data.txt", .{ .mode = .read_only });
    defer file.close();

    var file_buffer: [4096]u8 = undefined;
    var file_reader = file.reader(&file_buffer);
    const reader = &file_reader.interface;

    var ranges_list: std.ArrayList(ID_Ranges) = .empty;
    defer ranges_list.deinit(allocator);

    while (reader.takeDelimiterExclusive('\n')) |line| {
        reader.toss(1);
        if (line.len == 0) break;

        var it = std.mem.splitAny(u8, line, "-");
        const first_str = it.next().?;
        const min = try parseInt(u64, first_str, 10);
        const second_str = it.next().?;
        const max = try parseInt(u64, second_str, 10);
        const range = ID_Ranges{ .min = min, .max = max };
        try ranges_list.append(allocator, range);
    } else |err| switch (err) {
        error.EndOfStream => {},
        else => return err,
    }

    const ranges = try ranges_list.toOwnedSlice(allocator);

    var id_list: std.ArrayList(u64) = .empty;
    defer id_list.deinit(allocator);

    while (reader.takeDelimiterExclusive('\n')) |line| {
        reader.toss(1);
        const id = try parseInt(u64, line, 10);
        try id_list.append(allocator, id);
    } else |err| switch (err) {
        error.EndOfStream => {},
        else => return err,
    }

    var fresh_ids: u16 = 0;

    for (id_list.items) |id| {
        if (checkFreshness(id, ranges)) fresh_ids += 1;
    }
    try stdout.print("Number of fresh IDs: {d}\n", .{fresh_ids});
    try stdout.flush();

    try stdout.print("--" ** 20 ++ "\n", .{});
    const day: u8 = 5;
    try stdout.print("Start of Day {d} Part 2\n", .{day});
    try stdout.print("--" ** 20 ++ "\n", .{});
    try stdout.flush();

    std.mem.sort(ID_Ranges, ranges, {}, struct {
        fn lessThan(_: void, a: ID_Ranges, b: ID_Ranges) bool {
            return a.min < b.min;
        }
    }.lessThan);

    var merged: std.ArrayList(ID_Ranges) = .empty;
    defer merged.deinit(allocator);

    try merged.append(allocator, ranges[0]);

    for (ranges[1..]) |range| {
        var last = &merged.items[merged.items.len - 1];

        if (range.min <= last.max + 1) {
            if (range.max > last.max) last.max = range.max;
        } else {
            try merged.append(allocator, range);
        }
    }

    var total: u64 = 0;
    for (merged.items) |range| {
        total += (range.max - range.min + 1);
    }

    try stdout.print("Total fresh IDs: {d}\n", .{total});
    try stdout.flush();
}

pub fn main() !void {
    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const stdout = &stdout_writer.interface;
    const day: u8 = 5;
    try stdout.print("Start of Day {d} Part 1\n", .{day});
    try stdout.print("--" ** 20 ++ "\n", .{});
    try stdout.flush();
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    try dayFiveBothParts(stdout, allocator);
}