const std = @import("std"); // Wanted to implement both in a single modular and expansible way, so this is that. const string = []const u8; // to simplify a bit const Iterator = std.mem.SplitIterator(u8); const stepFnType = *const fn (*Iterator, []string) ?[]string; pub fn main() void { const input = @embedFile("input.asc"); // The fundamental difference lies in the way of processing the file, // so we abstract that into a function to be able to pass its pointer. std.debug.print("Part 1: {}\n", .{sumPriorities(input, stepInline, 2)}); std.debug.print("Part 2: {}\n", .{sumPriorities(input, stepInterline, 3)}); } fn sumPriorities(input: string, stepFn: stepFnType, comptime amount: usize) usize { var totalPriorities: usize = 0; var iter = std.mem.split(u8, input, "\n"); // This buffer is needed to not allocate but it shouldn't be used directly var _buffer = [_]string{undefined} ** amount; // Use the stepper to divide into slices properly while (stepFn(&iter, &_buffer)) |containers| { // If it wasn't found just contine with the next line const repe = findCommon(u8, containers) orelse continue; // Convert to priority as specified // 'a-z' -> '1-26', 'A-Z' -> '27-52' const priority = if (repe >= 'a') repe - 'a' + 1 else repe - 'A' + 27; totalPriorities += priority; } return totalPriorities; } // Helper to find the common needle in n haystacks // Returns null if not found fn findCommon(comptime T: type, haystacks: [][]const T) ?T { // Why if (haystacks.len <= 1) unreachable; // We need to find a common needle for all of the haystacks. // Compare each of the characters in the first one with // the other ones in sequence. // // - If a match was found, jump to the next haystack. // - If a match wasn't found, just to the next needle. needle: for (haystacks[0]) |needle| { // Semaphor to know if something was found when reaching // the end of loops. var found: bool = false; haystack: for (haystacks[1..]) |haystack| { found = false; for (haystack) |blade| { if (needle == blade) { found = true; break; } } if (!found) { // We didn't find the needle, try with another one continue :needle; } else { // We did find it! // Let's see if it's in the next haystack continue :haystack; } } // We found the needle in all haystacks, hooray! if (found) return needle; } // We ran out of needles and nothing was found return null; } // Steps the iterator and slices lines in the specified amount fn stepInline(iter: *Iterator, buffer: []string) ?[]string { // We reached the end const line = iter.next() orelse return null; // Line isn't valid if (line.len == 0 or line.len % buffer.len != 0) return stepInline(iter, buffer); const len = line.len / buffer.len; for (buffer) |_, i| { // Split line into slices into buffer buffer[i] = line[i * len .. (i + 1) * len]; } return buffer; } // Steps the iterator and puts whole lines in the specified amount fn stepInterline(iter: *Iterator, buffer: []string) ?[]string { for (buffer) |_, i| { // No more lines const line = iter.next() orelse return null; // Invalid input, try next one if (line.len <= 0) return stepInterline(iter, buffer); buffer[i] = line; } return buffer; }