finished day 12 2018

puzzles/2018/day12/README.md

@@ -0,0 +1,10 @@
+# Advent of Code 2018 - Day 12: [Subterranean Sustainability](https://adventofcode.com/2018/day/12)
+
+## [Write Up](https://codingap.github.io/advent-of-code/writeups/2018/day12)
+
+## Results
+
+|                  | **Part 1** | **Part 2** |
+| :--------------: | :--------: | :--------: |
+|   **Results**    | 3472 | 2600000000919 |
+| **Time (in ms)** | 1.14 | 14.05 |

puzzles/2018/day12/solution.ts

@@ -27,39 +27,80 @@ const part1 = (input: string) => {
         return obj;
     }, {});
 
-    for (let gen = 0; gen < 1; gen++) {
-        const min = Math.min(...Object.keys(state).map(num => parseInt(num)));
-        const max = Math.max(...Object.keys(state).map(num => parseInt(num)));
+    // go for 20 generations
+    for (let gen = 0; gen < 20; gen++) {
+        // find first and last plant
+        const min = Math.min(...Object.keys(state).filter(key => state[parseInt(key)]).map(num => parseInt(num)));
+        const max = Math.max(...Object.keys(state).filter(key => state[parseInt(key)]).map(num => parseInt(num)));
         const newState: { [key: number]: boolean } = {};
 
-        let debug = '';
-        for (let i = min; i <= max; i++) {
-            // let current = '';
-            // for (let j = -2; j <= 2; j++) {
-            //     if (state[i + j] === undefined) {
-            //         state[i + j] = false;
-            //         newState[i + j] = false;
-            //     }
-            //     current += state[i + j] ? '.' : '#';
-            // }
-
-            // newState[i] = rules[current] === '#';
-            // debug += rules[current] ? '#' : '.';
-            debug += state[i] ? '#' : '.';
+        // go through all plants and find new plants from them
+        for (let i = min - 4; i <= max + 4; i++) {
+            let current = '';
+            for (let j = -2; j <= 2; j++) {
+                if (state[i + j] === undefined) state[i + j] = false;
+                current += state[i + j] ? '#' : '.';
+            }
+
+            newState[i] = rules[current] === '#';
         }
 
         state = newState;
-        console.log(debug);
     }
 
-    return Object.values(state).map((plant, i) => plant ? i : 0).reduce((sum, num) => sum + num, 0);
+    return Object.entries(state).map(([i, plant]) => plant ? parseInt(i) : 0).reduce((sum, num) => sum + num, 0);
 };
 
 /**
  * the code of part 2 of the puzzle
  */
 const part2 = (input: string) => {
-    return 0;
+    const [initial, transforms] = input.trim().split('\n\n');
+
+    // intitialize state
+    let state: { [key: number]: boolean } = {};
+    initial.split(': ')[1].split('').forEach((char, i) => {
+        state[i] = char === '#';
+    });
+
+    // parse rules
+    const rules = transforms.split('\n').reduce<{ [key: string]: string }>((obj, line) => {
+        const [left, right] = line.split(' => ');
+        obj[left] = right;
+        return obj;
+    }, {});
+
+    // a pattern emerges after a certain time where the plants gain a specific amount each time
+    // find the amount and extrapolate
+    const differences: { [key: number]: number } = {};
+    let current = 0, generation = 0;
+    while (true) {
+        // find first and last plant
+        const min = Math.min(...Object.keys(state).filter(key => state[parseInt(key)]).map(num => parseInt(num)));
+        const max = Math.max(...Object.keys(state).filter(key => state[parseInt(key)]).map(num => parseInt(num)));
+        const newState: { [key: number]: boolean } = {};
+
+        // go through all plants and find new plants from them
+        for (let i = min - 4; i <= max + 4; i++) {
+            let current = '';
+            for (let j = -2; j <= 2; j++) {
+                if (state[i + j] === undefined) state[i + j] = false;
+                current += state[i + j] ? '#' : '.';
+            }
+
+            newState[i] = rules[current] === '#';
+        }
+
+        const newValue = Object.entries(state).map(([i, plant]) => plant ? parseInt(i) : 0).reduce((sum, num) => sum + num, 0);
+        const difference = newValue - current;
+        differences[difference] = (differences[difference] || 0) + 1;
+
+        if (differences[difference] >= 100) return newValue + (50000000000 - generation) * difference;
+
+        generation++;
+        current = newValue;
+        state = newState;
+    }
 };
 
 export { part1, part2 };