AoC day9 (#6)

* Start day9 puzzle

* Add dummy tests.

* Fix algorithm. Fix Tests. Implement base case.

* Add more failing tests.

* Implement partially combine function.

* Implement getPermutations function.

* Update algorithm.

* Add tests for getDistance

* Implement first 2 cases.

* Implement getDistance, fix tests

* Implement parseCityLine

* Solve demo sample

* Puzzle1, with error.

* Solve puzzle1

* Solve puzzle2 (there is no reason to create second file)

Author: lukasbicus

scripts/aoc2015/day9/input.txt

@@ -0,0 +1,28 @@
+Faerun to Norrath = 129
+Faerun to Tristram = 58
+Faerun to AlphaCentauri = 13
+Faerun to Arbre = 24
+Faerun to Snowdin = 60
+Faerun to Tambi = 71
+Faerun to Straylight = 67
+Norrath to Tristram = 142
+Norrath to AlphaCentauri = 15
+Norrath to Arbre = 135
+Norrath to Snowdin = 75
+Norrath to Tambi = 82
+Norrath to Straylight = 54
+Tristram to AlphaCentauri = 118
+Tristram to Arbre = 122
+Tristram to Snowdin = 103
+Tristram to Tambi = 49
+Tristram to Straylight = 97
+AlphaCentauri to Arbre = 116
+AlphaCentauri to Snowdin = 12
+AlphaCentauri to Tambi = 18
+AlphaCentauri to Straylight = 91
+Arbre to Snowdin = 129
+Arbre to Tambi = 53
+Arbre to Straylight = 40
+Snowdin to Tambi = 15
+Snowdin to Straylight = 99
+Tambi to Straylight = 70

scripts/aoc2015/day9/puzzle1.ts

@@ -0,0 +1,72 @@
+/**
+-- Day 9: All in a Single Night ---
+Every year, Santa manages to deliver all of his presents in a single night.
+
+This year, however, he has some new locations to visit;
+his elves have provided him the distances between every pair of locations.
+He can start and end at any two (different) locations he wants,
+but he must visit each location exactly once.
+What is the shortest distance he can travel to achieve this?
+
+  For example, given the following distances:
+
+London to Dublin = 464
+London to Belfast = 518
+Dublin to Belfast = 141
+The possible routes are therefore:
+
+Dublin -> London -> Belfast = 982
+London -> Dublin -> Belfast = 605
+London -> Belfast -> Dublin = 659
+Dublin -> Belfast -> London = 659
+Belfast -> Dublin -> London = 605
+Belfast -> London -> Dublin = 982
+
+The shortest of these is London -> Dublin -> Belfast = 605, and so the answer is 605 in this example.
+
+What is the distance of the shortest route?
+
+Puzzle 2 is the longest distance
+
+*/
+import { Cities, SimpleInputCities } from "./types.ts";
+import { getDistance, getPermutations, parseCityLine } from "./utils.ts";
+
+function getProcessFile(cityValues: string[]) {
+  return function processFile(text: string) {
+    const lines = text.split("\n");
+    const resolvedCombinations = new Map<string, number>();
+    for (const line of lines) {
+      // parse line by line
+      const { cityALiteral, cityBLiteral, distance } = parseCityLine(line);
+      if (cityALiteral && cityBLiteral) {
+        //     fill resolvedCombinations with initial data
+        resolvedCombinations.set(cityALiteral + cityBLiteral, distance);
+      } else {
+        throw new Error("Unknown literals");
+      }
+    }
+    // combine them with combine function. get list of combinations
+
+    const allPermutations = getPermutations(
+      new Set(cityValues),
+    );
+    const allDistances = [];
+    for (const permutation of allPermutations) {
+      //    for each combination, get distance, store it in array of distances
+      const distance = getDistance(permutation.join(""), resolvedCombinations);
+      allDistances.push(distance);
+    }
+    // find the smallest distance
+    console.log("Min distance", Math.min(...allDistances));
+    console.log("Max distance", Math.max(...allDistances));
+  };
+}
+
+// read file with cities and distances
+Deno.readTextFile("./simpleInput.txt").then(
+  getProcessFile(Object.values(SimpleInputCities).map(String)),
+);
+Deno.readTextFile("./input.txt").then(
+  getProcessFile(Object.values(Cities).map(String)),
+);

scripts/aoc2015/day9/simpleInput.txt

@@ -0,0 +1,3 @@
+London to Dublin = 464
+London to Belfast = 518
+Dublin to Belfast = 141

scripts/aoc2015/day9/types.ts

@@ -0,0 +1,16 @@
+export enum SimpleInputCities {
+  London = "A",
+  Dublin = "B",
+  Belfast = "C",
+}
+
+export enum Cities {
+  Faerun = "A",
+  Norrath = "B",
+  Tristram = "C",
+  AlphaCentauri = "D",
+  Arbre = "E",
+  Snowdin = "F",
+  Tambi = "G",
+  Straylight = "H",
+}

scripts/aoc2015/day9/utils.test.ts

@@ -0,0 +1,130 @@
+import { assertEquals, assertThrows } from "jsr:@std/assert@1";
+import { beforeEach, describe, it } from "@std/testing/bdd";
+import { combine, getDistance, parseCityLine } from "./utils.ts";
+
+describe("combine", () => {
+  describe('for set {"A"}', () => {
+    const uncombinedValues = new Set(["A"]);
+    it('Should return [["A"]] for empty currentArrays', function () {
+      assertEquals(
+        combine([[]], uncombinedValues),
+        [["A"]],
+      );
+    });
+    it('Should return [["X", "A"]] for currentArrays [["X"]]', function () {
+      assertEquals(
+        combine([["X"]], uncombinedValues),
+        [["X", "A"]],
+      );
+    });
+    it('Should add ["A"] to every array in currentArrays', function () {
+      assertEquals(
+        combine([["X", "Y"], ["Y", "X"]], uncombinedValues),
+        [["X", "Y", "A"], ["Y", "X", "A"]],
+      );
+    });
+  });
+
+  describe('for set {"A", "B"}', function () {
+    const uncombinedValues = new Set(["A", "B"]);
+    it('Should return result with arrays ["A", "B"], ["B", "A"] for empty currentArrays', function () {
+      assertEquals(combine([[]], uncombinedValues), [
+        ["A", "B"],
+        ["B", "A"],
+      ]);
+    });
+    it('Should return result with arrays ["X", "A", "B"], ["X", "B", "A"] for currentArrays [["X"]]', function () {
+      assertEquals(combine([["X"]], uncombinedValues), [
+        ["X", "A", "B"],
+        ["X", "B", "A"],
+      ]);
+    });
+
+    it('Should add arrays ["A", "B"], ["B", "A"] to every array in currentArrays', function () {
+      assertEquals(combine([["X", "Y"], ["Y", "X"]], uncombinedValues), [
+        ["X", "Y", "A", "B"],
+        ["X", "Y", "B", "A"],
+        ["Y", "X", "A", "B"],
+        ["Y", "X", "B", "A"],
+      ]);
+    });
+  });
+
+  describe('for set {"A", "B", "C"}', function () {
+    const uncombinedValues = new Set(["A", "B", "C"]);
+    it("Should return result with 6 arrays for empty currentArrays", function () {
+      assertEquals(combine([[]], uncombinedValues), [
+        ["A", "B", "C"],
+        ["A", "C", "B"],
+        ["B", "A", "C"],
+        ["B", "C", "A"],
+        ["C", "A", "B"],
+        ["C", "B", "A"],
+      ]);
+    });
+    it('Should return result with 6 arrays for currentArrays ["X"]', function () {
+      assertEquals(combine([["X"]], uncombinedValues), [
+        ["X", "A", "B", "C"],
+        ["X", "A", "C", "B"],
+        ["X", "B", "A", "C"],
+        ["X", "B", "C", "A"],
+        ["X", "C", "A", "B"],
+        ["X", "C", "B", "A"],
+      ]);
+    });
+  });
+});
+
+describe("getDistance", function () {
+  const resolvedCombinations = new Map<string, number>();
+  beforeEach(() => {
+    resolvedCombinations.clear();
+    resolvedCombinations.set("AB", 1);
+    resolvedCombinations.set("BC", 2);
+    resolvedCombinations.set("CD", 3);
+    resolvedCombinations.set("DE", 4);
+  });
+  it("Should throw error for unresolvable combination", function () {
+    assertThrows(() => {
+      getDistance("XY", resolvedCombinations);
+    });
+  });
+  it("Should resolve AB combination", function () {
+    assertEquals(getDistance("AB", resolvedCombinations), 1);
+  });
+  it("Should resolve BA combination", function () {
+    assertEquals(getDistance("BA", resolvedCombinations), 1);
+    assertEquals(resolvedCombinations.get("BA"), 1);
+  });
+  it("Should resolve ABC combination", function () {
+    assertEquals(getDistance("ABC", resolvedCombinations), 3);
+    assertEquals(resolvedCombinations.get("ABC"), 3);
+  });
+  it("Should resolve CBA combination", function () {
+    assertEquals(getDistance("CBA", resolvedCombinations), 3);
+    assertEquals(resolvedCombinations.get("CB"), 2);
+    assertEquals(resolvedCombinations.get("BA"), 1);
+    assertEquals(resolvedCombinations.get("CBA"), 3);
+  });
+  it("Should resolve ABCDE combination", function () {
+    assertEquals(getDistance("ABCDE", resolvedCombinations), 10);
+    assertEquals(resolvedCombinations.get("CDE"), 7);
+    assertEquals(resolvedCombinations.get("BCDE"), 9);
+    assertEquals(resolvedCombinations.get("ABCDE"), 10);
+  });
+});
+
+describe("parseCityLine", function () {
+  it("Should throw error for invalid city line", function () {
+    assertThrows(() => {
+      parseCityLine("ascsdf");
+    });
+  });
+  it("Should parse valid city line", function () {
+    assertEquals(parseCityLine("London to Dublin = 464"), {
+      cityALiteral: "A",
+      cityBLiteral: "B",
+      distance: 464,
+    });
+  });
+});