Add solution for 2017 Day 2

res/2016/day24/test_input.txt

@@ -0,0 +1,5 @@
+###########
+#0.1.....2#
+#.#######.#
+#4.......3#
+###########

res/2017/day01/test_input.txt

@@ -0,0 +1 @@
+123123

res/2017/day02/test_input.txt

@@ -0,0 +1,3 @@
+5 9 2 8
+9 4 7 3
+3 8 6 5

src/2016/Day24.cpp

@@ -2,30 +2,77 @@
 
 namespace y2016::day24
 {
-  REGISTER_DAY(2016, Day24, std::vector<int>, int);
+  REGISTER_DAY(2016, Day24, Array2D<char>, int);
 
-  REGISTER_TEST_EXAMPLE(2016, Day24, ExampleInput, 1, 0);
-  REGISTER_TEST(2016, Day24, Input, 1, 0);
-  REGISTER_TEST_EXAMPLE(2016, Day24, ExampleInput, 2, 0);
-  REGISTER_TEST(2016, Day24, Input, 2, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day24, ExampleInput, 1, 14);
+  REGISTER_TEST(2016, Day24, Input, 1, 448);
+  REGISTER_TEST_EXAMPLE(2016, Day24, ExampleInput, 2, 20);
+  REGISTER_TEST(2016, Day24, Input, 2, 672);
 
   READ_INPUT(input)
   {
-    std::vector<int> vec;
-    std::string str;
-    while (getline(input, str))
-    {
+    return Input::ReadArray2D(input);
   }
-    return vec;
+
+  struct State
+  {
+    Index2D pos;
+    char goalChar;
+
+    bool operator<(const State& other) const
+    {
+      return pos < other.pos;
+    }
+  };
+
+  std::vector<std::pair<int, State>> Branch(const Array2D<char>& map, const State& state)
+  {
+    std::vector<std::pair<int, State>> branches;
+    for (const auto& pos : map.GetNeighbors(state.pos, false))
+    {
+      if (map[pos] != '#')
+        branches.emplace_back(1, State{pos, state.goalChar});
+    }
+    return branches;
+  }
+
+  bool Goal(const Array2D<char>& map, const State& state)
+  {
+    return map[state.pos] == state.goalChar;
+  }
+
+  Graph<char, int> GetGraph(const Array2D<char>& map)
+  {
+    std::vector<Index2D> positions(10);
+    for (auto it = map.begin(); it != map.end(); it++)
+    {
+      if (*it >= '0' && *it <= '9')
+      {
+        positions[*it - '0'] = it.index;
+      }
+    }
+    while (!positions.back().IsValid())
+      positions.pop_back();
+
+    Graph<char, int> graph;
+    for (size_t i = 0; i < positions.size(); i++)
+    {
+      for (size_t j = i + 1; j < positions.size(); j++)
+      {
+        int distance = Helper::Dijkstras(map, State{positions[i], (char)(j + '0')}, Branch, Goal);
+        graph.AddTwoWayEdge(i + '0', j + '0', distance);
+      }
+    }
+    return graph;
   }
 
   OUTPUT1(input)
   {
-    return 0;
+    return Helper::TSP(GetGraph(input), '0', false);
   }
 
   OUTPUT2(input)
   {
-    return 0;
+    return Helper::TSP(GetGraph(input), '0', true);
   }
 }

src/2016/Day25.cpp

@@ -2,30 +2,196 @@
 
 namespace y2016::day25
 {
-  REGISTER_DAY(2016, Day25, std::vector<int>, int);
+  enum class Operator
+  {
+    Cpy,
+    Inc,
+    Dec,
+    Jnz,
+    Out,
+  };
 
-  REGISTER_TEST_EXAMPLE(2016, Day25, ExampleInput, 1, 0);
-  REGISTER_TEST(2016, Day25, Input, 1, 0);
-  REGISTER_TEST_EXAMPLE(2016, Day25, ExampleInput, 2, 0);
+  struct Instruction
+  {
+    Operator op;
+    std::variant<char, int> arg1;
+    std::variant<char, int> arg2;
+  };
+
+  REGISTER_DAY(2016, Day25, std::vector<Instruction>, int);
+
+  REGISTER_TEST(2016, Day25, Input, 1, 182);
   REGISTER_TEST(2016, Day25, Input, 2, 0);
 
+  std::variant<char, int> ReadArg(const std::string& str, int arg)
+  {
+    size_t pos = str.find(' ');
+    int i = 0;
+    while (i < arg)
+    {
+      pos = str.find(' ', pos + 1);
+      i++;
+    }
+
+    if (str[pos + 1] >= 'a' && str[pos + 1] <= 'd')
+      return str[pos + 1];
+
+    return (int)std::atoi(str.c_str() + pos + 1);
+  }
+
   READ_INPUT(input)
   {
-    std::vector<int> vec;
+    std::vector<Instruction> vec;
     std::string str;
     while (getline(input, str))
     {
+      Instruction instruction;
+      if (str[0] == 'c')
+      {
+        instruction.op = Operator::Cpy;
+        instruction.arg1 = ReadArg(str, 0);
+        instruction.arg2 = ReadArg(str, 1);
+      }
+      else if (str[0] == 'i')
+      {
+        instruction.op = Operator::Inc;
+        instruction.arg1 = ReadArg(str, 0);
+      }
+      else if (str[0] == 'd')
+      {
+        instruction.op = Operator::Dec;
+        instruction.arg1 = ReadArg(str, 0);
+      }
+      else if (str[0] == 'j')
+      {
+        instruction.op = Operator::Jnz;
+        instruction.arg1 = ReadArg(str, 0);
+        instruction.arg2 = ReadArg(str, 1);
+      }
+      else if (str[0] == 'o')
+      {
+        instruction.op = Operator::Out;
+        instruction.arg1 = ReadArg(str, 0);
+      }
+      vec.emplace_back(instruction);
     }
     return vec;
   }
 
+  void Toggle(Instruction& instruction)
+  {
+    switch (instruction.op)
+    {
+      case Operator::Cpy:
+        instruction.op = Operator::Jnz;
+        break;
+      case Operator::Inc:
+        instruction.op = Operator::Dec;
+        break;
+      case Operator::Dec:
+        instruction.op = Operator::Inc;
+        break;
+      case Operator::Jnz:
+        instruction.op = Operator::Cpy;
+        break;
+      case Operator::Out:
+        instruction.op = Operator::Inc;
+        break;
+    }
+  }
+
+  bool IsValid(const Instruction& instruction)
+  {
+    switch (instruction.op)
+    {
+      case Operator::Cpy:
+        return std::holds_alternative<char>(instruction.arg2);
+      case Operator::Inc:
+        return std::holds_alternative<char>(instruction.arg1);
+      case Operator::Dec:
+        return std::holds_alternative<char>(instruction.arg1);
+      case Operator::Jnz:
+        return true;
+      case Operator::Out:
+        return true;
+    }
+    return false;
+  }
+
+  int GetRegisterIndex(const std::variant<char, int>& c)
+  {
+    return std::get<char>(c) - 'a';
+  }
+
+  int GetValue(const std::vector<int>& registers, const std::variant<char, int>& data)
+  {
+    if (std::holds_alternative<int>(data))
+      return std::get<int>(data);
+    else
+      return registers[GetRegisterIndex(data)];
+  }
+
+  bool Run(std::vector<Instruction> instructions, std::vector<int> registers)
+  {
+    int count = 0;
+    for (size_t pc = 0; pc < instructions.size(); pc++)
+    {
+      // From analysis of the input, it loops the same output every time we get to pc = 8.
+      // As such, if we get there, and count is > 0, we know that the signal alternates, since we've already returned
+      // false if the output to this point is not alternating
+      if (pc == 8 && count > 0)
+        return true;
+      switch (instructions[pc].op)
+      {
+        case Operator::Cpy:
+        {
+          int number = GetValue(registers, instructions[pc].arg1);
+          registers[GetRegisterIndex(instructions[pc].arg2)] = number;
+          break;
+        }
+        case Operator::Inc:
+        {
+          registers[GetRegisterIndex(instructions[pc].arg1)]++;
+          break;
+        }
+        case Operator::Dec:
+        {
+          registers[GetRegisterIndex(instructions[pc].arg1)]--;
+          break;
+        }
+        case Operator::Jnz:
+        {
+          int value = GetValue(registers, instructions[pc].arg1);
+          if (value != 0)
+            pc += GetValue(registers, instructions[pc].arg2) - 1;
+          break;
+        }
+        case Operator::Out:
+        {
+          if (GetValue(registers, instructions[pc].arg1) != count % 2)
+            return false;
+          count++;
+        }
+        break;
+      }
+    }
+    return false;
+  }
+
   OUTPUT1(input)
   {
-    return 0;
+    int i = -1;
+    while (!Run(input, std::vector<int>{++i, 0, 0, 0}))
+      ;
+    return i;
   }
 
   OUTPUT2(input)
   {
-    return 0;
+    std::cout << "  ___                      ___" << std::endl;
+    std::cout << " (o o)                    (o o)" << std::endl;
+    std::cout << "(  V  ) MERRY CHRISTMAS! (  V  )" << std::endl;
+    std::cout << "--m-m----------------------m-m--" << std::endl;
+    return Run(input, std::vector<int>{12, 0, 0, 0});
   }
 }

src/2017/Day01.cpp

@@ -0,0 +1,39 @@
+#include "common/aoc.h"
+
+namespace y2017::day01
+{
+  REGISTER_DAY(2017, Day01, std::string, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day01, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day01, Input, 1, 1089);
+  REGISTER_TEST_EXAMPLE(2017, Day01, ExampleInput, 2, 12);
+  REGISTER_TEST(2017, Day01, Input, 2, 1156);
+
+  READ_INPUT(input)
+  {
+    std::string str;
+    getline(input, str);
+    return str;
+  }
+
+  int Solve(const std::string& str, int offset)
+  {
+    int count = 0;
+    for (int i = 0; i < str.size(); i++)
+    {
+      if (str[i] == str[(i + offset) % str.size()])
+        count += str[i] - '0';
+    }
+    return count;
+  }
+
+  OUTPUT1(input)
+  {
+    return Solve(input, 1);
+  }
+
+  OUTPUT2(input)
+  {
+    return Solve(input, input.size() / 2);
+  }
+}

src/2017/Day02.cpp

@@ -0,0 +1,67 @@
+#include "common/aoc.h"
+
+namespace y2017::day02
+{
+  REGISTER_DAY(2017, Day02, std::vector<std::vector<int>>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day02, ExampleInput, 1, 18);
+  REGISTER_TEST(2017, Day02, Input, 1, 48357);
+  REGISTER_TEST_EXAMPLE(2017, Day02, ExampleInput, 2, 9);
+  REGISTER_TEST(2017, Day02, Input, 2, 351);
+
+  READ_INPUT(input)
+  {
+    std::vector<std::vector<int>> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+      std::vector<int> vec2;
+      std::stringstream ss{str};
+      int i;
+      while (ss >> i)
+      {
+        vec2.emplace_back(i);
+      }
+      vec.emplace_back(vec2);
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    int checksum = 0;
+    for (const auto& vec : input)
+    {
+      int min = std::numeric_limits<int>::max();
+      int max = 0;
+      for (const auto& i : vec)
+      {
+        min = std::min(min, i);
+        max = std::max(max, i);
+      }
+      checksum += max - min;
+    }
+    return checksum;
+  }
+
+  OUTPUT2(input)
+  {
+    int checksum = 0;
+    for (int i = 0; i < input.size(); i++)
+    {
+      std::vector<int> divisible;
+      for (int j = 0; j < input[i].size(); j++)
+      {
+        for (int k = 0; k < input[i].size(); k++)
+        {
+          if (j == k)
+            continue;
+
+          if (input[i][j] % input[i][k] == 0)
+            checksum += input[i][j] / input[i][k];
+        }
+      }
+    }
+    return checksum;
+  }
+}

src/2017/Day03.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day03
+{
+  REGISTER_DAY(2017, Day03, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day03, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day03, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day03, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day03, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day04.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day04
+{
+  REGISTER_DAY(2017, Day04, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day04, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day04, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day04, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day04, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day05.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day05
+{
+  REGISTER_DAY(2017, Day05, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day05, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day05, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day05, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day05, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day06.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day06
+{
+  REGISTER_DAY(2017, Day06, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day06, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day06, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day06, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day06, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day07.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day07
+{
+  REGISTER_DAY(2017, Day07, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day07, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day07, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day07, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day07, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day08.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day08
+{
+  REGISTER_DAY(2017, Day08, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day08, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day08, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day08, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day08, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day09.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day09
+{
+  REGISTER_DAY(2017, Day09, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day09, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day09, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day09, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day09, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day10.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day10
+{
+  REGISTER_DAY(2017, Day10, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day10, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day10, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day10, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day10, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day11.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day11
+{
+  REGISTER_DAY(2017, Day11, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day11, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day11, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day11, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day11, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day12.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day12
+{
+  REGISTER_DAY(2017, Day12, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day12, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day12, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day12, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day12, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day13.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day13
+{
+  REGISTER_DAY(2017, Day13, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day13, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day13, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day13, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day13, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day14.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day14
+{
+  REGISTER_DAY(2017, Day14, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day14, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day14, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day14, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day14, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day15.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day15
+{
+  REGISTER_DAY(2017, Day15, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day15, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day15, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day15, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day15, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day16.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day16
+{
+  REGISTER_DAY(2017, Day16, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day16, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day16, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day16, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day16, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day17.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day17
+{
+  REGISTER_DAY(2017, Day17, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day17, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day17, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day17, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day17, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day18.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day18
+{
+  REGISTER_DAY(2017, Day18, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day18, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day18, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day18, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day18, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day19.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day19
+{
+  REGISTER_DAY(2017, Day19, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day19, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day19, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day19, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day19, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day20.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day20
+{
+  REGISTER_DAY(2017, Day20, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day20, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day20, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day20, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day20, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day21.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day21
+{
+  REGISTER_DAY(2017, Day21, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day21, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day21, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day21, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day21, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day22.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day22
+{
+  REGISTER_DAY(2017, Day22, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day22, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day22, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day22, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day22, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day23.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day23
+{
+  REGISTER_DAY(2017, Day23, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day23, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day23, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day23, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day23, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day24.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day24
+{
+  REGISTER_DAY(2017, Day24, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day24, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day24, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day24, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day24, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/2017/Day25.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2017::day25
+{
+  REGISTER_DAY(2017, Day25, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2017, Day25, ExampleInput, 1, 0);
+  REGISTER_TEST(2017, Day25, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2017, Day25, ExampleInput, 2, 0);
+  REGISTER_TEST(2017, Day25, Input, 2, 0);
+
+  READ_INPUT(input)
+  {
+    std::vector<int> vec;
+    std::string str;
+    while (getline(input, str))
+    {
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    return 0;
+  }
+
+  OUTPUT2(input)
+  {
+    return 0;
+  }
+}

src/common/lib/Graph.h

@@ -106,6 +106,11 @@ public:
     return graph.find(from)->second.find(to)->second;
   }
 
+  const std::map<Key, std::map<Key, Value>>& GetGraph() const
+  {
+    return graph;
+  }
+
   const std::map<Key, Value>& GetPaths(const Key& from) const
   {
     return graph.find(from)->second;

src/common/lib/Helper.h

@@ -506,17 +506,29 @@ struct Helper
   static void ResetTraceErrors();
 
 private:
-  template <typename Key, typename Value, typename Compare, typename Eval>
+  template <typename Key, typename Value>
+  static Value TSPCalculatePath(const Graph<Key, Value>& graph, const std::vector<Key>& path, bool returnToStart)
+  {
+    int cost = 0;
+    for (int i = 0; i < path.size() - 1; i++)
+    {
+      cost += graph.GetEdge(path[i], path[i + 1]);
+    }
+
+    if (returnToStart)
+      cost += graph.GetEdge(path.back(), path.front());
+
+    return cost;
+  }
+
+  template <typename Key, typename Value>
   static int TSP(const Graph<Key, Value>& graph,
                  const std::set<Key>& nodesLeft,
                  const std::vector<Key>& order,
-                 Compare compare,
-                 Eval eval)
+                 bool returnToStart)
   {
     if (nodesLeft.empty())
-    {
-      return eval(graph, order);
-    }
+      return TSPCalculatePath(graph, order, returnToStart);
 
     bool hasSet = false;
     Value tsp;
@@ -528,9 +540,9 @@ private:
       std::vector<Key> newOrder = order;
       newOrder.emplace_back(node);
       if (hasSet)
-        tsp = compare(tsp, TSP(graph, newNodesLeft, newOrder, compare, eval));
+        tsp = std::min(tsp, TSP(graph, newNodesLeft, newOrder, returnToStart));
       else
-        tsp = TSP(graph, newNodesLeft, newOrder, compare, eval);
+        tsp = TSP(graph, newNodesLeft, newOrder, returnToStart);
       hasSet = true;
     }
     return tsp;
@@ -539,28 +551,20 @@ private:
 public:
   // Key     - Node type of the graph
   // Value   - Edge type of the graph
-  // Compare - Value(Value, Value)
-  //           Given two solutions, which one is better
-  // Eval    - int(const Graph&, const std::vector<Key>&)
-  //           Given the graph and order of the TSP, what is the total cost
-  template <typename Key, typename Value, typename Compare, typename Eval>
-  static int TSP(const Graph<Key, Value>& graph, const Key& start, Compare compare, Eval eval)
+  template <typename Key, typename Value>
+  static int TSP(const Graph<Key, Value>& graph, const Key& start, bool returnToStart)
   {
     std::set<Key> nodes = graph.GetNodes();
     nodes.erase(nodes.find(start));
-    return TSP(graph, nodes, std::vector<Key>{start}, compare, eval);
+    return TSP(graph, nodes, std::vector<Key>{start}, returnToStart);
   }
 
   // Key     - Node type of the graph
   // Value   - Edge type of the graph
-  // Compare - Value(Value, Value)
-  //           Given two solutions, which one is better
-  // Eval    - int(const Graph&, const std::vector<Key>&)
-  //           Given the graph and order of the TSP, what is the total cost
-  template <typename Key, typename Value, typename Compare, typename Eval>
-  static int TSP(const Graph<Key, Value>& graph, Compare compare, Eval eval)
+  template <typename Key, typename Value>
+  static int TSP(const Graph<Key, Value>& graph, bool returnToStart)
   {
-    return TSP(graph, graph.GetNodes(), std::vector<Key>{}, compare, eval);
+    return TSP(graph, graph.GetNodes(), std::vector<Key>{}, returnToStart);
   }
 
   static bool traceErrors;