Add solution for 2016 Day 1

res/2016/day01/test_input.txt

@@ -0,0 +1 @@
+R8, R4, R4, R8

src/2016/Day01.cpp

@@ -0,0 +1,73 @@
+#include "common/aoc.h"
+
+namespace y2016::day01
+{
+  struct Move
+  {
+    char r;
+    int count;
+  };
+
+  REGISTER_DAY(2016, Day01, std::vector<Move>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day01, ExampleInput, 1, 8);
+  REGISTER_TEST(2016, Day01, Input, 1, 271);
+  REGISTER_TEST_EXAMPLE(2016, Day01, ExampleInput, 2, 4);
+  REGISTER_TEST(2016, Day01, Input, 2, 153);
+
+  READ_INPUT(input)
+  {
+    std::vector<Move> vec;
+    std::string str;
+    while (getline(input, str, ' '))
+    {
+      Move move;
+      move.r = str[0];
+      move.count = std::strtol(&str[1], nullptr, 10);
+      vec.emplace_back(move);
+    }
+    return vec;
+  }
+
+  OUTPUT1(input)
+  {
+    Index2D dir{1, 0};
+    Index2D pos{0, 0};
+    for (int i = 0; i < input.size(); i++)
+    {
+      if (input[i].r == 'R')
+        dir.RotateCW();
+      else
+        dir.RotateCCW();
+
+      pos = pos + dir * input[i].count;
+    }
+    return Helper::ManhattanDistance(pos, Index2D{0, 0});
+  }
+
+  OUTPUT2(input)
+  {
+    Index2D dir{1, 0};
+    Index2D pos{0, 0};
+    std::set<Index2D> visited;
+    visited.emplace(pos);
+    for (int i = 0; i < input.size(); i++)
+    {
+      if (input[i].r == 'R')
+        dir.RotateCW();
+      else
+        dir.RotateCCW();
+
+      for (int j = 0; j < input[i].count; j++)
+      {
+        pos = pos + dir;
+        if (visited.count(pos) != 0)
+        {
+          return Helper::ManhattanDistance(pos, Index2D{0, 0});
+        }
+        visited.emplace(pos);
+      }
+    }
+    return 0;
+  }
+}

src/2016/Day02.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day02
+{
+  REGISTER_DAY(2016, Day02, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day02, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day02, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day02, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, Day02, 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/2016/Day03.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day03
+{
+  REGISTER_DAY(2016, Day03, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day03, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day03, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day03, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day04.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day04
+{
+  REGISTER_DAY(2016, Day04, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day04, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day04, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day04, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day05.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day05
+{
+  REGISTER_DAY(2016, Day05, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day05, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day05, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day05, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day06.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day06
+{
+  REGISTER_DAY(2016, Day06, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day06, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day06, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day06, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day07.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day07
+{
+  REGISTER_DAY(2016, Day07, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day07, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day07, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day07, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day08.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day08
+{
+  REGISTER_DAY(2016, Day08, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day08, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day08, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day08, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day09.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day09
+{
+  REGISTER_DAY(2016, Day09, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day09, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day09, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day09, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day10.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day10
+{
+  REGISTER_DAY(2016, Day10, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day10, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day10, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day10, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day11.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day11
+{
+  REGISTER_DAY(2016, Day11, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day11, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day11, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day11, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day12.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day12
+{
+  REGISTER_DAY(2016, Day12, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day12, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day12, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day12, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day13.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day13
+{
+  REGISTER_DAY(2016, Day13, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day13, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day13, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day13, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day14.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day14
+{
+  REGISTER_DAY(2016, Day14, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day14, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day14, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day14, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day15.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day15
+{
+  REGISTER_DAY(2016, Day15, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day15, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day15, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day15, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day16.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day16
+{
+  REGISTER_DAY(2016, Day16, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day16, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day16, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day16, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day17.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day17
+{
+  REGISTER_DAY(2016, Day17, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day17, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day17, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day17, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day18.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day18
+{
+  REGISTER_DAY(2016, Day18, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day18, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day18, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day18, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day19.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day19
+{
+  REGISTER_DAY(2016, Day19, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day19, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day19, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day19, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day20.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day20
+{
+  REGISTER_DAY(2016, Day20, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day20, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day20, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day20, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day21.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day21
+{
+  REGISTER_DAY(2016, Day21, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day21, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day21, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day21, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day22.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day22
+{
+  REGISTER_DAY(2016, Day22, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day22, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day22, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day22, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day23.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day23
+{
+  REGISTER_DAY(2016, Day23, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day23, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day23, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day23, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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/2016/Day24.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day24
+{
+  REGISTER_DAY(2016, Day24, std::vector<int>, 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);
+
+  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/2016/Day25.cpp

@@ -0,0 +1,31 @@
+#include "common/aoc.h"
+
+namespace y2016::day25
+{
+  REGISTER_DAY(2016, Day25, std::vector<int>, int);
+
+  REGISTER_TEST_EXAMPLE(2016, Day25, ExampleInput, 1, 0);
+  REGISTER_TEST(2016, Day25, Input, 1, 0);
+  REGISTER_TEST_EXAMPLE(2016, Day25, ExampleInput, 2, 0);
+  REGISTER_TEST(2016, 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

@@ -9,6 +9,20 @@ struct Index2D
   int x = -1;
   int y = -1;
 
+  void RotateCW()
+  {
+    int tmp = y;
+    y = x;
+    x = -tmp;
+  }
+
+  void RotateCCW()
+  {
+    int tmp = y;
+    y = -x;
+    x = tmp;
+  }
+
   bool IsValid()
   {
     return x != -1 && y != -1;