Add solution for "Day 14: Restroom Redoubt", part 2

README.md

@@ -90,6 +90,14 @@ Adding up the products of area and perimeter, or area and corner count, per regi
 
 For each claw machine, we have to solve a simple linear equation system to get the number of required button pushes. Conveniently, for the given data, all of these systems have a unique solution. However, some solutions have to be excluded because the number of button pushes is not integer, or because the solutions are too high for part 1. The required integer tests are done by performing integer division, and comparing the dividend with the product of the integer quotient and the divisor.
 
+### Day 14: Restroom Redoubt
+
+:mag_right: Puzzle: <https://adventofcode.com/2024/day/14>, :white_check_mark: Solver: [`RestroomRedoubt.cpp`](src/RestroomRedoubt.cpp)
+
+For part 1, the resulting quadrant for each robot can be calculated directly, by multiplying the velocity vector by 100 and adding it to the position vector, modulo width or height to stay within the target range.
+
+When observing a few resulting robot configurations after each passed second, it becomes apparent that some of them show vertical or horizontal bands of clustering, and that these repeat every `width` or `height` seconds, respectively. With a bit of modulo calculus, the time after which the vertical and horizontal bands overlap can be determined, which is the solution for part 2.
+
 ## Thanks
 
 * [Alexander Brouwer](https://github.com/Bromvlieg) for getting the project set up with CMake.

include/aoc/Math.hpp

@@ -15,8 +15,26 @@
 
 #pragma once
 
+#include <tuple>
+
 class Math
 {
 public:
+    /// <summary>
+    /// Calculates an integer exponentiation.
+    /// </summary>
+    /// <param name="base">Base of the exponentiation.</param>
+    /// <param name="exponent">Exponent of the exponentiation</param>
+    /// <returns>'base' raised to the power of 'exponent'.</returns>
     static int ipow(const int base, const int exponent);
+
+    /// <summary>
+    /// Calculates the greatest common divisor gcd(a, b) and the coefficients x and y of Bézout's identity
+    /// ax + by = gcd(a, b). If a and b are coprime, then x is the modular multiplicative inverse of a modulo b, and y
+    /// is the modular multiplicative inverse of b modulo a.
+    /// </summary>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    /// <returns>A tuple of the gcd(a, b), x, and y.</returns>
+    static std::tuple<int, int, int> extendedEuclid(const int a, const int b);
 };

include/aoc/Point2.hpp

@@ -43,4 +43,5 @@ class Point2
     Point2& operator+=(const Point2& rhs);
     Point2& operator-=(const Point2& rhs);
     Point2& operator*=(const int rhs);
+    int& operator[](size_t coordinateIndex);
 };

include/aoc/RestroomRedoubt.hpp

@@ -16,14 +16,16 @@
 #pragma once
 
 #include <array>
+#include <vector>
 
+#include <aoc/Point2.hpp>
 #include <aoc/Solver.hpp>
 
 class RestroomRedoubt
     : public Solver
 {
 public:
-    RestroomRedoubt(const int width = 101, const int height = 103);
+    RestroomRedoubt(const int width = 101, const int height = 103, const bool runPart2 = true);
     virtual const std::string getPuzzleName() const override;
     virtual const int getPuzzleDay() const override;
     virtual void processDataLine(const std::string& line) override;
@@ -33,6 +35,10 @@ class RestroomRedoubt
     const int height_;
     const int halfWidth_;
     const int halfHeight_;
+    const bool runPart2_;
     std::array<int, 4> quadrants_;
+    std::vector<std::pair<Point2, Point2>> robots_;
     static constexpr int getNPredictionSeconds();
+    static constexpr int getEasterEggThreshold();
+    void findEasterEgg();
 };

src/Math.cpp

@@ -15,6 +15,8 @@
 
 #include <aoc/Math.hpp>
 
+#include <array>
+
 int Math::ipow(const int base, const int exponent)
 {
     int result = 1;
@@ -24,3 +26,22 @@ int Math::ipow(const int base, const int exponent)
     }
     return result;
 }
+
+std::tuple<int, int, int> Math::extendedEuclid(const int a, const int b)
+{
+    std::array<std::pair<int, int>, 3> rst{ { { a, b }, { 1, 0 }, { 0, 1 } } };
+    int q;
+    int r;
+
+    while (rst[0].second > 0)
+    {
+        q = rst[0].first / rst[0].second;
+        for (auto& p : rst)
+        {
+            r = p.first - q * p.second;
+            p.first = p.second;
+            p.second = r;
+        }
+    }
+    return { rst[0].first, rst[1].first, rst[2].first };
+}

src/Point2.cpp

@@ -84,3 +84,8 @@ Point2& Point2::operator*=(const int rhs)
     *this = *this * rhs;
     return *this;
 }
+
+int& Point2::operator[](size_t coordinateIndex)
+{
+    return coordinateIndex == 0 ? x : y;
+}

src/RestroomRedoubt.cpp

@@ -15,14 +15,17 @@
 
 #include <aoc/RestroomRedoubt.hpp>
 
+#include <algorithm>
+#include <array>
 #include <functional>
 #include <numeric>
 #include <sstream>
 
+#include <aoc/Math.hpp>
 #include <aoc/Point2.hpp>
 
-RestroomRedoubt::RestroomRedoubt(const int width, const int height)
+RestroomRedoubt::RestroomRedoubt(const int width, const int height, const bool runPart2)
-    : width_{ width }, height_{ height }, halfWidth_{ width / 2 }, halfHeight_{ height / 2 }
+    : width_{ width }, height_{ height }, halfWidth_{ width / 2 }, halfHeight_{ height / 2 }, runPart2_{ runPart2 }
 {
     quadrants_.fill(0);
 }
@@ -41,10 +44,10 @@ void RestroomRedoubt::processDataLine(const std::string& line)
 {
     std::istringstream stream{ line };
     char c;
-    Point2 p;
+    Point2 p, v;
-    Point2 v;
     stream >> c >> c >> p.x >> c >> p.y >> c >> c >> v.x >> c >> v.y;
 
+    // Calculates the resulting position, and shifts negative results back into the target range.
     Point2 position = p + v * getNPredictionSeconds();
     position.x %= width_;
     if (position.x < 0)
@@ -57,6 +60,7 @@ void RestroomRedoubt::processDataLine(const std::string& line)
         position.y += height_;
     }
 
+    // Determines the resulting quadrant from the position.
     if (position.x < halfWidth_)
     {
         if (position.y < halfHeight_)
@@ -79,14 +83,72 @@ void RestroomRedoubt::processDataLine(const std::string& line)
             quadrants_[3]++;
         }
     }
+
+    // Keeps track of the robot for part 2.
+    robots_.push_back({ p, v });
 }
 
 void RestroomRedoubt::finish()
 {
     part1 = std::accumulate(quadrants_.cbegin(), quadrants_.cend(), 1, std::multiplies<int>{});
+
+    if (runPart2_)
+    {
+        findEasterEgg();
+    }
 }
 
 constexpr int RestroomRedoubt::getNPredictionSeconds()
 {
     return 100;
 }
+
+constexpr int RestroomRedoubt::getEasterEggThreshold()
+{
+    return 25;
+}
+
+void RestroomRedoubt::findEasterEgg()
+{
+    std::array<int, 2> patterns{ 0, 0 };
+    std::array<int, 2> sizes{ width_, height_ };
+    for (size_t i = 0; i < 2; i++)
+    {
+        int seconds{ 0 };
+        while (patterns[i] == 0)
+        {
+            std::vector<int> buckets(sizes[i], 0);
+            for (auto& robot : robots_)
+            {
+                buckets[robot.first[i]]++;
+                robot.first[i] += robot.second[i];
+                if (robot.first[i] < 0)
+                {
+                    robot.first[i] += sizes[i];
+                }
+                else if (robot.first[i] >= sizes[i])
+                {
+                    robot.first[i] -= sizes[i];
+                }
+            }
+            auto it = std::find_if(buckets.cbegin(), buckets.cend(), [](int x) { return x > getEasterEggThreshold(); });
+            if (it != buckets.cend())
+            {
+                patterns[i] = seconds;
+            }
+            seconds++;
+        }
+    }
+
+    // Determines the iteration where the repeating patterns of horizontal and vertical bands overlap, that is
+    //     patterns_0 + width * x = patterns_1 + height * y
+    // for two positive integers 'x' and 'y'. This is equivalent to finding 'x' such that
+    //     width * x ≡ patterns_1 - patterns_0 (modulo height)
+    // We can determine the modular multiplicative inverse of 'width' modulo 'height' with the extended Euclidean
+    // algorithm.
+    const auto [gcd, invHeight, invWidth] = Math::extendedEuclid(height_, width_);
+    // With that we can find 'x'.
+    int x{ (invWidth * (patterns[1] - patterns[0])) % height_ };
+    // And calculate when the overlap occurs.
+    part2 = patterns[0] + width_ * x;
+}

tests/src/TestCases.cpp

@@ -226,11 +226,11 @@ TEST_CASE("[RestroomRedoubtTests]")
     TestContext test;
     SECTION("FullData")
     {
-        test.run(std::make_unique<RestroomRedoubt>(), 224969976, 0, test.getInputPaths());
+        test.run(std::make_unique<RestroomRedoubt>(), 224969976, 7892, test.getInputPaths());
     }
     SECTION("ExampleData")
     {
-        test.run(std::make_unique<RestroomRedoubt>(11, 7), 12, 0, test.getExampleInputPaths());
+        test.run(std::make_unique<RestroomRedoubt>(11, 7, false), 12, 0, test.getExampleInputPaths());
     }
 }