Packet Scanners - Advent of Code - 20171213

ac20171213.js

let test_1 = `0: 3
1: 2
2: 4
4: 4
6: 5
8: 8
10: 6
12: 6
14: 6
16: 6
18: 8
20: 8
22: 12
24: 10
26: 9
28: 8
30: 8
32: 12
34: 12
36: 12
38: 12
40: 8
42: 12
44: 14
46: 14
48: 10
50: 12
52: 12
54: 14
56: 14
58: 14
62: 12
64: 14
66: 14
68: 14
70: 12
74: 14
76: 14
78: 14
80: 18
82: 17
84: 30
88: 14`;

let test_2 = `0: 3
1: 2
4: 4
6: 4`;

let fireWallScan_bad = function(firewall) {
  let maxDepth = firewall.reduce((acc, v, i) => {
    acc = acc < v ? v : acc;
    return acc;
  }, 0);

  return firewall.reduce((acc, v, i) => {
    let location = (i + 1) % (2 * v - 1);
    if (location == 0) {
      acc += i * v;
    }
    return acc;
  }, 0);
};

let updateSensorLocations = function(
  firewall,
  sensorLocation,
  sensorDirection
) {
  sensorDirection = sensorDirection.slice();
  sensorLocation = sensorLocation.slice().map((s, j) => {
    s += sensorDirection[j];
    if (s == firewall[j] || s == -1) {
      sensorDirection[j] *= -1;
      s += 2 * sensorDirection[j];
    }
    return s;
  });

  return [sensorLocation, sensorDirection];
};

let fireWallScan_1 = function(firewall, offset = 0) {
  let maxDepth = firewall.length - 1;
  let sensorLocation = firewall.map(v => 0);
  let sensorDirection = firewall.map(v => 1);
  let cost = 0;

  for (let i = 0; i < offset; i++) {
    [sensorLocation, sensorDirection] = updateSensorLocations(
      firewall,
      sensorLocation,
      sensorDirection
    );
  }

  for (let i = 0; i < firewall.length; i++) {
    let range = firewall[i];
    if (sensorLocation[i] == 0) {
      cost += i * range;
      cost = i == 0 ? 100000 : cost;
    }
    [sensorLocation, sensorDirection] = updateSensorLocations(
      firewall,
      sensorLocation,
      sensorDirection
    );
  }

  return cost;
};

let fireWallScan_2 = function(firewall) {
  return firewall.reduce((acc, v, i) => {
    if (i % ((v - 1) * 2) == 0) {
      acc += i * v;
    }
    return acc;
  }, 0);
};

let fireWallScan = fireWallScan_2;

// To much brute force. Recalculated the offset every time through the loop hurt throughput.
let findFireWallHole_bad = function(firewall) {
  let cost = -1;
  let offset = -1;

  while (cost !== 0) {
    offset += 2;
    cost = fireWallScan(firewall, offset);
  }

  return offset;
};

// help https://www.reddit.com/r/adventofcode/comments/7jgyrt/2017_day_13_solutions/dr6cos4/
let findFireWallHole_1 = function(firewall) {
  let offset = 0;
  let searching = true;

  let detected = function(v, i, arr) {
    return (i + offset) % ((v - 1) * 2) == 0 ? false : true;
  };

  while (searching) {
    searching = false;
    if (!firewall.every(detected)) {
      searching = true;
      offset++;
    }
  }

  return offset;
};

let findFireWallHole_2 = function(firewall) {
  let offset = -1;
  let detected = false;

  while (!detected) {
    offset++;
    detected = firewall.every(
      (v, i) => ((i + offset) % ((v - 1) * 2) == 0 ? false : true)
    );
  }

  return offset;
};

let findFireWallHole = findFireWallHole_2;

let test = test_1;

test = test
  .split('\n')
  .map(v => v.split(':').map(v => parseInt(v)))
  .reduce((acc, [depth, range], i) => {
    acc[depth] = range;
    return acc;
  }, []);

let result;
result = fireWallScan(test, 0);
console.log(result);

result = findFireWallHole(test);
console.log(result);