feat(hanoi): create exercise

20_hanoi/README.md

@@ -0,0 +1,39 @@
+# Exercise 20 - hanoi
+
+Good job, you have come a very long way. You should be proud of yourself for making it this far. At this point, you hopefully feel comfortable
+with recursion, and so, this **final recursive exercise** should give you a proper challenge and take your abilities to the *next* level.
+
+Tower of Hanoi is a classic challenge in which we have 3 towers. Tower 2 and tower 3 are empty.
+Tower 1 has `n` disks. The goal is to move all disks from tower 1 to tower 3 so that they are in the exact same order. For instance:
+
+```javascript
+[[3, 2, 1], [], []] 
+
+// ...
+
+[[], [], [3, 2, 1]]
+```
+
+The rules are as follows:
+- Each disk has a length. For abstraction purposes, we will imagine each disk as an integer with that disk's length.
+- We can only move 1 disk at a time between any of the towers
+- The towers are modelled as stacks. We can move disks from the top of one stack to the top of another stack with the `Array.prototype.pop` and `Array.prototype.push` methods.
+- **Disks can only be placed on top of disks that are smaller**. For instance, we cannot have the tower `[3, 4]` but `[4, 3]` is fine.
+
+Your task is to create a function, `hanoi(n)`, that when given the number of disks in the starting tower (`n`), will return an array. The first element of this array will be the towers' initial state. The last element will be the towers' final state. Every intermediary element will represent a step to get from the initial position to the final position.
+The function **must** return a solution in the minimum number of moves. i.e. there will be no duplicates in the array returned.
+
+For example, lets say we had given this function `3`, it will then output the Tower of Hanoi solution as a series of steps:
+
+```
+[
+[[3, 2, 1], [], []],
+[[3, 2], [], [1]],
+[[3], [2], [1]],
+[[3], [2, 1], []],
+[[], [2, 1], [3]],
+[[1], [2], [3]],
+[[1], [], [3, 2]],
+[[], [], [3, 2, 1]],
+]
+```

20_hanoi/hanoi.js

@@ -0,0 +1,6 @@
+const hanoi = function() {
+
+};
+
+// Do not edit below this line
+module.exports = hanoi;

20_hanoi/hanoi.spec.js

@@ -0,0 +1,15 @@
+const hanoi = require('./hanoi');
+
+describe('hanoi', () => {
+  test('First test description', () => {
+    // Replace this comment with any other necessary code, and update the expect line as necessary
+
+    expect(hanoi()).toBe('');
+  });
+
+  test.skip('Second test description', () => {
+    // Replace this comment with any other necessary code, and update the expect line as necessary
+
+    expect(hanoi()).toBe('');
+  });
+});

20_hanoi/solution/hanoi-solution.js

@@ -0,0 +1,29 @@
+const hanoi = function (
+  n,
+  fromTowerIndex = 0,
+  storageTowerIndex = 1,
+  toTowerIndex = 2,
+  towers = [
+    Array(n)
+      .fill() // Array function creates an array with "empty" slots which map does not iterate over
+      .map((_, i) => n - i),
+    [],
+    [],
+  ],
+  steps = [towers.map((tower) => [...tower])],
+) {
+  if (n === 0) return steps;
+
+  hanoi(n - 1, fromTowerIndex, toTowerIndex, storageTowerIndex, towers, steps);
+
+  towers[toTowerIndex].push(towers[fromTowerIndex].pop());
+
+  steps.push(towers.map((tower) => [...tower]));
+
+  hanoi(n - 1, storageTowerIndex, fromTowerIndex, toTowerIndex, towers, steps);
+
+  return steps;
+};
+
+// Do not edit below this line
+module.exports = hanoi;

20_hanoi/solution/hanoi-solution.spec.js

@@ -0,0 +1,61 @@
+const hanoi = require("./hanoi-solution");
+
+describe("hanoi", () => {
+  test("hanoi(1) should solve the puzzle in 1 move", () => {
+    const result = hanoi(1);
+    const expected = [
+      [[1], [], []],
+      [[], [], [1]],
+    ];
+    expect(result).toEqual(expected);
+  });
+
+  test("hanoi(2) should solve the puzzle in 3 moves", () => {
+    const result = hanoi(2);
+    const expected = [
+      [[2, 1], [], []],
+      [[2], [1], []],
+      [[], [1], [2]],
+      [[], [], [2, 1]],
+    ];
+    expect(result).toEqual(expected);
+  });
+
+  test("hanoi(3) should solve the puzzle in 7 moves", () => {
+    const result = hanoi(3);
+    const expected = [
+      [[3, 2, 1], [], []],
+      [[3, 2], [], [1]],
+      [[3], [2], [1]],
+      [[3], [2, 1], []],
+      [[], [2, 1], [3]],
+      [[1], [2], [3]],
+      [[1], [], [3, 2]],
+      [[], [], [3, 2, 1]],
+    ];
+    expect(result).toEqual(expected);
+  });
+
+  test("hanoi(4) should solve the puzzle in 15 moves", () => {
+    const result = hanoi(4);
+    const expected = [
+      [[4, 3, 2, 1], [], []],
+      [[4, 3, 2], [1], []],
+      [[4, 3], [1], [2]],
+      [[4, 3], [], [2, 1]],
+      [[4], [3], [2, 1]],
+      [[4, 1], [3], [2]],
+      [[4, 1], [3, 2], []],
+      [[4], [3, 2, 1], []],
+      [[], [3, 2, 1], [4]],
+      [[], [3, 2], [4, 1]],
+      [[2], [3], [4, 1]],
+      [[2, 1], [3], [4]],
+      [[2, 1], [], [4, 3]],
+      [[2], [1], [4, 3]],
+      [[], [1], [4, 3, 2]],
+      [[], [], [4, 3, 2, 1]],
+    ];
+    expect(result).toEqual(expected);
+  });
+});