advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2021/19.yml

@@ -0,0 +1,33 @@
+---
+- :author: prafster
+  :url: https://www.reddit.com/r/adventofcode/comments/rjpf7f/2021_day_19_solutions/hrxvfgt/
+  :body: |-
+    ## Julia
+
+    This is simpler than it appears. The only maths you need is a bit of vectors/matrices and how to rotate a point in 3D. For reference see [here](https://www.euclideanspace.com/maths/algebra/matrix/transforms/examples/index.htm).
+
+    The algorithm is:
+
+    1. For each scanner, find the square distance between each pair of beacons.
+    2. Compare these distances between scanners. That tells you which scanners overlap.
+    3. For each of these overlapping scanners (s1 and s2, say), use a pair of beacons to find the correct rotation of beacons in s2 so that they align to beacons in s1. As part of finding the rotation, the location of the scanner (relative to the first scanner) pops out.
+
+    There are more comments in the code.
+
+    I'm learning Julia for this AoC and really enjoying it. It's especially good for anything vaguely maths-related (as you'd expect). It's a nice short, expressive language but also accessible, like Python and Ruby, and much faster.
+
+    [Solution](https://github.com/Praful/advent_of_code/blob/main/2021/src/day19.jl).
+  :replies: []
+- :author: '0x8b'
+  :url: https://www.reddit.com/r/adventofcode/comments/rjpf7f/2021_day_19_solutions/hpg0mnm/
+  :body: Please check out my simple solution in Ruby ;) https://github.com/0x8b/advent.of.code.each/blob/main/src/2021/19.rb
+  :replies: []
+- :author: akanet
+  :url: https://www.reddit.com/r/adventofcode/comments/rjpf7f/2021_day_19_solutions/hp844vn/
+  :body: |-
+    [Ruby](https://gist.github.com/vincentwoo/dd1136e151c9035e090dd6401f301dcf)
+
+    This was very difficult, especially given that I have the unusual constraint of programming these entirely within the CoderPad online environment. Ruby doesn't have especially advanced/accelerated numerics, so in order to get down to a solution that could run in a few seconds, I had to do some fingerprinting of the beacons. My hunch worked out - if you take as a fingerprint for each beacon simply its offset to its closest neighbor, that's enough to quickly find matches between the other scanner sets.
+
+    I also streamed myself doing this one for any masochists who want to watch me fail for three hours: https://www.twitch.tv/videos/1237510167
+  :replies: []

data/data/solutions/reddit/ruby/2021/20.yml

@@ -0,0 +1,82 @@
+---
+- :author: oantolin
+  :url: https://www.reddit.com/r/adventofcode/comments/rkf5ek/2021_day_20_solutions/hpd67g2/
+  :body: Another nice and easy one. I represented the infinite image as a pair of the background pixel state and a 2D-array of bits for the pixels. Here's a Common Lisp [program](https://topaz.github.io/paste/#XQAAgAD//////////wAUGQimgx+p6PZhRh7uIO5BVNPIdKEN9R6L6scYP/cAtBpttmBcgWreKz63ht/gJSzjtvO4chAn6ZfcoR0DXWrYkvC8H/QG01B9a4HC8MoJR96YoTr9mETWtJrmJyK0h4tDxxZfRzcOJkqt2/lSGETvOMlvKy/yR95Gw/NQqsA8paa+UNcnqTz8QiQm3Cu0xpJsLZW39bm3IYbrY1pPW0qnEraIm7E3evFhjoQZ4/NzDUNrnfUs+5WWCYsXiHMA55NVYziJt58pcFueeeVD1VUE6EPHEdsft4pobxD/RBl9HHzrROUIWDIVzZ6EUSsygIqIVGEhC5FBIV0spVYtE9nS4qpGxeMoM9l1GfjPawkGrvtrubYnbgJag6laI2/OD4thVrIKNvAZpkEKATVBQiS/+ObhMFrOoL9QOZTkoDjJi/vqgHgS3VvI1DxD6RrRv0riTy//iFV057ir47bomGG2/LZoC13BEetVMfd8UogwunoXYIuc47m4flV/tnlvDVigafmjdgGxnTDwgWe7YPORfvMfuP81Mn9pid4WwsecPagk4GI8M3Th9VMXQF7KseVO7M2PPQtBnBjZtCsN8YJZAiGaZ+z0IiApVeN/t5JA+KqVZvh+9GlqEnOVNB8T35szNHZAfBr++DNqInj/NvxaAjjz8atmdgO5xuOVbDOGwRqnsCKx5oCPbK3bn2U4ZgeirbmS2+YQA/7+j0trTVtZwLBtfEGAPCbL+W4grzL6LS9ze99DarpORC8ueB99ckBWe0OJUnCMux/ivj/YHM62f7wLtoxynLVabMeFEBnPq0eGAExuZAM7T43BcXK596ANAbLkCSXzU9fQqMvNhqcwHO/Be0knOF45ywmwk3NiwvzRdSo=).
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rkf5ek/2021_day_20_solutions/hp9gnx3/
+  :body: |-
+    Ruby, 27 / 48
+
+    This code takes about 1 minute to run.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBABAAAAAAAAAAwmwkaZkNyucjRo5PEOiSLn/5zr9kB/QThE8vgTmi6oyT3+aXlhUW0ABt1nAPo6i/3sWbYF3R2eNo/qYKrAqTKXlgwUw7K8V+VHzxODyW853Ng1JXJ0T1s3UJNhF8KIYkcmBg+uHC4jW/+NvwmBL1NCTpY8aDLI79EU/So+Idud4uR+V/FucK4MgVoGt6CRyqCTd2Y92QjiX1C9PLKguDKRHgyp+KwXFpYvOLMvDmTBUXR/+P8+UaiBRi/gjAPiZCx8LC5xIi4ByLrgLf4ydgDhEXelaGw93JlaAI7eklEzyUO6trKA7Xq7+ccUygH0/Vuf1yNXmaCWtq0YwT/4WzLrtW8ECbaC8RXvAFMlpEzOB83CF9g/ktgtJ5WJZYDn9u6KrwzyTk5yHxsXbGHQJ3ldWF4BiUdiEUWUlsoChfizRcBiCNo+waWRWMvMLknVHE6zmDEL8+yzIbIIlSicZvfFlskvPTfAPN4vhszYDSP/e3xZOvhWk1ripjwtIKw8gN/y6ExJBmNqxWi49b72HLA3PodioYT56o3SpTq3aEYLVMdpVIPWKkA+A5OY7vxytL3t5mbhSHsMxZPZgWaRJHvaHVse2LzhGLBLiObW6GB/S2gE29ycigcf265hyziY/7+t57/zqPBJ7eZZR9LAusQxeyehczK8f74BRAm)
+
+    I saw that the first character in the real input is `#`. My approach to solving this:
+
+    - Known rate of growth: Every enhancement increases the image bounds by only 1.
+      - So the bounds used to count the lights in the final image is hardcoded.
+    - Use a lazily-computed, memoized, infinitely-sized sparse grid.
+      - The input image uses a Hash using `[i,j]` tuple as a key/argument.
+      - The enhanced layers implemented using a Proc with `[i,j]` tuple an argument.
+      - Both Hash and Proc has a common interface: `image[coord]`. On the Hash it looks up the value, on the Proc it invokes associated code. I love Ruby’s polymorphism.
+      - This means `50.times { image = enhance[image] }` finishes instantly because the enhancement is lazy and each pixel is calculated only when the pixel data is accessed.
+      - Using `cache[key] ||= begin … end`, the pixel’s result in each layer is cached, which speeds up the calculation by a lot.
+  :replies:
+  - :author: Floozutter
+    :url: https://www.reddit.com/r/adventofcode/comments/rkf5ek/2021_day_20_solutions/hp9qaw8/
+    :body: Kudos! I tried to do the exact same thing in Python, but I was much slower even with the help of the standard library's `functools.cache`. ([Python](https://github.com/Floozutter/aoc-2021-python/blob/9d9800c94bf66890a0123a744352bf2fd8d7105f/day20/main.py), 1680/1482)
+    :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rkf5ek/2021_day_20_solutions/hp9hlzi/
+  :body: |-
+    Ruby, 330/250
+
+    I did the thing I normally do with 2D grids, just put everything into a Hash with complex number keys (real part = row number, imaginary part = column number), because Ruby doesn't have tuples like Python. Then the only trick is to remember to flip the default value of the Hash from 0 to 1 or vice versa each iteration.
+
+    It takes about 10 seconds on my laptop to run Part 2, plenty quick enough so didn't bother searching for a more efficient way.
+
+    ```ruby
+    alg, data = open("input").read.split("\n\n").map{_1.gsub(".", "0").gsub("#", "1").split("\n")}
+    alg = alg.join("")
+    rows = data.count
+    input_image = Hash.new(0)
+    data.each_with_index do |row, i|
+      row.chars.each_with_index do |col, j|
+        input_image[i + j.i] = col.to_i
+      end
+    end
+
+    def read_neighbours(c)
+      return [c - 1 - 1.i, c - 1, c + 1.i - 1, c - 1.i, c, c + 1.i, c + 1 - 1.i, c + 1, c + 1 + 1.i]
+    end
+
+    def transform(input, alg, rows, step)
+      orig_default = input[20000 + 1.i]
+      output = Hash.new(1 - orig_default)
+      [*0 - step...rows + step].each do |row|
+        [*0 - step...rows + step].each do |col|
+          lookup = read_neighbours(row + col.i).map{input[_1].to_s}.join("").to_i(2)
+          output[row + col.i] = alg[lookup]
+        end
+      end
+      output
+    end
+
+    (1..50).each{|n| input_image = transform(input_image, alg, rows, n)}
+    p input_image.values.tally
+    ```
+  :replies: []
+- :author: klaustopher
+  :url: https://www.reddit.com/r/adventofcode/comments/rkf5ek/2021_day_20_solutions/hpa1nm8/
+  :body: |-
+    [Ruby](https://github.com/klaustopher/advent-of-code/commit/c26699666014342b17a93d5c8fc332ce4fa6d07a)
+
+    First, I am really happy that Ruby allows setting a default value that will be returned, when a key is not known. This really helps keeping a lot of the boilerplate checks (are we still in bounds, etc) out of the code.
+
+    Also this year has tought me that a lot of times it does not make sense to create an Array of Arrays to store a matrix, as this will explode quickly, but instead going with the `Hash<Point, Value>` "pattern".
+
+    Really happy how it turned out, eventhough it took me a while to find the solution that I need to look at the 0-index item of the "algorithm" to figure out that I need to flip the default value.
+
+    Cool task all in all
+  :replies: []

data/data/solutions/reddit/ruby/2021/21.yml

@@ -0,0 +1,37 @@
+---
+- :author: akanet
+  :url: https://www.reddit.com/r/adventofcode/comments/rl6p8y/2021_day_21_solutions/hpe3ocx/
+  :body: |-
+    [Ruby, 300 something / #40](https://gist.github.com/vincentwoo/7fa2e268e38fb4f24ff574bb7aafa5cf)
+
+    This one has a really straightforward expression in Ruby and I was pleased to hit on the part 2 solution very quickly! My best time this year. Ruby's array#product + a simply DFS formulation with a good base case and memoization makes this one an execution of a classic genre of CS exercises.
+  :replies:
+  - :author: dtinth
+    :url: https://www.reddit.com/r/adventofcode/comments/rl6p8y/2021_day_21_solutions/hpe4a4j/
+    :body: |-
+      Wow, that was short and sweet, congrats!
+
+      I got 126/208 with Ruby but overall approach is similar as yours. [part 1](https://topaz.github.io/paste/#XQAAAQBrAgAAAAAAAAARiAaHkimM1L0GLNx/znbFBIXJUq4OAYq7F5gsWSI/Zf/cROCWdXwSvBaCOGeH7dkU0VjqJgnGDcQAgrt8e8ilKTeF8Wj+TB24EBkFl5j9z7E/CQeCOIEUIChQLjvYHGsRN6mpe2K4dM8/Cykv5JSYkDXvg4dXJ8BTfIFzppQd5jOzUjAkDzPcoSKixeFnEUxyhCjXUK8hNoGsjDrTvKk3l+ZEG9HXBzYrJEm2sD16dtK7SIuy7kDO5XSLYUUr8Xcp33EmnZhfGRDcqoflZ/1QtuCad0TBoJyFdpiMhC4SuunCWEl9RpPKZA6/FQyWWOrKGohmniC1tJnTfBvnE2rwbN6kk+fGfviGaA3SngdP6xXdtdSCMSAKhHOB/+cPXGI=), [part 2](https://topaz.github.io/paste/#XQAAAQDrBgAAAAAAAAARiAaHkimM1L5fGNx/znbFBIXJUq4OAYq7F5gsWSI/ZgRsWLZU530cwM0amFHmyGStC1BzErFR7hOKRgW/uaJYbDQVuNCREoNP+iLglL5pGLhKwxlmKfT2pc4IGe2Flsd73pzSEhNk7doP3k+jTo2Gfz3gVmtGjttC363vHXtKkAWo2i+2vjzFQb+WIxm/3fFvikFewghYM/1OJB3HkzudkCmG4mvVHX9XCHDFpNo6PX8iAW8E+y8BE5LjnOly2HJz2rOpTkZ1o52fHDtw1x5ggxh46XJAupT1S7kUmZaz2sCPbHW5ZXIH+B3Kka3Ovwi0Dz/UeULdUNzZnAonH3YlbozRJlA1yT7Vc1HUn5ndA9a3YYX/YvIh50afOR/Nx9YfwpiLf5EKk/2l4EtdgVx6ZyHZEns8y3rMMq/On5Ma+cw3gAkwg2AnViOnDE5pNJ6Uv0pYBbX7qhR+EkGe3Ve+y0uO4gLIpUfNZLysEhH7A25UFoUrpcK9k5ELLxTEZtr4WeDYT7bLrVcmCxfbHOs44YYz8SVVVc7+q3HRl3EtcL/IpIXuIq0BbqR5u6YRSNZsOURHmXAPIFKHEtBTc7i8gMlTt9xyOfmyYCslbV4Nwa6yEqwOVjjShIFJ7jupallDBWbIvPOzMYRsRDNrY+95bYyOuFdyFO2SF7TgJwsVn77wuWxhVw2MtVGgBrC6pc2+ZeCO8mhrbdPFA9KBkyS+2HBuEXNe3Yzq23m7V46/5iWAqjQKeu8F0AKk1+or8+wnPktxuBPKX6cUmiKPA0TnBKy3e2xUsg89OL63CcV6gztZwR32PIVseXni//aQs/Y=)
+    :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rl6p8y/2021_day_21_solutions/hpe8olo/
+  :body: |-
+    Ruby 520/670
+
+    [Paste](https://topaz.github.io/paste/#XQAAAQB6BQAAAAAAAAAyGUj/T013v+3M6iPeYaEYKjDOPj+SunFjyKu7G9tDJ4VlnFyoEt+BNzGPSzhCpeeqi5Vn4HaG4tVCwmpi/pqc4HpKDpR2uJ+niIJuJ9VGRIbrfV+fMg85nxphrRuiwhHftRx7jYRK75lJBr9kr5jj5oJE21h3yWQfobm2s+otwnbU1Y9y24LskUUk3pbi9G3Aeh5QU8i/SPbvRN2z1Iy5mA2YrAlb3tJSktQZizSYUwZ+KD8UVAyP4ieknB4QthPFXnpxdJRp2GZxLtE5MBPBxEp9CBYEc/cPB+b1HcbJ7KjrcuPvR4Bqy+XA9AKbhuuynL+67zFZsDFlRU62OKXMDUEDM44XCaeXjeQyeyhh2m4rkbloxcuPCvwmF1QJK4xPmbxUZn6z5IxY+PbC/ljospg9QIpQSSvWoDa91Vu0foTziLkMBjWRcFTVmtJlaw38io5g1XYT9GOwKiuzOhil2zSq9qaI951/FBIaeuugy01/4vqQCyJFjQDzn+v23IoKzL/w76lOxcTQgDWhklFTdV3Ut1/jeXJYfKhQzxTmQjJHl2wQxXDfSAlR5ilzC4vz3VY+omej6QLqAujWtfvmmOvRwvvRa1Cbbulx0GTPT5xDNtKalNKTRZo9BOd8grW5lyOhk5DeV2Ot/0uWONT3GVhUebW/ZOqUEpbqRoKFg1GgS7cs1mv2Hu/NnJUG683oMGNr3f7+q+4=)
+
+    Pretty straightforward day. With only 27 possible universes per roll, it made sense to hard-code a Hash with the possible outcomes without writing loops for "roll each die as 1, 2, or 3".
+
+    I'm surprised that, unlike the clownfish day, you could still run Part 2 in a reasonable amount of time (~30s) without memoization. With memoization, it runs in 270ms, and even if you set the winning score to 50, it will spit out a 35-digit number for how many universes Player 1 wins in within 5 seconds.
+  :replies:
+  - :author: 1234abcdcba4321
+    :url: https://www.reddit.com/r/adventofcode/comments/rl6p8y/2021_day_21_solutions/hpe9o8r/
+    :body: There's never been a puzzle that requires numbers larger than **53** -bit integers. So they'd definitely need to make the question ask for something different if the winning score was any higher than like, 22, unless they decide to break this restriction they've always had.
+    :replies: []
+  - :author: rabuf
+    :url: https://www.reddit.com/r/adventofcode/comments/rl6p8y/2021_day_21_solutions/hpe8u42/
+    :body: |-
+      I like your use of complex numbers for the return. I'm usually very quick to use them for other problems, surprised I didn't think of that today. About to give it a shot and see what impact it has on my performance.
+
+      Curiously, that doubled the runtime versus my initial list-based version (return a pair).
+    :replies: []

data/data/solutions/reddit/ruby/2021/22.yml

@@ -0,0 +1,25 @@
+---
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rlxhmg/2021_day_22_solutions/hpix5qp/
+  :body: |-
+    Ruby, 145 / 45 ([Part 1](https://topaz.github.io/paste/#XQAAAQAVAwAAAAAAAAAyGEruliPhN7cj9y4sPOl/eSs4uSkd5mZOCSu8uBmXEkoNkgiNtw8yNqy281DF4KLR1oO9DUYIGNjSuOdzoZcTAVrDKG3xJhkRhzxhbpPRNzcTb9s6dc2vWNGToQR0qwGEoOdG9MdPQ0pfIYd5QRU9qaKEoKaHLCepEdH5rFR7Lc4zX1tN/5bXESYuudEm16AplawF91xrWX/ZCbIrfRGcLtDDV6HkLkybcvSErDKo1D2Nmnm3OGcuNyscGJv10AdB4R4vFNUvrEpRY6H6+bAxT/9VmRy4e3wekDEOuldZkT7UBgWCwfqyodKqgUX5Dfc7FaMntMhSms7mDvUyIZoZMZ0HiulPVlJqQ2AoDnUnU/GqAmwdBuGFFbTjBlTTInBfv9rbs0wKAbPtlSUKOXKvqnAf//Y4JaQ=), [Part 2](https://topaz.github.io/paste/#XQAAAQByBgAAAAAAAAAhnUhGbrHQXPsQ7Mdo7ZkPpEmH6VBEqcrPU555F7dPhTDZyB3YHrPiTHCDGPZS3zQLgj+SuYga60UYXUu3Pr4KKA5lZ+ah+f6sOZAYO5tsCTg2gEeV5+Bb3+lEdnL7bH/OGqF2jkd8ohf3LpdA4IaqbMKbMEduoIw1+IcV8c98Uo95NWGuUpZt6C37i8OptMuPPlep4DREPfksBh+92S6sQxFF1OSIntiYn8ete9cOtsSTSJP7NIQOTosYEjP/KVHI1x6G8yL9Lo526nRgTXUj52BST9M+4FDcjlbSImYsG1fu3z2iN5t3oMuqCOEZ1ajKiYouBndPUapg7xVV2C4x3h3boFZJNVgJmXR/4uKoTcakKMGj377A3hUCZ3+rLEZ01ZqgAv9xPpkQufxd9u5rvB7xTYOTuaUI0GPSFlYgb88ZXsXwOA69i37l4n3iuY5r01UeGEW+Ko6OrokcJehFZEh/mTKZMXvoR0NlgKvkzQYXbslJZ3pyImvPezUw3H1P/qLA8HTnpEZJ7mle0k2+Ya3YcMcfI2J2lFOuG0gYkGFQmul4livkzwav71+Zb5mCW6eY5UCA2u4RTsBKxNSw9q+IsfDB0ABlt6q6TW8PhHCi+0OJYxsnmJAbd1QqK7KTEMwUTgCoBULCzzUq6Isy2SVe9lc5UgBHxLLVqxNvA3dProx92Q31jWIW9LssWHNoeHGJ7DX8NPM4rHNnp2NXljR5APn0VR9atOFBm9olBZknp9a0Fplg/YpM5OJf/Mz8XJb14F9z7PCV3qkZYyHnKRrEXvfB0XxRDxaCm2fR24qIowEbWj67h1FA2bxI+///uqv2OA==))
+
+    My part 1 uses naive algorithm. For part 2, if a new cuboid intersects any existing cuboid, they are broken down into 27 parts, and the parts that intersects the new cuboid is deleted.
+
+    Here’s a diagram showing how the above approach was implemented: [https://imgur.com/WHPsnch](https://imgur.com/WHPsnch)
+  :replies: []
+- :author: '0x623'
+  :url: https://www.reddit.com/r/adventofcode/comments/rlxhmg/2021_day_22_solutions/hpk0e3o/
+  :body: "[Ruby3](https://carbon.now.sh/?bg=rgba%2874%2C144%2C226%2C1%29&t=material&wt=none&l=ruby&ds=false&dsyoff=20px&dsblur=68px&wc=false&wa=true&pv=56px&ph=56px&ln=true&fl=1&fm=JetBrains+Mono&fs=14px&lh=152%25&si=false&es=1x&wm=false&code=class%2520Cube%250A%2520%2520%2520%2520attr_reader%2520%253Ax%252C%2520%253Ay%252C%2520%253Az%250A%2520%2520%2520%2520def%2520initialize%28x%252C%2520y%252C%2520z%29%250A%2520%2520%2520%2520%2520%2520%2520%2520%2540x%252C%2520%2540y%252C%2520%2540z%2520%253D%2520x%252C%2520y%252C%2520z%250A%2520%2520%2520%2520end%250A%250A%2520%2520%2520%2520def%2520and%28c%29%250A%2520%2520%2520%2520%2520%2520%2520%2520x%2520%253D%2520%2540x%2520.and%2520c.x%250A%2520%2520%2520%2520%2520%2520%2520%2520y%2520%253D%2520%2540y%2520.and%2520c.y%250A%2520%2520%2520%2520%2520%2520%2520%2520z%2520%253D%2520%2540z%2520.and%2520c.z%250A%2520%2520%2520%2520%2520%2520%2520%2520Cube.new%28x%252C%2520y%252C%2520z%29%2520unless%2520x.empty%253F%2520or%2520y.empty%253F%2520or%2520z.empty%253F%250A%2520%2520%2520%2520end%250A%250A%2520%2520%2520%2520def%2520vol%2520%253D%2520%2540x.size%2520*%2520%2540y.size%2520*%2520%2540z.size%250Aend%250A%250Aclass%2520Range%250A%2520%2520%2520%2520def%2520and%28r%29%250A%2520%2520%2520%2520%2520%2520%2520%2520l1%252C%2520r1%2520%253D%2520minmax%250A%2520%2520%2520%2520%2520%2520%2520%2520l2%252C%2520r2%2520%253D%2520r.minmax%250A%2520%2520%2520%2520%2520%2520%2520%2520%255Bl1%252C%2520l2%255D.max%2520..%2520%255Br1%252C%2520r2%255D.min%250A%2520%2520%2520%2520end%250A%250A%2520%2520%2520%2520def%2520empty%253F%2520%253D%2520size.zero%253F%250Aend%250A%250Apos%252C%2520neg%2520%253D%2520%255B%255D%252C%2520%255B%255D%250AINPUT.each_line%2520%257B%2520%257Cln%257C%250A%2520%2520%2520%2520%252F%28%255Cw%252B%29%2520x%253D%28.%252B%29%252Cy%253D%28.%252B%29%252Cz%253D%28.%252B%29%2524%252F%2520%253D%7E%2520ln%250A%2520%2520%2520%2520c%2520%253D%2520Cube.new%2520*%255B%25242%252C%2520%25243%252C%2520%25244%255D.map%2520%257B%2520eval%2520_1%2520%257D%250A%2520%2520%2520%2520p%2520%253D%2520neg.map%2520%257B%2520_1%2520.and%2520c%2520%257D.compact%250A%2520%2520%2520%2520n%2520%253D%2520pos.map%2520%257B%2520_1%2520.and%2520c%2520%257D.compact%250A%2520%2520%2520%2520pos.concat%28p%29%250A%2520%2520%2520%2520neg.concat%28n%29%250A%2520%2520%2520%2520pos%2520%253C%253C%2520c%2520if%2520%25241%2520%253D%253D%2520%27on%27%250A%257D%250A%250Avp%2520%253D%2520pos.sum%2520%2526%253Avol%250Avn%2520%253D%2520neg.sum%2520%2526%253Avol%250Ap%2520vp-vn), algebra of sets."
+  :replies:
+  - :author: veydar_
+    :url: https://www.reddit.com/r/adventofcode/comments/rlxhmg/2021_day_22_solutions/hpk37xp/
+    :body: Your code block doesn't display correctly on https://old.reddit.com/r/adventofcode/comments/rlxhmg/2021_day_22\_solutions/ since it doesn't work with backticks.
+    :replies:
+    - :author: '0x623'
+      :url: https://www.reddit.com/r/adventofcode/comments/rlxhmg/2021_day_22_solutions/hpmwb99/
+      :body: |-
+        Thanks for noticing.
+
+        Just woke up in my timezone.
+      :replies: []

data/data/solutions/reddit/ruby/2021/23.yml

@@ -0,0 +1,39 @@
+---
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hpnimr1/
+  :body: |-
+    Ruby, 613 / 24
+
+    The code for Part 1 works for Part 2 almost unchanged. It is using the A\* algorithm, with the heuristics function calculated by using the energy required if moving through other amphipods is possible. Using OOP (classes) allowed me to think in higher levels and helps me avoid silly mistakes.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQCVDQAAAAAAAAARiAbIwVXFxjAJJHIZV+wBHEZFeC3GZ4Ka+BhTFElBsHSTqIHYjGdGmAgAx34U7qbprjAArkbhNA4RwfhdWIWgbhzrjvP0U+CNMAq9615LgkDJKZkBtXDZ9wjkYS/Ozhnun4JZ218tnYALzAs4dUlmQaGj9FNfjL5zYTOVEBSjBkf6SXebMNod9Ff+pAm5zYqH41osDGHdQv4zZwwCjpda32zs9WbZhl0j2OMZ6ERxgyt5hfNinBY6Qg8JgFJVDCrZv8oDcO6CTsB69Zfju6DcoZebFjrHucSMr2bLASJPDcoZUrmXIfGTf7Fkycic4tUX++lHD5il82COmUxz1sSJG5VUc/9U/oDYctfE1rUHQwQHZix6DOc8yQCQUR4hXU8Eofo6S2CIYbRDgZIcLtY7Jqo4vX5gGHNEgJWgJUywghg4rsE2STbunDGdLBBQWidtD0jsQerIQHhE8AMlDGgsapwzjy8KUtC7GAvRXS/ouB7cd48NBOc1BNvz/uSDM3OAAGwuKOoKOBj0ErYzMThOJ7ABWyu3q9fKoW5QDESh4gNn86jB037AEFYgl2ezMq/K2eIYdmLC779bmFNLokPnYxypJMAJArmHlILpd+vNccIRsuQQtCpvLpQ67fDLaSXIZHZmPsGJDX1SUL9tp3viPep8WrMvKBV2Z7deXUBnM9SsY8XNJea7b7Nuo8NaBiWo72kUoj/aVLXK3Jfyk1NSPUhg6JHTF7/QTjRopqJv2IP3vvg0hiTxJeNOtqlP9qCyudDeFj5DvoAdFxXiMMIIH7vulwIF1pb06dnk6YNlItbRtSvJPSFdnnWvHSi2rXp6++vWp3itONil1il+8F21t1GdQSmP8jNxFKyKJ2DsCsuqFImVWNicUCZPAlecz/NqV99YUJZsVuzUzIu2NROEfigOdtX2QxmOzl48mDkFG2VFCQrH0JOoQFy+xXNZQPrZ5Dw1dVo3wBV0QoivDMEkDEYRRXBVjW7oSDKou92lK6KGkdCRVvqlXW/KfEp225MAZBQLT/Mb2JTFIcfe+IPo/iTEqfmXgIAAxsJDxVlbXfVRt5AUP03PWB7xDwMBWg9jiqcsXAY0fdtIkIhPkhdu4antj1gqAl0qX3F3PknSN/RS1XgG5Y+8/XWroXMgHMMQ7H87La5/7KCCHfKTls5fiEqgkpUqu8hT568A73rcH3CNQWk2npQCwcOeVd2tcttxRt11rNJLEEBPzb7gyxC85sJxYSJ+4MkJs/do4uOvOA1A9qvWC/Wer+p2nXWcYpNmb49AmzTFQvKQWVJXhscM3D8Om+YeGBIgE/4ekFKR9GEAgSGbidTT/ra816NUFM5246DWZHhT+zyDK+jdCSZCDDu3T3l2MV+6RoeKZY5KTsOyLlZ2BPuYS9z0c4tDKOd7sK5e+qC7LnexD3b8xNNh7LqMGzc3gE6q/Z/kH5SB2WroCvwh5n30fInRPaFF/3BKaQA=)
+
+    I’m not sure if there is some kind of shortcut that people are solving Part 1 so quickly, but I was quite glad I didn’t take it, otherwise I would lose more time in Part 2.
+  :replies:
+  - :author: PendragonDaGreat
+    :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hpniv5a/
+    :body: A lot of people (myself included) solved part 1 by hand knowing it would bite us later all the same.
+    :replies:
+    - :author: NecessaryWolfie
+      :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hpnkj1p/
+      :body: Part 2 was doable by hand too! At least, solving part 1 by hand did not come back to bite me.
+      :replies:
+      - :author: dan_144
+        :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hpnr2ir/
+        :body: I did them both by hand knowing as I did part 1 that it was a gamble on being able to do part 2 the same way. After a few misfires on part 2 I considered switching to write code, but ended up sticking with it and even improved my standing a bit.
+        :replies:
+        - :author: M1ngXU
+          :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hppgnmw/
+          :body: |-
+            > but ended up sticking with it and even improved my standing a bit.
+
+            same, but gave up after 3 hours. should've read ALL the rules though (didn't saw rule 3)
+          :replies: []
+    - :author: "[deleted]"
+      :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hpntj8k/
+      :body: "[deleted]"
+      :replies:
+      - :author: PendragonDaGreat
+        :url: https://www.reddit.com/r/adventofcode/comments/rmnozs/2021_day_23_solutions/hpnuatj/
+        :body: Yeah, I did some arts and crafts to make a board that I then slide little paper tiles around till I got the right answer. Worked way better than I was hoping tbh, and saves me from trying to figure out how to code a solution.
+        :replies: []

data/data/solutions/reddit/ruby/2021/24.yml

@@ -0,0 +1,87 @@
+---
+- :author: pedantic_git
+  :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hq1lrig/
+  :body: |-
+    My first time commenting but just came here to say how much I enjoyed this puzzle. I went down loads of the rabbitholes here gradually getting more and more complex in my analysis of the code but as I started optimizing at every step (being aware that the "mod 26" at any step would always correspond to a specific digit because the offset was never greater than 15 = 26-9) it eventually became apparent that the digits are effectively paired with each other and the algorithm could be reduced to just:
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    w = ARGV[0]&.split('')&.map(&:to_i) or fail "Please supply serial"
+
+    if (w[3] == w[2]-7) &&
+       (w[7] == w[6]-4) &&
+       (w[9] == w[8]-2) &&
+       (w[10] == w[5]-8) &&
+       (w[11] == w[4]+3) &&
+       (w[12] == w[1]+7) &&
+       (w[13] == w[0]+4)
+      puts "PASS"
+    else
+      puts "FAIL"
+    end
+    ```
+  :replies:
+  - :author: Fjodleik
+    :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hq4lwp5/
+    :body: I also enjoyed this one a lot, but I can understand some people did not like having to “solve for the input”. Once you notice the pairing, though, it becomes so simple. I kind of brute forced the search for section pairs by trying all input values with all subsequent pairs. The ones that left z at zero I removed and repeated until there were no sections left.
+    :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hpsvnvp/
+  :body: Ruby, 2504/2383. I took a 5-hour break after the leaderboard capped. Converting assembly code into Excel helps me to understand the code more easily. [Here’s the writeup.](https://notes.dt.in.th/20211224T121217Z7595)
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hptf9hd/
+    :body: THANK YOU, this really helped me when I was stuck!
+    :replies: []
+- :author: '0x623'
+  :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hps8zzq/
+  :body: |-
+    [Spreadsheet](https://p.sda1.dev/3/8ec8161a31bce96c098e0bb848979b85/image.png) 437/524 (w/ Ruby to convert input into cells)
+
+    I think the essence of today's challenge is a stack of 26-based ints;
+
+    the goal is to feed register `w` with int value `1..9` to make the stack empty at the end.
+  :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hps5dit/
+  :body: |-
+    Ruby / Solving by hand
+
+    100 billion is too many entries to brute force. But when I made it print out the values of [w, x, y, z] after each instruction, I noticed a striking pattern.
+
+    Once I realized there was a pattern, I looked through the puzzle input line by line - it's divided into 14 equal portions, each of which:
+
+    - begins by taking an input into `w`
+
+    - copying the value of `z` over to `x`
+
+    - incrementing or decrementing by a number, and then comparing the resulting `x` to `w`.
+
+    - if the numbers are equal, x ends up getting set to 0, otherwise x is set to 1.
+
+    - then, a few instructions that will roughly multiply the number z by 26. But if x = 0, there will be an adding 0 or multiplying by 0 somewhere along the way that prevents this.
+
+    The key insight is that as long as `x = w` every time that equality is tested, a bunch of instructions will zero out and leave you with a zero or a very small value in `z` (it's a zero on the last step), but if not, `z` will grow astronomically large.
+
+    (I'm not sure how different other people's inputs are, but I assume the principle should be similar)
+
+    EDIT: Looks like everyone's input works the same way. There are seven portions of instructions which cause z to multiply by 26 (roughly) i.e. add a digit if z is represented in base 26, and seven other portions that give you the opportunity to divide by 26 i.e. remove a digit if z is represented in base 26. There were only seven opportunities out of the 14 portions of instructions where x could equal w, so you have to take all seven of them to cancel out the other seven portions where z will increase no matter what, and leave you with z = 0 at the end.
+
+    Eventually, I discovered that any number `ABCDEFGHIJKLMN`, where each letter is a digit between 1 to 9, will result in z = 0 provided seven specific criteria, or relations between seven pairs of digits. (For example, one of them for my puzzle input was K = N, so I set both K and N to 9 for Part 1, and both to 1 for Part 2)
+
+    [Paste](https://topaz.github.io/paste/#XQAAAQBnAwAAAAAAAAA0m4rOIJ/Vs98O8bk0HwBwC8CGP7GAHnowSbHmnjBGuFEw3moG4b3uTDNNGuQ8NldxbVfto+7W2Tao22AB/fFKHY802kKbeuLgR4F1jN47PXuJnmKNsr6+N3K+5zgaNC/uYi/VpcJKZRlJcnbMFk4/K8bSezUy/cVzgulNb6XlVq/pcNkdXi0Ejgo3FWsYIIfL6LCJ4fUYPJl5oSAy4PvBRwh6UJw0LjCtmQuBJBCipjQEHG97ZKPNUvDwFseUXxcG9zg2dvOHvq/BAoaiXKgFdEdB+tw1wm7vVVQQaA6LdjKGJllEUImFP/3FUGoHXnp6pvlwQdcChDQj5mG5chZdHE7p37hjsjdnEv3z5YvdDv1ErANPDYzQlusG1hwzSvsQjZOFMwohpSOvtpbzIGR8z4AeXLfLs/xqn4cjc40pEVpnVfSoS5ugdWvqeW+mVtj9QsD1VR9q1FGIUWHaa1oKI69EmoiMhi3w6wfHaeXBFXg/GX5jvTUAo0mE22nxl63aYTJZn3+Swf+POpGg) of my code - but I only used this to verify an answer I derived with pen and paper.
+  :replies:
+  - :author: TheZigerionScammer
+    :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hpsg1kv/
+    :body: I'm surprised you had a relation where two digits were equal to each other. All of mine were offset by a number. K = N + 6 or K = N-3 for example.
+    :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/rnejv5/2021_day_24_solutions/hpsnckl/
+  :body: |-
+    [Ruby](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/24/monad.rb) (1566/1482)
+
+    This one hurt my head for quite some time, trying to keep track of all the possible states while going through the code manually, reverse engineering it. In the end I realized that keeping track of all the possible states where the formula stored in `z` just continued to grow was a silly idea, [giving me a lot of parentheses back](https://xkcd.com/297/).
+
+    Now my generalized solution extracts the relevant values from the input code (after verifying that the input follows the expected format), constructs the max and min valid inputs and, (since I had already implemented code for running the input) verifies that they actually output 0 before showing them.
+  :replies: []

data/data/solutions/reddit/ruby/2021/25.yml

@@ -0,0 +1,44 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/ro2uav/2021_day_25_solutions/hpwmry6/
+  :body: |-
+    ## Ruby
+
+    My original implementation took 1.7 seconds to run my input. That was unacceptable. Got it down to around 200 ms by representing both entire herds as a single huge number each and using bit shifts to check+move the entire herd at once. Much better.
+
+    https://github.com/petertseng/adventofcode-rb-2021/blob/master/25_sea_cucumber.rb
+
+    Core:
+
+    ```ruby
+    moving_east = east & ~shleft[east | south]
+    east = east & ~moving_east | shright[moving_east]
+
+    moving_south = south & ~shup[east | south]
+    south = south & ~moving_south | shdown[moving_south]
+    ```
+
+    Haskell code for the same (https://github.com/petertseng/adventofcode-hs-2021/blob/master/bin/25_sea_cucumber.hs) runs in about 70 ms.
+
+    I'd like to thank Eric and the team for a great year. Hope to see you again next year.
+  :replies:
+  - :author: oantolin
+    :url: https://www.reddit.com/r/adventofcode/comments/ro2uav/2021_day_25_solutions/hq19xtj/
+    :body: Very cool idea!
+    :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/ro2uav/2021_day_25_solutions/hpwb7dt/
+  :body: |-
+    Ruby
+
+    Like last year, Day 25 was pretty simple and a brute force without optimizations will do the job (my code found the solution in 11 seconds)
+
+    [Paste](https://topaz.github.io/paste/#XQAAAQA7BAAAAAAAAAAyGEruliPhN/2VjNRwSh95yTuZN04pQWoN9g7bR/xYBHqIn30bXxNvltGCkq9colyBYz2lxQ5Kix+Qg8BmQRBU0nNIndpQjcjuiBTLW4aWb+cL9wOOwik7VkEgaq+RoiT4k0gLd+3bU4K0MiS/J23x1ZAjE6LZG6QIj1DjZX9zp2zhqnwZJAUEPF8M8g2gL+VDzKYPfo4/dAsUR5KUhKGZoCBOSoGfGjuTOMT1ILFNtOucv4HWHzQ9AAzJhE8smW/uRXChP+l0EXjtS1YfYbTi7VxymggFVnOcaw6cmR7nzvnJhmtENbFotynSxbvRs6SVcUHjgBpSqO4EBK2Gtloxzkz1NjWtZ4j1hY/yC/mqVGfRk7yv6TGRe5UR+m9ilrGuOhWynVxqJqx9nyNkuMO+CBCRB+y7gjOoY6/XC7fD8u7Xp8BZjqK/rfs2XBLsuvEgxA5Cuf0n4+aKENArnrMvQs6GnqUqZU0V7X/d14YrLNLnubRdOJoY24Fj3BOMQAY7F4zhW9eVR+7X6vW6J1/MApuZkdBxs2JKLywjUc77EyTJAyXtuMawM1HJac1kI+YA5Mb3M4hOrR8lrxJjBtrUywJt4SjelYkU1VDmGch0GN4+Or2MVaADHEzCMn4aNU41//cO3lE=)
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/ro2uav/2021_day_25_solutions/hpw071h/
+  :body: |-
+    Ruby, 46 / 48 [part 1](https://topaz.github.io/paste/#XQAAAQA+AwAAAAAAAAAxnUmZz3Bbg2Zrn8i5KN1LZO/GzeJFKsxXfmp6B4TL2X6q0SLGloC1tIU4BGykpxqN/HiB2eUZFeL6O+G3OwWsleA/eUqdw4KEwwFvAEhEddGCwRYrZiQeEE1zN9xmhraZuZchC0JOJrbeR2H3XfZ8jF9+pUhRjkMnykuE9G2k4yDwz3prPgp9a0tQkvZpXtVL9ZYDNw5eG2Id9hxBzO23mcyvr4cgHIeYw81xysx3zH0YwJDU7Rfh4KKZR+plHNO3pNHq6Y71Xb4W2lqL61Psa2bmjG5xFFei/P6YTHomuAN8g3O4wylk1ZSeeGJUYAOViPWEmWaaQA27lacDUYWv0AOqjodMQb6ynSXHJyb5wlV+0mB8S2e3euBNoJ7hSNlZlCewMo1Kdn+mxsCwr/QS67p9NfVD8p36p1vcCkERYAe4TMMgNxvmZvABWji9gX03LpvqGlktEvxtYK3MajMTWEBrMBk1sg1uIW+GJvthZVh6qdT2fFZQF98bOrUafdqhspPY20H1HHaatRxvEmbfMUXWZ2UCvQ9F0wsF3yf/+vv+jA==), [part 2](https://github.com/dtinth/advent-of-code-2021#solutions) (1366 points total)
+
+    That was fun, and it is the first year I got all 50 stars! Previous years I gave up when there is a very very hard puzzle. Enjoyed it very much, thanks Eric for running this!
+  :replies: []