original source: [https://adventofcode.com/2021/day/14](https://adventofcode.com/2021/day/14)

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 <em>polymer template</em> and a list of <em>pair insertion</em> 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:

<pre>

<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>

</pre>

The first line is the <em>polymer template</em> - this is the starting point of the process.

The following section defines the <em>pair insertion</em> rules. A rule like <code>AB -> C</code> means that when elements <code>A</code> and <code>B</code> are immediately adjacent, element <code>C</code> should be inserted between them. These insertions all happen simultaneously.

So, starting with the polymer template <code>NNCB</code>, the first step simultaneously considers all three pairs:

- The first pair (<code>NN</code>) matches the rule <code>NN -> C</code>, so element <code><em>C</em></code> is inserted between the first <code>N</code> and the second <code>N</code>.

- The second pair (<code>NC</code>) matches the rule <code>NC -> B</code>, so element <code><em>B</em></code> is inserted between the <code>N</code> and the <code>C</code>.

- The third pair (<code>CB</code>) matches the rule <code>CB -> H</code>, so element <code><em>H</em></code> is inserted between the <code>C</code> and the <code>B</code>.

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 <code>N<em>C</em>N<em>B</em>C<em>H</em>B</code>.

Here are the results of a few steps using the above rules:

<pre>

<code>Template: NNCB

After step 1: NCNBCHB

After step 2: NBCCNBBBCBHCB

After step 3: NBBBCNCCNBBNBNBBCHBHHBCHB

After step 4: NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB

</code>

</pre>

This polymer grows quickly. After step 5, it has length 97; After step 10, it has length 3073. After step 10, <code>B</code> occurs 1749 times, <code>C</code> occurs 298 times, <code>H</code> occurs 161 times, and <code>N</code> occurs 865 times; taking the quantity of the most common element (<code>B</code>, 1749) and subtracting the quantity of the least common element (<code>H</code>, 161) produces <code>1749 - 161 = <em>1588</em></code>.

Apply 10 steps of pair insertion to the polymer template and find the most and least common elements in the result. <em>What do you get if you take the quantity of the most common element and subtract the quantity of the least common element?</em>

The resulting polymer isn't nearly strong enough to reinforce the submarine. You'll need to run more steps of the pair insertion process; a total of <em>40 steps</em> should do it.

In the above example, the most common element is <code>B</code> (occurring <code>2192039569602</code> times) and the least common element is <code>H</code> (occurring <code>3849876073</code> times); subtracting these produces <code><em>2188189693529</em></code>.

Apply <em>40</em> steps of pair insertion to the polymer template and find the most and least common elements in the result. <em>What do you get if you take the quantity of the most common element and subtract the quantity of the least common element?</em>

using System.Collections.Generic;

using System.Linq;

namespace AdventOfCode.Y2021.Day14;

class Solution : Solver {

public object PartOne(string input) => Solve(input, 10);

public object PartTwo(string input) => Solve(input, 40);

long Solve(string input, int steps) {

var (polymer, elements, polymerFromMolecule) = Parse(input);

var cache = new Dictionary<(string, int, char), long>();

// getElementCountAfterNSteps: Determines how many atoms of the element

// are present after N steps, if we are starting from the given polymer.

// This function needs to be cached or it will never terminate.

long getElementCountAfterNSteps(string polymer, int steps, char element) {

var key = (polymer, steps, element);

if (!cache.ContainsKey(key)) {

long res = 0L;

if (steps == 0) {

// no more steps to do, just count the element in the polymer:

res = polymer.Count(ch => ch == element);

} else {

// The idea is that we can go over the molecules in the polymer,

// and deal with them one by one. Do one replacement, recurse and

// sum the element counts:

for (var j = 0; j < polymer.Length - 1; j++) {

var molecule = polymer.Substring(j, 2);

var count = getElementCountAfterNSteps(

polymerFromMolecule[molecule],

steps - 1,

element

);

// if the molecule ends with the searched element, the next one will include it as well,

// we shouldn't count it twice:

if (element == molecule[1] && j < polymer.Length - 2) {

count--;

}

res += count;

}

}

cache[key] = res;

}

return cache[key];

}

// using the above helper, we can just ask for the count of each element, and quickly compute the answer

var elementCountsAtTheEnd = (

from element in elements

select getElementCountAfterNSteps(polymer, steps, element)

).ToArray();

return elementCountsAtTheEnd.Max() - elementCountsAtTheEnd.Min();

}

(string polymer, HashSet<char> elements, Dictionary<string, string> polymerFromMolecule) Parse(string input) {

var blocks = input.Split("\n\n");

// we will start from this polymer

var polymer = blocks[0];

// the map contains the resulted polymer after the replacement, not just the inserted element:

var polymerFromMolecule = (

from line in blocks[1].Split("\n")

let parts = line.Split(" -> ")

select (molecule: parts[0], element: parts[1])

).ToDictionary(p => p.molecule, p => p.molecule[0] + p.element + p.molecule[1]);

// set of all elements for convenience:

var elements = polymerFromMolecule.Keys.Select(molecule => molecule[0]).ToHashSet();

return (polymer, elements, polymerFromMolecule);

}

PFVKOBSHPSPOOOCOOHBP

FV -> C

CP -> K

FS -> K

VF -> N

HN -> F

FF -> N

SS -> K

VS -> V

BV -> F

HC -> K

BP -> F

OV -> N

BF -> V

VH -> V

PF -> N

FC -> S

CS -> B

FK -> N

VK -> H

FN -> P

SH -> V

CV -> K

HP -> K

HO -> C

NO -> V

CK -> C

VB -> S

OC -> N

NS -> C

NF -> H

SF -> N

NK -> S

NP -> P

OO -> S

NH -> C

BC -> H

KS -> H

PV -> O

KO -> K

OK -> H

OH -> H

BH -> F

NB -> B

FH -> N

HV -> F

BN -> S

ON -> V

CB -> V

CF -> H

FB -> S

KF -> S

PS -> P

OB -> C

NN -> K

KV -> C

BK -> H

SN -> S

NC -> H

PK -> B

PC -> H

KN -> S

VO -> V

FO -> K

CH -> B

PH -> N

SO -> C

KH -> S

HB -> V

HH -> B

BB -> H

SC -> V

HS -> K

SP -> V

KB -> N

VN -> H

HK -> H

KP -> K

OP -> F

CO -> B

VP -> H

OS -> N

OF -> H

KK -> N

CC -> K

BS -> C

VV -> O

CN -> H

PB -> P

BO -> N

SB -> H

FP -> F

SK -> F

PO -> S

KC -> H

VC -> H

NV -> N

HF -> B

PN -> F

SV -> K

PP -> K

2937

3390034818249

Write(0xcc00, false, " █ █ █ █ █ █▄█\n █ █ █▄█ ▀▄▀ █▄▄ █ █ █▄ █▄█ █ █▄ █▄█ █▄█ █▄▄ int y = 2021;\n ");

Write(0xcc00, false, " \n ");

Write(0xb5ed, false, " .. . ' . ~. .. ");

Write(0xb5ed, false, " . ");

Write(0xa2db, false, " . ~ ' . . . ' ");

Write(0xa2db, false, " .. ");

Write(0x91cc, false, " . . . .'. ' . . ' ");

Write(0xffffff, false, ".' ");

Write(0x91cc, false, ".. ");

Write(0x85c0, false, "~ . . . ~ . . ");

Write(0x79b5, false, ". . . . . ");

Write(0x6daa, false, " . . .' . ");

Write(0x619f, false, " . . . ' . '' ");

Write(0x5a98, false, " .' . . . . ");

Write(0x5291, false, " . . . . ");

Write(0x4a8a, false, " . . ' ' ");

Write(0x4282, false, " . ... . ");

Write(0x3b7b, false, ".. ~ .' ");

Write(0xa47a4d, false, "..'' ''' ...: ");

Write(0x3374, false, " . '. .. .");

Write(0x666666, false, " ...'");

Write(0xa47a4d, false, "' ..': ");

Write(0xcccccc, false, "14 ");

Write(0xffff66, false, "**\n ");

Write(0x333333, false, ". . .~ ' ' ...''");

Write(0xa47a4d, false, "' ");

Write(0xc74c30, false, "'");

Write(0x666666, false, "15\n ");

Write(0x333333, false, " ' ");

Write(0x666666, false, "16\n 17\n ");

Write(0x666666, false, " 18\n 19\n ");

Write(0x666666, false, " 20\n ");

Write(0x666666, false, " 21\n 22\n ");

Write(0x666666, false, " 23\n ");

Write(0x666666, false, " 24\n 25\n \n");