advent_of_ruby 0.3.1 → 0.3.2

data/data/solutions/reddit/ruby/2022/14.yml

@@ -1,6 +1,6 @@
 ---
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06mkyf/
+  :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06mkyf
   :body: |-
     Ruby
 
@@ -9,22 +9,22 @@
     Video Walkthrough: [YouTube](https://youtu.be/PTmSGQnGoXM)
   :replies:
   - :author: mizunomi
-    :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06qhj0/
+    :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06qhj0
     :body: Well done with the solution, but please, as suggested, do not upload your inputs to public repositories.
     :replies:
     - :author: skagedal
-      :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06zveq/
+      :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06zveq
       :body: Where is this suggested? I've read through the posting rules but probably missed something. Or is it suggested somewhere on the AoC site itself..?
       :replies:
       - :author: mizunomi
-        :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j075a64/
+        :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j075a64
         :body: |-
           This is visible in the subreddit wiki. Usually, the moderator reminds posters about this.
 
           [Link](https://www.reddit.com/r/adventofcode/wiki/troubleshooting/no_asking_for_inputs/)
         :replies: []
 - :author: mathem17
-  :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j05q56v/
+  :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j05q56v
   :body: |-
     [Ruby](https://github.com/jzhang113/adventofcode/blob/01b815bbd93a405f590095393867beed301cd3db/2022/solutions/14.rb) 2010 / 3400
 

data/data/solutions/reddit/ruby/2022/15.yml

@@ -1,6 +1,6 @@
 ---
 - :author: "[deleted]"
-  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0ed50d/
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0ed50d
   :body: |-
     Ruby, Part 2.
 
@@ -60,7 +60,7 @@
     ```
   :replies: []
 - :author: kateba72
-  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0atlef/
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0atlef
   :body: |-
     ## Ruby ~13 ms
 
@@ -80,11 +80,11 @@
     [https://github.com/Kateba72/advent\_of\_code/blob/main/2022/day15.rb](https://github.com/Kateba72/advent_of_code/blob/main/2022/day15.rb)
   :replies:
   - :author: captainAwesomePants
-    :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0audhv/
+    :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0audhv
     :body: Love the diagonal coordinates!
     :replies: []
 - :author: mathem17
-  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0alfzg/
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0alfzg
   :body: |-
     [Ruby](https://github.com/jzhang113/adventofcode/blob/d95083d71d99277c0cac5b4ba2b07d6cb58df892/2022/solutions/15.rb) 953/408
 
@@ -96,11 +96,11 @@
     This mean we can work entirely with ranges, which is much faster than enumerating all the possible points. (Technically, the point could be on the edges, which would result in one range not covering the whole row, but I didn't run into that in my input)
   :replies: []
 - :author: akanet
-  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0bexon/
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0bexon
   :body: 'I spent some time trying to think of a very elegant, simple, and fast algorithm in Ruby. I''m very pleased with this result: [https://twitter.com/fulligin/status/1603369386085036032/photo/1](https://twitter.com/fulligin/status/1603369386085036032/photo/1), which basically finds the y-intercepts for all lines drawn on the map as if they were infinitely long, and then simply checks each of the rows for the missing beacon.'
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0cral9/
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0cral9
   :body: |-
     Ruby
 

data/data/solutions/reddit/ruby/2022/16.yml

@@ -1,13 +1,13 @@
 ---
 - :author: akanet
-  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0tmzbw/
+  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0tmzbw
   :body: |-
     After long thought, I've got my [Ruby solution](https://gist.github.com/vincentwoo/db6cf426bc3f5f6a23ad21e89315c383) running in a few seconds. I tried lots of different tricks, like running each search independently of the other on different subsets of nodes, but eventually got a full search working with both agents. A few things that were important were conceiving of each valve opening of having a total upfront value based on the current time, modelling the whole graph as just direct pairs between all valves, building in the opening time into those edges, and most importantly, having a good estimation function for being able to early terminate subtree searches. For example, if you have [20m, 10m] left for your agents, you can calculate an upper bound of pressure that can be released by looking at the minimum edge lengths remaining for each unvisited valve, and multiplying each of those valve values by the highest of your agent times, while decrementing that time by that minimum edge length.
 
     I got 48th on part one, and 1935th on part two, lmao.
   :replies: []
 - :author: ingOmar
-  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0ns731/
+  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0ns731
   :body: |-
     I was stumped on this until I reread Prof. O'Neil's comment a few more times along with his Perl code. And then I finally got it, and solved part 1 using a straightforward BFS in an iterative loop.
 
@@ -26,14 +26,14 @@
     Am I doomed to spend retirement doing programming puzzles (not that I'm anywhere near there yet)? If so, I know I'll be coming back to part2 to work out a faster solution. Please don't delete this thread for another 30 years.
   :replies: []
 - :author: damyvv
-  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0gkcxc/
+  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0gkcxc
   :body: |-
     Ruby Part 1 and 2 have a combined runtime of **278ms**.
 
     The [code](https://github.com/damyvv/advent-of-code-2022/blob/master/solutions/day16.rb) is horrible, but performance is great.The basic idea of the algorithm is to consider all the valves we can move to. We compute how long it will take to move to a valve, and we also precompute how much pressure will be released in total by this valve using the remaining time. Then, if there are paths that have an equal distance, we only have to consider the path that has the highest potential pressure release. This drastically reduces the iterations needed, hence the low runtime. Also, the distances are not precomputed, but they are cached. This is more efficient, since we don't need all paths (for example we can skip all paths that have 0 flow rate, as we will never move to them, only pass them).
   :replies:
   - :author: Laugarhraun
-    :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0goxqz/
+    :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0goxqz
     :body: |-
       Your solution does not look correct.
 
@@ -44,6 +44,6 @@
       Your solution happens to work for your specific input, but it's not a correct solution.
     :replies: []
   - :author: Healthy-Chemistry664
-    :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0gmv8g/
+    :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0gmv8g
     :body: I tried your code and it didn't produce the right answer for me?
     :replies: []

data/data/solutions/reddit/ruby/2022/17.yml

@@ -1,6 +1,6 @@
 ---
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0p56hx/
+  :url: https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0p56hx
   :body: |-
     Ruby
 
@@ -9,7 +9,7 @@
     Video Walkthrough: [YouTube](https://youtu.be/uwQoa2xkbfA)
   :replies: []
 - :author: SnooConfections2453
-  :url: https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0maq3b/
+  :url: https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0maq3b
   :body: |-
     140 lines of readable ruby code. Runs in a bit over half a second.
 

data/data/solutions/reddit/ruby/2022/18.yml

@@ -1,6 +1,6 @@
 ---
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0uweyj/
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0uweyj
   :body: |-
     Ruby
 
@@ -9,7 +9,7 @@
     Video Walkthrough: [YouTube](https://youtu.be/2L8gHiNnZ9w)
   :replies: []
 - :author: "[deleted]"
-  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0s1vh0/
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0s1vh0
   :body: |-
     Ruby, part 2. But it is annoyingly slow–takes about 12 minutes on my machine. Is it possible to speed it up without changing the approach?
 
@@ -72,11 +72,11 @@
     ```
   :replies:
   - :author: "[deleted]"
-    :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0ti4hn/
+    :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0ti4hn
     :body: 'Ok, to speed up 100 times: use a set to store cubes instead of an array.'
     :replies: []
 - :author: whezya
-  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0ryg57/
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0ryg57
   :body: |-
     **Ruby**
 
@@ -87,7 +87,7 @@
     I never used a flood algorithm before, so this is my first attempt, benchmark gave me 2 sec on my computer. [Readme](https://github.com/rbellec/advent_of_code_2022/blob/main/README.md) explain how to use it. Would be happy to discuss about it.
   :replies: []
 - :author: SwampThingTom
-  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0qht6f/
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0qht6f
   :body: |-
     I'm solving each of this year's problems in a different language, roughly in the order in which I learned them.
 
@@ -96,7 +96,7 @@
     https://github.com/SwampThingTom/AoC2022/tree/main/18-BoilingBoulders
   :replies: []
 - :author: jstanley0
-  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0op0zl/
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0op0zl
   :body: |-
     _Ruby_
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j142h8c/
+  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j142h8c
   :body: |-
     Ruby
 
@@ -9,14 +9,14 @@
     Video Walkthrough: [YouTube](https://youtu.be/FdZ_vpf-VEU)
   :replies: []
 - :author: akanet
-  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j0tkaz7/
+  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j0tkaz7
   :body: |-
     [Ruby](https://topaz.github.io/paste/#XQAAAQCBBAAAAAAAAAAlkUd1JxEvDhwoUT5C66Qze8FtdpxEzJYhvPke6qNjV4PA2OeOLQPreA1+6lfcYrgKm8Gq8wrgh9XN9tGh8PMAOkjwJbmMaPbeGa2JFbYbiQ9McQIo3cw3qvh1Ji/22fPb0wr9vMpep2wgEA1+U4iQ3Crqe3cPNymc83HiUEohFqNv8Xg552dPBw4BR0Zse85imqqc402jEEOFD+9eBeF78t17Gb7iPGWpbsLJMkhOmVDskfeJauN0Klgg92Ii31gLjD8SzUCMtf7r8k+cqVxs3JWlHxj77Ym79mEJ3EElGn7vHRaEAyCvRMW2+zv2JmPLdTAUbxpncHZRgO3sfqfgks74ao6TpJCHN0uvp5ZZQ5nK2S5xWa8tjet0lpE1TSzA6hZI6xWrY1c35XuBQjaAKus+VJb/2T9CpbzT/n8Eb3FtjdpAbaXrHJs/30B8y7ZlyebOsE4Nxe3q/z6Bd7Wa4N3csq8aljVrp3ZJgqMTKxW6pyPMmfdE2fQ/gGoIR5RDh7/br3yFbpubCzFSR1k0WbW8j/t37lS/O4qw2/xwwEqaAt3tyMz82sWehuuJWPY5WF9YyZ4WXTY9Tl0l+vEo3VcZ1xv1isgwwJarX/XUEalpLaT+Mv8LH614rIMpIGB9NlLS0zM32BNKpt7/+fl6OA==), 777/485.
 
     Here's a very elegant and terse Ruby solution that runs quickly with only one, incredibly hacky optimization: do BFS search but rank each successor generation by their resources and robots, from geodes down to ore, and just keep the 5000 best ones. This is sufficient and sort of a marvel to behold.
   :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j0v1i6m/
+  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j0v1i6m
   :body: |-
     [Ruby](https://github.com/globalreset/advent_of_code_2022/blob/main/day19/dayNineteen.rb)
 

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

@@ -1,13 +1,13 @@
 ---
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j18nj2y/
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j18nj2y
   :body: |-
     Ruby
 
     Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/20)Video Walkthrough: [YouTube](https://youtu.be/szXQTRybPAI)
   :replies: []
 - :author: dtinth
-  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j12cr45/
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j12cr45
   :body: |-
     **Ruby** , with rotating arrays:
 
@@ -26,7 +26,7 @@
     ```
   :replies: []
 - :author: whezya
-  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j10t1i9/
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j10t1i9
   :body: |-
     **Ruby**
 
@@ -37,7 +37,7 @@
     https://github.com/rbellec/advent\_of\_code\_2022/blob/main/app/daily\_problems/day\_20.rb
   :replies: []
 - :author: jstanley0
-  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xw35j/
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xw35j
   :body: |-
     # Ruby, 437/334
 
@@ -65,14 +65,14 @@
     ```
   :replies:
   - :author: "[deleted]"
-    :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0yin0g/
+    :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0yin0g
     :body: |-
       Exactly the same idea to use the number + original position.
 
       There is a guy who uses Python and often uses complex numbers to store information. I wonder if he used them today, seems to fit well :)
     :replies:
     - :author: 4HbQ
-      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0yxzqw/
+      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0yxzqw
       :body: |-
         [Maybe](https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyug6hl/)[I](https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izhzxb6/)[am](https://www.reddit.com/r/adventofcode/comments/zjnruc/2022_day_12_solutions/izw63we/)[that](https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j061f6z/)[guy](https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0kdnnj/)?
 
@@ -81,18 +81,18 @@
         In case you're interested, it does work and looks like [this](https://topaz.github.io/paste/#XQAAAQADAQAAAAAAAAA8HMAC0B10JGvJxk1ICqx0YTnnfz/f4KkcTEpfucim8ULWQSRYZBfXObTE2OdlMYGbQsY7+p1vB9dTESMHaog9kTvMa09i7wJBCx3J5GHdmWv98l/yxeHO65EExHVDflnmMdr0EygoA80iMjB2s7L6j8Tyo0WuMGummilYRJx1sJT+ptMYHKLSDQP/6DLmiXSNjNvx4HBrHWGB5W7K/8MkepJ8LYJK0gRTKP/Q5KxSJWG5b0+gBdrhpx/EqiylybH/+LazgA==).
       :replies:
       - :author: "[deleted]"
-        :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0z6eiz/
+        :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0z6eiz
         :body: |-
           That guy: [https://www.youtube.com/watch?v=w9Sk7lvyGZI](https://www.youtube.com/watch?v=w9Sk7lvyGZI) :)
 
           No complex numbers today, a linked list :(
         :replies: []
     - :author: jstanley0
-      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j114qpe/
+      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j114qpe
       :body: ooh, putting the original index in an imaginary part is delightfully perverse. I love it
       :replies: []
   - :author: Elavid
-    :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xyhwz/
+    :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xyhwz
     :body: |-
       I used Ruby too! I used a doubly-linked list where each node is a hash that contains the value, and links to the previous and next nodes. Each node also contains an extra pointer to the node that was originally after it in the input ~~(I didn't realize the input numbers would be unique, like you did)~~.
 
@@ -101,15 +101,15 @@
       I thought my approach should be faster than the simple array style because it requires very little writing of data, but I guess I'm getting slowed down by having a big data structure that I have to read a whole lot. I have to traverse through nodes one at a time to find my insert positions every time I move a node.
     :replies:
     - :author: jstanley0
-      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xzk4s/
+      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xzk4s
       :body: My solution doesn’t depend on the numbers being unique. Are they? I just paired each number with its original position and searched for that to find which number to move. I’m sure it could have been done more efficiently but I was up very late doing the previous problem…
       :replies:
       - :author: Elavid
-        :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0y1df3/
+        :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0y1df3
         :body: Oh yeah, you're right.
         :replies: []
 - :author: Nnnes
-  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0y2lsg/
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0y2lsg
   :body: |-
     # Ruby
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j1czuwm/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j1czuwm
   :body: |-
     Ruby
 
@@ -9,7 +9,7 @@
     Video Walkthrough: [YouTube](https://youtu.be/8_LvF2C4myo)
   :replies: []
 - :author: "[deleted]"
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j16ddx9/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j16ddx9
   :body: |-
     Ruby, part 2. The code is horrible, but I am kind of proud of myself, seeing how others used binary search, o some online equation solvers.
 
@@ -109,7 +109,7 @@
     ```
   :replies: []
 - :author: tgoesh
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j163fyh/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j163fyh
   :body: |-
     # [Ruby](https://topaz.github.io/paste/#XQAAAQCfBQAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kt1xH5HTAZ5BobIVaNmvr5uBT8lIWMVDPZEFxdcpn3Nj9lGXzliPRlIkeaE/uxw0eRYNQ0wHIgpqPDGvjVfR4EKOziEs6xQZ45nkYjc9RLRFCQt6D781H8E6UUKqPEZDvik3xRVWko1Oy0Ub+/OXUWd6N4CU6dt57vEYuOkjUl+8Br7Fqb6iNscVaYLIVFAQnOBCNq58vf9S7JAMlPRPLpvMuviy3kcQA/4McodaSdOMSfK3INWV1Jn8n1kI4FAN3O0ONmLb+Qz8sMiEkcIH5qA7tU4V/Q1BQynqWFGrAvGjWTigKhdwrgdLEqtlPNXjKas/he+1UL4NDu2g2C8HznNtS4U7tr5H8TSf7SwySjWiXKvlhyqnT4MZ2hRuOwQckAmUgQYXIY1fCZyi+bZE0lcZ72p9ZnBTPnnWd7ztLjvhpNT9uvJ56pUzEMks7b/y7GtQN8do7nxva1zvKNydtg2vEkQ3JTMRi5MudW7vUzUuOObK6bPblyvnCT7rWcCTxFh/dZOS3yGTzJJvFGBYLMNme26xv923It0J8sg6+loG7WsHOnF+XJ1hNyfISyBHIxm3+DVSs4eUSVSx9Uvt4s8Hg9FmKwIVSQoN1W0U0dVOPInwIHeR4RfckEAJZfbdIsxS3tTaHP4sq4NuHF7velg9GPBjEqxU8R7EL0iXUX4EkxG/Ch5FpMGk+x+VGOOX5tNgTvLRorC9z+TduRZlbeagxryvyOawx6+YB81wA8cG38f5u5e3IxVmMKwT8vQkVdbeeG1RHagPjlSvrt+BUTtU9gvaMoyTslaNzWbamfgTLyJD9pNbRSlPu7JHB449pTr0F+wQSr7h+XgopbP8CyBOpzYq4GN8Om5021qgHC0kDHv/fWVUJ)
 
@@ -120,7 +120,7 @@
     Works great, though.
   :replies: []
 - :author: shandley256
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j15orhb/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j15orhb
   :body: |-
     Quite pleased with my Ruby solution for part 1:
 
@@ -130,7 +130,7 @@
     ```
   :replies: []
 - :author: Elavid
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12tsyo/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12tsyo
   :body: |-
     ## Bit-based binary search!
 
@@ -163,7 +163,7 @@
     ```
   :replies: []
 - :author: riffraff
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12v3v6/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12v3v6
   :body: |-
     evals galore! Ruby + Z3
 
@@ -197,7 +197,7 @@
     ```
   :replies: []
 - :author: jstanley0
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12rghz/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12rghz
   :body: |-
     ## [Ruby](https://github.com/jstanley0/advent-2022/blob/main/21.rb) 540/1917
 
@@ -208,7 +208,7 @@
     I decided to solve it for real. I essentially built a binary tree for the side of the equation containing `humn` and I simplified it one step at a time. For instance if I had 3 - (...) = 5150 I turned that into (...) = -5147 and then repeated until the left side contained only `humn`
   :replies:
   - :author: mynt
-    :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12rmnr/
+    :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12rmnr
     :body: |-
       Similar approach except wolfram Alpha worked!
 
@@ -219,11 +219,11 @@
       ((((92540050790154-(9\*(((((280+(((((((2\*(264+((516+(((660+(2\*((2\*(530+((((313+(((((3\*(615+(((8\*(915+((((246+(4\*(((483+(((((((80+(((((8\*((((3\*(789+((107+((x-745)/3))\*11)))-695)/4)-486))+570)/5)-757)/3))\*5)+411)\*2)-885)+552)+802))/2)-686)))/5)-175)/3)))-66)/2)))-319)\*2)+133)+570))/2)-955)/2)))-768)))/3)-223))/5)))-933)/5)+765)\*9)-193)\*2))/2)+689)/6)-230)))\*2)+138)/12)=5697586809113
     :replies: []
   - :author: Pakosh
-    :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12sq66/
+    :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12sq66
     :body: Natural language complains for me as well but once I switch to the math input, its ok.
     :replies: []
 - :author: p_tseng
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12szc6/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12szc6
   :body: |-
     In both Ruby and Haskell, you can define a map that's defined in terms of itself! This allows you to resolve the "monkeys might need to wait for other monkeys to compute their values" situation, without worrying about the code taking forever by repeatedly recomputing values that you've already computed in the past. In Ruby, you do this:
 
@@ -253,7 +253,7 @@
     Oh yeah I managed to just barely sneak into the top 100 for part 2 today, great. I used binary search to do part 2. The difference is that i[n Ruby binary search is built-in](https://www.rubydoc.info/stdlib/core/Array:bsearch) whereas in Haskell you have to write it yourself.
   :replies: []
 - :author: whezya
-  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j14dptm/
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j14dptm
   :body: |-
     [**Ruby solution**](https://github.com/rbellec/advent_of_code_2022/blob/main/app/daily_problems/day_21.rb)
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: Elavid
-  :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17o4by/
+  :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17o4by
   :body: |-
     ## Ruby, 546/476
 
@@ -19,11 +19,11 @@
     When I didn't get the right answer for part 2, I added a **sanity check** : after doing one of these special cases I made sure that I could turn around and get back to the location where I was previously (and be facing the opposite direction). The sanity check revealed two or three bugs and allowed me to get the right answer. This one was the longest one yet, I think! Took me 110 minutes to finish and it was very repetitive.
   :replies:
   - :author: silxikys
-    :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17os2m/
+    :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17os2m
     :body: I tried this and it helped me debug my part2! I had a `x` where I should have put a `y`...
     :replies: []
 - :author: dtinth
-  :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17l4fq/
+  :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17l4fq
   :body: |-
     **Ruby** (16/50)
 
@@ -49,6 +49,6 @@
     ```
   :replies:
   - :author: riffraff
-    :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17ng8x/
+    :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17ng8x
     :body: oh, incrementing both in one go is clever, I wish I had thought of that.
     :replies: []

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

@@ -1,13 +1,13 @@
 ---
 - :author: jstanley0
-  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1gv7tr/
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1gv7tr
   :body: |-
     [Ruby](https://github.com/jstanley0/advent-2022/blob/main/24.rb) 369/332
 
     This one was fun! Figuring out a trick that would let me treat this like other A\* searches I've done in the past was very rewarding. Essentially instead of operating on a fixed map, each search state stores a time value and calculates what the map will look like at decision time. Each blizzard's location is computable at any arbitrary time _t_ using modulo math. \>!it helps that there are no vertical blizzards in the entry/exit columns.!\< Maps are memoized for performance. I probably could have saved some memory had I realized the map state starts repeating, but it performs well enough (part 2 takes about 2 seconds in total).
   :replies: []
 - :author: Elavid
-  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1gwew0/
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1gwew0
   :body: |-
     ## [Ruby](https://github.com/DavidEGrayson/adventofcode/blob/434f2b4693f1e1b1b4add4b279c69acc4b3fde65/2022_24/advent.rb), 1107/988, 85 lines
 
@@ -20,7 +20,7 @@
     Another observation that helped me is that you should **solve part 2 by just doing the same search you did in part 1, but doing it three times with different parameters**. There are no blizzards passing through the start or end points, so you always want to reach those points as fast as possible. (You can always spend some time waiting _after_ you get there.)
   :replies:
   - :author: lbl_ye
-    :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h65q2/
+    :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h65q2
     :body: |-
       for faster code you must change to simpler algorithm
 
@@ -31,7 +31,7 @@
       it would be simpler if you stepped for each minute, and computed/fetched "phase" one time only for all states and moved all states together to time+1
     :replies:
     - :author: Elavid
-      :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h79r4/
+      :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h79r4
       :body: |-
         Wow, it's right! The code is taking about 2 seconds now if I do a simple breadth-first search:
 
@@ -51,7 +51,7 @@
         ```
       :replies: []
 - :author: sigmazero13
-  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h33hm/
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h33hm
   :body: |-
     **Ruby**
 
@@ -72,25 +72,25 @@
     EDIT: Forgot to mention: running part 2 takes about 4.5s. So about 1.5 seconds per leg.
   :replies:
   - :author: johnpeters42
-    :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h5vpx/
+    :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h5vpx
     :body: I tried to approach it that way, but it seemed to slow down by a lot more than what you describe, up to where I killed it and went back to the drawing board. I'm vaguely curious how far off the mark I really was (I ended up using A\* instead).
     :replies:
     - :author: sigmazero13
-      :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1j2ivm/
+      :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1j2ivm
       :body: Can you post your code? Maybe I can help see what might be slowing it down
       :replies:
       - :author: johnpeters42
-        :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1jle0s/
+        :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1jle0s
         :body: I didn't keep a copy. I think maybe I was wasting time on BFS backward from the end location at any possible blizzard state, rather than forward from t = 0.
         :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h7cxs/
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h7cxs
   :body: |-
     [Ruby](https://github.com/globalreset/advent_of_code_2022/blob/main/day24/dayTwentyFour.rb)
 
     For part 1, I did a simple BFS and simulated the entire board of blizzards every minute (caching the result for that minute). In part 2, this was taking way too long. So I realized that I'm simulating the entire board when I only care about the row/col the expedition is on, plus/minus one row/col. So I rewrote it to create a lookup for all of the blizzards indexed by their row/col and their direction. Then when I wanted to check whether a position was open, I got only the relevant blizzards, shifted them by the amount of time that had passed, and checked for collision. Whole thing runs both parts in 30s.
   :replies: []
 - :author: crazywulf
-  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1hbbuv/
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1hbbuv
   :body: "[Ruby](https://gist.github.com/rolfschmidt/a4cb3722b9339ea4691d586a43d09f78), 12 sec for both parts."
   :replies: []

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

@@ -1,6 +1,6 @@
 ---
 - :author: jstanley0
-  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1miman/
+  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1miman
   :body: |-
     **Ruby**. Code golf coming full circle. ~~134 bytes~~ (EDIT: see replies, down to **111** so far). The first line converts and adds the input and the second line converts the answer to SNAFU. I feel like I should be able to tighten it.
 
@@ -10,7 +10,7 @@
     ```
   :replies:
   - :author: jstanley0
-    :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1my0v1/
+    :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1my0v1
     :body: |-
       132 bytes. I could eliminate a comma on line one by using `_1` and `_2` in the block with two variables, and I could eliminate the parens on line 2 by moving the `tr` outside the loop, although I had to replace `$><<` with `puts` due to operator precedence so I just saved one byte there.
 
@@ -20,7 +20,7 @@
       ```
     :replies:
     - :author: jstanley0
-      :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1mzmlr/
+      :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1mzmlr
       :body: |-
         for `r` in `0..4`, that horrible ternary `(r>2?1:0)` is equivalent to `r/3`. that saves me _six bytes_, bringing my total to **126** :
 
@@ -30,7 +30,7 @@
         ```
       :replies:
       - :author: jstanley0
-        :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1w31h7/
+        :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1w31h7
         :body: |-
           simplifying part 2 and using the same digit string as the first line: **111**
 
@@ -41,7 +41,7 @@
           ```
         :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1mbzpd/
+  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1mbzpd
   :body: |-
     Ruby
 
@@ -50,7 +50,7 @@
     Video Walkthrough: [YouTube](https://youtu.be/54WUMyWJars)
   :replies: []
 - :author: Elavid
-  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1l0sak/
+  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1l0sak
   :body: |-
     ## [Ruby](https://github.com/DavidEGrayson/adventofcode/blob/2e4ade3ec9de6690e62559daba758ebe02fa0689/2022_25/advent.rb), adding the SNAFU numbers directly without converting to integers
 
@@ -59,21 +59,21 @@
     **Update:** The version I posted above converts individual SNAFU digits to integers and back to SNAFU, but that's not very cool. [Here is a new version that uses _no integers at all_.](https://github.com/DavidEGrayson/adventofcode/blob/327b66c17407f0398666af1ee9a6c4c0fc18aae5/2022_25/advent.rb)
   :replies:
   - :author: e_blake
-    :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1pzwur/
+    :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1pzwur
     :body: |-
       Looks similar to [mine](https://www.reddit.com/r/adventofcode/comments/zvduql/2022_day_25m4_solution_without_doing_any_addition/?utm_source=share&utm_medium=web2x&context=3), except I coded my lookup table with DMZOT to avoid even the appearance of integers in my table ;)
 
       And yes, the technique of building up adder/carry on smaller chunks from right to left is how arbitrary-precision big integer libraries work; it's just a tradeoff of whether the smaller adds can be performed directly by lookup table (as is possible with base-5 SNAFU) or utilizes smaller-precision integer math while building up to the larger precision.
     :replies: []
   - :author: dong_chinese
-    :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1l15ai/
+    :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1l15ai
     :body: Awesome, most creative solution I've seen so far.
     :replies:
     - :author: Elavid
-      :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1lbib2/
+      :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1lbib2
       :body: Well, I'm more deserving of that comment now that I've posted a new version with no integers being used at all.
       :replies: []
 - :author: Nnnes
-  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1l1d2h/
+  :url: https://www.reddit.com/r/adventofcode/comments/zur1an/2022_day_25_solutions/j1l1d2h
   :body: "# Ruby\n\n116/100 I got my first point since day 1 \U0001F389\n\n```ruby\ndef s2d(s) = s.tr('=\\-012', '01234').to_i(5).then{ |x|\n  x - ('2' * x.to_s(5).size).to_i(5) }\ndef d2s(d) = (('2' * d.to_s(5).size).to_i(5) + d).to_s(5).tr('01234', '=\\-012')\n\nputs d2s(STDIN.readlines.map{ |x| s2d(x) }.sum)\n```\n\nDon't need any modulos or iterating over digits with this method. Just some conversion in and out of normal base 5.\n\n> !my actual solution was to manually change digits until it matched lol. I wrote this afterwards!\\<"
   :replies: []