|
| 1 | +use std::collections::{HashMap, HashSet, VecDeque}; |
| 2 | + |
| 3 | +use aoc_utils::*; |
| 4 | +use itertools::Itertools; |
| 5 | + |
| 6 | +advent_of_code::solution!(24); |
| 7 | + |
| 8 | +#[derive(Debug, Clone)] |
| 9 | +struct RuleParts { |
| 10 | + left: String, |
| 11 | + right: String, |
| 12 | + out: String, |
| 13 | +} |
| 14 | + |
| 15 | +#[derive(Debug, Clone)] |
| 16 | +enum Rule { |
| 17 | + And(RuleParts), |
| 18 | + Or(RuleParts), |
| 19 | + Xor(RuleParts), |
| 20 | +} |
| 21 | + |
| 22 | +impl Rule { |
| 23 | + fn from_strs(left: &str, rule: &str, right: &str, out: &str) -> Self { |
| 24 | + match rule { |
| 25 | + "AND" => Rule::And(RuleParts { |
| 26 | + left: left.to_owned(), |
| 27 | + right: right.to_owned(), |
| 28 | + out: out.to_owned(), |
| 29 | + }), |
| 30 | + "OR" => Rule::Or(RuleParts { |
| 31 | + left: left.to_owned(), |
| 32 | + right: right.to_owned(), |
| 33 | + out: out.to_owned(), |
| 34 | + }), |
| 35 | + "XOR" => Rule::Xor(RuleParts { |
| 36 | + left: left.to_owned(), |
| 37 | + right: right.to_owned(), |
| 38 | + out: out.to_owned(), |
| 39 | + }), |
| 40 | + _ => panic!("Unknown rule: {}", rule), |
| 41 | + } |
| 42 | + } |
| 43 | + |
| 44 | + fn left(&self) -> &str { |
| 45 | + match self { |
| 46 | + Rule::And(parts) => &parts.left, |
| 47 | + Rule::Or(parts) => &parts.left, |
| 48 | + Rule::Xor(parts) => &parts.left, |
| 49 | + } |
| 50 | + } |
| 51 | + |
| 52 | + fn right(&self) -> &str { |
| 53 | + match self { |
| 54 | + Rule::And(parts) => &parts.right, |
| 55 | + Rule::Or(parts) => &parts.right, |
| 56 | + Rule::Xor(parts) => &parts.right, |
| 57 | + } |
| 58 | + } |
| 59 | + |
| 60 | + fn out(&self) -> &str { |
| 61 | + match self { |
| 62 | + Rule::And(parts) => &parts.out, |
| 63 | + Rule::Or(parts) => &parts.out, |
| 64 | + Rule::Xor(parts) => &parts.out, |
| 65 | + } |
| 66 | + } |
| 67 | + |
| 68 | + fn apply(&self, registers: &mut HashMap<String, u64>) { |
| 69 | + let left = registers.get(self.left()).unwrap(); |
| 70 | + let right = registers.get(self.right()).unwrap(); |
| 71 | + let out = match self { |
| 72 | + Rule::And(_) => left & right, |
| 73 | + Rule::Or(_) => left | right, |
| 74 | + Rule::Xor(_) => left ^ right, |
| 75 | + }; |
| 76 | + registers.insert(self.out().to_owned(), out); |
| 77 | + } |
| 78 | +} |
| 79 | + |
| 80 | +fn parse_input(input: &str) -> (HashMap<String, u64>, Vec<Rule>) { |
| 81 | + let blocks = input.blocks(); |
| 82 | + let registers = blocks[0] |
| 83 | + .mlines(|s| { |
| 84 | + let parts = s.split_once(": ").expect("Should have a colon"); |
| 85 | + |
| 86 | + ( |
| 87 | + parts.0.to_owned(), |
| 88 | + parts.1.parse::<u64>().expect("Should be a number"), |
| 89 | + ) |
| 90 | + }) |
| 91 | + .into_iter() |
| 92 | + .collect::<HashMap<String, u64>>(); |
| 93 | + let rules = blocks[1].mlines(|l| { |
| 94 | + let mut parts = l.split_whitespace(); |
| 95 | + Rule::from_strs( |
| 96 | + parts.next().unwrap(), |
| 97 | + parts.next().unwrap(), |
| 98 | + parts.next().unwrap(), |
| 99 | + parts.nth(1).unwrap(), |
| 100 | + ) |
| 101 | + }); |
| 102 | + (registers, rules) |
| 103 | +} |
| 104 | + |
| 105 | +pub fn part_one(input: &str) -> Option<u64> { |
| 106 | + let (mut registers, rules) = parse_input(input); |
| 107 | + let mut queue = VecDeque::from(rules); |
| 108 | + while !queue.is_empty() { |
| 109 | + let rule = queue.pop_front().unwrap(); |
| 110 | + if !registers.contains_key(rule.left()) || !registers.contains_key(rule.right()) { |
| 111 | + queue.push_back(rule); |
| 112 | + continue; |
| 113 | + } |
| 114 | + rule.apply(&mut registers); |
| 115 | + } |
| 116 | + let mut zs = registers |
| 117 | + .into_iter() |
| 118 | + .filter(|(k, _)| k.starts_with("z")) |
| 119 | + .collect::<Vec<_>>(); |
| 120 | + zs.sort(); |
| 121 | + Some(zs.into_iter().rev().fold(0, |acc, (_, v)| acc << 1 | v)) |
| 122 | +} |
| 123 | + |
| 124 | +pub fn part_two(input: &str) -> Option<String> { |
| 125 | + let (registers, rules) = parse_input(input); |
| 126 | + let max_number = registers.len() / 2; |
| 127 | + |
| 128 | + // FULL ADDER |
| 129 | + // (first bits aren't a full adder) |
| 130 | + // (for last FA, COUT is the extra output) |
| 131 | + // |
| 132 | + // Xn XOR Yn -> VAL0 <= FAGate0 |
| 133 | + // Xn AND Yn -> VAL1 <= FAGate1 |
| 134 | + // VAL0 AND CIN -> VAL2 <= FAGate2 |
| 135 | + // VAL0 XOR CIN -> Zn <= FAGate3 |
| 136 | + // VAL1 OR VAL2 -> COUT <= FAGate4 |
| 137 | + |
| 138 | + let mut bad_outputs = HashSet::new(); |
| 139 | + // check FAGate0 gates for Zns |
| 140 | + // each of these should be An XOR Bn -> VAL0n |
| 141 | + // except for the first one, which should be x00 XOR y00 -> z00 |
| 142 | + let fa0s = rules |
| 143 | + .iter() |
| 144 | + .filter(|r| { |
| 145 | + if let Rule::Xor(parts) = r { |
| 146 | + (parts.left.starts_with("x") || parts.right.starts_with("x")) |
| 147 | + && (parts.left.starts_with("y") || parts.right.starts_with("y")) |
| 148 | + } else { |
| 149 | + false |
| 150 | + } |
| 151 | + }) |
| 152 | + .collect_vec(); |
| 153 | + fa0s.iter().for_each(|r| { |
| 154 | + if r.out().starts_with("z") && r.out() != "z00" && (r.left() != "x00" || r.right() != "x00") |
| 155 | + { |
| 156 | + bad_outputs.insert(r.out()); |
| 157 | + } |
| 158 | + }); |
| 159 | + |
| 160 | + // call rules that do not take Xn & Yn gates as inputs indirect |
| 161 | + // check all XOR gates that are indirect (FAGate3) |
| 162 | + // each of these should be outputting to a zXX |
| 163 | + let fa3s = rules |
| 164 | + .iter() |
| 165 | + .filter(|r| { |
| 166 | + if let Rule::Xor(parts) = r { |
| 167 | + !(parts.left.starts_with("x") |
| 168 | + || parts.right.starts_with("x") |
| 169 | + || parts.left.starts_with("y") |
| 170 | + || parts.right.starts_with("y")) |
| 171 | + } else { |
| 172 | + false |
| 173 | + } |
| 174 | + }) |
| 175 | + .collect_vec(); |
| 176 | + fa3s.iter().for_each(|r| { |
| 177 | + if !r.out().starts_with("z") { |
| 178 | + bad_outputs.insert(r.out()); |
| 179 | + } |
| 180 | + }); |
| 181 | + |
| 182 | + // check all output gates |
| 183 | + // each of these should be VAL0 XOR CIN -> Zn (FAGate3) |
| 184 | + // except for the last one, which should be VAL1 OR VAL2 -> COUT |
| 185 | + let outputs = rules |
| 186 | + .iter() |
| 187 | + .filter(|r| r.out().starts_with("z")) |
| 188 | + .collect_vec(); |
| 189 | + let max_output = format!("z{:02}", max_number); |
| 190 | + outputs.iter().for_each(|r| { |
| 191 | + if r.out() == max_output { |
| 192 | + if !matches!(r, Rule::Or(_)) { |
| 193 | + bad_outputs.insert(r.out()); |
| 194 | + } |
| 195 | + } else { |
| 196 | + if !matches!(r, Rule::Xor(_)) { |
| 197 | + bad_outputs.insert(r.out()); |
| 198 | + } |
| 199 | + } |
| 200 | + }); |
| 201 | + |
| 202 | + // all FAGate0 gates MUST be inputs to a FAGate3 gate |
| 203 | + let bad_fa0s = fa0s |
| 204 | + .iter() |
| 205 | + .filter(|r| { |
| 206 | + if r.out() == "z00" { |
| 207 | + return false; |
| 208 | + } |
| 209 | + if bad_outputs.contains(r.out()) { |
| 210 | + // skip - already a bad output |
| 211 | + return false; |
| 212 | + } |
| 213 | + !fa3s |
| 214 | + .iter() |
| 215 | + .any(|r2| r2.left() == r.out() || r2.right() == r.out()) |
| 216 | + }) |
| 217 | + .collect_vec(); |
| 218 | + bad_fa0s.iter().for_each(|r| { |
| 219 | + bad_outputs.insert(r.out()); |
| 220 | + let intended_out = format!("z{}", &r.left()[1..]); |
| 221 | + let expected_fa3 = fa3s |
| 222 | + .iter() |
| 223 | + .find(|r2| r2.out() == intended_out) |
| 224 | + .expect("Shoud have a next"); |
| 225 | + let left = expected_fa3.left(); |
| 226 | + let right = expected_fa3.right(); |
| 227 | + // find an FAGate4 that outputs a c_in used as input to the expected FAGate3 |
| 228 | + // the other input should be the output of the bad FAGate0 |
| 229 | + rules.iter().for_each(|r3| { |
| 230 | + if matches!(r3, Rule::Or(_)) { |
| 231 | + if r3.out() == left { |
| 232 | + bad_outputs.insert(right); |
| 233 | + } |
| 234 | + if r3.out() == right { |
| 235 | + bad_outputs.insert(left); |
| 236 | + } |
| 237 | + } |
| 238 | + }); |
| 239 | + }); |
| 240 | + Some(bad_outputs.iter().sorted().join(",")) |
| 241 | +} |
| 242 | + |
| 243 | +#[cfg(test)] |
| 244 | +mod tests { |
| 245 | + use super::*; |
| 246 | + |
| 247 | + #[test] |
| 248 | + fn test_part_one() { |
| 249 | + let result = part_one(&advent_of_code::template::read_file("examples", DAY)); |
| 250 | + assert_eq!(result, Some(4)); |
| 251 | + } |
| 252 | + |
| 253 | + #[test] |
| 254 | + fn test_part_one_2() { |
| 255 | + let result = part_one(&advent_of_code::template::read_file_part( |
| 256 | + "examples", DAY, 1, |
| 257 | + )); |
| 258 | + assert_eq!(result, Some(2024)); |
| 259 | + } |
| 260 | +} |
0 commit comments