advent_of_ruby 0.3.1 → 0.3.2

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

@@ -1,13 +1,13 @@
 ---
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2kuqgw/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2kuqgw
   :body: |-
     Didn't have much time to work on this yesterday. Pretty much just a straight-shoot A\* but finding a priority queue gem with all the needed functionality took a while (still learning the language). show\_path is for debugging only.
 
     [paste](https://topaz.github.io/paste/#XQAAAQD7CgAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcHDkxoKCi/QicVvXncjAUUoxkur5sqQIbSDx0EVfweW3ZBi4EtB90UU2lVihnGKgad/aNndLI1/96SSzT9/XIkQE9bEwoDE+cjtfansHNQsT0mbhdU/+I8GNDOKAX2/S+NgzD7SAYOeVot2EAjLeg4Xeax1wTLHCxhcYPx8TtwpF+UQPBHw2B6299QQ6vja1sg+rJfvLRnkvgfis5melbecWtAig6a5sVjU7m6E4LzFVLevGnL1ptUPGUQQ4WPg0t6c5y9qYr4t/IVg9FR2wqBNE8w4Xp2YwQ5zzTV2/CgnFDO+piJ4ohxbn8JnR1H8hQL5ecYDonEEb1mtdoErmdy6zEoPSU9qDC7Uj06FCV13yo9U+9kY3pdb2vbzCHqHuSEn2ypELHY63vkNCbA7yKsg+y4DjIlxmJhfOJWCTYne/SYUS9Qu0P9tMg3fDYjUlnkw2mf/4aPdejIpn3iFw70/VlvhTYr5NY+zqKGOD2Hdmivi1gHmvh39aq/2ElQyRz7ZvY/uHeqmAvTN+moGbxGYj2YbivaCNYf1lfvBuI69CwNUhylms5lS9fX+ibXNBbreme3E3QliDtI9EI1nrXFE8OFzfkxnBpdA7IvpzG1PUof0nhImSBH+pr4r9AVjSH2U7KiWhaXia5+Ds+el6z3LFMNLx4/mkAvOG849gzkkhI/p5THN0T+ZvMQ8CHR8WnOrejtM5v1bG+gcW0W0voT/Lnfr4DKsyQ2bvcgaRyDlyGXTRjSVZ/7PJSQ6lTvgsekNx1dAg26fzRRRpoBYMrIE8tjntQIXqL+wdwIfrwnLJniGztyWwdd5xX3aqQ9VQu3P7PdS9x+/sSTtDUaqBXgbVXJCUTWkJrvfYPsTuN4JuOCjO09ORJLYjbM3pinvlaKdvMKj5g2Bri9+9kYa4KyLACCjblk6oJfJCixO4WhyZNP9xmHprNhvsmMMiyissGJb684XMSprZp/L6kYZ2eCno3aydx5MI3gLnS8R/BhXzpflUNHvGLC6NPQHFC1A2sYFGpgW3APfC9JBlxGlNpsoBMLY7UZGiPzZfP0uubBIIPV1UYPLt2Af+AxGIaEODLBHxeGoam8habktqeTYl3NhBFcKprdM16hx1jP9ElOXdOUDzmk1ld9J5n6K2yvvZySmYaJZu2znrInEvjfopjPzG5oQai55agyJoHh+4d6whHQfcLdCPO0fRrIkeadv9To75aRXj7hIoEGG3Z+Ui7lXnnUXQUvIewNJHKCkiFyKgS0MhLgP9hkAWYvH3PByoX0uAeD/Di7KKYO3p/aW2b0mB44m+uqTr1TSmN4c3BLfuV5FqmqKAfgSEFKAWsDo3P4K25YhNe4TC0tBDIn/+8EdO)
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2fcks7/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2fcks7
   :body: |-
     [Day 16](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day16/day16.rb)
 
@@ -16,13 +16,13 @@
     For Part 2 I didn't quite understand what they meant by best path, but after a while I got it, and it became clear we could do a dfs after we know the final score, the idea is there can be multiple path that leads to the end point with the same score. We want to find all those path, so it became a relatively straight forward dfs to find the path. Then you can store the chain in a set, which would give you a unique count at the end.
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2d2o8k/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2d2o8k
   :body: |-
     Super messy, implemented Dijkstra, then used the info from this to rewalk the graph pruning for paths the exceep the shortest path to each node. Works, but not pretty!
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/16](https://github.com/careyi3/aoc_2024/tree/master/solutions/16)
   :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2c4bi8/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hfboft/2024_day_16_solutions/m2c4bi8
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day16.rb)"
   :replies: []

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

@@ -1,6 +1,6 @@
 ---
 - :author: Symbroson
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2t16pp/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2t16pp
   :body: |-
     late to the party, because I didn't think my approach through the end
 
@@ -13,14 +13,14 @@
     The full ruby code is available [here](https://github.com/alex-Symbroson/Advent-of-Code/blob/master/2024/17.rb) and there is also C++ version also available [here](https://github.com/alex-Symbroson/Advent-of-Code/blob/master/2024/17.cpp)
   :replies: []
 - :author: eggselent_folk
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2pnlcb/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2pnlcb
   :body: |-
     [Code](https://topaz.github.io/paste/#XQAAAQBeCQAAAAAAAAARiAqHodvKIwHSvNw9kKWn/nYvsilVuEqA02Yvh73BCxyQtWtpitgBJEp5hJogQfXndNsYMoivkyHhpWNZLlIYputlxm3To4bk40Bv6y7Xub1USc6R5yr0jAlIK62Z9OZy0fhCy4JMLwcaDZlNf2Rdm1ryPwCNBC5/7aXJMlKROh3BfSyBI+Uy5tYoXczafdX4cY+hAC57q+y6ODUHpUg6U+wf3ZmCJEMaadzeP2ViPskDmHi7JF3F/2/+wpWHjY+FtSjwFp/K8SbptL2PxGvGiJ9sbtLlfEuNHoPF6zEOBbdElRt4JaPkVJJv1pkX+d8TlP6sKymTXnKG+yJVqCB9kuqDov6a/0S8ViCjplymRnJDIZFWD96wZTqjrBSmbG74+Dqe8uCkhyJGkGaLSzp5ne1o9gxwDe8x13lwVC52uil+uAz15ounMtqpvmQhlCk+aW0GG8TEqXQv5rkGp6LkLoKh6JIqfoXH3XJPAosaX04x1IN2PVyIoGG9xqDCMPYbeAtTiDowz75M+KQJ3BF/e03A4B0PiuSe+bu7TVGeGbJYEsJ/vjHILw/8HswDJxQ0Q441Il7K15TfrYU7lMNGtBKJINtsyKuwIpGradRE9hWXTp/8cSpYNlKv9NHnug2Qdw3+HNpWgoZ8+HeNxG5NooyU2hz7P+UeQfZnZWRK5eKxze6I2DZMKJR8nG+W/wYF0fYQq53tj7xbC0XGycJ0WcxWODHPGzpeRsIzf/MdidIZ94MZaoH7qowOOZPScXy82wwDZYI938R1fJswWAQftyBpkXGG7P6hl3AdBB5UKu0UWpDTAiwi/qge7jTHtsaoyziO6sJ4y9pKZBRXijqDDAfKNZ6dWo0OfNXFeqZ4eVWHhJ0R918GUCRE+CvrCPlNLbeZ2wX6dCaw3JkxyrlsKRVnk5nnYy3a6UFyn7A8tTZurpvt3jqm1HODTFkKm2tqOE4ZP1vmizqOMYssotD6OL64ZRSrI1W3PFN9zBavriIBsqzfcDy4chlEAPsPeqhKyICd0fiZcQpTk7HPY+EgbmkDcbWJOI1fIN5wRlPpIaYarji0myUt7usEWao/saqGr/9D9zsA)
 
     This one is super challenging. I had already reverse-engineered the instructions since yesterday because brute forcing is not possible, but I could not figure out how to quickly remove the impossible cases. I need to come back the next day and have a read on Reddit comments ☺️, to finally realize my wrong approach to test the register A number.
   :replies: []
 - :author: jafuentest
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2ns6ah/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2ns6ah
   :body: |-
     Got part 2 to run in ~0.090s
 
@@ -35,7 +35,7 @@
     [Here's the code](https://raw.githubusercontent.com/jafuentest/advent-of-code/refs/heads/main/2024/solution-17-2.rb)
   :replies: []
 - :author: yourparadigm
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2kvvae/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2kvvae
   :body: |-
     [LANGUAGE: Ruby + Go]
 
@@ -46,7 +46,7 @@
     [Ruby](https://github.com/phene/advent-of-code/blob/main/2024/17/17.rb) and [Go](https://github.com/phene/advent-of-code/blob/main/2024/17/17.go)
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2kvu0c/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2kvu0c
   :body: |-
     [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day17/day17.rb)
 
@@ -59,7 +59,7 @@
     Edit: So, I am almost certain everyone has the 0, 3 instruction in their chain because that is the only operation that can change A, in other words, you can use that to your advantage because once you know A, the other values should be determinable programmatically even if you dont what your program's routine is
   :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2kubku/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2kubku
   :body: |-
     [part1](https://topaz.github.io/paste/#XQAAAQDCBwAAAAAAAAARiArGwlYyUY4y4+WXcBMx4AslbmwFSidMZ9Hevh3xVA2dW72YBXGMPfL/wI7RP69L7aVaWqtyPOxw2CanNE1oQ80boojjqwC7+uN804+FxmmMONZpbzehJAU4wRQLn73839CWEtvaxc2pYLBommamF4lPyzcqzCwA61hoXkOlhzg3QvYjnCNXElBbjKUh1h/ZRZxbXrV+rmqAsgxe+Vm3YMwoTw/CJHgoBn9eCRqLmnlweORtd/72b3/WvJDe7acD5pNlIn15NVh3LecKCoBptKyKC53JXC4NWF9fwMM/C1eVbEboPaYfcsoDeLIuO6Xew9ynnWK4Hd4ETU3Z2nbkYQlDZTaHSc+JhlrLaohnVa3/Ymv2ya2/Xadl5gRZqzHlftF3P9kg+yT8jDmCGNqBsAGBMUY209WBDlC1eWWQe4oGcrktTqP7T8a9Kp5tSUgHeCVSwppftAzF3EqdMmgEIhxe7in408mSz7im/XJxUfJrFRHqa9VdiOGnu+f0oTcoyINxT6U/EaMmc/Sd7Mt3W5C6MyRnIFE3dbtUNtUi6E6fEXMqxopvf10ffTVwIKAAWs0PEzh3ntBSy29JLJFNRRidGsqE4hrFH0Sg+6pxnuLQDeB8jqhU83gSsOOi5J8DQxJU0bgbk+7SVa09UiPhK97PKeKz28LqqbJ8S7+72Ctxwf13SEeHMYswCgjrCnq3fChj6WOz5CqsTvxItQg/ptxZxbmvWYtqiTJ2lm7ilVrUwhQuGZEtPeTOwdq/wpwvqL1y52iJTj1vD1frPw5R3gmgARhlE/0Y/kkxPHFHZ0HRwuzspyq0BNzeF+6elwKIRdLx7uhD5Ke0JjW9DNFXRaOPEmsQLP3sMCGdkYvK7NAi+PpvyK5fSwviCaM4ym6dBUOpZQxl1G3CaEixj6P/8OLDVg==)
 
@@ -68,25 +68,25 @@
     Just my implementation of a (reverse) assembler and a simulator for today's insturction set. For part 2 I tried to understand the program but cannot produce desired behavior consistently. Ended up just doing a reverse search which ran very quickly due to low branching factor.
   :replies: []
 - :author: iwanttoseeyourcatpls
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2k254j/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2k254j
   :body: |-
     Once I understood what part 2 was asking for, it worked itself out, but it took me a long time to get to that point. The lightbulb moment for me was realizing that the computer would eat one three-bit-chunk to produce each output, so instead of looking for an integer I really was looking for a string (that represented an integer in base 8)
 
     [github](https://github.com/ggggbbybby/aoc2024/blob/master/day17.rb#L135-L160)
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2imo9r/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2imo9r
   :body: |-
     Part 2 was very tricky, I didn't have a good instinct on it until I went looking for a hint on the subreddit. I wouldn't have made the mental leap on my own, even after I understood it, coding it took me a little while, I tied myself up in knots thinking about how to match what I had done to the result. Got there in the end, fun puzzle!
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/17](https://github.com/careyi3/aoc_2024/tree/master/solutions/17)
   :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2h27ko/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2h27ko
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day17.rb)"
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2jgi69/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2jgi69
   :body: |-
     First brute-forcing the right half of A, then the left one.
 
@@ -135,7 +135,7 @@
     ```
   :replies:
   - :author: _tfa
-    :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2k6onx/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hg38ah/2024_day_17_solutions/m2k6onx
     :body: |-
       Stupid me! Why do I program two loops from 0 to 16777215 when I could do also with 16 loops from 0 to 7? Okay, it's a bit more than that, but now it takes only a few milliseconds...
 

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

@@ -1,13 +1,13 @@
 ---
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2qz0ir/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2qz0ir
   :body: |-
     [paste](https://topaz.github.io/paste/#XQAAAQB8CgAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcHDkxoKCi/QicVvXncjAUUpHr5KdZkGS65g6AjDBWjmhQNW8xAK3HDD/WikKVUN9CVUuws2wjHNA0gkOrWaunxXGb7F1LN9Mh5X9aKBT4gCSnSL/LmXJUgDHwUcfjeObrm2HC08TifVBY73P2y27+qwFuy6xAQ/tz7dRDfaVpEhcD4AHNF4ZUVHwWIdkktDYSaE7FBpJYg+AfLUIvuJWQ0pRnoqiVZOSuI0xVbxkVLx1meM5iFpbtAgDgsd/Wk3hR4hwGsneHCBb8lHVFXNp5a0wAZ8HxfRipV7xQRw5jHk+LR+3Nyzo+9Ted5oin5K56cB7jRG7vVDt48avyH0rv1rREnsmCv+rLj92PrYmAitWZRwZezqvW1fpLvCXTFMdh+z853tmJmf1pm7vHBs72GAPTtQ0whmls3GVjoA5eXUsr98DOZttwNUVG/WquEOVWILYFTpI8zz2/lkYK+FzljmDLbLsDvnVeGqQtnBp69KsW6nNfnHCKstApuJv1wOm3oytOhQiAlNzPOixIfFvU9ekkVE0ioYca/f21MNhtRYD+TQbBT5iWFS33Sf4m7wn6RNmO6PGFbebSSHWPRiqgQssHvF7a4OQGPn2oYSbtfur4DRukbf5XoXyGxdAAc/JfTWpWnPLnlKwMYJBdrMQdbV3WmKkVvSA/vEwPLrGJvGzsdwkVvhes2dPC5aprhZ1CP2nHOsngFOzNAJUJF1XqcfIbgEwbhOphCvB21DMRnOplX5bsRJtjG0EOIPfxaMYa+iGj8IYgEii5hJzTD5N4/Tm7yhhMgJ7vsAahBrD3PkE0I4I6tPDFdFooM0HxiUReVgOIjrNNDn0h4+Pw5Y0aZ0X4y+nrGCLEgradBwAEKtw6wM7i8EYB5yLbKhi0SWnfTV9BMU2R4VxWWK2Iz6dVA8Gaah01q0szgu+jK2cqCG/XPS+Fg4QY+S2SnFBE8jmiXWbQ7qiRCKkoL3V5qtBytNTmadie3EJ4WzvE2iqZ4f/iY1etPI0/+CP7Dfmq2/muNX0c0a3QM/CnuEaxqcbr6N1birgg3FgEvTw94cU094rpJ0D79u4XM6IZ3Qpiw+otDtvVB0fw7NojydwFVk+kJcBE4IecieHCHfX7mkKWHjNxztLpXm1KzqaHMpg3udDyzxe2ltIkXQQWiCqMuc886HNGZcE/oea2gdjMFxKtClaqha2lDfRIdMtLZK/lET3SDlkSZoFjvnGDZ8hAmlFVgJ+C8IBtoasCWkkvO1Isb4In1cs1ohN8Qo2CCq7RmCJaW/SmK83iOr00COiVIXBW2LSpGjfJpPqHpUEeaPD8tcFjgaLAO1mIXQI3gQm7Z3R6fn+Cu7eQkh9fTb/WGN9kZvyAAUnLP+NgyHhMlLO+o8NUVcYemP3oMz2Zn3MSIJ/i6n//BXjMA==)
 
     Just reuse day 16 A\* implementation with a binary search for part 2
   :replies: []
 - :author: el_daniero
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2pkmwq/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2pkmwq
   :body: |-
     I thought part 2 was gonna be about making the run while the bytes were falling down (or was it? I'm not sure), so I made a search that allowed stepping on a cell before a byte potentially lands on it. Turns out that wasn't necessary, but at least I could solve part 2 only by adding a few lines without changing any existing lines:
 
@@ -26,7 +26,7 @@
     The whole thing here: https://github.com/daniero/code-challenges/blob/master/aoc2024/ruby/18.rb
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2p22rz/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2p22rz
   :body: |-
     [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day18/day18.rb)
 
@@ -35,7 +35,7 @@
     Part 2 reuses the djikstra algorithmn above, and brute f-, nah I am just playing, you can optimize it. Basically when you do djikstra's algo, you can also determine the shortest path that was taken, and store them in a set, and as you iterate through your test data, if the indices don't interfere with your current known path, then you can skip it, and move on to the next until you find one that does. Then simply recalculate and repeat, until you get a measurement where the final node is infinity meaning you never reached it.
   :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2mbzzn/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2mbzzn
   :body: |-
     Reused my dijkstra from day 16. And part 2 was a simple binary search.
 
@@ -58,7 +58,7 @@
     [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/18/solution.rb)
   :replies:
   - :author: iandj1
-    :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2njxk9/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2njxk9
     :body: |-
       I had similar, but used the built-in [binary search function](https://docs.ruby-lang.org/en/master/bsearch_rdoc.html)
 
@@ -71,11 +71,11 @@
       ```
     :replies:
     - :author: globalreset
-      :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2ommf1/
+      :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2ommf1
       :body: Nice! Thanks for that! I love all the ruby built-ins and didn’t realize this existed. That’s going in the toolbox.
       :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2mtflo/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2mtflo
   :body: |-
     ```ruby
     input = File.read("input.txt")
@@ -120,14 +120,14 @@
     ```
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2n1l5g/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2n1l5g
   :body: |-
     Dijkstra again, and for part 2, 30 seconds worth of manual binary searching!
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/18](https://github.com/careyi3/aoc_2024/tree/master/solutions/18)
   :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2nhy32/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hguacy/2024_day_18_solutions/m2nhy32
   :body: |-
     [Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day18.rb)
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: jafuentest
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2x6w5g/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2x6w5g
   :body: |-
     Filtering down the patterns really helped, specially on part 2, ex:
 
@@ -9,15 +9,15 @@
     [Part 1](https://raw.githubusercontent.com/jafuentest/advent-of-code/refs/heads/main/2024/solution-19-1.rb), [Part 2](https://raw.githubusercontent.com/jafuentest/advent-of-code/refs/heads/main/2024/solution-19-2.rb)
   :replies:
   - :author: craigontour
-    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m4qoaf6/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m4qoaf6
     :body: Very impressed with your solution. Had you used it for some other problem before?
     :replies:
     - :author: jafuentest
-      :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m5rgbud/
+      :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m5rgbud
       :body: Thanks! Filtering usually works to reduce execution time when complexity is quadratic or worse
       :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2widl9/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2widl9
   :body: |-
     ```ruby
     input = File.read('input19.txt').split("\n\n")
@@ -44,11 +44,11 @@
     After writing separate functions for part 1 and part 2 I realized only part 2 is needed to solve both parts. This can probably go faster but the code is already so minimal I don't really see where improvements can be found
   :replies:
   - :author: eggselent_folk
-    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2wtil3/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2wtil3
     :body: "I was stuck because my implementation was trying to seek through the design string back-and-forth, instead of using each towel as the start of the search. I realized the problem is I did not consider the uniqueness of some of the possible arrangements. Just realized this after reading your solution.\n\nNice and well-written. \U0001F44D"
     :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2uyv5y/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2uyv5y
   :body: |-
     [day19 git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day19/day19.rb)
 
@@ -59,7 +59,7 @@
     Then you drop in your memoization to optimize because you will be encountering repeated patterns of words and indexes.
   :replies: []
 - :author: Symbroson
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sv7i7/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sv7i7
   :body: |-
     golfed both parts: 143 bytes.
 
@@ -74,7 +74,7 @@
     ```
   :replies: []
 - :author: Mon_Ouie
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2s3zyk/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2s3zyk
   :body: |-
     Nothing special about the recursive search for part 2, but part 1 was solved using the cute `Regexp.union` method.
 
@@ -110,7 +110,7 @@
     ```
   :replies:
   - :author: whyrememberpassword
-    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sa7kd/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sa7kd
     :body: |-
       yeah this (along with the equivalent python version) doesn't work on my input. here's a minimized test case that breaks your solution
 
@@ -121,11 +121,11 @@
       ```
     :replies: []
   - :author: globalreset
-    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sbkg8/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sbkg8
     :body: Nice, that is cute!
     :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2tfq1q/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2tfq1q
   :body: |-
     ```ruby
     t, p = File.read("input.txt").split("\n\n")
@@ -142,7 +142,7 @@
     ```
   :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sc76v/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sc76v
   :body: |-
     I'm scared for tomorrow. Part 1, I started off with a simple "select all the patterns that work for the start of the current design, then check if any recursions on the substring after that pattern get us to the end of string". Part 2 was just change the .any? on that second part to .sum and adding memoization so we could complete in reasonable time. I later went back and adjusted my part 1 to use a regex trick that I learned here so hopefully I'll remember it for next time.
 
@@ -168,11 +168,11 @@
     ```
   :replies:
   - :author: riffraff
-    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sdi3m/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sdi3m
     :body: ah I love part 1!
     :replies: []
 - :author: riffraff
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sco2c/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sco2c
   :body: |-
     basic recursion and memoization. For some reason the Memoist library has decided not to work at the top level anymore, which I'm sure it did at some time, so I need to define a useless class but eh, it works and solve each part in 1s (could do both together, but I usually don't)
 
@@ -212,14 +212,14 @@
     ```
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sxxpi/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2sxxpi
   :body: |-
     Straight forward today, I did a recursive solution which finds matches for the start of the string, then chomps off the ones that match from the string and trys again. Part 1, short circuit to return true if it finds any valid combo. Part 2, remove ths short circuit return logic so that we check each path, but add a cache to speed it up.
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/19](https://github.com/careyi3/aoc_2024/tree/master/solutions/19)
   :replies: []
 - :author: jstanley0
-  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2s6hju/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hhlb8g/2024_day_19_solutions/m2s6hju
   :body: |-
     665/869
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: eggselent_folk
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m32h60h/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m32h60h
   :body: |-
     Part 1
 
@@ -16,7 +16,7 @@
     I tried a similar approach to Part 1, but it was really slow. Then I realized there’s no need to keep running Dijkstra since there’s only one path. Instead, we can just use the path we already have: the savings come from how many grid cells along the path we can skip minus how many we pass by 'cheating' through the wall.
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m32dmpd/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m32dmpd
   :body: |-
     [Day 20 git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day20/day20.rb)
 
@@ -27,14 +27,14 @@
     Edit: implemented manhattan distance instead. Learned something today.
   :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m31r0rz/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m31r0rz
   :body: |-
     [paste](https://topaz.github.io/paste/#XQAAAQBSBQAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8fKlEL/CNiVvHcK3eo2f1wG2uFy9c4gJqYPLUFmRQObk0r1ctDG23Tm34gRt6y0eQyY1K3b+i262JFsBcUTwua3DLm6KSkqYEXQeJcnMzX2GiPxLyHJWGSpd1fxuDnJy73MlIlL5A6O9r7sUJc74tEcDpuOSFvnIDUAJroBJOl4///H6DVYUL4ZAWQeDifCTkpGd48wf1XWh8OaloKZi3EBui3TYbf2XczZyUTJ0gCrwy+Vh0acUQfuSoTFGJySKo455BdcpopJKl1y3juBmP7oTORtH9I+4Yc9FW6x16Zu2xxSRUQlgzbf1x9qA59hab7ZSSFhgnpgKR6yEueMsduCcaTE1MrEBvThUWafam677wcu+jaQ0J84QspD7caKAlferv+Cj6YKtb/tS78hON9X62Q3+NBEhKbWgkmSs1PcSSmSWgs42iMkoOr9LXiNfqHCdow+xffrKvSWd3WUHN5tOBn2/PX1R+2MMcMD4wUHU+1P6f5hal6aCciijFQ0qntvI31170SCUg5hBWTqE6dsM1/zVWkIBB/gbB70aKBu3Qy2Agvif5WFB9bkR0kjjnpR6QbiR4KCh90LFncnJON33o5rLoSRAJoAX7OxByKGSgzusOC1JU9xhRYzPFiLQHTI4k/ZRdX6QWrS/VNyt489cJmMbQ6EZXS2aSNxDtXZ0Pm1aQYcpSQwVxg9KYOECireQAH48ATQOjXOAcdn2yBJMFPtw0yGLODKhKxBj/RCss1ZFRDrLxOdeuQTyEAlkxA3LEvUBMmyXOIiv09YUM/5OhmCMOYedljBc2+9RK4+e/rLITQNz/vHkIsQ==)
 
     I really don't think today's problem description was very good. Part 1 was clear but I just didn't read carefully. Part 2 sure felt a bit underspecified
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2yun6p/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2yun6p
   :body: |-
     ```ruby
     start, target, map = nil, nil, Set.new
@@ -74,7 +74,7 @@
     ```
   :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2ycfqu/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2ycfqu
   :body: |-
     Advent of the Grid! Quick bfs to get the shortest path. It wasn't immediately obvious to me that there was only one path through, so I wasted time trying to tweak my bfs at first. My find\_path function returns a hash of all the points on the grid and their step counts. For part 1, I went to every point and checked if 1 or 2 steps in any direction would let me short circuit the path. For part 2, this was slow, but worked just changing it to 20 steps in any direction. I cut part 2 down from 7 seconds to 4 by instead testing every point in the grid with every later point to see if it was less than the cheat distance away from the first point. This technique slowed down part 1 quite a bit. I'm curious if anyone found faster solutions.
 
@@ -94,18 +94,18 @@
     [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/20/solution.rb)
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2zkao9/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2zkao9
   :body: |-
     Not too bad today, I was surprised that my lazy solution for part 2 worked in a reasonable time. I made a mistake at the start and assumed that there was a third move needed to get you back onto the track and was overcomplicating it, but turned out not to be an issue anyway. Solution is to run dijkstra, then with the known set of visited paths, for each one, see if it is N steps away (through walls) from another visited point on the path who's distance from the start is longer. For part 1 N = 2, for part 2, N = 20. I use a dump 40x40 grid in the second part centered on the point of interst and then calculate all the points that have a manhatten distance of 20 or less as candidates.
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/20](https://github.com/careyi3/aoc_2024/tree/master/solutions/20)
   :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2zvmsc/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2zvmsc
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day20.rb)"
   :replies: []
 - :author: masterarms
-  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2z9o0z/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hicdtb/2024_day_20_solutions/m2z9o0z
   :body: |-
     For part1 the brute force solution (doing a BFS for every possible cheat pair from the start and the end) correctly finished before I wrote the faster solution for both parts. But it was clear that part2 would take ages.
 

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

@@ -1,17 +1,17 @@
 ---
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m3c99gh/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m3c99gh
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day21.rb)"
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m38oozv/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m38oozv
   :body: |-
     [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day21/day21.rb)
 
     Struggled hard on this one. Recognized that it was dp problem, but I had issue figuring out what I needed to memoize. I also made a mistake of selecting individual sub sequence by "weighing" them based on the number of movements required, and selecting only one of them. That was a mistake. Weighing them is fine, but all the substrings of the same weight must be accounted for as well, and that took some snooping around here to figure out.
   :replies: []
 - :author: NullT3rminated
-  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m33nqyg/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hj2odw/2024_day_21_solutions/m33nqyg
   :body: |-
     [Language: Ruby 710/223]
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3dig7t/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3dig7t
   :body: |-
     Really overcomplicated this on my first attempt and wrote something that took 20s. Significantly refactored and this runs in about 1s which is just fine by me for AoC purposes.
 
@@ -50,18 +50,18 @@
     ```
   :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3c9pg4/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3c9pg4
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day22.rb)"
   :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3a99nb/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3a99nb
   :body: |-
     Busy weekend, didn't get day 21 done yet, but happy this one wasn't too bad. For part 2 I generated a hash of all sequences I encountered and stored the values found. Then I summed the matching sequences across each start number, the largest value in the end was the correct answer. Fairly slow, but not optimised at all, can deffinately make it faster. Runs in about 5 seconds for me.
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/22](https://github.com/careyi3/aoc_2024/tree/master/solutions/22)
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3a2wy5/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m3a2wy5
   :body: |-
     [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day22/day22.rb)
 
@@ -70,7 +70,7 @@
     Part 2, I used an inner set to mark sequences I already seen for a number, and it gets processed into a frequency table, which accumulates the price, then it's a simple sort, and pick the last one. There was one mistake I made, and it was that I choose the maximal value a particular sequence is worth for a number, cuz I figure that is the best way to min max, but it turns out the monkey only picks a sequence the first time it appears.
   :replies: []
 - :author: Sharparam
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m38ylua/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m38ylua
   :body: |-
     (1352/1270)
 
@@ -79,7 +79,7 @@
     Completes both parts in around 43 seconds on my machine, pure brute force. With how easy today was it makes me shiver in fear for the coming two final days before day 25…
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m39lq9x/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m39lq9x
   :body: |-
     ```ruby
     input = File.readlines("input.txt").map(&:to_i)
@@ -118,7 +118,7 @@
     ```
   :replies: []
 - :author: birblett
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m390b32/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m390b32
   :body: |-
     ```ruby
     puts (seq = {}) && File.read("in.txt").split(/\n/).map(&:to_i).sum { |cu, h = {}, last4 = 1048575|
@@ -134,7 +134,7 @@
     just use the last 4 prices as a key to sum up the results of each individual sequence. used some funky bitwise stuff during key generation to save the overhead of passing entire arrays around as keys. runs in about ~1s on my machine (using truffleruby).
   :replies: []
 - :author: yourparadigm
-  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m39a4gv/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hjroap/2024_day_22_solutions/m39a4gv
   :body: |-
     [LANGUAGE: Go]
 

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

@@ -1,6 +1,6 @@
 ---
 - :author: False-Expression-985
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3i1ax2/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3i1ax2
   :body: |-
     Code: [https://github.com/ChrisBrandhorst/adventofcode/blob/master/2024/23/main.rb](https://github.com/ChrisBrandhorst/adventofcode/blob/master/2024/23/main.rb)
 
@@ -50,7 +50,7 @@
     The bottom count is equal to the initial entries' `to[].size - 1` (if you include the intersection with itself, you can skip the minus 1). **This only holds for the answer set** , so you can stop after you find the first one (which for me is after just 39 of 3380 input entries).
   :replies: []
 - :author: FCBStar-of-the-South
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gwj71/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gwj71
   :body: |-
     [paste](https://topaz.github.io/paste/#XQAAAQB6BQAAAAAAAAARiAlH8dxNBu7dkgwpusw3/1N9B7LsXMI7hyVChWl1ep9IBYPPdblNB+e+LbTiO+aeJ6+cRA4yPOmC7Qaz1eL62nSqw7zBuYzSqTOFQgaI2kIHocSAPLoEezoZhVcCkfVH5FIAQyQU0OcylwJssDkMV0w3PaMNhW6cQTeersZZZUr0mekSjDa8+ZRH9ekQB/LYwBKvIiAdv5FzbvVSy+d5x4vlb1w2z6CBmjFMC2TYZVh2n5N8QIZH7ZQ4zDP0NKCsyjHrXTG3F8VrOdBd6XC3cTTYnD2Fh/H76DmJdLQP94jhhQLXfksvRyAOFNvCInesVrqV4AuJZzY63HPM0/r30G9oLhbLEb/I8O+GnDDFdev26UrYVPg4o2FYAVW5SipZceu1bwUhtiyWNzM+Ij+VgD130gLmfJZDbSMtMJtcbu4ZZtZkhgt+4u/1dNEs7bGM1GqpOpV0mK4HFZCkWSVZCJuxApFU2PlSAYgb3Y+gJqnm1EzczY/15xn0dQD3nujF2Mccg7Qt/AXm7WPL59wIjA+qiTx3A2t7ugnOA7ZGKqVXI7uU3F8A0UeMhNxsGEcLIrlyiOpzmiqnv1dC62nrf7nXPkW+nUbvwsIyYDg9c9dbnwlar7HnGjJCGp+A66MeZOUTnxP5h4EKcrUC7OoEU1qRMMohzBcoXbetm/wW7iZFmYAAoX48j33ks0VECGdbsSQjIpJH2jp+kN04jJiHXcAOqU0QkLkp2AeR676ucv328GMdWGNeKFsXwOrYlhAq+JYG0OFLr58WPeN+aIeHvb5B0Q2/OPobygzzr/Gtl/ufGr73AZ0KqmdcZqq03eYiFBeyvb//VQw0AA==)
 
@@ -59,18 +59,18 @@
     For part 2, today I learnt about the [Bron–Kerbosch algorithm](https://en.wikipedia.org/wiki/Bron%E2%80%93Kerbosch_algorithm). Actually a somewhat straight-shot algorithm once you understand it
   :replies:
   - :author: ChasmoGER
-    :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3him0j/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3him0j
     :body: Thanks for sharing the algorithm name!
     :replies: []
 - :author: careyi4
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gsazr/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gsazr
   :body: |-
     That was fun, did a dumb check every combinations thing for the first part. Then for part 2, I constructed a binary number for each set of points and what it was connected to. I then anded each pair of these sets. A group of connected computers should contain a the same number of computers in common. So by tallying the results of all the ands, you can see the one that occours the most should be the largest number of connected computers.
 
     [https://github.com/careyi3/aoc\_2024/tree/master/solutions/23](https://github.com/careyi3/aoc_2024/tree/master/solutions/23)
   :replies: []
 - :author: JAntaresN
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gkxv7/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gkxv7
   :body: |-
     [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day23/day23.rb)
 
@@ -81,7 +81,7 @@
     Overall, alot easier than I thought it would be cuz when I did the first part, I had expected another memoization slog fest like a few days ago.
   :replies: []
 - :author: el_daniero
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gd7b0/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3gd7b0
   :body: |-
     ```ruby
     require 'set'
@@ -115,11 +115,11 @@
     ```
   :replies: []
 - :author: Stronbold
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3fy0wg/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3fy0wg
   :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day23.rb)"
   :replies: []
 - :author: _tfa
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3fxw3m/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3fxw3m
   :body: |-
     Nothing special here. Runs in ~ 100ms
 
@@ -155,7 +155,7 @@
     ```
   :replies: []
 - :author: yourparadigm
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3ee1s7/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3ee1s7
   :body: |-
     851/1863
 
@@ -164,7 +164,7 @@
     [paste](https://topaz.github.io/paste/#XQAAAQB1BQAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw6AjPxo/gbHVfkb/lFqEN/cVLFFRr5hB8At2Ya6RvYvxrcrj9+/hWpyd2xTGLsezZSupxlbZ8zenEPWJeoe7/CshYyiqEEaTOm7lLuqxNFbbIMrN7ugc9qoSceYRu1lQzsT4BsDnLd6zxO0da4l73kExIxHwmjktTM4qNlMhR2mhfRkuOVHu4qnDnt6xGkT7/jjpUvk+yRqvP5ijERekL+j9DBL44H/1L8a8fiupGXI/pzcSWoPv+F2geLy0M81z9UX4obpEPiIyQWPEJ50gWwLXaQSZm5ELexB8ciciGRcQ5nedFd12DJck3atWOGk6MOYQi6H9brjxpRVwr0XWP+AFdetJbUbZXA6UkfIagBn1ioXgjPd4OGfqg1207D4k5uhSPyGFo+2EG65qPsPKt+Vq6lAN+a6htIwz92yEQU4bTtgbwohEnAG660Grc1UhpYyR8xgV93c4sIg2mrXD+TkNxdE3DMFXdKOaJqAD/ubmwUEsZrIZbGLgcpqzYrkhC6tfSa1KeXkGxs7N7Z8QLmop8V9ZAmaYY0SKT7VPN3yTM/gEifrxpW/WGN+zT6g5lwyUYVjFmHAuzbcxOqOAfASlVR044i+kC+9MFPL2e6z996vwJVl2EQIq5IJ0UeMhyx81CdjBacMjeF676MKd3y51ToIPFAVqDVAsWtPOLuAi8wIYAgZovrdWV7oDP0gHXja3H/+Y0b16)
   :replies: []
 - :author: globalreset
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3ekc9i/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3ekc9i
   :body: |-
     I just recursively tried to build the largest group I could starting with the beginning network of each node. Runtime was longer than I could wait so started looking for speedups. My biggest speedup was maintaining a running max and skipping over nodes whose starting network was smaller than my current max group. Still only got it down to 1.6s so I want to play around with better algorithms.
 
@@ -196,7 +196,7 @@
     ```
   :replies: []
 - :author: Mon_Ouie
-  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3eqwj1/
+  :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3eqwj1
   :body: |-
     Just for reference, the basic DFS search for a maximum clique seems to have first been described by [Carraghan and Pardalos (1990)](https://www.sciencedirect.com/science/article/abs/pii/016763779090057C). It includes a pruning step that some solutions here don't have (you can backtrack early if the current clique combined with all vertices that can extend it would still not be bigger than the current best clique). The inputs are easy enough that you don't even need this.
 
@@ -247,10 +247,10 @@
     ```
   :replies:
   - :author: "[deleted]"
-    :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3eqwj9/
+    :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3eqwj9
     :body: "[removed]"
     :replies:
     - :author: Mon_Ouie
-      :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3er960/
+      :url: https://www.reddit.com/r/adventofcode/comments/1hkgj5b/2024_day_23_solutions/m3er960
       :body: Why is this case sensitive though?
       :replies: []