Advent of Code 2021 - Day 14

Author: CodingNagger

README.md

@@ -31,3 +31,4 @@ Last year I ran a [cruise log for my 25 days competing in the Advent of Code](ht
 - [The Advent of Code 2021 Day 11, Octopussy light](https://www.codingnagger.com/2021/12/11/the-advent-of-code-2021-day-11-octopussy-light/)
 - [The Advent of Code 2021 Day 12, Going deep and hard](https://www.codingnagger.com/2021/12/12/the-advent-of-code-2021-day-12-going-deep-and-hard/)
 - [The Advent of Code 2021 Day 13, Nautical origami](https://www.codingnagger.com/2021/12/13/the-advent-of-code-2021-day-13-nautical-origami/)
+- [The Advent of Code 2021 Day 14, Buckets of love](https://www.codingnagger.com/2021/12/14/the-advent-of-code-2021-day-14-buckets-of-love/)

src/main/java/com/codingnagger/App.java

@@ -5,6 +5,7 @@
 import com.codingnagger.days.Day11;
 import com.codingnagger.days.Day12;
 import com.codingnagger.days.Day13;
+import com.codingnagger.days.Day14;
 import com.codingnagger.days.Day9;
 import com.codingnagger.utils.InputLoader;
 
@@ -18,9 +19,9 @@ public class App {
     public static void main(String[] args) throws IOException {
         System.out.println("Advent of Code 2021");
 
-        List<String> input = InputLoader.Load("day13.txt");
+        List<String> input = InputLoader.Load("day14.txt");
 
-        Day day = new Day13();
+        Day day = new Day14();
 
         System.out.println("Part 1:");
         System.out.println(day.partOne(input));

src/main/java/com/codingnagger/days/Day14.java

@@ -1,15 +1,97 @@
 package com.codingnagger.days;
 
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 public class Day14 implements Day {
     @Override
     public String partOne(List<String> input) {
-        return null;
+        return polymerize(input, 10);
     }
 
     @Override
     public String partTwo(List<String> input) {
-        return null;
+        return polymerize(input, 40);
+    }
+
+    private String polymerize(List<String> input, int rounds) {
+        LinkedHashMap<String, BigInteger> bucket = createBucket(input.get(0));
+        Map<String, Character> insertionPairs = input.stream().skip(2).map(i -> i.split(" -> ")).collect(Collectors.toUnmodifiableMap(i -> i[0], i -> i[1].charAt(0)));
+
+        for (int i = 0; i < rounds; i++) {
+            bucket = polymerize(bucket, insertionPairs);
+        }
+
+        Map<Character, BigInteger> countCharacters = countCharacters(bucket);
+
+        return String.valueOf(countCharacters.values().stream().max(Comparator.naturalOrder()).get().subtract(countCharacters.values().stream().min(Comparator.naturalOrder()).get()));
+    }
+
+    private LinkedHashMap<String, BigInteger> createBucket(String polymerTemplate) {
+        LinkedHashMap<String, BigInteger> bucket = new LinkedHashMap<>();
+
+        List<Character> template = Arrays.stream(polymerTemplate.split("")).map(s -> s.charAt(0)).collect(Collectors.toList());
+
+        for (int i = 0; i < template.size()-1; i++) {
+            String pair = new String(new char[]{template.get(i), template.get(i+1)});
+            if (bucket.containsKey(pair)) {
+                bucket.put(pair, bucket.get(pair).add(BigInteger.ONE));
+            } else {
+                bucket.put(pair, BigInteger.ONE);
+            }
+        }
+
+        return bucket;
+    }
+
+    private Map<Character, BigInteger> countCharacters(LinkedHashMap<String, BigInteger> polymerTemplate) {
+        Map<Character, BigInteger> characterCounts = new HashMap<>();
+
+        for (Map.Entry<String, BigInteger> pair : polymerTemplate.entrySet()) {
+            char[] chars = pair.getKey().toCharArray();
+
+            if (characterCounts.isEmpty()) {
+                characterCounts.put(chars[0], polymerTemplate.get(pair.getKey()));
+            }
+
+            if (!characterCounts.containsKey(chars[1])) {
+                characterCounts.put(chars[1], polymerTemplate.get(pair.getKey()));
+            } else {
+                characterCounts.put(chars[1], characterCounts.get(chars[1]).add(polymerTemplate.get(pair.getKey())));
+            }
+        }
+
+        return characterCounts;
+    }
+
+    private LinkedHashMap<String, BigInteger> polymerize(LinkedHashMap<String, BigInteger> bucket, Map<String, Character> insertionPairs) {
+        LinkedHashMap<String, BigInteger> newBucket = new LinkedHashMap<>();
+
+        for (String key : bucket.keySet()) {
+            char c = insertionPairs.get(key);
+            String firstNewPair = new String(new char[]{key.charAt(0), c});
+            String secondNewPair = new String(new char[]{c, key.charAt(1)});
+
+            if (newBucket.containsKey(firstNewPair)) {
+                newBucket.put(firstNewPair, newBucket.get(firstNewPair).add(bucket.get(key)));
+            } else {
+                newBucket.put(firstNewPair, bucket.get(key));
+            }
+
+            if (newBucket.containsKey(secondNewPair)) {
+                newBucket.put(secondNewPair, newBucket.get(secondNewPair).add(bucket.get(key)));
+            } else {
+                newBucket.put(secondNewPair, bucket.get(key));
+            }
+        }
+
+        return newBucket;
     }
 }

src/main/resources/day14.txt

@@ -0,0 +1,102 @@
+SFBBNKKOHHHPFOFFSPFV
+
+HB -> C
+KO -> S
+KK -> N
+PF -> F
+VB -> F
+KC -> S
+BP -> H
+SS -> H
+BS -> B
+PB -> O
+VH -> C
+BK -> S
+BO -> F
+HN -> V
+NN -> K
+PV -> C
+NH -> P
+KP -> N
+NB -> V
+NF -> V
+PP -> O
+PN -> B
+VN -> K
+SC -> O
+NS -> N
+SV -> B
+BV -> P
+FV -> F
+OK -> H
+HF -> F
+CV -> K
+KB -> C
+OB -> B
+NO -> V
+OF -> B
+HP -> C
+BB -> F
+FB -> H
+OC -> K
+NV -> H
+OV -> S
+OP -> N
+SP -> N
+FK -> F
+VV -> B
+VK -> H
+OS -> F
+CO -> F
+CH -> V
+HV -> V
+FN -> B
+CS -> F
+PS -> F
+HS -> F
+VO -> K
+NP -> F
+FP -> B
+KF -> P
+CC -> N
+BF -> S
+VP -> F
+HO -> H
+FC -> F
+BH -> K
+NK -> S
+BN -> V
+SH -> K
+CP -> B
+VS -> K
+ON -> S
+FS -> P
+HK -> F
+PC -> O
+KN -> H
+CK -> N
+HH -> N
+CN -> S
+BC -> K
+PH -> N
+OO -> B
+FO -> O
+SK -> B
+FF -> V
+VC -> N
+SF -> N
+KH -> V
+SO -> F
+KS -> H
+SB -> K
+VF -> V
+PK -> O
+OH -> N
+HC -> F
+PO -> O
+NC -> F
+FH -> V
+KV -> V
+CB -> C
+CF -> O
+SN -> H

src/test/java/com/codingnagger/days/Day14Test.java

@@ -15,13 +15,13 @@ public class Day14Test {
     public void partOne_shoudlYieldCorrectResult() {
         String result = DAY.partOne(INPUT);
 
-        assertThat(result).isEqualTo(null);
+        assertThat(result).isEqualTo("1588");
     }
 
     @Test
     public void partTwo_shoudlYieldCorrectResult() {
         String result = DAY.partTwo(INPUT);
 
-        assertThat(result).isEqualTo(null);
+        assertThat(result).isEqualTo("2188189693529");
     }
 }

src/test/resources/day14.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