From 4e8c71543cfd36143d05e6680bcd99d3498036fc Mon Sep 17 00:00:00 2001 From: Alfred Melch Date: Sun, 29 Jan 2023 18:30:11 +0100 Subject: [PATCH] commit working tree --- 2021/day14/Cargo.lock | 25 ++++++++++ 2021/day14/Cargo.toml | 9 ++++ 2021/day14/README.md | 86 ++++++++++++++++++++++++++++++++ 2021/day14/input/example0 | 18 +++++++ 2021/day14/input/example1 | 5 ++ 2021/day14/input/input | 102 ++++++++++++++++++++++++++++++++++++++ 2021/day14/src/main.rs | 74 +++++++++++++++++++++++++++ 7 files changed, 319 insertions(+) create mode 100644 2021/day14/Cargo.lock create mode 100644 2021/day14/Cargo.toml create mode 100644 2021/day14/README.md create mode 100644 2021/day14/input/example0 create mode 100644 2021/day14/input/example1 create mode 100644 2021/day14/input/input create mode 100644 2021/day14/src/main.rs diff --git a/2021/day14/Cargo.lock b/2021/day14/Cargo.lock new file mode 100644 index 0000000..965cb1f --- /dev/null +++ b/2021/day14/Cargo.lock @@ -0,0 +1,25 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "day14" +version = "0.1.0" +dependencies = [ + "itertools", +] + +[[package]] +name = "either" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" + +[[package]] +name = "itertools" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3" +dependencies = [ + "either", +] diff --git a/2021/day14/Cargo.toml b/2021/day14/Cargo.toml new file mode 100644 index 0000000..d455175 --- /dev/null +++ b/2021/day14/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "day14" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +itertools = "0.10.0" diff --git a/2021/day14/README.md b/2021/day14/README.md new file mode 100644 index 0000000..2155042 --- /dev/null +++ b/2021/day14/README.md @@ -0,0 +1,86 @@ +https://adventofcode.com/2021/day/14 + +## \--- Day 14: Extended Polymerization --- + +The incredible pressures at this depth are starting to put a strain on your +submarine. The submarine has +[polymerization](https://en.wikipedia.org/wiki/Polymerization) equipment that +would produce suitable materials to reinforce the submarine, and the nearby +volcanically-active caves should even have the necessary input elements in +sufficient quantities. + +The submarine manual contains instructions for finding the optimal polymer +formula; specifically, it offers a _polymer template_ and a list of _pair +insertion_ rules (your puzzle input). You just need to work out what polymer +would result after repeating the pair insertion process a few times. + +For example: + +[code] + + NNCB + + CH -> B + HH -> N + CB -> H + NH -> C + HB -> C + HC -> B + HN -> C + NN -> C + BH -> H + NC -> B + NB -> B + BN -> B + BB -> N + BC -> B + CC -> N + CN -> C + +[/code] + +The first line is the _polymer template_ \- this is the starting point of the +process. + +The following section defines the _pair insertion_ rules. A rule like `AB -> +C` means that when elements `A` and `B` are immediately adjacent, element `C` +should be inserted between them. These insertions all happen simultaneously. + +So, starting with the polymer template `NNCB`, the first step simultaneously +considers all three pairs: + + * The first pair (`NN`) matches the rule `NN -> C`, so element `_C_` is inserted between the first `N` and the second `N`. + * The second pair (`NC`) matches the rule `NC -> B`, so element `_B_` is inserted between the `N` and the `C`. + * The third pair (`CB`) matches the rule `CB -> H`, so element `_H_` is inserted between the `C` and the `B`. + +Note that these pairs overlap: the second element of one pair is the first +element of the next pair. Also, because all pairs are considered +simultaneously, inserted elements are not considered to be part of a pair +until the next step. + +After the first step of this process, the polymer becomes `N _C_ N _B_ C _H_ +B`. + +Here are the results of a few steps using the above rules: + +[code] + + Template: NNCB + After step 1: NCNBCHB + After step 2: NBCCNBBBCBHCB + After step 3: NBBBCNCCNBBNBNBBCHBHHBCHB + After step 4: NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB + +[/code] + +This polymer grows quickly. After step 5, it has length 97; After step 10, it +has length 3073. After step 10, `B` occurs 1749 times, `C` occurs 298 times, +`H` occurs 161 times, and `N` occurs 865 times; taking the quantity of the +most common element (`B`, 1749) and subtracting the quantity of the least +common element (`H`, 161) produces `1749 - 161 = _1588_`. + +Apply 10 steps of pair insertion to the polymer template and find the most and +least common elements in the result. _What do you get if you take the quantity +of the most common element and subtract the quantity of the least common +element?_ + diff --git a/2021/day14/input/example0 b/2021/day14/input/example0 new file mode 100644 index 0000000..b5594dd --- /dev/null +++ b/2021/day14/input/example0 @@ -0,0 +1,18 @@ +NNCB + +CH -> B +HH -> N +CB -> H +NH -> C +HB -> C +HC -> B +HN -> C +NN -> C +BH -> H +NC -> B +NB -> B +BN -> B +BB -> N +BC -> B +CC -> N +CN -> C diff --git a/2021/day14/input/example1 b/2021/day14/input/example1 new file mode 100644 index 0000000..71d2d9e --- /dev/null +++ b/2021/day14/input/example1 @@ -0,0 +1,5 @@ +Template: NNCB +After step 1: NCNBCHB +After step 2: NBCCNBBBCBHCB +After step 3: NBBBCNCCNBBNBNBBCHBHHBCHB +After step 4: NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB diff --git a/2021/day14/input/input b/2021/day14/input/input new file mode 100644 index 0000000..0193644 --- /dev/null +++ b/2021/day14/input/input @@ -0,0 +1,102 @@ +CKKOHNSBPCPCHVNKHFFK + +KO -> C +SO -> S +BF -> V +VN -> B +OV -> K +VH -> O +KV -> N +KB -> F +NB -> C +HS -> K +PF -> B +HB -> N +OC -> H +FS -> F +VV -> S +KF -> C +FN -> F +KP -> S +HO -> N +NH -> K +OO -> S +FB -> C +BP -> F +CH -> N +SN -> O +KN -> B +CV -> O +CC -> B +VB -> C +PH -> V +CO -> K +KS -> K +BK -> N +FH -> S +PV -> H +CB -> P +FO -> F +BB -> K +OB -> C +HH -> F +ON -> O +FK -> B +NF -> F +SV -> F +CP -> H +SS -> B +OP -> H +NS -> O +HK -> N +BC -> P +NV -> V +VS -> F +PC -> V +CS -> F +NP -> V +PS -> F +VC -> F +KK -> S +PO -> P +HF -> H +KC -> P +SF -> N +BV -> N +FF -> V +FV -> V +BO -> N +OS -> C +OF -> H +CN -> S +NO -> O +NC -> B +VK -> C +HN -> B +PK -> N +SK -> S +HV -> F +BH -> B +OK -> S +VO -> B +BS -> H +PP -> N +SC -> K +BN -> P +FC -> S +SB -> B +SH -> H +NN -> V +NK -> N +VF -> H +CF -> F +PB -> C +SP -> P +KH -> C +VP -> N +CK -> H +HP -> P +FP -> B +HC -> O +PN -> F +OH -> H diff --git a/2021/day14/src/main.rs b/2021/day14/src/main.rs new file mode 100644 index 0000000..dd98adf --- /dev/null +++ b/2021/day14/src/main.rs @@ -0,0 +1,74 @@ +use itertools::Itertools; +use std::collections::HashMap; +use std::io::stdin; +use std::io::BufRead; + +fn main() { + let stdin = stdin(); + let mut lines = stdin.lock().lines().map(|l| l.unwrap()); + let polymer_template = lines.next().unwrap(); + lines.next(); + + let mut insertion_rules = HashMap::new(); + for line in lines { + let mut elements = line.chars().filter(|c| c.is_ascii_alphabetic()); + let a = elements.next().unwrap(); + let b = elements.next().unwrap(); + let c = elements.next().unwrap(); + let pair = (a, b); + insertion_rules.insert(pair, c); + } + + dbg!(&polymer_template); + println!("Insertion rules: {:?}", insertion_rules); + + let mut tuple_counter: HashMap<(char, char), i64> = HashMap::new(); + + for tuple in polymer_template.chars().tuple_windows() { + *tuple_counter.entry(tuple).or_insert(0) += 1; + } + + let mut step = 0; + + loop { + let mut next_counter = HashMap::new(); + for ((a, b), amount) in tuple_counter { + if let Some(c) = insertion_rules.get(&(a, b)) { + let c = *c; + *next_counter.entry((a, c)).or_insert(0) += amount; + *next_counter.entry((c, b)).or_insert(0) += amount; + } + } + let length = next_counter.values().sum::() + 1; + tuple_counter = next_counter; + + step += 1; + println!("After step {}: Length {}", step, length); + if step >= 40 { + break; + } + } + + let mut element_counter = HashMap::new(); + for ((a, b), amount) in tuple_counter { + *element_counter.entry(a).or_insert(0) += amount; + *element_counter.entry(b).or_insert(0) += amount; + } + let first_element = polymer_template.chars().next().unwrap(); + let last_element = polymer_template.chars().last().unwrap(); + *element_counter.entry(first_element).or_insert(0) += 1; + *element_counter.entry(last_element).or_insert(0) += 1; + for amount in element_counter.values_mut() { + *amount >>= 1; + } + println!("Element counter {:?}", element_counter); + + let mut amounts: Vec<&i64> = element_counter.values().collect(); + amounts.sort(); + let least_common = amounts.get(0).unwrap(); + let most_common = amounts.last().unwrap(); + let answer = *most_common - *least_common; + + println!("{:?}", amounts); + dbg!(answer); +}