moving to let

Author: shahata

src/2015/day03.js

@@ -2,7 +2,7 @@ function step(x, y) {
   return pos => ({ x: pos.x + x, y: pos.y + y });
 }
 
-let steps = {
+const steps = {
   "<": step(-1, 0),
   ">": step(1, 0),
   "^": step(0, -1),

src/2015/day07.js

@@ -1,4 +1,4 @@
-let ops = {
+const ops = {
   AND: (p1, p2) => (2 ** 16 + (p1 & p2)) % 2 ** 16,
   OR: (p1, p2) => (2 ** 16 + (p1 | p2)) % 2 ** 16,
   NOT: (p1, p2) => (2 ** 16 + ~p2) % 2 ** 16,

src/2016/day08.js

@@ -14,7 +14,7 @@ function rect(state, x, y) {
 }
 
 function rotateRow(state, x, y) {
-  const moved = state[y].splice(-x, x);
+  let moved = state[y].splice(-x, x);
   state[y] = moved.concat(state[y]);
   return state;
 }
@@ -33,32 +33,32 @@ function flatten(screen) {
 
 function parseCommand(command) {
   if (command.startsWith("rect")) {
-    const [, x, y] = command.match(/^rect (\d+)x(\d+)$/);
+    let [, x, y] = command.match(/^rect (\d+)x(\d+)$/);
     return state => rect(state, +x, +y);
   } else if (command.startsWith("rotate row")) {
-    const [, y, x] = command.match(/^rotate row y=(\d+) by (\d+)$/);
+    let [, y, x] = command.match(/^rotate row y=(\d+) by (\d+)$/);
     return state => rotateRow(state, +x, +y);
   } else if (command.startsWith("rotate column")) {
-    const [, x, y] = command.match(/^rotate column x=(\d+) by (\d+)$/);
+    let [, x, y] = command.match(/^rotate column x=(\d+) by (\d+)$/);
     return state => rotateColumn(state, +x, +y);
   }
 }
 
 function solve(input, width, height) {
-  const screen = init(width, height);
+  let screen = init(width, height);
   return input
     .split("\n")
     .map(parseCommand)
     .reduce((state, fn) => fn(state), screen);
 }
 
 export function part1(input, width = 50, height = 6) {
-  const final = solve(input, width, height);
+  let final = solve(input, width, height);
   return flatten(final).filter(x => x).length;
 }
 
 export function part2(input, width = 50, height = 6) {
-  const final = solve(input, width, height);
+  let final = solve(input, width, height);
   return ocr(
     final.map(row => `${row.map(x => (x ? "#" : ".")).join("")}`).join("\n"),
   );

src/2016/day09.js

@@ -1,11 +1,11 @@
 function decodeLength(s, v2) {
-  const [, prefix, lengthStr, timesStr, rest] = s.match(
+  let [, prefix, lengthStr, timesStr, rest] = s.match(
     /^([^(]*)(?:\((\d+)x(\d+)\))?(.*)$/,
   );
   if (lengthStr) {
-    const length = +lengthStr;
-    const times = +timesStr;
-    const repeat =
+    let length = +lengthStr;
+    let times = +timesStr;
+    let repeat =
       times * (v2 ? decodeLength(rest.slice(0, length), v2) : length);
     return prefix.length + repeat + decodeLength(rest.slice(length), v2);
   } else {

src/2016/day10.js

@@ -17,10 +17,10 @@ export function day(input, low = 17, high = 61) {
   }
 
   function parse(line) {
-    const match = line.match(
+    let match = line.match(
       /^bot (\d+) gives low to (bot|output) (\d+) and high to (bot|output) (\d+)$/,
     );
-    const [, bot, lowDest, lowIndex, highDest, highIndex] = match;
+    let [, bot, lowDest, lowIndex, highDest, highIndex] = match;
     return state => {
       if (state.bots[bot] && state.bots[bot].length === 2) {
         state = assign(state, `${lowDest}s`, +lowIndex, state.bots[bot][0]);
@@ -34,20 +34,20 @@ export function day(input, low = 17, high = 61) {
   function init(lines) {
     return lines.reduce(
       (state, line) => {
-        const [, value, bot] = line.match(/^value (\d+) goes to bot (\d+)$/);
+        let [, value, bot] = line.match(/^value (\d+) goes to bot (\d+)$/);
         return assign(state, "bots", +bot, +value);
       },
       { bots: {}, outputs: {} },
     );
   }
 
-  const lines = input.split("\n");
-  const state = init(lines.filter(x => x.startsWith("value")));
-  const instructions = lines.filter(x => x.startsWith("bot")).map(parse);
+  let lines = input.split("\n");
+  let state = init(lines.filter(x => x.startsWith("value")));
+  let instructions = lines.filter(x => x.startsWith("bot")).map(parse);
   while (instructions.some(update => update(state))) {
     /**/
   }
 
-  const part2 = state.outputs[0] * state.outputs[1] * state.outputs[2];
+  let part2 = state.outputs[0] * state.outputs[1] * state.outputs[2];
   return { part1, part2 };
 }

src/2016/day11.js

@@ -2,11 +2,11 @@ import { combinations } from "combinatorial-generators";
 
 function parse(input) {
   let pieces = [];
-  const state = {
+  let state = {
     elevator: 0,
     floors: input.split("\n").map(x => {
-      const generators = x.match(/[^\s]+(?=\s*generator)/g) || [];
-      const microchips = x.match(/[^\s]+(?=-compatible microchip)/g) || [];
+      let generators = x.match(/[^\s]+(?=\s*generator)/g) || [];
+      let microchips = x.match(/[^\s]+(?=-compatible microchip)/g) || [];
       pieces = pieces.concat(generators).concat(microchips);
       return { generators, microchips };
     }),
@@ -59,8 +59,8 @@ function legal(state) {
 }
 
 function getMoves(state, diff) {
-  const src = state.floors[state.elevator];
-  const pairs = src.generators.filter(x => src.microchips.includes(x));
+  let src = state.floors[state.elevator];
+  let pairs = src.generators.filter(x => src.microchips.includes(x));
   return pairs
     .map(x => ({ generators: [x], microchips: [x] }))
     .concat(
@@ -91,7 +91,7 @@ function getNeighbors(state) {
 }
 
 function done(state) {
-  const { generators, microchips } = state.floors.at(-1);
+  let { generators, microchips } = state.floors.at(-1);
   return state.pieces.length === generators.length + microchips.length;
 }
 
@@ -136,15 +136,13 @@ function stringify({ elevator, floors }) {
 }
 
 function solve(state) {
-  const queue = [{ distance: 0, state, path: [state] }];
-  const visited = new Set().add(stringify(state));
+  let queue = [{ distance: 0, state, path: [state] }];
+  let visited = new Set().add(stringify(state));
   while (queue.length > 0) {
-    const { state, distance, path } = queue.shift();
-    const neighbors = getNeighbors(state).filter(
-      x => !visited.has(stringify(x)),
-    );
-    for (const x of neighbors) {
-      const json = stringify(x);
+    let { state, distance, path } = queue.shift();
+    let neighbors = getNeighbors(state).filter(x => !visited.has(stringify(x)));
+    for (let x of neighbors) {
+      let json = stringify(x);
       if (done(x)) {
         // path.concat(x).forEach(state => console.log(print(state), '\n----------------------'));
         return distance + 1;
@@ -161,7 +159,7 @@ export function part1(input) {
 }
 
 export function part2(input) {
-  const state = parse(input);
+  let state = parse(input);
   state.floors[0].generators.push("elerium", "dilithium");
   state.floors[0].microchips.push("elerium", "dilithium");
   state.pieces.push("elerium", "dilithium", "elerium", "dilithium");

src/2024/day06.js

@@ -1,4 +1,4 @@
-let step = {
+const step = {
   up: { x: 0, y: -1, turn: "right" },
   down: { x: 0, y: 1, turn: "left" },
   left: { x: -1, y: 0, turn: "up" },