Day 14. Part 2

Hank · Hank · commit 83c9eed8e612 · 2020-12-14T16:47:49.000+01:00
diff --git a/2020/14/solve.js b/2020/14/solve.js
@@ -18,4 +18,4 @@ const solve2 = () => {
 };
 
 solve1();
-//solve2();
+solve2();
diff --git a/2020/14/test.js b/2020/14/test.js
@@ -1,4 +1,4 @@
-const { util1, util2, write } = require('./utils');
+const { util1, util2, write, getAdresses } = require('./utils');
 
 describe('it should solve part 1 and part 2', () => {
   const input1 = [
@@ -8,14 +8,24 @@ describe('it should solve part 1 and part 2', () => {
     'mem[8] = 0',
   ];
 
+  const input2 = [
+    'mask = 000000000000000000000000000000X1001X',
+    'mem[42] = 100',
+    'mask = 00000000000000000000000000000000X0XX',
+    'mem[26] = 1',
+  ];
+
   test('it should solve example 1', () => {
     expect(write(11, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X')).toEqual(73);
     expect(write(101, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X')).toEqual(101);
     expect(write(0, 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X')).toEqual(64);
     expect(util1(input1)).toEqual(165);
   });
 
-  /* test('it should solve example 2', () => {
-    expect(util2(input1)).toEqual(0);
-  }); */
+  test('it should solve example 2', () => {
+    expect(getAdresses(42, '000000000000000000000000000000X1001X')).toEqual([26, 27, 58, 59]);
+    expect(getAdresses(26, '00000000000000000000000000000000X0XX')).toEqual([16, 17, 18, 19, 24, 25, 26, 27]);
+
+    expect(util2(input2)).toEqual(208);
+  });
 });
diff --git a/2020/14/utils.js b/2020/14/utils.js
@@ -1,13 +1,67 @@
 /* eslint-disable no-bitwise */
 
+const intToBin = (int) => (int >>> 0).toString(2).padStart(36, 0);
+
 const bitwiseAnd = (value, mask) => {
-  const bin = (value >>> 0).toString(2).padStart(36, 0);
+  const bin = intToBin(value);
   const andMask = mask.replace(/X/g, '1');
-  return andMask.split('').map((bit, index) => bin[index] & bit).join('');
+  return andMask
+    .split('')
+    .map((bit, index) => bin[index] & bit)
+    .join('');
 };
 const bitwiseOr = (bin, mask) => {
   const orMask = mask.replace(/X/g, '0');
-  return orMask.split('').map((bit, index) => bin[index] | bit).join('');
+  return orMask
+    .split('')
+    .map((bit, index) => bin[index] | bit)
+    .join('');
+};
+
+const applyMaskToAdress = (address, mask) =>
+  intToBin(address)
+    .split('')
+    .map((bit, i) => {
+      if (mask[i] === '0') {
+        return bit;
+      }
+      if (mask[i] === '1') {
+        return 1;
+      }
+      return 'X';
+    })
+    .join('');
+
+const getNumberOfAddresses = (mask) =>
+  2 *
+  mask.split('').reduce((sum, bit) => {
+    if (bit === 'X') {
+      sum += 1;
+    }
+    return sum;
+  }, 0);
+
+const replaceX = (addressMask) => {
+  const index = addressMask.indexOf('X');
+  if (index === -1) {
+    return addressMask;
+  }
+  return [
+    replaceX(
+      `${addressMask.substring(0, index)}0${addressMask.substring(index + 1)}`,
+    ),
+    replaceX(
+      `${addressMask.substring(0, index)}1${addressMask.substring(index + 1)}`,
+    ),
+  ];
+};
+
+const getAdresses = (address, mask) => {
+  const addressMask = applyMaskToAdress(address, mask);
+
+  return replaceX(addressMask)
+    .flat(20)
+    .map((address) => parseInt(address, 2));
 };
 
 const write = (value, mask) => {
@@ -44,8 +98,24 @@ const util1 = (input) => {
 };
 
 const util2 = (input) => {
-  console.log(input);
-  return input;
+  const result = input.reduce(({ memory, currentMask }, row) => {
+    const [, mask] = row.match(/mask = ([X01]+)/) || [];
+    const [, address, value] = row.match(/mem\[(\d+)\] = (\d+)/) || [];
+    if (mask !== undefined) {
+      currentMask = mask;
+    }
+    if (address) {
+      const addresses = getAdresses(address, currentMask);
+      addresses.forEach((address) => {
+        memory[address] = value;
+      });
+    }
+    return { memory, currentMask };
+  }, { memory: {}, currentMask: '' });
+  return Object.values(result.memory).reduce((sum, value) => {
+    sum += Number(value);
+    return sum;
+  }, 0);
 };
 
-module.exports = { util1, util2, write };
+module.exports = { util1, util2, write, getAdresses };
