|
| 1 | +const std = @import("std"); |
| 2 | +const mem = std.mem; |
| 3 | +const io = std.io; |
| 4 | + |
| 5 | +const MAX_FILE_SIZE = 25_000; |
| 6 | + |
| 7 | +const PassportField = enum(u8) { |
| 8 | + invalid = 0b00000000, |
| 9 | + cid = 0b00000001, |
| 10 | + byr = 0b00000010, |
| 11 | + iyr = 0b00000100, |
| 12 | + eyr = 0b00001000, |
| 13 | + hgt = 0b00010000, |
| 14 | + hcl = 0b00100000, |
| 15 | + ecl = 0b01000000, |
| 16 | + pid = 0b10000000, |
| 17 | + required = 0b11111110, |
| 18 | + |
| 19 | + inline fn fromString(str: []const u8) PassportField { |
| 20 | + |
| 21 | + if (mem.eql(u8, str, "byr")) return PassportField.byr; |
| 22 | + if (mem.eql(u8, str, "iyr")) return PassportField.iyr; |
| 23 | + if (mem.eql(u8, str, "eyr")) return PassportField.eyr; |
| 24 | + if (mem.eql(u8, str, "hgt")) return PassportField.hgt; |
| 25 | + if (mem.eql(u8, str, "hcl")) return PassportField.hcl; |
| 26 | + if (mem.eql(u8, str, "ecl")) return PassportField.ecl; |
| 27 | + if (mem.eql(u8, str, "pid")) return PassportField.pid; |
| 28 | + if (mem.eql(u8, str, "cid")) return PassportField.cid; |
| 29 | + |
| 30 | + return PassportField.invalid; |
| 31 | + } |
| 32 | + |
| 33 | + fn validate(self: PassportField, field_value: []const u8) !bool { |
| 34 | + // TODO: investigate if zig has regex in std (would probably be slower though) |
| 35 | + |
| 36 | + switch(self) { |
| 37 | + .byr, .iyr, .eyr => { |
| 38 | + const value: i32 = try std.fmt.parseInt(i32, field_value, 10); |
| 39 | + |
| 40 | + switch(self) { |
| 41 | + .byr => return value >= 1920 and value <= 2002, |
| 42 | + .iyr => return value >= 2010 and value <= 2020, |
| 43 | + .eyr => return value >= 2020 and value <= 2030, |
| 44 | + else => unreachable, |
| 45 | + } |
| 46 | + }, |
| 47 | + |
| 48 | + .hgt => { |
| 49 | + const m_index = field_value.len - 2; |
| 50 | + |
| 51 | + const measure = field_value[m_index..field_value.len]; |
| 52 | + const value = try std.fmt.parseInt(i32, field_value[0..m_index], 10); |
| 53 | + |
| 54 | + if (mem.eql(u8, measure, "cm")) { |
| 55 | + return value >= 150 and value <= 193; |
| 56 | + } |
| 57 | + |
| 58 | + if (mem.eql(u8, measure, "in")) { |
| 59 | + return value >= 59 and value <= 76; |
| 60 | + } |
| 61 | + |
| 62 | + return false; |
| 63 | + }, |
| 64 | + |
| 65 | + .hcl => { |
| 66 | + if (field_value[0] != '#') return false; |
| 67 | + |
| 68 | + var i: usize = 1; |
| 69 | + while (i < field_value.len) : (i += 1) { |
| 70 | + if (i > 6) return false; |
| 71 | + |
| 72 | + switch (field_value[i]) { |
| 73 | + 'a'...'f', '0'...'9' => continue, |
| 74 | + else => return false, |
| 75 | + } |
| 76 | + } |
| 77 | + |
| 78 | + return true; |
| 79 | + }, |
| 80 | + |
| 81 | + .ecl => { |
| 82 | + if (mem.eql(u8, field_value, "amb") |
| 83 | + or mem.eql(u8, field_value, "blu") |
| 84 | + or mem.eql(u8, field_value, "brn") |
| 85 | + or mem.eql(u8, field_value, "gry") |
| 86 | + or mem.eql(u8, field_value, "grn") |
| 87 | + or mem.eql(u8, field_value, "hzl") |
| 88 | + or mem.eql(u8, field_value, "oth") |
| 89 | + ) return true; |
| 90 | + |
| 91 | + return false; |
| 92 | + }, |
| 93 | + |
| 94 | + .pid => { |
| 95 | + if (field_value.len != 9) return false; |
| 96 | + |
| 97 | + var i: usize = 0; |
| 98 | + while(i < field_value.len) : (i += 1) { |
| 99 | + switch (field_value[i]) { |
| 100 | + '0'...'9' => continue, |
| 101 | + else => return false, |
| 102 | + } |
| 103 | + } |
| 104 | + |
| 105 | + return true; |
| 106 | + }, |
| 107 | + |
| 108 | + else => return true, |
| 109 | + } |
| 110 | + |
| 111 | + unreachable; |
| 112 | + } |
| 113 | +}; |
| 114 | + |
| 115 | + |
| 116 | +pub inline fn countValidPass(bytes: []u8) struct {naive: u32, improved: u32} { |
| 117 | + var maybe_valid_passports: u32 = 0; |
| 118 | + var valid_passports: u32 = 0; |
| 119 | + |
| 120 | + var fields_found_map: u8 = 0; |
| 121 | + var fields_valid: bool = true; |
| 122 | + var lines = mem.split(bytes, "\n"); |
| 123 | + |
| 124 | + line_read: while (lines.next()) |line| { |
| 125 | + |
| 126 | + if (line.len <= 2) { |
| 127 | + if (fields_found_map >= @enumToInt(PassportField.required)) { |
| 128 | + maybe_valid_passports += 1; |
| 129 | + valid_passports += @boolToInt(fields_valid); |
| 130 | + } |
| 131 | + |
| 132 | + fields_valid = true; |
| 133 | + fields_found_map = @enumToInt(PassportField.invalid); |
| 134 | + continue; |
| 135 | + } |
| 136 | + |
| 137 | + var words = mem.split(line, " "); |
| 138 | + while (words.next()) |word| { |
| 139 | + var i: usize = 0; |
| 140 | + while (i < word.len) : (i += 1) { |
| 141 | + if (word[i] == ':') break; |
| 142 | + } |
| 143 | + |
| 144 | + const field = PassportField.fromString(word[0..i]); |
| 145 | + fields_found_map |= @enumToInt(field); |
| 146 | + |
| 147 | + const field_value = word[i + 1..word.len]; |
| 148 | + const valid: bool = field.validate(field_value) catch false; |
| 149 | + fields_valid = fields_valid and valid; |
| 150 | + } |
| 151 | + } |
| 152 | + |
| 153 | + return .{ |
| 154 | + .naive = maybe_valid_passports, |
| 155 | + .improved = valid_passports |
| 156 | + }; |
| 157 | +} |
| 158 | + |
| 159 | + |
| 160 | +pub fn main() anyerror!void { |
| 161 | + const in = std.io.getStdIn().reader(); |
| 162 | + const stdout = std.io.getStdOut().writer(); |
| 163 | + |
| 164 | + var bytes: [MAX_FILE_SIZE]u8 = undefined; |
| 165 | + const length = try in.readAll(&bytes); |
| 166 | + |
| 167 | + var valid_count = countValidPass(bytes[0..length]); |
| 168 | + |
| 169 | + try stdout.print("{}\n", .{valid_count.naive}); |
| 170 | + try stdout.print("{}\n", .{valid_count.improved}); |
| 171 | +} |
0 commit comments