advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,215 @@
+---
+- :author: mpyne
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1yfahi/
+  :body: |-
+    I actually did this in Rust first but I think Ruby makes this pretty elegant in conjunction with a bit of more advanced high school algebra
+
+    ```ruby
+    require 'matrix'
+
+    data = File.read(ARGV.shift || 'input').split("\n\n").map { |p|
+      match = /(\d+)\D*(\d+)\D*(\d+)\D*(\d+)\D*(\d+)\D*(\d+)/.match(p)
+      match[1..].map(&:to_i)
+    }
+
+    # performs part 1 and part 2 in sequence
+    [0, 10000000000000].each { |offset|
+      sum = data.map { |data|
+        x1, y1, x2, y2, x_tot, y_tot = data
+        x_tot += offset
+        y_tot += offset
+
+        claw = Matrix.columns([[x1, y1], [x2, y2]])
+        total = Matrix.columns([[x_tot, y_tot]])
+        (claw.inverse * total).column(0).to_a
+      }.filter { |res|
+        [res[0], res[1]].all? { |x| x.denominator == 1 }
+      }.map { |res|
+        3 * res[0].to_i + res[1].to_i
+      }.sum
+
+      puts "#{sum}"
+    }
+    ```
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1uhhgl/
+  :body: |-
+    golfed both parts: 164 bytes
+
+    ```ruby
+    l=$<.read.split("\n\n").map{_1.scan(/\d+/).map(&:to_f)}
+    2.times{|i|i*=1e13;l.map{_1[4]+=i;_1[5]+=i}
+    p l.sum{b=(_6*(_1-3*_3)-_5*(_2-3*_4))/(_1*_4-_2*_3)
+    b%1==0?b:0}}
+    ```
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1to61k/
+  :body: |-
+    My strategy started off thinking I was going to do some dynamic programming to get to the result. But I quickly scrapped that and fell on my trusty Z3 solver. Which made part 2 pretty trivial. So after I was done, I went back and re-educated myself about how to solve a system of equations (without a solver!). And Cramer's rule came in handy.
+
+    ```ruby
+    def solve(ax, ay, bx, by, px, py)
+      # Cramer's rule
+      # d = |ax bx| , a = |px bx| / d , b = |ax py| / d
+      # |ay by| |py by| |ay py|
+      d = ax * by - bx * ay # determinant
+      return nil if(d == 0) # skip parallel lines
+
+      a = (px * by - py * bx) / (d*1.0)
+      b = (py * ax - px * ay) / (d*1.0)
+      return nil unless a == a.floor && b == b.floor # skip non-integer solution
+
+      return nil if a < 0 || b < 0 # skip negative solution
+
+      [a.floor, b.floor]
+    end
+    ```
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/13/solution.rb)
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1trx40/
+  :body: |-
+    I initially solved part 1 with brute force, knowing it would not work, then I went straight to Z3 cause I need to save brain cycles for future problems :)
+
+    ```ruby
+    def solve_chunk(a, b, p, offset)
+      solver = Z3::Optimize.new
+
+      ax = Z3.Int("ax")
+      ay = Z3.Int("ay")
+      bx = Z3.Int("bx")
+      by = Z3.Int("by")
+      px = Z3.Int("px")
+      py = Z3.Int("py")
+      times_a = Z3.Int("times_a")
+      times_b = Z3.Int("times_b")
+
+      solver.assert(ax == a[0])
+      solver.assert(ay == a[1])
+      solver.assert(bx == b[0])
+      solver.assert(by == b[1])
+      solver.assert(px == (p[0] + offset))
+      solver.assert(py == (p[1] + offset))
+
+      solver.assert((ax * times_a + bx * times_b) == px)
+      solver.assert((ay * times_a + by * times_b) == py)
+
+      solver.assert(times_a >= 0)
+      solver.assert(times_b >= 0)
+
+      solver.minimize(times_a)
+
+      if solver.satisfiable?
+        solver.model.to_h[times_a].to_i * 3 + solver.model.to_h[times_b].to_i
+      else
+        0
+      end
+    end
+
+    def solve_easy(chunks)
+      chunks.sum { solve_chunk(_1, _2, _3, 0) }
+    end
+
+    def solve_hard(chunks)
+      chunks.sum { solve_chunk(_1, _2, _3, 10000000000000) }.sum
+    end
+    ```
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1u0zjj/
+  :body: |-
+    [LANGUAGE: Python]
+
+    I'm not great at math, especially not when it's been years since I was in uni.
+
+    I solved part 1 with Ruby, without any fancy tricks really: [[GitHub]](https://github.com/Sharparam/advent-of-code/blob/main/src/2024/13/solve.rb)
+
+    But for part 2 that obviously wouldn't work, so I had to switch to Python to get (easy) access to Z3: [[GitHub]](https://github.com/Sharparam/advent-of-code/blob/main/src/2024/13/part2.py)
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1uaeue/
+  :body: |-
+    Easy maths today!
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/13](https://github.com/careyi3/aoc_2024/tree/master/solutions/13)
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1uasny/
+  :body: |-
+    ```ruby
+    @input = File.read("input.txt")
+                 .scan(/.*?X\+(\d+), Y\+(\d+).*?X\+(\d+), Y\+(\d+).*?X=(\d+), Y=(\d+)/m)
+                 .map{ _1.map(&:to_f)}
+
+    X = lambda{ |a, b, c, d, e, f| (e*c - b*f) / (e*a - b*d) }
+    Y = lambda{ |a, b, c, d, e, f| (a*f - c*d) / (e*a - b*d) }
+
+    def tokens(offset=0) =
+      @input.map { |ax, ay, bx, by, px, py| 3 * X.call(ax, bx, px+offset, ay, by, py+offset) +
+                                                Y.call(ax, bx, px+offset, ay, by, py+offset) }
+            .filter{ _1 % 1 == 0}
+            .sum
+            .to_i
+    p tokens
+    p tokens(10000000000000)
+    ```
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1ut6aq/
+  :body: |-
+    [Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day13.rb)
+
+    Solved with linear algebra.
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1uz84m/
+  :body: |-
+    ```ruby
+    require_relative 'utils'
+
+    # x1, y1, x2, y2, target_x, target_y in order
+    machines = File.read('input13.txt').split("\n\n").map { |machine| ints(machine) }
+
+    def validate_solution(sol_x, sol_y, part2: false)
+      tol = 0.001
+      int_x = sol_x.round
+      int_y = sol_y.round
+      return 0 unless (sol_x - int_x).abs < tol && (sol_y - int_y).abs < tol
+
+      return 3 * int_x + int_y if part2
+
+      int_x.between?(0, 100) && int_y.between?(0, 100) ? 3 * int_x + int_y : 0
+    end
+
+    def matrix_inverse(machine, part2: false)
+      if part2
+        machine[4] += 10_000_000_000_000
+        machine[5] += 10_000_000_000_000
+      end
+
+      det = (machine[0] * machine[3] - machine[1] * machine[2]).to_f
+      return 0 if det.zero?
+
+      sol_x = (1 / det) * (machine[4] * machine[3] - machine[5] * machine[2])
+      sol_y = (1 / det) * (machine[4] * -machine[1] + machine[5] * machine[0])
+      validate_solution(sol_x, sol_y, part2: part2)
+    end
+
+    puts machines.map { |machine| matrix_inverse(machine) }.sum
+    puts machines.map { |machine| matrix_inverse(machine, part2: true) }.sum
+    ```
+
+    Sure love when the input is nice to you.
+  :replies: []
+- :author: iwanttoseeyourcatpls
+  :url: https://www.reddit.com/r/adventofcode/comments/1hd4wda/2024_day_13_solutions/m1tjnxv/
+  :body: |-
+    [github](https://github.com/ggggbbybby/aoc2024/blob/master/day13.rb)
+
+    I used regular old algebra to solve it. I was a little thrown off by the "minimum number of tokens" because there wasn't more than one solution for each machine, I thought I would have to do more math than this when I read the description.
+
+    the hardest part of this was dealing with floating point math. even using big decimal, 28.999999 doesn't equal 29.
+  :replies: []

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

@@ -0,0 +1,47 @@
+---
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hdvhvu/2024_day_14_solutions/m22vdlg/
+  :body: |-
+    [github link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day14/day14.rb)
+
+    Part 1. I solved it with math. Yeah it was just plug in any iteration, and it works.
+
+    Part 2, simply using part 1 to brute force until a tree appeared. Honestly all I had to do was look for the trunk, but this required me to know what the tree looked like before hand, so it's a bit cheesing it. Originally I considered looking for a pattern where I would check for a 3, 5, 7 pattern but the trunk approach was easier since it is a simple 3, 3, 3 pattern.
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hdvhvu/2024_day_14_solutions/m21yspj/
+  :body: |-
+    Fun simulation code, but the second part got me a little bit. Then I decided to dump 10000 iterations of ascii terminal vis into a text file. ctrl-f for a long chain of '#' characters, found it and had the iterations also dump into the file above each frame. Very silly solution but worked!
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/14](https://github.com/careyi3/aoc_2024/tree/master/solutions/14)
+  :replies: []
+- :author: '442401'
+  :url: https://www.reddit.com/r/adventofcode/comments/1hdvhvu/2024_day_14_solutions/m211gxk/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQD5BwAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw3D1UZFlD3WW8r2Z9pYT30ODveiMJ3JeJFSTLhdWR3FmXt2oGu9YdB1CZE/gbIVlI1reXAJ8hMN6/7ctv/R0Gq8QgadIdMfp96vKa6SL0+aCJbqFXXQPgfIdtmSyzc0vmg67mqsuw6FBP+h6e62YhnTlA1M9ZB4fFkq2IwKQB3KdY5OyU39DVK423dPSFsZaMUaZPmrWqRemZmUxTaFe24U0F1OH+kMj9WfvRpS/5KxpCmVKWoOWV7aD7HWNapE4+uUuy17VxFh6KVOPIImIePgLUWBrVJ/WORNx9hCMM3kZqnkhtbkRO42eksRrlrGae6ac6HcQqh5yUioH8o8bzSFTg3A1vW9LB1HIGBCZIkfD3VwQnG2ktnq3YTPhdrIQ8NtFTNQmjIHdIecGZiJ0wC8FRwbMm+WHj0gQIf2hZ4xOrJS/bmKCP0bJcJCzjmnoJ+kS8PZQFSWoodkIqxgRMweGE3RPHQZLcTiIt+fgz1tN1Rbh5x6gRMDqBr/GY8aHHaqmskM1EE1Sa74Kwe5JhfrTTMKTlkq0Je4ijjQ5eAv/FjUBlecdUedPKHfOjU1rEKRASgTZYtkR+4RAhOxN9by1+TXX3blFMS8hi1tn3gR5cfBDbXvZpLpflD7DLDwqnrKtUUcBxT6GHaDW6W8mcmN4nmzT8qlFAQ6jitlOL5r/NgjSTKH66lezo5vMLcs+BKZILQnr1kzjGLVJZlrAjfLqdDch+WBLK1HIY+SFJ2iEwiVcIPqZIm1E7vLIUSn8AU16MgmufZMgMLEt2AYJYPsECZtSF1s6Zyv30w5BfgCM+XFx49FDUHBaCsK7IYiy/G3H9WNVHbP5xTafb6QCGL8etSb3/0B5rQA=)
+
+    Ashamed to say that I had to take a hint from the main thread. Of course the safety factor will be low when the robots are playing at being a Christmas tree.
+  :replies: []
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1hdvhvu/2024_day_14_solutions/m1zapc1/
+  :body: |-
+    1115/747
+
+    The trick mentioned several times in here about unique points can be an optimization, but it didn't uniquely provide the Easter egg time. I used a strategy of looking for the largest contiguous group of robots.
+
+    [GitHub](https://github.com/phene/advent-of-code/blob/main/2024/14/14.rb)
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hdvhvu/2024_day_14_solutions/m20hz1s/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQBdBAAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDtBnHwB0CRbBF+F9hNoUjkUtOS/X/ERl2aixnmPmVTO8ihaWOMh31/f3Q1zLWH7F6R00l6RGeDO0jreNP7EvY3PTzZqtcxb5RsbMz90I/ZfBOsQAywaMAjun3bW8cpyFEqjc0j8kCBgmmJoHhu7yQZzRIH+xNVGSrO0yyJmVrOksWBbA0KVUYsy6Cucdruq/mvoGJ3UGoFATeyeBHnDxnTEH4gPglavFLM46aTOP0hnROPZIPB3fAGxD0sixBXxyyABiNhLnUjFQ6oM+UsSM3bdPrCVRUoCrwGKCCc+fKEIXUkP7RQuWYoDTAiaEACjEhU8h8GZtNaeZ/A02TehyOrl40bLkwhruWJHKKW/Mqn2a353+CqsWg7QdVONzNr0CEq4NF4ogz5ss3LlIWpM9PYlijrCYUJ1HQJ21p/SZrbQTr/nQWYBmfPTclbCzZmeCqnu7Y+kxTxmAFIbMHZDtH+O+1FYyjzNGIY6dY7jDqHEn1QEUcE1iJPwH/tjIcnK8krcYKfHCK2yOBdUJVAWuPwvy2I7LPaxsOAA0Ko7gwYhcnvO25vqHNYB7SfSvqW0OdvkQqG34hejARc2x8X56QSnmwG14bgmJVvJceQ8Xw2JCCMtC3N5lxTYyb3/+IEJsg==)
+
+    Why code when manual inspection do trick (and probably faster too)
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hdvhvu/2024_day_14_solutions/m20p7jj/
+  :body: |-
+    [Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day14.rb)
+
+    I tried to find the tree by looking at the grid dispersion. It kinda worked for my input, where the sum of variation in the X and Y axis were minimum when the tree appeared.
+  :replies: []

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

@@ -0,0 +1,39 @@
+---
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hele8m/2024_day_15_solutions/m28qx6c/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQCTDwAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8fKlEL/C49oYSKRg6kqFigCWb/16n+qCCjbP0ro+FJ5Lds084T3zBc6WcbkVlzWed3N6KtpvKaegCunJV8PM0gPtPpMyqCFRqRG829y5sW84lHf6woq6lGRggpQyqR7GtmLGaPMMY2BfleWpgpEm1HehYyjrmilBo/w/R+WezfouXB0TNNU1kP96i35zUeTHQbIPC8LikUpClkoA0K0fyiHTaY50HOGOb0GF4HgcCtxyh+HZH/HjFPjZOooy8IMOSaSor4dxQGsMNj5+zyUhqSqMndNhvIFm6VhtpkWIwAXSUBhlhz+GGp9pBDlFIOwmJ4dG0Z0vZ052IDprrvXxMEZfPDTBi0YQNNXwjgaFbp0YV+nJE01p6+6E6ouZVVwPfENnpQ/s4SQvFUy9UtsDHIax2xVu1kC4z++FnjSiKBF7yoR1cGjM/BBgXAS+mDoTOBPM+IGuMf8FEChkj3s/klR6Rmq9SfA+GXHymPtePyM8CQWJ3P0+RqmPKwNilieD7nmHgYcoAk63dDvN/12gan6NF+n4j8SQH77hBbmPa495jy3FG0ZuXVf/ti15gvzxQtXUfOsXfUAQFXwgFDZiwN1+fG5Qs7HWRCMAhmN1FlluDk0rwSgiYZO5o/K+S93Y8kmpv4OyfGivuYUiwP/PF+YeUMJFPR8WVT0sHESeKriG78MOOhYN/DKvMK7Ev+68IXsMHf4IavaQKetmm/Ol0VNWaz2mn3ejAVCPQcVnrfEQKFW0o+zlVOtBu2qv05dqpQxpU776Y++8iXbWDRs7Aotg0FU2TLIPhkybf6VnWpYKMmGK2l1LU7Ip/hMGZ7gvJKqYS2RcHo4Fj2O/F7BTP7Ke+JGatcs8lSZ+YtP4YX9rkIbKqeo2kdn/4S+Hw16RBmkE0q3p/Ww93JGmNbYa18XminY40lisb5OP3ZF42BYAJomWUIj/1qQfrM9T70Veju3/bInk4wxmRN1GLBYUObx5SZ/RCRSNwINfUpEnEU4ZmsML8eSHiYzoy9xwWjFTOCmNYw1dAKjhGrzCj8Yh+lCw3SYT7p8JFVw0YlT2uKBQE5b+rUnHpWKr4A3wGRW92ycqFzunDlKtXKUPDQxcH8JukIVks3P01tYqJqn9YPesFaPjf2SXQ3A5cJTZKjHr/DCLhF6Fg45bklpG6uY09yTL3XZ0bKmz6qDCzs4LvgMZyqLc4XWgofyfJI1EvgQgVHP7LW0oRZ7yskMWxlbuzhza7N/gCiW7ZN51J6B3wHF06LRSdof//eZDSmiJVL7Chu4dZJ+uLiIUZHEwP+4xXQpZFJbE7jKQpIPv7cO8Z95Fj0ygFHrS24c+KoJqWFcps0jbx+sJX8AhIZ4w6iBQT7IHOQ6SX1ifet5izobBHGJxCpNS5uqzk2MK5+8MGp/7FCJbQCD7R2t/jJg1Ifo+0dzDYxLwKhMjFP+jCfJIZ1E2kotRRd5kxYefiAUPqV+j0kgzI6iL/iB6PVBLFqC6T0gF5x/jmqeBOLOggncddkFERNBlOOS5ml/tyJl10irhFcmt+iv5AVlkVyL62ULAH60KmcTrWrJll4TZ2cIN0DugFaOtHL+TE8pJ/UoERX0eUfqPhWkuJ16MmmO8pkkviYICpvZK6753+eWen)
+
+    I hate debugging recursion so I didn't do that. Part 2 horizontal movement is pretty close to part 1. For part 2 vertical movement I deployed the ol' "implement how you would solve this manually strategy" and it worked very well with minimal debugging needed. A quick BFS to get all the boxes that will be shuffled (this also checks whether there is any wall blocking them) and then simply shift the boxes up/down. Ended up accidentally breaking the logic when I was refactoring tho, silly me
+
+    This was my 250th stars all events together! I will probably put a pause on the remaining 10 days until the new year and just enjoy my travel now
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hele8m/2024_day_15_solutions/m27vmxb/
+  :body: |-
+    [day15 ruby](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day15/day15.rb)
+
+    Not proud of what i wrote cuz it's alot, but part 2 is almost the same as part1, only really needed a special looping condition for the up and downs since overlapping between 2 indices is only possible there, while left and right movement is irrelevant since we can treat [, and] the same as O in horizontal movement
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hele8m/2024_day_15_solutions/m27hdah/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day15.rb)"
+  :replies: []
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1hele8m/2024_day_15_solutions/m24tmi4/
+  :body: |-
+    1385/1756
+
+    The logic for part 2 came to me immediately, but I probably burned 20 minutes on part 2 scoring because I misinterpreted it as edge of the box to the closest edge of the map.
+
+    [Github](https://github.com/phene/advent-of-code/blob/main/2024/15/15.rb)
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1hele8m/2024_day_15_solutions/m257pq6/
+  :body: |-
+    (1843/4158)
+
+    Code I got the stars with: [[GitHub]](https://github.com/Sharparam/advent-of-code/blob/39369be3fab24d4ed959c73e5d90fbdbf830fcc9/src/2024/15/solve.rb)
+
+    Current improved code: [[GitHub]](https://github.com/Sharparam/advent-of-code/blob/main/src/2024/15/solve.rb) (After looking at a friend's solution and improving mine based on that.)
+  :replies: []

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

@@ -0,0 +1,28 @@
+---
+- :author: FCBStar-of-the-South
+  :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/
+  :body: |-
+    [Day 16](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day16/day16.rb)
+
+    Struggled alot today actually, with part 1. I recognized that it was Djistrka but I didn't understand that each direction for each node matter as well.
+
+    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/
+  :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/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day16.rb)"
+  :replies: []

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

@@ -0,0 +1,151 @@
+---
+- :author: Symbroson
+  :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
+
+    After reverse engineering the code I noticed, that each output is based on a few octal input digits of the A register. I first thought it was 3 and I was wondering why 50% of my solutions were off by 1 digit after running my program, until I was given the hint by u/IsatisCrucifer that it was actually 4 digits.
+
+    So my actual algorithm for part 2 first builds all possible octal digit tuples for every output digit 0-7. These are used to backtrace the program digits into all possible digit combinations, joined by the predecessors and successors. The minimum of these converted to decimal should be the required value for register A.
+
+    The total runtime is somewhat between 40-50ms in ruby
+
+    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/
+  :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/
+  :body: |-
+    Got part 2 to run in ~0.090s
+
+    Part 1 doesn't need much explanation. For part 2, I started by brute forcing values of A and noticed a couple things"
+
+    1. The resulting output array, has n positions, where n is log\_8(A), so any A under 64 will give an output of [x1, x2], any A under 512 will give [x1, x2, x3] and so on. So your A will be lo lower than 8^x, where x is the size of the target array minus 1.
+
+    2. The last numbers in the resulting array are pretty consistent. You'll notice that for any A in [512, 1023], all resulting arrays will have the same last element (1 in my case), so they all look like this: [x1, x2, x3, **1**]. 512 in octal is 0o1000, 1023 is 0o1777.
+
+    So basically, when you simulate for any A between [512, 4095], if the last element is not the one you wanted, increase A by 0o1000 (512), if the last one is right, but the previous one is not, then increase only by 64, and so on.
+
+    [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/
+  :body: |-
+    [LANGUAGE: Ruby + Go]
+
+    Part 1 tripped me up with the last 2 instructions updating register a instead of the input register, but was ultimately straightforward.
+
+    Part 2 required a lot of analysis by just iterating over inputs and observing outputs. Helped when I was outputting as binary and noticing the relationship between output and individual octets, then I could use a BFS to search the space of octets rather than the massive computation of just iterating.
+
+    [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/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day17/day17.rb)
+
+    Part 1 simple case statements to handle different inputs.
+
+    Part 2 is a hard coded solution that can only solve my give instruction.
+
+    Basically I pulled a pro gamer move, and mathematically predetermined what to back track for my register A. I interpreted my sequence and realized some orders of the operations don't hinder the result of A, and in fact, by undoing the operation that changes my A, the previous A value can determine the B and C values.
+
+    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/
+  :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==)
+
+    [part2](https://topaz.github.io/paste/#XQAAAQCXAgAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8fK6shsLMxUnjj4w2Dxtm76YG+Ui+FyApxoSPvgUv5cG2pzVNPg0y3Vu+3Kam1P7ywJ+DqkKIAOI0qlV1go6l12TMl9D4hmAnGtfMhvWy/97VE+/LLamYXgpgeMq5ykWCAMpaHJsFYYtR1OC733PrCgGTRWQvJEqZw7GsXJXRo3ABgDTZO3QfFDyswtExyk8cTcJbWO8c3Cw16gBhXIJ00lzK4H7i/x9K87JcrUM2Ff2T83gOTEre89SCgOJ69fnVLS/dMai/coiot7PhOnGQd8wJIJGTIPCK09znLMFFsriy1b5cAwaTxoNLCFXtnJ2aBqpbEF21M/RcwgVGmBQLoj+AUzBRNEGv0JYUxvRGBCk9DUxe1akgkOhiLoJ6NZPvYVbZSjpIIw4EzU40CDP61fboWZZPVZwTPfuxjRAtnl6c40J5c21Q9c2QUYqXrkHPC32vMlEY4qc52YDv/oZw/w==)
+
+    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/
+  :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/
+  :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/
+  :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/
+  :body: |-
+    First brute-forcing the right half of A, then the left one.
+
+    ```ruby
+    regA, prg = File.read("input.txt").scan(/Register A: (\d+).*Program: (.*)/m).flatten
+
+    regA = regA.to_i
+    @prg = prg.split(?,).map(&:to_i)
+
+    def func(a)
+        b, c, i = 0, 0, 0
+        out = []
+
+        loop do
+            op, v = @prg[i..i+1]
+            combo = [0, 1, 2, 3, a, b, c][v]
+
+            case op
+                when 0 then a = a / 2 ** combo
+                when 1 then b ^= v
+                when 2 then b = combo % 8
+                when 3 then i = (a!=0 ? v-2 : i)
+                when 4 then b = b ^ c
+                when 5 then out << combo % 8
+                when 6 then b = a / 2 ** combo
+                when 7 then c = a / 2 ** combo
+            end
+            i+=2
+            return out if i >= @prg.size
+        end
+    end
+
+    def search(start, rightHalf)
+        offset, range = rightHalf ? [24, 8..] : [0, 0..]
+        result = Float::INFINITY
+
+        (0..7).to_a.repeated_permutation(8).each do |digits|
+            a = digits.map.with_index{|d, i| d << ((3*i)+offset) }.inject(&:|) | start
+            result = [result, a].min if func(a)[range] == @prg[range]
+        end
+        result
+    end
+
+    puts func(regA).map(&:to_s).join(?,)
+    puts search(search(0, true), false)
+    ```
+  :replies:
+  - :author: _tfa
+    :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...
+
+      ```ruby
+      def search2(pos, a)
+          return a if func(a) == @prg
+          f = (0..7).to_a.filter{ |c| func(a | c << pos*3) [pos] == @prg[pos] }
+          f.map{|j| search2(pos-1, a | j << pos*3)}
+      end
+
+      puts search2(15,0).flatten.min
+      ```
+    :replies: []

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

@@ -0,0 +1,135 @@
+---
+- :author: FCBStar-of-the-South
+  :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/
+  :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:
+
+    ```ruby
+    # Part 1
+    grid = make_grid(input.take(WAIT))
+    p find_path(grid, WAIT)
+
+    # Part 2
+    puts input.drop(WAIT).find.with_index { |(x,y),i|
+      grid[y][x] = i+WAIT
+      !find_path(grid, i+WAIT+1)
+    }&.join(",")
+    ```
+
+    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/
+  :body: |-
+    [git link](https://github.com/jw-rx-93/advent-of-code-2024/blob/main/day18/day18.rb)
+
+    Part 1 djikstra algo. It is literally the same solution I used for day 16, except the scoring is different.
+
+    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/
+  :body: |-
+    Reused my dijkstra from day 16. And part 2 was a simple binary search.
+
+    ```ruby
+    def part_2
+      min, max = 1024, data.size
+      byteCnt = loop do
+        mid = (max + min)/2
+        if (find_path(data[0...mid].to_set) == nil)
+          max = mid
+        else
+          min = mid
+        end
+        break min + 1 if max - min <= 1
+      end
+      "#{data[byteCnt-1][0]},#{data[byteCnt-1][1]}"
+    end
+    ```
+
+    [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/
+    :body: |-
+      I had similar, but used the built-in [binary search function](https://docs.ruby-lang.org/en/master/bsearch_rdoc.html)
+
+      ```ruby
+      # part 2
+      index = (0...falling.count).bsearch do |i|
+        !calc_distances(size, start, falling[0,i+1].to_set)[finish]
+      end
+      puts falling[index].join(',')
+      ```
+    :replies:
+    - :author: globalreset
+      :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/
+  :body: |-
+    ```ruby
+    input = File.read("input.txt")
+                .scan(/(\d+),(\d+)/m)
+                .map{ |x, y| Complex(x.to_i, y.to_i)}
+
+    ADJ = [-1+0i, 0-1i, 1+0i, 0+1i]
+    START, TARGET = 0+0i, 70+70i
+    BOUNDS = (0..70)
+
+    def dist(walls, pos)
+        queue = [START]
+        d = Hash.new(Float::INFINITY)
+        d[START] = 0
+        until queue.empty?
+            node = queue.pop
+            ADJ.map{ |adj| node + adj }
+               .filter{ |p| BOUNDS.include?(p.real) && BOUNDS.include?(p.imag) && !walls.include?(p)}
+               .each{ |p| (d[p] = d[node]+1; queue << p) if d[node]+1 < d[p] }
+        end
+        d[TARGET]
+    end
+
+    def reachable?(walls)
+        visited = Set.new([START])
+        queue = [START]
+        until queue.empty?
+            node = queue.pop
+            return true if node == TARGET
+            ADJ.map{ |adj| node + adj }
+               .filter{ |p| BOUNDS.include?(p.real) && BOUNDS.include?(p.imag) && !walls.include?(p) && !visited.include?(p)}
+               .each{ |p| visited << p; queue << p }
+        end
+    end
+
+    puts dist(Set.new(input[0...1024]), START)
+
+    walls = Set.new(input)
+    pos = input[input.rindex{ |v| reachable?(walls.delete(v))}]
+
+    puts "#{pos.real},#{pos.imag}"
+    ```
+  :replies: []
+- :author: careyi4
+  :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/
+  :body: |-
+    [Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day18.rb)
+
+    Almost like everyone here, walk the grid with BFS and solved part 2 with binary search.
+  :replies: []