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 exactly the in the 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 disks' 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 and add them to the top 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 following tower: `[3, 4]`. It would violate the rules
+
+Your task is to create a function, `hanoi`, that when given an integer `n` will perform the required operations to transport all the numbers from the `first tower`
+onto the `third tower`.
+
+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);
+    expect(result).toEqual([
+      [[1], [], []],
+      [[], [], [1]],
+    ]);
+    expect(result.length).toBe(2);
+  });
+
+  test("hanoi(2) should solve the puzzle in 3 moves", () => {
+    const result = hanoi(2);
+    expect(result).toEqual([
+      [[2, 1], [], []],
+      [[2], [1], []],
+      [[], [1], [2]],
+      [[], [], [2, 1]],
+    ]);
+    expect(result.length).toBe(4);
+  });
+
+  test("hanoi(3) should solve the puzzle in 7 moves", () => {
+    const result = hanoi(3);
+    expect(result).toEqual([
+      [[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.length).toBe(8);
+  });
+
+  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);
+  });
+});