✨ Days 23 and 24 completed

monicatvera · monicatvera · commit 5641bb41d20c · 2022-12-25T17:47:05.000Z
diff --git a/2022/challenge-23/README.md b/2022/challenge-23/README.md
@@ -0,0 +1,44 @@
+# Instructions
+
+We are testing a new CPU for the Santa Claus' sleigh. But we still have to program the software that will run on it.
+
+The CPU has available 8 registers, which are named V00..V07. At the start of the program, all the registers contain 0. The CPU supports the following instructions:
+
+MOV Vxx,Vyy: copies the value from register Vxx to register Vyy; MOV n,Vxx: assign the numeric constant n to register Vxx (overwrite if already has a value); ADD Vxx,Vyy: calculates (Vxx + Ryy) and stores the result in Vxx; DEC Vxx: decrements Vxx value by 1. INC Vxx: increments Vxx value by 1. JMP i: jumps to instruction number i if V00 is different to 0. i is guaranteed to be a valid instruction number and 0 would be the first command.
+
+As the CPU is 8-bit, the number it could represent goes from 0 to 255. If you increment the number 255 causes overflow and results in 0. And if you decrement 0, it results in 255. Keep in mind then that number 280 is the same as 24 (280 - 256 = 24).
+
+After the last instruction has been executed, you should return an array with the result for every register. From V00 to V07. Examples:
+
+```javascript
+executeCommands([
+  'MOV 5,V00', // V00 is 5
+  'MOV 10,V01', // V01 is 10
+  'DEC V00', // V00 is now 4
+  'ADD V00,V01', // V00 = V00 + V01 = 14
+]);
+
+// Output: [14, 10, 0, 0, 0, 0, 0]
+
+executeCommands([
+  'MOV 255,V00', // V00 is 255
+  'INC V00', // V00 is 256, overflows to 0
+  'DEC V01', // V01 is -1, overflows to 255
+  'DEC V01', // V01 is 254
+]);
+// Output: [0, 254, 0, 0, 0, 0, 0]
+
+executeCommands([
+  'MOV 10,V00', // V00 is 10
+  'DEC V00', // decrement V00 by 1  <---┐
+  'INC V01', // increment V01 by 1      |
+  'JMP 1', // loop until V00 is 0 ----┘
+  'INC V06', // increment V06 by 1
+]);
+
+// Output: [ 0, 10, 0, 0, 0, 0, 1, 0 ]
+```
+
+All the commands provided are already validated and guaranteed to be correct.
+
+Based on SpaceX technical interview from CodeSignal
diff --git a/2022/challenge-23/solution.js b/2022/challenge-23/solution.js
@@ -0,0 +1,83 @@
+const solve = (commands) => {
+  const cpu = {
+    V00: 0,
+    V01: 0,
+    V02: 0,
+    V03: 0,
+    V04: 0,
+    V05: 0,
+    V06: 0,
+    V07: 0,
+  };
+
+  const checkOverflow = (result) => {
+    result > 255 ? (result = result - 256) : result;
+    result < 0 ? (result = 256 + result) : result;
+    return result;
+  };
+
+  const compile = (command, line) => {
+    let from, target, result;
+    switch (command) {
+      case 'MOV':
+        [from, target] = line.slice(4).split(',');
+        cpu[from]
+          ? (cpu[target] = cpu[from])
+          : (cpu[target] = Number(from));
+        break;
+      case 'ADD':
+        [target, from] = line.slice(4).split(',');
+        result = checkOverflow(cpu[from] + cpu[target]);
+        cpu[target] = cpu[from] + cpu[target];
+        break;
+      case 'DEC':
+        target = line.split(' ')[1];
+        result = checkOverflow(cpu[target] - 1);
+        cpu[target] = result;
+        break;
+      case 'INC':
+        target = line.split(' ')[1];
+        result = checkOverflow(cpu[target] + 1);
+        cpu[target] = result;
+        break;
+      case 'JMP':
+        break;
+    }
+  };
+
+  for (let i = 0; i < commands.length; i++) {
+    const current = commands[i];
+    const order = current.slice(0, 3);
+    compile(order, current);
+  }
+
+  return Object.values(cpu);
+};
+
+/*
+solve([
+  'MOV 5,V00', // V00 is 5
+  'MOV 10,V01', // V01 is 10
+  'DEC V00', // V00 is now 4
+  'ADD V00,V01', // V00 = V00 + V01 = 14
+]);
+*/
+
+/*
+solve([
+  'MOV 255,V00', // V00 is 255
+  'INC V00', // V00 is 256, overflows to 0
+  'DEC V01', // V01 is -1, overflows to 255
+  'DEC V01', // V01 is 254
+]);
+*/
+
+solve([
+  'MOV 10,V00', // V00 is 10
+  'DEC V00', // decrement V00 by 1  <---┐
+  'INC V01', // increment V01 by 1      |
+  'JMP 1', // loop until V00 is 0 ----┘
+  'INC V06', // increment V06 by 1
+]);
+
+module.exports = { solve };
diff --git a/2022/challenge-23/solution.spec.js b/2022/challenge-23/solution.spec.js
@@ -0,0 +1,11 @@
+const { solve } = require('./solution');
+
+test('Test challenge #', () => {
+  expect(
+    solve(['MOV 5,V00', 'MOV 10,V01', 'DEC V00', 'ADD V00,V01']),
+  ).toEqual([14, 10, 0, 0, 0, 0, 0, 0]);
+
+  expect(solve(['MOV 255,V00', 'INC V00', 'DEC V01', 'DEC V01'])).toEqual([
+    0, 254, 0, 0, 0, 0, 0, 0,
+  ]);
+});
diff --git a/2022/challenge-24/README.md b/2022/challenge-24/README.md
@@ -0,0 +1,40 @@
+# Instructions
+
+It's the day! Today we're going to deliver gifts… but the warehouses are a maze and the elves are lost.
+
+Indielfo Jones wants to write a program that, upon receiving a matrix, knows if it can quickly exit the maze from its entrance to the exit.
+
+Mazes have the following positions:
+
+`W`: It's a wall, you can't pass through there. `S`: Entry point to the warehouse. `E`: Exit point from the warehouse. : White spaces are where you can pass through.
+
+Valid movements are from one position up, down, left, or right. You can't move diagonally.
+
+```javascript
+canExit([
+  [' ', ' ', 'W', ' ', 'S'],
+  [' ', ' ', ' ', ' ', ' '],
+  [' ', ' ', ' ', 'W', ' '],
+  ['W', 'W', ' ', 'W', 'W'],
+  [' ', ' ', ' ', ' ', 'E'],
+]); // -> true
+
+// You can exit because you start at [0, 4]
+// and there's a path to the exit which is [4, 4]
+
+canExit([
+  [' ', ' ', 'W', 'W', 'S'],
+  [' ', ' ', ' ', 'W', ' '],
+  [' ', ' ', ' ', 'W', ' '],
+  ['W', 'W', ' ', 'W', 'W'],
+  [' ', ' ', ' ', ' ', 'E'],
+]); // -> false
+```
+
+// There's no way to get from [0, 4] to [4, 4]
+
+Remember that:
+
+- You only have to return whether you can exit the maze with a boolean.
+- You can't jump over W walls.
+- You can't exit the limits of the matrix, you always have to follow an internal path.
diff --git a/2022/challenge-24/solution.js b/2022/challenge-24/solution.js
@@ -0,0 +1,48 @@
+const solve = (maze) => {
+  const used = [];
+  let start = [];
+
+  for (let i = 0; i < maze.length; i++) {
+    for (let j = 0; j < maze[0].length; j++) {
+      if (maze[i][j] === 'S') {
+        start = [i, j];
+        break;
+      }
+    }
+  }
+
+  const checkMovement = (coords) => {
+    return (
+      maze[coords[0]] &&
+      maze[coords[0]][coords[1]] &&
+      maze[coords[0]][coords[1]] !== 'W'
+    );
+  };
+
+  const scape = (maze, currentPositon) => {
+    used.push(currentPositon.join(','));
+
+    const [currentRow, currentColumn] = currentPositon;
+    const up = [currentRow, currentColumn + 1];
+    const down = [currentRow, currentColumn - 1];
+    const left = [currentRow - 1, currentColumn];
+    const right = [currentRow + 1, currentColumn];
+    const possibleMovements = [];
+
+    if (checkMovement(up)) possibleMovements.push(up);
+    if (checkMovement(down)) possibleMovements.push(down);
+    if (checkMovement(left)) possibleMovements.push(left);
+    if (checkMovement(right)) possibleMovements.push(right);
+
+    return possibleMovements.some(
+      (movement) =>
+        maze[movement[0]][movement[1]] === 'E' ||
+        (!used.includes(movement.join(',')) && scape(maze, movement)),
+    );
+  };
+
+  const possible = scape(maze, start);
+  return possible;
+};
+
+module.exports = { solve };
diff --git a/2022/challenge-24/solution.spec.js b/2022/challenge-24/solution.spec.js
@@ -0,0 +1,63 @@
+const { solve } = require('./solution');
+
+test('Test challenge #', () => {
+  expect(
+    solve([
+      [' ', ' ', 'W', ' ', 'S'],
+      [' ', ' ', ' ', ' ', ' '],
+      [' ', ' ', ' ', 'W', ' '],
+      ['W', 'W', ' ', 'W', 'W'],
+      [' ', ' ', ' ', ' ', 'E'],
+    ]),
+  ).toBe(true);
+
+  expect(
+    solve([
+      [' ', ' ', 'W', 'W', 'S'],
+      [' ', ' ', ' ', 'W', ' '],
+      [' ', ' ', ' ', 'W', ' '],
+      ['W', 'W', ' ', 'W', 'W'],
+      [' ', ' ', ' ', ' ', 'E'],
+    ]),
+  ).toBe(false);
+
+  expect(
+    solve([
+      [' ', ' ', 'W', 'W', 'S'],
+      [' ', ' ', ' ', 'W', ' '],
+      [' ', ' ', ' ', 'W', ' '],
+      ['W', 'W', ' ', ' ', 'W'],
+      [' ', ' ', ' ', ' ', 'E'],
+    ]),
+  ).toBe(false);
+
+  expect(solve([['E', ' ', ' ', ' ', 'S']])).toBe(true);
+
+  expect(solve([['E', ' ', 'W', ' ', 'S']])).toBe(false);
+
+  expect(solve([['E', ' ', 'W', ' ', 'S']])).toBe(false);
+
+  expect(
+    solve([
+      ['E', ' ', 'W', ' ', 'S'],
+      [' ', ' ', ' ', ' ', ' '],
+      ['W', 'W', 'W', 'W', 'W'],
+    ]),
+  ).toBe(true);
+
+  expect(
+    solve([
+      ['E', ' ', 'W', ' ', 'S'],
+      [' ', ' ', 'W', ' ', ' '],
+      ['W', 'W', 'W', 'W', 'W'],
+    ]),
+  ).toBe(false);
+
+  expect(
+    solve([
+      ['E', 'S', 'W', 'W', 'W'],
+      ['W', 'W', 'W', 'W', 'W'],
+      ['W', 'W', 'W', 'W', 'W'],
+    ]),
+  ).toBe(true);
+});
