Add solution for 2017 Day 2

res/2016/day22/test_input.txt

@@ -0,0 +1,11 @@
+root@ebhq-gridcenter# df -h
+Filesystem            Size  Used  Avail  Use%
+/dev/grid/node-x0-y0   10T    8T     2T   80%
+/dev/grid/node-x0-y1   11T    6T     5T   54%
+/dev/grid/node-x0-y2   32T   28T     4T   87%
+/dev/grid/node-x1-y0    9T    7T     2T   77%
+/dev/grid/node-x1-y1    8T    0T     8T    0%
+/dev/grid/node-x1-y2   11T    7T     4T   63%
+/dev/grid/node-x2-y0   10T    6T     4T   60%
+/dev/grid/node-x2-y1    9T    8T     1T   88%
+/dev/grid/node-x2-y2    9T    6T     3T   66%

res/2016/day23/test_input.txt

@@ -0,0 +1,7 @@
+cpy 2 a
+tgl a
+tgl a
+tgl a
+cpy 1 a
+dec a
+dec a

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/Day22.cpp

@@ -2,30 +2,135 @@
 
 namespace y2016::day22
 {
-  REGISTER_DAY(2016, Day22, std::vector<int>, int);
+  struct Fs
+  {
+    int used;
+    int avail;
 
-  REGISTER_TEST_EXAMPLE(2016, Day22, ExampleInput, 1, 0);
+    bool operator==(const Fs& other) const
-  REGISTER_TEST(2016, Day22, Input, 1, 0);
+    {
-  REGISTER_TEST_EXAMPLE(2016, Day22, ExampleInput, 2, 0);
+      return used == other.used && avail == other.avail;
-  REGISTER_TEST(2016, Day22, Input, 2, 0);
+    }
+  };
+
+  REGISTER_DAY(2016, Day22, Array2D<Fs>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day22, ExampleInput, 1, 7);
+  REGISTER_TEST(2016, Day22, Input, 1, 1024);
+  REGISTER_TEST_EXAMPLE(2016, Day22, ExampleInput, 2, 7);
+  REGISTER_TEST(2016, Day22, Input, 2, 230);
 
   READ_INPUT(input)
   {
-    std::vector<int> vec;
+    std::vector<std::pair<std::pair<int, int>, Fs>> fss;
+    Array2D<Fs> vec{};
     std::string str;
+    getline(input, str);
+    getline(input, str);
+    int maxX = 0;
+    int maxY = 0;
     while (getline(input, str))
     {
+      // /dev/grid/node-x0-y0     91T   71T    20T   78%
+      Fs fs;
+      std::stringstream ss{str};
+      int dummy;
+      int x;
+      int y;
+      ss >> "/dev/grid/node-x" >> x >> "-y" >> y >> dummy >> "T" >> fs.used >> "T" >> fs.avail >> "T";
+      fss.emplace_back(std::pair{std::pair{x, y}, fs});
+      maxX = std::max(maxX, x);
+      maxY = std::max(maxY, y);
+    }
+    vec = Array2D<Fs>{maxX + 1, maxY + 1};
+    for (const auto& [pos, fs] : fss)
+    {
+      vec.Set(pos.first, pos.second, fs);
     }
     return vec;
   }
 
+  struct State
+  {
+    Index2D goal;
+    Index2D empty;
+
+    bool operator<(const State& other) const
+    {
+      if (goal != other.goal)
+        return goal < other.goal;
+      return empty < other.empty;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const State& state)
+    {
+      return os << state.goal << " " << state.empty;
+    }
+  };
+
+  std::vector<std::pair<int, State>> Branch(const Array2D<Fs>& initial, const State& state)
+  {
+    std::vector<std::pair<int, State>> states{};
+    Fs emptyFs = initial.Get(state.empty);
+    std::vector<Index2D> neighbors = initial.GetNeighbors(state.empty, false);
+    for (const auto& neighbor : neighbors)
+    {
+      if (initial.Get(neighbor).used < 400)
+      {
+        State newState = state;
+        if (neighbor == state.goal)
+          newState.goal = state.empty;
+        newState.empty = neighbor;
+        states.emplace_back(1, newState);
+      }
+    }
+    return states;
+  }
+
+  bool Goal(const Array2D<Fs>& initial, const State& state)
+  {
+    return state.goal == Index2D{0, 0};
+  }
+
+  int Heuristic(const Array2D<Fs>& initial, const State& state)
+  {
+    return state.goal.x + state.goal.y;
+  }
+
   OUTPUT1(input)
   {
-    return 0;
+    int count = 0;
+    for (const auto& val : input)
+    {
+      if (val.used == 0)
+        continue;
+      for (const auto& val2 : input)
+      {
+        if (val == val2)
+          continue;
+        if (val.used <= val2.avail)
+        {
+          count++;
+        }
+      }
+    }
+    return count;
   }
 
   OUTPUT2(input)
   {
-    return 0;
+    State state;
+    state.goal = Index2D{input.width - 1, 0};
+    for (int i = 0; i < input.height; i++)
+    {
+      for (int j = 0; j < input.width; j++)
+      {
+        if (input.Get(j, i).used == 0)
+        {
+          state.empty = Index2D{j, i};
+        }
+      }
+    }
+    return Helper::AStar(input, state, Heuristic, Branch, Goal);
   }
 }

src/2016/Day23.cpp

@@ -2,30 +2,197 @@
 
 namespace y2016::day23
 {
-  REGISTER_DAY(2016, Day23, std::vector<int>, int);
+  enum class Operator
+  {
+    Cpy,
+    Inc,
+    Dec,
+    Jnz,
+    Tgl
+  };
 
-  REGISTER_TEST_EXAMPLE(2016, Day23, ExampleInput, 1, 0);
+  struct Instruction
-  REGISTER_TEST(2016, Day23, Input, 1, 0);
+  {
-  REGISTER_TEST_EXAMPLE(2016, Day23, ExampleInput, 2, 0);
+    Operator op;
-  REGISTER_TEST(2016, Day23, Input, 2, 0);
+    std::variant<char, int> arg1;
+    std::variant<char, int> arg2;
+  };
+
+  REGISTER_DAY(2016, Day23, std::vector<Instruction>, int);
+
+  REGISTER_TEST(2016, Day23, Input, 1, 11415);
+  REGISTER_TEST(2016, Day23, Input, 2, 479007975);
+
+  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] == 't')
+      {
+        instruction.op = Operator::Tgl;
+        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::Tgl:
+        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::Tgl:
+        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)];
+  }
+
+  int Run(std::vector<Instruction> instructions, std::vector<int> registers)
+  {
+    int i = 0;
+    for (size_t pc = 0; pc < instructions.size(); pc++)
+    {
+      i++;
+      if (!IsValid(instructions[pc]))
+        continue;
+      // The input program I got does a multiplication (a = b * d). So instead of using the ++, -- operators, calculate
+      // it directly and set the registers to expected value after the operation is done.
+      // Other inputs might have different pc position, and multiply different registers.
+      if (pc == 4)
+      {
+        registers[0] = registers[1] * registers[3];
+        registers[3] = 0;
+        registers[2] = registers[1];
+        pc = 9;
+      }
+      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::Tgl:
+        {
+          int offset = registers[GetRegisterIndex(instructions[pc].arg1)];
+          if (pc + offset >= 0 && pc + offset < instructions.size())
+            Toggle(instructions[pc + offset]);
+        }
+        break;
+      }
+    }
+    return registers[0];
+  }
+
   OUTPUT1(input)
   {
-    return 0;
+    return Run(input, std::vector<int>{7, 0, 0, 0});
   }
 
   OUTPUT2(input)
   {
-    return 0;
+    return Run(input, std::vector<int>{12, 0, 0, 0});
   }
 }

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_EXAMPLE(2016, Day24, ExampleInput, 1, 14);
-  REGISTER_TEST(2016, Day24, Input, 1, 0);
+  REGISTER_TEST(2016, Day24, Input, 1, 448);
-  REGISTER_TEST_EXAMPLE(2016, Day24, ExampleInput, 2, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day24, ExampleInput, 2, 20);
-  REGISTER_TEST(2016, Day24, Input, 2, 0);
+  REGISTER_TEST(2016, Day24, Input, 2, 672);
 
   READ_INPUT(input)
   {
-    std::vector<int> vec;
+    return Input::ReadArray2D(input);
-    std::string str;
-    while (getline(input, str))
-    {
   }
-    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);
+  struct Instruction
-  REGISTER_TEST(2016, Day25, Input, 1, 0);
+  {
-  REGISTER_TEST_EXAMPLE(2016, Day25, ExampleInput, 2, 0);
+    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/Array2D.h

@@ -500,6 +500,11 @@ struct Array2D
     return ConstIterator{*this, Index2D{0, height}};
   }
 
+  bool operator<(const Array2D<T>& other) const
+  {
+    return array2D < other.array2D;
+  }
+
   friend std::ostream& operator<<(std::ostream& os, const Array2D& array2D)
   {
     for (int y = 0; y < array2D.height; y++)

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

@@ -11,6 +11,7 @@
 #include <map>
 #include <numeric>
 #include <set>
+#include <variant>
 #include <vector>
 
 #include "Array2D.h"
@@ -33,6 +34,9 @@ static std::ostream& operator<<(std::ostream& stream, const std::map<T, S>& cont
 template <typename T, typename S>
 static std::ostream& operator<<(std::ostream& stream, const std::pair<T, S>& pair);
 
+template <typename Arg1, typename Arg2, typename... Args>
+static std::ostream& operator<<(std::ostream& stream, const std::variant<Arg1, Arg2, Args...>& variant);
+
 struct Helper
 {
   struct ScopedTraceErrorDisabler
@@ -502,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,
+                 bool returnToStart)
-                 Eval eval)
   {
     if (nodesLeft.empty())
-    {
+      return TSPCalculatePath(graph, order, returnToStart);
-      return eval(graph, order);
-    }
 
     bool hasSet = false;
     Value tsp;
@@ -524,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;
@@ -535,28 +551,20 @@ private:
 public:
   // Key     - Node type of the graph
   // Value   - Edge type of the graph
-  // Compare - Value(Value, Value)
+  template <typename Key, typename Value>
-  //           Given two solutions, which one is better
+  static int TSP(const Graph<Key, Value>& graph, const Key& start, bool returnToStart)
-  // 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)
   {
     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)
+  template <typename Key, typename Value>
-  //           Given two solutions, which one is better
+  static int TSP(const Graph<Key, Value>& graph, bool returnToStart)
-  // 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)
   {
-    return TSP(graph, graph.GetNodes(), std::vector<Key>{}, compare, eval);
+    return TSP(graph, graph.GetNodes(), std::vector<Key>{}, returnToStart);
   }
 
   static bool traceErrors;
@@ -639,3 +647,10 @@ static std::ostream& operator<<(std::ostream& stream, const std::pair<T, S>& pai
 {
   return stream << "(" << pair.first << ", " << pair.second << ")";
 }
+
+template <typename Arg1, typename Arg2, typename... Args>
+static std::ostream& operator<<(std::ostream& stream, const std::variant<Arg1, Arg2, Args...>& variant)
+{
+  std::visit([&stream](const auto& value) { stream << value; }, variant);
+  return stream;
+}