2018 day9

3 files changed, 51 insertions, 32 deletions

diff --git a/src/2018/day9/README.md b/src/2018/day9/README.md
index 04805aa..58266d1 100644
--- a/src/2018/day9/README.md
+++ b/src/2018/day9/README.md
@@ -48,3 +48,8 @@ Here are a few more examples:
 30 players; last marble is worth 5807 points: high score is 37305
 What is the winning Elf's score?
 
+--- Part Two ---
+
+Amused by the speed of your answer, the Elves are curious:
+
+What would the new winning Elf's score be if the number of the last marble were 100 times larger?
diff --git a/src/2018/day9/aoc.cpp b/src/2018/day9/aoc.cpp
index 7771b28..5cf5571 100644
--- a/src/2018/day9/aoc.cpp
+++ b/src/2018/day9/aoc.cpp
@@ -2,9 +2,9 @@
 
 namespace aoc2018 {
 
-int day9(int players, int point) {
+size_t day9(size_t players, size_t point) {
   marble_circle mc(point, players);
-  mc.alloc(23);
+  mc.alloc(1, 7, 23);
   return mc.high();
 }
 
diff --git a/src/2018/day9/aoc.h b/src/2018/day9/aoc.h
index d6de331..016ee2b 100644
--- a/src/2018/day9/aoc.h
+++ b/src/2018/day9/aoc.h
@@ -7,50 +7,63 @@ namespace aoc2018 {
 struct marble {
   marble* prev = nullptr;
   marble* next = nullptr;
-  int value = 0;
+  size_t value = 0;
 };
 
 struct marble_circle {
   std::vector<marble> marbles;
-  std::vector<int> players;
+  std::vector<size_t> players;
   marble* current;
-  int point;
+  size_t point;
 
-  void insert(marble& p, marble& n, marble& x) noexcept {
-    p.next = &x;
-    x.next = &n;
-    x.prev = &p;
-    n.prev = &x;
+  void insert(marble* p, marble* n, marble* x) noexcept {
+    p->next = x;
+    x->next = n;
+    x->prev = p;
+    n->prev = x;
   }
 
-  int high() const noexcept {
-    int score = 0;
+  size_t high() const noexcept {
+    size_t score = 0;
     for (auto& p : players) {
       score = std::max(score, p);
     }
     return score;
   }
 
-  void remove(marble& x) noexcept {
-    x.prev->next = x.next;
-    x.next->prev = x.prev;
+  void remove(marble* x) noexcept {
+    x->prev->next = x->next;
+    x->next->prev = x->prev;
   }
 
-  marble& next(marble* c, int n) noexcept {
+  marble* next(marble* c, int n) noexcept {
     while (n-- > 0) {
       c = c->next;
     }
-    return *c;
+    return c;
   }
 
-  marble& prev(marble* c, int n) noexcept {
+  marble* prev(marble* c, int n) noexcept {
     while (n-- > 0) {
       c = c->prev;
     }
-    return *c;
+    return c;
   }
 
-  marble_circle(int n, int p) : marbles(n + 1), players(p) {
+  void print() {
+    marble* x = &marbles[0];
+    while (true) {
+      if (x->next == &marbles[0]) {
+        printf("%zu\n", x->value);
+        break;
+      } else {
+        printf("%zu -> ", x->value);
+        x = x->next;
+      }
+    }
+  }
+
+  marble_circle(size_t n, size_t p) : marbles(n + 1), players(p) {
     marbles[0].next = &marbles[1];
     marbles[0].prev = &marbles[1];
     marbles[0].value = 0;
@@ -63,28 +76,29 @@ struct marble_circle {
     point = 1;
   }
 
-  void alloc(int x) {
-    int i = 2;
-    while (point < int(marbles.size())) {
-      int p = point + 1;
+  void alloc(int a, int b, int c) {
+    size_t i = 2;
+    while (point < marbles.size() - 1) {
+      // print();
+      size_t p = point + 1;
       marbles[p].value = p;
 
-      if (p % x == 0) {
-        marble& m = prev(current, 7);
-        players[i - 1] += p + m.value;
-        current = m.next;
+      if (p % c == 0) {
+        marble* m = prev(current, b);
+        players[i - 1] += p + m->value;
+        current = m->next;
         remove(m);
       } else {
-        marble& m = next(current, 1);
-        insert(m, *m.next, marbles[p]);
+        marble* m = next(current, a);
+        insert(m, m->next, &marbles[p]);
         current = &marbles[p];
       }
       point = p;
-      i = i == int(players.size()) ? 1 : i + 1;
+      i = i == players.size() ? 1 : i + 1;
     }
   }
 };
 
-int day9(int players, int point);
+size_t day9(size_t players, size_t point);
 
 } // namespace aoc2018