Added day15 part 2

Author: hankolsen

day15/description.txt

@@ -36,4 +36,51 @@ Here, you can see that the lowest (here, rightmost) 16 bits of the third value m
 
 To get a significant sample, the judge would like to consider 40 million pairs. (In the example above, the judge would eventually find a total of 588 pairs that match in their lowest 16 bits.)
 
-After 40 million pairs, what is the judge's final count?
+After 40 million pairs, what is the judge's final count?
+
+--- Part Two ---
+
+In the interest of trying to align a little better, the generators get more picky about the numbers they actually give to the judge.
+
+They still generate values in the same way, but now they only hand a value to the judge when it meets their criteria:
+
+Generator A looks for values that are multiples of 4.
+Generator B looks for values that are multiples of 8.
+Each generator functions completely independently: they both go through values entirely on their own, only occasionally handing an acceptable value to the judge, and otherwise working through the same sequence of values as before until they find one.
+
+The judge still waits for each generator to provide it with a value before comparing them (using the same comparison method as before). It keeps track of the order it receives values; the first values from each generator are compared, then the second values from each generator, then the third values, and so on.
+
+Using the example starting values given above, the generators now produce the following first five values each:
+
+--Gen. A--  --Gen. B--
+1352636452  1233683848
+1992081072   862516352
+ 530830436  1159784568
+1980017072  1616057672
+ 740335192   412269392
+These values have the following corresponding binary values:
+
+01010000100111111001100000100100
+01001001100010001000010110001000
+
+01110110101111001011111010110000
+00110011011010001111010010000000
+
+00011111101000111101010001100100
+01000101001000001110100001111000
+
+01110110000001001010100110110000
+01100000010100110001010101001000
+
+00101100001000001001111001011000
+00011000100100101011101101010000
+Unfortunately, even though this change makes more bits similar on average, none of these values' lowest 16 bits match. Now, it's not until the 1056th pair that the judge finds the first match:
+
+--Gen. A--  --Gen. B--
+1023762912   896885216
+
+00111101000001010110000111100000
+00110101011101010110000111100000
+This change makes the generators much slower, and the judge is getting impatient; it is now only willing to consider 5 million pairs. (Using the values from the example above, after five million pairs, the judge would eventually find a total of 309 pairs that match in their lowest 16 bits.)
+
+After 5 million pairs, but using this new generator logic, what is the judge's final count?

day15/index.js

@@ -5,11 +5,11 @@ getInput()
   .then((data) => {
 
     const factorA = 16807;
+    const multipleA = 4;
     const factorB = 48271;
+    const multipleB = 8;
     const divisor = 2147483647;
-    let length = 40000000;
-    const pairs = {};
-    let [[, nextValueA], [, nextValueB]] = data.map(row => row.split('with '));
+    const [[, startValueA], [, startValueB]] = data.map(row => row.split('with '));
 
     const toBinary = value => value.toString(2).padStart(32, '0').slice(16, 32);
 
@@ -19,6 +19,11 @@ getInput()
     ];
 
     const part1 = () => {
+      const pairs = {};
+      let length = 40000000;
+      let nextValueA = startValueA;
+      let nextValueB = startValueB;
+
       while (length) {
         [nextValueA, nextValueB] = generate(nextValueA, nextValueB);
 
@@ -35,8 +40,32 @@ getInput()
     };
 
     const part2 = () => {
+      const pairs = {};
+      const comparablesA = [];
+      const comparablesB = [];
+      let nextValueA = startValueA;
+      let nextValueB = startValueB;
 
+      while (comparablesB.length <= 5000000) {
+        [nextValueA, nextValueB] = generate(nextValueA, nextValueB);
+        if (nextValueA % multipleA === 0) {
+          comparablesA.push(nextValueA);
+        }
+        if (nextValueB % multipleB === 0) {
+          comparablesB.push(nextValueB);
+        }
+      }
 
+      comparablesB.forEach((valueB, index) => {
+        const binA = toBinary(comparablesA[index]);
+        const binB = toBinary(valueB);
+        if (binA === binB) {
+          pairs[binA] = pairs[binA] ? pairs[binA] += 1 : 1;
+        }
+      });
+
+      const numberOfPairs = Object.values(pairs).reduce((sum, value) => sum + value, 0);
+      console.log(numberOfPairs);
     };
 
     part1();