chore(*): Move old solutions into a separate folder

old/2021/14/14.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <RootNamespace>_14</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Update="input.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Creek.HelpfulExtensions" Version="1.4.3" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
+  </ItemGroup>
+
+</Project>

old/2021/14/Program.cs

@@ -0,0 +1,260 @@
+using Creek.HelpfulExtensions;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+
+namespace Day14
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var sr = new StreamReader("input.txt");
+            var translate = new Dictionary<string, string>();
+
+            string polymer = sr.ReadLine();
+
+            while (!sr.EndOfStream)
+            {
+                string line = sr.ReadLine();
+                if (line.Length > 0)
+                {
+                    var p = line.Split(" -> ");
+                    translate.Add(p[0], p[1]);
+                }
+            }
+
+            var pairs = new Dictionary<string, ulong>();
+            var elements = new Dictionary<string, ulong>();
+
+            for (int k = 0; k < polymer.Length - 1; k++)
+            {
+                var p = polymer.Substring(k, 2);
+                pairs.TryAdd(p, 0);
+                pairs[p]++;
+            }
+
+            for (int k = 0; k < polymer.Length; k++)
+            {
+                elements.TryAdd(polymer[k].ToString(), 0);
+                elements[polymer[k].ToString()]++;
+            }
+
+            for (int i = 0; i < 40; i++)
+            {
+                var newpairs = new Dictionary<string, ulong>();
+                foreach (var p in pairs.Keys)
+                {
+                    var insert = translate[p];
+                    var c = pairs[p];
+                    newpairs.TryAdd(p[0] + insert, 0);
+                    newpairs[p[0] + insert] += c;
+                    newpairs.TryAdd(insert + p[1], 0);
+                    newpairs[insert + p[1]] += c;
+                    elements.TryAdd(insert, 0);
+                    elements[insert] += c;
+                }
+                pairs = newpairs;
+            }
+
+            ulong min = ulong.MaxValue;
+            ulong max = ulong.MinValue;
+            ulong sum = 0;
+
+            foreach (var a in elements.Values)
+            {
+                if (a > max) max = a;
+                if (a < min) min = a;
+                sum += a;
+            }
+
+            Console.WriteLine($"Result: {max} - {min} = {max - min}, length = {sum}");
+        }
+
+        //static void Main(string[] args)
+        //{
+        //    string[] lines = File.ReadAllLines("input.txt");
+
+
+        //    //Part1(lines);
+        //    Part2(lines);
+        //}
+
+        static void Part1(string[] lines)
+        {
+            string polymerTemplate = lines[0];
+
+            Console.WriteLine($"Template: {polymerTemplate}");
+
+            // Pair insertion rules are stored from index 2 onwards
+            // A rule like AB -> C means that when elements A and B are immediately adjacent, element C
+            // should be inserted between them.
+            // Also, because all pairs are considered simultaneously, inserted elements are not considered
+            // to be part of a pair until the next step.
+
+            List<Rule> rules = new List<Rule>();
+            // Consider each rule
+            for (int i = 2; i < lines.Length; i++)
+            {
+                // e.g. AB -> C
+                string pairToMatch = lines[i].Substring(0, 2);
+                string characterToInsert = lines[i].Substring(6, 1);
+
+                rules.Add(new Rule()
+                {
+                    First = pairToMatch[0],
+                    Second = pairToMatch[1],
+                    Insert = characterToInsert[0],
+                });
+            }
+
+            // Set the number of steps to run
+            for (int i = 0; i < 10; i++)
+            {
+                CompleteStep(ref polymerTemplate, ref lines, rules);
+                //Console.WriteLine($"After step {i+1}: {polymerTemplate}");
+            }
+
+            // Count occurrences of each character
+            char[] chars = polymerTemplate.ToCharArray();
+            List<char> uniqueCharacters = chars.Select(x => x).Distinct().ToList();
+            List<(char character, int count)> countList = new List<(char character, int count)>();
+
+            foreach (char character in uniqueCharacters)
+            {
+                countList.Add((character, polymerTemplate.Count(c => c == character)));
+            }
+
+            (char character, int count) mostCommon = countList.MaxBy(x => x.count);
+            (char character, int count) leastCommon = countList.MinBy(x => x.count);
+
+            Console.WriteLine(mostCommon.count - leastCommon.count);
+        }
+
+        static void Part2(string[] lines)
+        {
+            string polymerTemplate = lines[0];
+
+            Console.WriteLine($"Template: {polymerTemplate}");
+
+            // Pair insertion rules are stored from index 2 onwards
+            // A rule like AB -> C means that when elements A and B are immediately adjacent, element C
+            // should be inserted between them.
+            // Also, because all pairs are considered simultaneously, inserted elements are not considered
+            // to be part of a pair until the next step.
+
+            Dictionary<(char, char), char> rules = new Dictionary<(char, char), char>();
+            // Consider each rule
+            for (int i = 2; i < lines.Length; i++)
+            {
+                // e.g. AB -> C
+                string pairToMatch = lines[i].Substring(0, 2);
+                string characterToInsert = lines[i].Substring(6, 1);
+
+                rules.Add((pairToMatch[0], pairToMatch[1]), characterToInsert[0]);
+            }
+
+            // Set the number of steps to run
+            for (int i = 0; i < 40; i++)
+            {
+                Stopwatch stopWatch = new Stopwatch();
+                stopWatch.Start();
+                
+                CompleteStepNew(ref polymerTemplate, rules);
+
+                stopWatch.Stop();
+                TimeSpan ts = stopWatch.Elapsed;
+                string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
+                    ts.Hours, ts.Minutes, ts.Seconds,
+                    ts.Milliseconds / 10);
+                Console.WriteLine($"Step {i + 1} took {elapsedTime}");
+            }
+
+            // Count occurrences of each character
+            char[] chars = polymerTemplate.ToCharArray();
+            List<char> uniqueCharacters = chars.Select(x => x).Distinct().ToList();
+            List<(char character, int count)> countList = new List<(char character, int count)>();
+
+            foreach (char character in uniqueCharacters)
+            {
+                countList.Add((character, polymerTemplate.Count(c => c == character)));
+            }
+
+            (char character, int count) mostCommon = countList.MaxBy(x => x.count);
+            (char character, int count) leastCommon = countList.MinBy(x => x.count);
+
+            Console.WriteLine(mostCommon.count - leastCommon.count);
+        }
+
+        static void CompleteStepNew(ref string polymerTemplate, Dictionary<(char, char), char> rules)
+        {
+            LinkedList<char> temporaryList = new LinkedList<char>();
+            char[] temporaryTemplate = polymerTemplate.ToCharArray();
+
+            for (int i = 0; i < temporaryTemplate.Length; i++)
+            {
+                temporaryList.AddLast(temporaryTemplate[i]);
+            }
+
+            LinkedListNode<char> pointer = temporaryList.Find(temporaryList.First());
+
+            // Insert the new character into the linked list but do not change the temporary template we're checking against
+            for (int i = 0; i < temporaryTemplate.Count() - 1; i++)
+            {
+                char insertValue;
+                
+                //using ("First".DisposableStopWatch())
+                //{
+                rules.TryGetValue((temporaryTemplate[i], temporaryTemplate[i + 1]), out insertValue);
+                //}
+
+                temporaryList.AddAfter(pointer, insertValue);
+
+                // Move on an extra position as we have added a node
+                pointer = pointer.Next.Next;
+            }
+
+            polymerTemplate = String.Join("", temporaryList);
+            //polymerTemplate = string.Concat(temporaryList); // this is slower
+        }
+
+        static void CompleteStep(ref string polymerTemplate, ref string[] lines, List<Rule> rules)
+        {
+            LinkedList<char> temporaryList = new LinkedList<char>();
+            List<char> temporaryTemplate = new List<char>();
+
+            foreach (char character in polymerTemplate)
+            {
+                temporaryList.AddLast(character);
+                temporaryTemplate.Add(character);
+            }
+
+            LinkedListNode<char> pointer = temporaryList.Find(temporaryList.First());
+
+            // Insert the new character into the linked list but do not change the temporary template we're checking against
+            for (int i = 0; i < temporaryTemplate.Count() - 1; i++)
+            {
+                Rule matchingRule = rules.FirstOrDefault(r => r.First == temporaryTemplate.ElementAt(i) && r.Second == temporaryTemplate.ElementAt(i + 1));
+
+                if (matchingRule is not null)
+                {
+                    temporaryList.AddAfter(pointer, matchingRule.Insert);
+
+                    // Move on an extra position as we have added a node
+                    pointer = pointer.Next;
+                }
+
+                pointer = pointer.Next;
+            }
+
+            polymerTemplate = String.Join("", temporaryList);
+        }
+
+
+        class Rule
+        {
+            public char First { get; set; }
+            public char Second { get; set; }
+            public char Insert { get; set; }
+        }
+    }
+}

old/2021/14/TaskPart1.txt

@@ -0,0 +1,48 @@
+--- Day 14: Extended Polymerization ---
+The incredible pressures at this depth are starting to put a strain on your submarine. The submarine has 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:
+
+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
+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 NCNBCHB.
+
+Here are the results of a few steps using the above rules:
+
+Template:     NNCB
+After step 1: NCNBCHB
+After step 2: NBCCNBBBCBHCB
+After step 3: NBBBCNCCNBBNBNBBCHBHHBCHB
+After step 4: NBBNBNBBCCNBCNCCNBBNBBNBBBNBBNBBCBHCBHHNHCBBCBHCB
+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?

old/2021/14/TaskPart2.txt

@@ -0,0 +1,6 @@
+--- Part Two ---
+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 40 steps should do it.
+
+In the above example, the most common element is B (occurring 2192039569602 times) and the least common element is H (occurring 3849876073 times); subtracting these produces 2188189693529.
+
+Apply 40 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?

old/2021/14/input.txt

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