advent_of_ruby 0.3.1 → 0.3.2

data/data/solutions/reddit/ruby/2024/05.yml

@@ -1,17 +1,17 @@
 ---
 - :author: '442401'
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0my8nw/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0my8nw
   :body: |-
     This was a fun one, implementing a custom sort algorithm. I have no idea what type of sort I created, or what the Big O notation might be, but it works and seems to be fairly performant.
 
     [pastie](https://topaz.github.io/paste/#XQAAAQBcBAAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw3D1UZFlD3WW8r2Z9pYT30X7PldGU70XB3egANSDGaglT19UFgzZK2FcUaGiOj2QwDkRsdSI8VlTlRHSx96rEK2fgYkMopVYMKvFrxYEOtlpraQtqXI869FkwIsNbKnv6kcagyhdLWfX1FrLl8cJPgtkQe8xLG+avOac7tsm2wzZjJAichGLIJe9pTdisr1vtXsU3qY0B+qxOP04rSWBTWOsIUzYidqufpLIMbHSc2mRiKVRtfOPytmcjdxuNZ88HGUtQYhQj5oRfApkIikmSc7LwHkj+/qxyQ/14ilCVT1UA+dggc1BlIiGBMDdiyKElBXCnuPhwhZnHZ4ydwmaw0i0QafjZcAQiq8KsDn+SSZLxk3cL1AS5MkB8D+vl96hAPL1U8Q4cZVmMA/0hp4tZOrPZrdm6H1jpMMPLFq4MR5QxHAEgv+AG8Q+uPPtIoba+uvxlwXQyuEEUWUudm3ee1Xfvsj5vOZVA/YVg8F1LwpawkD46eKBV8A2at6zmXymUBhK3JhHhAQIb2drHe61bY5XIkjxHzKoS4SSjWwlExFQ7Z05kxWy3WsxazIE7ID/mP6iVSLUE1kMpUhcd1I8oidpQBtSBHCSEXRhC8c2+F8spS5DlP0//yr/1AA=)
   :replies:
   - :author: nullset_2
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0t597s/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0t597s
     :body: "+1 for ruby \\<3"
     :replies: []
 - :author: Sharparam
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0hz686/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0hz686
   :body: |-
     ```ruby
     orderings, updates = ARGF.read.split "\n\n"
@@ -40,7 +40,7 @@
     Part 2 was quite easy by just using the rules in a custom comparator for the `sort` method.
   :replies: []
 - :author: riffraff
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i076g/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i076g
   :body: |-
     3324/5754
 
@@ -49,11 +49,11 @@
     [https://gist.github.com/riffraff/70e9feca5b8d3c236557a7e0796268db](https://gist.github.com/riffraff/70e9feca5b8d3c236557a7e0796268db)
   :replies:
   - :author: musifter
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iepv5/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iepv5
     :body: Don't worry about not using a topological sort. The input is not a DAG, it has loops. There is no complete sort of the pages, only subsets of them.
     :replies: []
 - :author: el_daniero
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kiv0k/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kiv0k
   :body: |-
     Had a hunch about this one. Felt pretty good when on part 2 I just had to change a `.filter` into a `.partition` and the rest just fell in place by itself :)
 
@@ -85,21 +85,21 @@
     ([part 2 diff](https://github.com/daniero/code-challenges/commit/6923d035a911359c626333c75bae423c28d0c553))
   :replies:
   - :author: TailorSubstantial863
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kylv4/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kylv4
     :body: |-
       I'm pretty sure my code does the exact same thing as yours (algorithmically speaking) but it takes 83 lines.
 
       nicely done. I'm gonna have to put your code in debug mode to figure it out I think.
     :replies: []
 - :author: gosshedd
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iagt3/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iagt3
   :body: |-
     Using the spaceship operator makes both parts equally simple.
 
     [Gist](https://gist.github.com/gmitrev/47b0498c2bd403589cd866b2b077689a)
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0ihywy/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0ihywy
   :body: |-
     Part 1
 
@@ -132,18 +132,18 @@
     ```
   :replies:
   - :author: Ill_Information_9522
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0lng6f/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0lng6f
     :body: Enjoying following along with your solutions after solving them myself with my beginner's grasp of Ruby. Thanks for sharing.
     :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k2hny/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k2hny
   :body: |-
     [paste](https://topaz.github.io/paste/#XQAAAQA0AwAAAAAAAAA5GUqKNoFH6SMqoVC09YUYn9dyScIBDNYTI4hnvKYWXrPwLsHeHO6l2A0mcRl8Ns3HhQylr3Khfz4JY3+czGhZ93QRGZ/H13DAhWFK7sa7Zv6wWS5++4B4VBZWS5ooiS9de/AlbgI7SjS9heaT2QZnwnZj8giLuaos879X3tI0OJIAogzVUHsgYA0ss0NCeSeaaYRd5dTDriXvXcR0BJQhPeX656k0aWJc79qLHua5fmyFZlpkgrmWHeyQcwm2HzboaMyI/PkhtftOcshzo6ZF1Fn7BRPLa0yZS+JtnWne3EwZRdofK4WG9fc//SX9tbDPgPzr6nYntRd6tKj6WoQNGbtVnOEMA2gKAm4nkVd5SxafWvtFGYpqVBu+r5l6ZIef8H3S7eXUz8qMynQtLBemtp5tY8OnRd6NYf6pRe5XfCBYuuihZxi63r2bpv7S2qR0C/ZenWzHdeCYwMvvEg8M2GwIASjVE1KXXIh38dhsMemXkqdBaX1CUWqSYebyBGT9zhDtieKKnpdIk/18Tf3qLsMSzff/tJCSSw==)
 
     Very interesting problem that is actually quite educational about binary relation and total ordering. Might write up a tutorial post later as a review for myself as well ([done!](https://www.reddit.com/r/adventofcode/comments/1h7mm3w/2024_day_05_part_2_how_nice_is_the_input_a_binary))
   :replies: []
 - :author: Symbroson
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kvznz/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kvznz
   :body: |-
     both parts, quick and easy:
 
@@ -169,7 +169,7 @@
     ```
   :replies: []
 - :author: The_Jare
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0l9y1s/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0l9y1s
   :body: |-
     ```ruby
     rules, reports = ARGF.map(&:strip).reject(&:empty?).partition { | l | l.index("|") }
@@ -196,32 +196,32 @@
     ```
   :replies: []
 - :author: HAEC_EST_SPARTA
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i5hkk/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i5hkk
   :body: |-
     [Solution on sourcehut](https://git.sr.ht/%7Eawsmith/advent-of-code/tree/2024-ruby/item/lib/day05.rb)
 
     I wasted a significant amount of time implementing a topological sort of the ordering constraints, just to discover that my input had cycles, so that sort wasn't really possible. After that, I implemented the non-graph solution above. Notable features are the reversal of the updates in `unordered?`, which allows me to check whether any ordering constraint is violated without having to iterate through the constraints, and the usage of an insertion-sort-style first-fit allocation algorithm for pages in Part 2 to perform the allocation of each page in linear time.
   :replies:
   - :author: Eilip999
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i6mgo/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i6mgo
     :body: |-
       It should not be possible for cycles in input to happen, if it was a case you wouldn't be able to sort it even with your algorithm which is not based on graph.
 
       Edit, Okay it might be possible to have cycle in rules, but then cycle should not be visible in list of pages, so like, you have the edges, but vertices are missing so these edges should not be included in the graph.
     :replies:
     - :author: HAEC_EST_SPARTA
-      :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i7zul/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i7zul
       :body: Right, the global set of ordering constraints does contain cycles, although if you pare it down to only the pages contained in each update, then that is no longer the case. I realised that a bit too late, but _c'est la vie_.
       :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i6xkn/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0i6xkn
   :body: |-
     I initially wasted time creating "before rules" and "after rules" for part 2, thinking I would need the reverse map to 'squeeze' a value in to the right place. But saw through testing after I was done that it was pointless. I wish I would've thought of the 'sort' method though as that's a clean result.
 
     [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/05/solution.rb)
   :replies: []
 - :author: im_sofi
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0ix512/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0ix512
   :body: |-
     Interesting day. Worked a bit on my `std++` library and added a `Enumerable#partitions` function to allow a partitioned scan of `|left, current, right|` over the elements so i could handle the rules being defined as `before` and `after`.
 
@@ -230,7 +230,7 @@
     https://github.com/soupglasses/advent-of-code/blob/main/2024/ruby/day\_05.rb
   :replies: []
 - :author: Independent_Top_8716
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iy7eq/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0iy7eq
   :body: |-
     After (not unexpectedly) realizing that a recursive or permutations based approach would not scale for part2 I used a hinted approach for part 2
 
@@ -292,30 +292,30 @@
     ```
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0j6f41/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0j6f41
   :body: |-
     It wasn't immediately obvious to me that implementing a ruby sort function would just work here, but it seems there is only one validly sorted order for the string based on the rules, making this leap confirmed the solution to me.
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/5](https://github.com/careyi3/aoc_2024/tree/master/solutions/5)
   :replies:
   - :author: FCBStar-of-the-South
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jtl71/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jtl71
     :body: I did not want to implement sorting because there is not any guarantee that the | relation is transitive but apparently it is
     :replies:
     - :author: careyi4
-      :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k1hjd/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k1hjd
       :body: Yeah, same, it didn't feel like it should work, but when I tried it and it did work I was surprised. I felt like there surely should be multiple orders that satisified the rules, apparently not per the rules.
       :replies:
       - :author: FCBStar-of-the-South
-        :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k23ww/
+        :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0k23ww
         :body: I was probably reading between the lines too closely haha. The example explicitly checked the ordering between every pair instead of just the adjacent pairs and I thought that's a sign the relation might not be transitive
         :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0j9e9o/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0j9e9o
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day05.rb)"
   :replies: []
 - :author: masterarms
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jm95n/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jm95n
   :body: |-
     Part 2 took me quite some time before realizing a sort would work.
 
@@ -361,7 +361,7 @@
     ```
   :replies: []
 - :author: fredster231
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jploy/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0jploy
   :body: |-
     ```ruby
     rules, updates = File.readlines('005.input')
@@ -388,14 +388,14 @@
     ```
   :replies: []
 - :author: clonewolf
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kh6du/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kh6du
   :body: |-
     Unable to do a TSort on the whole set, I'm doing TSorts on each subset of the graph defined by each update.
 
     [https://github.com/christopher-b/advent-of-code/blob/main/lib/advent/year2024/day05.rb](https://github.com/christopher-b/advent-of-code/blob/main/lib/advent/year2024/day05.rb)
   :replies: []
 - :author: sigmazero13
-  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kl2i7/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kl2i7
   :body: |-
     Parts 1 and 2 together.
 
@@ -404,7 +404,7 @@
     Basically, just created a Page class with methods to allow for custom sorting using the rules. From there, finding the valid updates (and fixing the invalid ones) was a piece of cake.
   :replies:
   - :author: rcraggs
-    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kpg4l/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h71eyz/2024_day_5_solutions/m0kpg4l
     :body: |-
       I did the same thing in Python. No idea about efficiency but it makes for really tidy code and a simple idea
 

data/data/solutions/reddit/ruby/2024/06.yml

@@ -1,6 +1,6 @@
 ---
 - :author: tycoon177
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0xo9lk/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0xo9lk
   :body: |-
     [Part 1 and 2](https://github.com/BenMcH/advent-of-code/blob/df8325ce8e633e307b599a8e367537351c993e8b/2024/lib/day_06.rb)
 
@@ -9,7 +9,7 @@
     By re-using that previous state in this manner, I was able to shave this solution down to 1.5 seconds with ease. I'm sure I could further optimize, but I'm happy at this point.
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pdsmr/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pdsmr
   :body: |-
     Just brute force today...
 
@@ -18,62 +18,62 @@
     Edit: Optimized my solution a bit, but still takes ~17 sec for part 2.
   :replies:
   - :author: quokka70
-    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0qlk97/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0qlk97
     :body: Using a Set for @grid instead of an array will make `grid.include?` faster (unless the hashing overhead is too much).
     :replies:
     - :author: _tfa
-      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0uf1wc/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0uf1wc
       :body: You are right. That was the optimization I did after I sent the code to pastebin (couldn't edit it there)
       :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0q4x8j/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0q4x8j
   :body: |-
     Biggest thing that tripped me up was I was failing to recheck if I was facing another wall after rotating. A litreal one word change from an if statement to a while loop fix it for me.
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/6](https://github.com/careyi3/aoc_2024/tree/master/solutions/6)
   :replies:
   - :author: globalreset
-    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0qdjv8/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0qdjv8
     :body: Same!
     :replies: []
 - :author: nothimofc
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0ny6iz/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0ny6iz
   :body: |-
     While Part 1 (counting distinct positions visited) works relatively fast, Part 2 (finding loop-causing obstacle positions) is extremely slow for large grids.
 
     [github](https://github.com/osu/advent-of-code/blob/main/day6/joe.rb)
   :replies:
   - :author: nothimofc
-    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0nywg2/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0nywg2
     :body: I would appreciate any advice from fellow ruby enjoyers I could have gotten a much better placement than 70/10 :( if it was faster.
     :replies:
     - :author: Lucky_Menu3724
-      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o4twa/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o4twa
       :body: |-
         Here is what I did. I tested your code and mine was about twice as fast, but it took me a lot longer than you to write :) 18s to run on an old laptop.
 
         [https://gist.github.com/imme5150/d51ab9746902aa1e2609bc7d1cbb3866](https://gist.github.com/imme5150/d51ab9746902aa1e2609bc7d1cbb3866)
       :replies:
       - :author: nothimofc
-        :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o6704/
+        :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o6704
         :body: Sheesh nice
         :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o89vy/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0o89vy
   :body: |-
     Got stuck for an hour on part 2 before realizing that the obstacle created a situation where you could turn away from a wall to find another wall. Tricky since I got away without handling that case in part 1. Seems like the input was constructed just to allow that mistake on part 1 and kill me on part 2. Just a matter of changing "if(grid[nextPos]=='#' || nextPos==obstructedPos)" into "while(...)".
 
     [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/06/solution.rb)
   :replies: []
 - :author: akanet
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0oma65/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0oma65
   :body: |-
     [https://gist.github.com/vincentwoo/bff280de0b1fb16d4e511d85c339879a](https://gist.github.com/vincentwoo/bff280de0b1fb16d4e511d85c339879a)
 
     Was pleased enough to find a formulation that uses the same code for both initially running through the maze as well as splitting off to see if each next step's hypothetical obstacle would generate a loop. Sharing the in-progress seen list saves quite a bit of time. 35 lines and about 2s runtime.
   :replies: []
 - :author: masterarms
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0ot8pg/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0ot8pg
   :body: |-
     It was quickly obvious that trying a block on every empty grid position would not scale. But with 2 optimisations the runtime was tolerable.
 
@@ -134,7 +134,7 @@
     ```
   :replies:
   - :author: masterarms
-    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pa90y/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pa90y
     :body: |-
       I was not too happy with the rotation and moving logic, so I made a second version using Complex numbers as the coordinates. In that case a movement is simply an addition and a rotation of the direction a multiplication by `Complex::I`.
 
@@ -146,25 +146,25 @@
       ```
     :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pjb4l/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pjb4l
   :body: |-
     Brute force solution for part 2, runs in 40s for both parts.
 
     [Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day06.rb)
   :replies: []
 - :author: Infinite-Club4374
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0podjn/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0podjn
   :body: "Hey all! I’m having a bit of trouble locating the last edge cases, anyone have any ideas?\n\nWith my custom input my solution gives 1573 but should be 1686. Would really appreciate any insights or help \U0001F499\n\n[GitHub](https://github.com/Leftyxiv/advent_of_code/blob/main/2024/day6/day6.rb)"
   :replies:
   - :author: ash30342
-    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0prpve/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0prpve
     :body: I think you missed that when you turn right, you can immediately encounter an obstacle again. You should keep turning until you can move on. That tripped me up :)
     :replies:
     - :author: Infinite-Club4374
-      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pse59/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0pse59
       :body: "You just saved my life!!\n\nI had a check for that initially but I only turned once instead of looping and you gave me the idea to loop until a direction was good!\n\nTHANK YOU SO MUCH INTERNET FRIEND\U0001F499\U0001F499\U0001F499\U0001F499"
       :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0sbg2g/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h7tovg/2024_day_6_solutions/m0sbg2g
   :body: "[paste](https://topaz.github.io/paste/#XQAAAQA9BwAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8e/u+sq3cCy1X/xTZynv7KRl8RXO1kbXSYEeewqIPU0fRMdhsu3XI1mrs7eplcKLDUV5gsYYjnL57KBqLKkESiAilkCA2oAYk88/KK9PDxx8gLQ8UR3fan3QjqEMmpkVn9gsXhcp76M+iRq5JO7RtciTlNresld3ohY6cDF4LkORgw1x+6070yQMPm6H73KV3/ZqetWgQsuoQGbRsIZKIJ1g1dF7+lXRk/Q2acJ9bjkLkBoB2nI3LIzyhJWhDRZaF6AITEktez3wabyinxaV6WxtS5DgefV7XzSVjD62J8lnwOs5/8bT/Q3pjLeHBqDNq7ygcMtuTRzO6H1fiVfovOq06jEFwuCgmFJc+T7+Qs9Vx+t/ah2QhVWBTg2OKP95QrtbtEgyWf/zZIm+JnGb6Mpy2tkr+Mb9JVC2GqlVwofAR9yWURwil94aW8EN4nyO7IvbCU9e2jbmqzPcw9w5wkytEmOuI++GC7i7vYkZoJwSFaIy/kv2gUO8vtmqt3jdlizWjXdV1bmq/AZtPYMl5ZRpFqYkL6G5I25oEX5bV5IzYQGz857jPbLPjhTMjmNYvZO5jr88co3qhPc3UzVPFw0zjL5C1sSn1OTDk2LnWetfwvu6BoQ5+X6R+JuEdMP/256fHSruPzd3ZURw2rZg3gzuqBPgVcHyLXQlqy0TsWJm8Sq5qwFHqcAiceCHzDIBAkq28j8mkO05HJz9pOoRTDqrkdQeyWKqVYnP9HKsC4/qf8+3KG8HVgka6pSgOSgFZ4PdcYB+IH+2z3v179uN2/uc2AGp7L/31Ylg=)"
   :replies: []

data/data/solutions/reddit/ruby/2024/07.yml

@@ -1,6 +1,6 @@
 ---
 - :author: RazarTuk
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ynz5p/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ynz5p
   :body: |-
     These isn't enough Ruby on this subreddit, so I may as well start posting _my_ solutions. Also, this is very intentionally only part _1_, in case anyone reading wants to practice by extending it for part 2. And I know it would probably be easier to just tokenize each line as I'm reading them in, but I'm using that first line as boilerplate so I don't have to think about input.
 
@@ -32,7 +32,7 @@
     EDIT: Oh, and it executes in ~100ms
   :replies: []
 - :author: SwagosaurusFlex
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u8enb/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u8enb
   :body: |-
     I'm having trouble figuring out why my solution isn't passing for Part 2. It works on Part 1 and the example case, but it's giving too high of an answer on Part 2. Any help appreciated, thanks
 
@@ -73,19 +73,19 @@
     ```
   :replies:
   - :author: thereal_peasant
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uabou/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uabou
     :body: 'What happens when your `runningTotal` is equal to the `total` but there are still numbers left in `parts`? For example, take the input `''100: 10 10 3''`. Does this return `true`? Should it?'
     :replies:
     - :author: SwagosaurusFlex
-      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ucr4t/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ucr4t
       :body: Ah that makes sense, can't believe I missed that! Thanks, finally got the star
       :replies: []
     - :author: ASteelyDan
-      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uf841/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uf841
       :body: Ah, had the same problem, thank you!
       :replies: []
 - :author: NullT3rminated
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tr6lg/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tr6lg
   :body: |-
     970/553
 
@@ -94,22 +94,22 @@
     First time getting top 1000, which is exciting for me! Definitely not the fastest solution though.
   :replies:
   - :author: FCBStar-of-the-South
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ttgnx/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ttgnx
     :body: |-
       Oh and I was excited to be the first Ruby in the megathread haha
 
       What is your runtime like? I only started learning ruby by doing AoC this year so I will really appreciate it if you can give me some feedback on my solution!
     :replies:
     - :author: NullT3rminated
-      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tuf38/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tuf38
       :body: I get about 3 seconds on my laptop. Just slow enough to make me start to worry and start thinking about optimizations before it completed. YJIT speeds it up by about 300ms.
       :replies:
       - :author: FCBStar-of-the-South
-        :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tv98q/
+        :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tv98q
         :body: I think the only difference between our implementation is how we do ||. You use string concatenation and I use the logarithm. Will have to benchmark your way tmr
         :replies:
         - :author: NullT3rminated
-          :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u8m8s/
+          :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u8m8s
           :body: |-
             Ok I changed mine to use log10 instead of string concatenation, and I went from 2.781s with YJIT to 1.549s with YJIT, so log is definitely faster.
 
@@ -132,7 +132,7 @@
             ```
           :replies: []
 - :author: yourparadigm
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tyk8p/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tyk8p
   :body: |-
     [LANGUAGE: Go]
 
@@ -143,7 +143,7 @@
     [Ruby Solution](https://github.com/phene/advent-of-code/blob/main/2024/07/7.rb) runs in about 2s and [Go Solution](https://github.com/phene/advent-of-code/blob/main/2024/07/7.go) runs in 1s.
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uc4nt/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uc4nt
   :body: |-
     Part 1
 
@@ -176,18 +176,18 @@
     ```
   :replies:
   - :author: Ill_Information_9522
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m1b2e92/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m1b2e92
     :body: This is great... very idiomatic. Still learning-- hadn't though of adding a bar operator to Integer. Love the built-in permutation methods though, quite handy. Not sure if other languages have such powerful stdlibs.
     :replies: []
 - :author: fredster231
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vh0np/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vh0np
   :body: |-
     10 seconds lol, fun anonymous recursive pattern tho
 
     https://gist.github.com/scockram/3ce5efc10cad27bf08c78bca4bcffd5f
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vm2bo/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vm2bo
   :body: |-
     Tight on time today, brute force did the job!
 
@@ -196,7 +196,7 @@
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/7](https://github.com/careyi3/aoc_2024/tree/master/solutions/7)
   :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tt4k6/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tt4k6
   :body: |-
     ```ruby
     require_relative 'utils'
@@ -240,15 +240,15 @@
     Edit: not using a set cuts this down to barely a second
   :replies:
   - :author: yourparadigm
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u05oy/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u05oy
     :body: You'd save a lot of time and memory by not saving all the possible results.
     :replies:
     - :author: FCBStar-of-the-South
-      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0xtael/
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0xtael
       :body: Eh this morning I just said what if I don’t do any deduplication with sets. Cut it right down to barely over a second and that’s good enough for me
       :replies: []
 - :author: riffraff
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ttkxm/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ttkxm
   :body: |-
     today was ... easy? I wasted some time on part 1 cause I tried to build the result down by subtracting and dividing instead of building it up, which didn't work. Also on part two I thought brute force would take a while, but turned out I was brute forcing \*the whole input as a single line\* which, well, didn't go anywhere.
 
@@ -283,11 +283,11 @@
     ```
   :replies:
   - :author: phord
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tuz30/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tuz30
     :body: It never occurred to me to optimize by stopping when I exceed the target. But it ran so fast from the start, I obviously didn't need to.
     :replies: []
 - :author: masterarms
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0usl5m/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0usl5m
   :body: |-
     Not the weekend day I feared :)
 
@@ -323,7 +323,7 @@
     ```
   :replies:
   - :author: masterarms
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0w9n1j/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0w9n1j
     :body: |-
       Going from right to left is _much_ faster.
 
@@ -367,7 +367,7 @@
       ```
     :replies: []
 - :author: el_daniero
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v417f/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v417f
   :body: |-
     I could smell the Dynamic Programming from far away, but this is the first time I've realized that I don't have to build up that whole double array to keep track of everything. Probably also the first time I wrote a nested `reduce` like that.
 
@@ -396,7 +396,7 @@
     ```
   :replies:
   - :author: el_daniero
-    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v9d0d/
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v9d0d
     :body: |-
       And a brute force solution for good measure
 
@@ -419,11 +419,11 @@
       ```
     :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v7ys7/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v7ys7
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day07.rb)"
   :replies: []
 - :author: mpyne
-  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vjiih/
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vjiih
   :body: |-
     I was doing my solutions in Rust this year, but Ruby has an iterator operator that is more or less genetically designed for this problem, `repeated_permutation`, so I wanted to throw it in and test it out.