adam/AdventOfCode
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

extract parsing code for day2 + tidy

Browse source
This commit is contained in:
Adam Millerchip 2022-08-12 00:22:15 +09:00
parent 462ab21364
commit 59157c5a11
1 changed files with 31 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
2020/zig/src/day02.zig
View file

@ -1,90 +1,60 @@
const std = @import("std"); const std = @import("std");
const Allocator = std.mem.Allocator; const gpa = @import("util.zig").gpa;
const List = std.ArrayList; const ArrayList = std.ArrayList;
const Map = std.AutoHashMap; const tokenize = std.mem.tokenize;
const StrMap = std.StringHashMap; const parseInt = std.fmt.parseInt;
const BitSet = std.DynamicBitSet; const print = std.debug.print;
const Str = []const u8;
const util = @import("util.zig");
const gpa = util.gpa;
const data = @embedFile("input"); const data = @embedFile("input");
const Rule = struct {
a: u8, b: u8, char: u8, password: []const u8
};
pub fn main() !void { pub fn main() !void {
print("Part 1: {d}\n", .{part1()}); const rules = try parse();
print("Part 2: {d}\n", .{part2()}); print("Part 1: {d}\n", .{part1(rules)});
print("Part 2: {d}\n", .{part2(rules)});
} }
// TODO remove duplication by building a struct from the input?
fn part1() !u16 { fn parse() ![]Rule {
var it = tokenize(u8, data, "\n"); var it = tokenize(u8, data, "\n");
var valid_pw_count: u16 = 0; var rules = ArrayList(Rule).init(gpa);
while (it.next()) |line| { while (it.next()) |line| {
var line_it = tokenize(u8, line, ": -"); var line_it = tokenize(u8, line, ": -");
const min_val = try parseInt(u8, line_it.next().?, 10); const a = try parseInt(u8, line_it.next().?, 10);
const max_val = try parseInt(u8, line_it.next().?, 10); const b = try parseInt(u8, line_it.next().?, 10);
const req_char = line_it.next().?[0]; const char = line_it.next().?[0];
const password = line_it.next().?; const password = line_it.next().?;
try rules.append(Rule{.a = a, .b = b, .char = char, .password = password});
}
return rules.toOwnedSlice();
}
// count how many times req_char is in password fn part1(rules: []Rule) !u16 {
var valid_pw_count: u16 = 0;
for (rules) |rule| {
var count: u8 = 0; var count: u8 = 0;
for (password) |password_char| { for (rule.password) |password_char| {
if (req_char == password_char) if (rule.char == password_char)
count += 1; count += 1;
} }
if (min_val <= count and count <= max_val) if (rule.a <= count and count <= rule.b)
valid_pw_count += 1; valid_pw_count += 1;
} }
return valid_pw_count; return valid_pw_count;
} }
fn part2() !u16 { fn part2(rules: []Rule) !u16 {
var it = tokenize(u8, data, "\n");
var valid_pw_count: u16 = 0; var valid_pw_count: u16 = 0;
while (it.next()) |line| { for (rules) |rule| {
var line_it = tokenize(u8, line, ": -"); const a_match = rule.password[rule.a-1] == rule.char;
const pos_a = try parseInt(u8, line_it.next().?, 10); const b_match = rule.password[rule.b-1] == rule.char;
const pos_b = try parseInt(u8, line_it.next().?, 10);
const req_char = line_it.next().?[0];
const password = line_it.next().?;
const a_match = password[pos_a-1] == req_char;
const b_match = password[pos_b-1] == req_char;
// No xor in zig? // No xor in zig?
if (a_match and !b_match or !a_match and b_match) if (a_match and !b_match or !a_match and b_match)
valid_pw_count += 1; valid_pw_count += 1;
} }
return valid_pw_count; return valid_pw_count;
} }
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const indexOf = std.mem.indexOfScalar;
const indexOfAny = std.mem.indexOfAny;
const indexOfStr = std.mem.indexOfPosLinear;
const lastIndexOf = std.mem.lastIndexOfScalar;
const lastIndexOfAny = std.mem.lastIndexOfAny;
const lastIndexOfStr = std.mem.lastIndexOfLinear;
const trim = std.mem.trim;
const sliceMin = std.mem.min;
const sliceMax = std.mem.max;
const parseInt = std.fmt.parseInt;
const parseFloat = std.fmt.parseFloat;
const min = std.math.min;
const min3 = std.math.min3;
const max = std.math.max;
const max3 = std.math.max3;
const print = std.debug.print;
const assert = std.debug.assert;
const sort = std.sort.sort;
const asc = std.sort.asc;
const desc = std.sort.desc;