advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,269 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j1czuwm/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/21)
+
+    Video Walkthrough: [YouTube](https://youtu.be/8_LvF2C4myo)
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j16ddx9/
+  :body: |-
+    Ruby, part 2. The code is horrible, but I am kind of proud of myself, seeing how others used binary search, o some online equation solvers.
+
+    The idea is starting from root build two chains of operations - one which ends in 'humn' and the other, where it ends in value node. Then at the root we know the final value of one chain, and need to go through the human chain reversing each operation so we end up with the initial value 'humn' should return.
+
+    ```ruby
+    # frozen_string_literal: true
+
+    require 'set'
+
+    file_path = File.expand_path('input.txt', __dir__ )
+
+    file = File.open(file_path)
+    $monkeys = Set.new
+
+    file.readlines.map(&:chomp).each do |line|
+      name, rest = line.split ':'
+      parts = rest.split ' '
+      if parts.size == 1
+        $monkeys.add({ name: name, value: parts.first.to_i })
+      else
+        $monkeys.add({ name: name, left: parts.first, op: parts[1].to_sym, right: parts.last, value: nil })
+      end
+    end
+
+    human_chain = []
+    target = 'humn'
+    loop do
+      monkey = $monkeys.find { _1[:left] == target || _1[:right] == target }
+      human_chain << monkey
+      break if monkey[:name] == 'root'
+
+      target = monkey[:name]
+    end
+
+    $human_chain_names = human_chain.map { _1[:name] }
+    monkey = $monkeys.find { _1[:name] == 'root' }
+    other_chain = []
+    loop do
+      target = [monkey[:left], monkey[:right]].reject { $human_chain_names.include? _1 }.first
+      break unless monkey[:value].nil?
+
+      other_chain << monkey
+      monkey = $monkeys.find { _1[:name] == target }
+    end
+
+    def value(node)
+      node = $monkeys.find { _1[:name] == node }
+      return node[:value] unless node[:value].nil?
+
+      left = value(node[:left])
+      right = value(node[:right])
+      left.send(node[:op], right)
+    end
+
+    def perform(target, known_value, op, side)
+      return (target - known_value) if op == :+
+      return (target / known_value) if op == :*
+
+      if op == :-
+        return (target + known_value) if side == :left
+        return (known_value - target) if side == :right
+      end
+      return (target * known_value) if side == :left
+      return (known_value / target) if side == :right
+    end
+
+    def reverse(chain, target)
+      chain = chain.drop(1)
+      monkey = chain.first
+      loop do
+        left = monkey[:left]
+        right = monkey[:right]
+        op = monkey[:op]
+
+        if left == 'humn'
+          known_value = value(right)
+          return perform(target, known_value, op, :left)
+        elsif right == 'humn'
+          known_value = value(left)
+          return perform(target, known_value, op, :right)
+        end
+
+        known_node = [left, right].reject { $human_chain_names.include? _1 }.first
+        next_node = [left, right].select { $human_chain_names.include? _1 }.first
+        known_value = value(known_node)
+        side = ($human_chain_names.include? left) ? :left : :right
+        target = perform(target, known_value, op, side)
+        monkey = $monkeys.find { _1[:name] == next_node }
+      end
+    end
+
+    root = $monkeys.find { _1[:name] == 'root' }
+    target = value([root[:left], root[:right]].reject { $human_chain_names.include? _1 }.first)
+
+    print reverse(human_chain.reverse, target)
+    ```
+  :replies: []
+- :author: tgoesh
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j163fyh/
+  :body: |-
+    # [Ruby](https://topaz.github.io/paste/#XQAAAQCfBQAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kt1xH5HTAZ5BobIVaNmvr5uBT8lIWMVDPZEFxdcpn3Nj9lGXzliPRlIkeaE/uxw0eRYNQ0wHIgpqPDGvjVfR4EKOziEs6xQZ45nkYjc9RLRFCQt6D781H8E6UUKqPEZDvik3xRVWko1Oy0Ub+/OXUWd6N4CU6dt57vEYuOkjUl+8Br7Fqb6iNscVaYLIVFAQnOBCNq58vf9S7JAMlPRPLpvMuviy3kcQA/4McodaSdOMSfK3INWV1Jn8n1kI4FAN3O0ONmLb+Qz8sMiEkcIH5qA7tU4V/Q1BQynqWFGrAvGjWTigKhdwrgdLEqtlPNXjKas/he+1UL4NDu2g2C8HznNtS4U7tr5H8TSf7SwySjWiXKvlhyqnT4MZ2hRuOwQckAmUgQYXIY1fCZyi+bZE0lcZ72p9ZnBTPnnWd7ztLjvhpNT9uvJ56pUzEMks7b/y7GtQN8do7nxva1zvKNydtg2vEkQ3JTMRi5MudW7vUzUuOObK6bPblyvnCT7rWcCTxFh/dZOS3yGTzJJvFGBYLMNme26xv923It0J8sg6+loG7WsHOnF+XJ1hNyfISyBHIxm3+DVSs4eUSVSx9Uvt4s8Hg9FmKwIVSQoN1W0U0dVOPInwIHeR4RfckEAJZfbdIsxS3tTaHP4sq4NuHF7velg9GPBjEqxU8R7EL0iXUX4EkxG/Ch5FpMGk+x+VGOOX5tNgTvLRorC9z+TduRZlbeagxryvyOawx6+YB81wA8cG38f5u5e3IxVmMKwT8vQkVdbeeG1RHagPjlSvrt+BUTtU9gvaMoyTslaNzWbamfgTLyJD9pNbRSlPu7JHB449pTr0F+wQSr7h+XgopbP8CyBOpzYq4GN8Om5021qgHC0kDHv/fWVUJ)
+
+    Built a simple traverser to parse the tree for step one, so instead of rebuilding for step two I started returning a chain of nested lambdas of inverted operations from humn which was then called from root. Added maybe a dozen lines, because of the three different cases for the inverse functions.
+
+    Has some horrible practices, including monkey patching the traverser into the tree hash.
+
+    Works great, though.
+  :replies: []
+- :author: shandley256
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j15orhb/
+  :body: |-
+    Quite pleased with my Ruby solution for part 1:
+
+    ```ruby
+        STDIN.readlines.map { |line| line.split(": ") }.each { |name, expr| define_method(name) { eval(expr) } }
+        puts root
+    ```
+  :replies: []
+- :author: Elavid
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12tsyo/
+  :body: |-
+    ## Bit-based binary search!
+
+    Here is my [Ruby code](https://gist.github.com/DavidEGrayson/5094af019366700029eff76246fc1391) solving part 2 using a bit-based binary search.
+
+    I've never seen anyone talk about bit-based binary searches except for [here](https://twitter.com/DavidEGrayson/status/1595900172692660224), but to me they are incredibly easy to understand and code, so I want to tell people about them. Each iteration determines exactly one bit in the answer. There is no need to keep track of a range or update midpoints. The core of the algorithm is:
+
+    ```ruby
+    guess = 0
+    let i iterate from 63 down to 0: # or use a higher starting point
+      mask = 1 << i
+      if (guess | mask) is not higher than the number we are looking for:
+        guess = (guess | mask)
+    ```
+
+    Here is my Ruby implementation of that idea to elegantly solve part 2:
+
+    ```ruby
+    # try_humn(0) is a large positive number.
+    # try_humn(1 << 64) is a large negative nubmer.
+    # Given the observations above, let's do a bit-based binary search to find the
+    # largest humn value where try_humn is positive, then just add 1 to it to get
+    # the lowest value where where try_humn is 0.
+    guess = 0
+    63.downto(0) do |i|
+      mask = 1 << i
+      guess |= mask if try_humn(guess | mask) > 0
+    end
+    puts guess + 1
+    ```
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12v3v6/
+  :body: |-
+    evals galore! Ruby + Z3
+
+    ```ruby
+      def part1(input)
+        prog = input.map do |l|
+          l.sub(/(\w+):(.*)/, 'def \1(); \2 ; end')
+        end
+
+        eval(prog.join)
+        root
+      end
+
+      require "z3"
+
+      def part2(input)
+        env = Hash.new { |h, k| h[k] = Z3.Int(k) }
+        prog = input.map do |l|
+          l = l.sub(/root: (.*) \+ (.*)\n/, 'solver.assert env["\1"] == env["\2"]' + "\n")
+          l = l.sub(/humn: (.*)\n/, 'env["humn"]' + "\n")
+          l = l.sub(/(\w+): (\d+)\n/, 'solver.assert(env["\1"] == \2)' + "\n")
+          l = l.sub(/(\w+): (\w+) (.) (\w+)\n/, 'solver.assert(env["\1"] == (env["\2"] \3 env["\4"]))' + "\n")
+          l
+        end
+
+        solver = Z3::Solver.new
+        eval(prog.join)
+        solver.satisfiable?
+        solver.model.to_h[env["humn"]].to_i
+      end
+    ```
+  :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12rghz/
+  :body: |-
+    ## [Ruby](https://github.com/jstanley0/advent-2022/blob/main/21.rb) 540/1917
+
+    Part 1 is a simple recursive function.
+
+    For part 2 I first turned the equation into a string and tried to paste it into Wolfram Alpha, but it complained it was too long. Other sites I googled choked on it as well, including sites listed elsewhere in this thread. Oh well.
+
+    I decided to solve it for real. I essentially built a binary tree for the side of the equation containing `humn` and I simplified it one step at a time. For instance if I had 3 - (...) = 5150 I turned that into (...) = -5147 and then repeated until the left side contained only `humn`
+  :replies:
+  - :author: mynt
+    :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12rmnr/
+    :body: |-
+      Similar approach except wolfram Alpha worked!
+
+      Might have to go back latter and make something that actually works by itself as well.
+
+      My string was:
+
+      ((((92540050790154-(9\*(((((280+(((((((2\*(264+((516+(((660+(2\*((2\*(530+((((313+(((((3\*(615+(((8\*(915+((((246+(4\*(((483+(((((((80+(((((8\*((((3\*(789+((107+((x-745)/3))\*11)))-695)/4)-486))+570)/5)-757)/3))\*5)+411)\*2)-885)+552)+802))/2)-686)))/5)-175)/3)))-66)/2)))-319)\*2)+133)+570))/2)-955)/2)))-768)))/3)-223))/5)))-933)/5)+765)\*9)-193)\*2))/2)+689)/6)-230)))\*2)+138)/12)=5697586809113
+    :replies: []
+  - :author: Pakosh
+    :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12sq66/
+    :body: Natural language complains for me as well but once I switch to the math input, its ok.
+    :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j12szc6/
+  :body: |-
+    In both Ruby and Haskell, you can define a map that's defined in terms of itself! This allows you to resolve the "monkeys might need to wait for other monkeys to compute their values" situation, without worrying about the code taking forever by repeatedly recomputing values that you've already computed in the past. In Ruby, you do this:
+
+    ```ruby
+    def monkey_math(monkeys)
+      Hash.new { |h, k|
+        v = monkeys.fetch(k)
+        h[k] = v.is_a?(Integer) ? v : h[v[0]].send(v[1], h[v[2]])
+      }
+    end
+    ```
+
+    (Full at https://github.com/petertseng/adventofcode-rb-2022/blob/master/21_monkey_math.rb)
+
+    In Haskell, you do this:
+
+    ```ruby
+    math :: Map String Monkey -> Map String Int
+    math monkeys = cache
+      where cache = Map.map eval monkeys
+            eval (Const n) = n
+            eval (Op a b op) = (cache Map.! a) `op` (cache Map.! b)
+    ```
+
+    (Full at https://github.com/petertseng/adventofcode-hs-2022/blob/master/bin/21_monkey_math.hs)
+
+    Oh yeah I managed to just barely sneak into the top 100 for part 2 today, great. I used binary search to do part 2. The difference is that i[n Ruby binary search is built-in](https://www.rubydoc.info/stdlib/core/Array:bsearch) whereas in Haskell you have to write it yourself.
+  :replies: []
+- :author: whezya
+  :url: https://www.reddit.com/r/adventofcode/comments/zrav4h/2022_day_21_solutions/j14dptm/
+  :body: |-
+    [**Ruby solution**](https://github.com/rbellec/advent_of_code_2022/blob/main/app/daily_problems/day_21.rb)
+
+    I started by trying to write a treetop parser (again) to explain how this works to some friends... And skipped to problem as soon as I saw my time limit approaching.
+
+    First part was easy, I was scared of cycle in data or tricks that would need monkey number starting with 1... But nothing of this.
+
+    For second part, after having a function writing the final equation, I thought about an object that could act both way : evaluating a result if both side are values or solving values of 1 side with the other side value and the operator then propagate solve but... I heard the trick about complex number before finishing this and once you see it it's too late (first time I speak about solution before finishing my attempt).
+
+    I tried it and find it quite elegant, I could find the solution using all problem 1 code and very few more lines.
+
+    [https://github.com/rbellec/advent_of_code_2022/blob/main/app/daily_problems/day\_21.rb](https://github.com/rbellec/advent_of_code_2022/blob/main/app/daily_problems/day_21.rb)
+  :replies: []

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

@@ -0,0 +1,54 @@
+---
+- :author: Elavid
+  :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17o4by/
+  :body: |-
+    ## Ruby, 546/476
+
+    [https://gist.github.com/DavidEGrayson/7750e1c2abdc41d57ae397b7227086dd](https://gist.github.com/DavidEGrayson/7750e1c2abdc41d57ae397b7227086dd)
+
+    I didn't do anything particularly special, except surrounding my map with extra space characters on all sides so I didn't have to do bounds checks and could avoid off-by-one errors at the end. I spent most of my time developing 14 ~~special cases~~ edge cases that look like this:
+
+    ```ruby
+    elsif (1..50).include?(new_x) && new_y == 100 # E to C
+      new_x, new_y = 51, transform(1, 50, 51, 100, new_x)
+      new_face = 0
+    ```
+
+    I only wrote those edge cases whenever my program wrote the "Unknown space" message telling me it was confused about where to go. I really should have made it so my code generated the correct `elsif` clause that I needed to my code to match the unknown case it encountered; that would have saved me probably 10 minutes of thinking. I'm kind of a fan of computers helping humans to write code.
+
+    When I didn't get the right answer for part 2, I added a **sanity check** : after doing one of these special cases I made sure that I could turn around and get back to the location where I was previously (and be facing the opposite direction). The sanity check revealed two or three bugs and allowed me to get the right answer. This one was the longest one yet, I think! Took me 110 minutes to finish and it was very repetitive.
+  :replies:
+  - :author: silxikys
+    :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17os2m/
+    :body: I tried this and it helped me debug my part2! I had a `x` where I should have put a `y`...
+    :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17l4fq/
+  :body: |-
+    **Ruby** (16/50)
+
+    - [Part 1](https://topaz.github.io/paste/#XQAAAQBqCAAAAAAAAAARiAaHkimM1L0GOHPHCZqDbEUyv/VFgsoWjJHla1Ou6vy4S39kofbg3JpXhFkqVxIs0PHBJ3M3EvC8gTJYpxXngia+mnZC7Y68EBrbdF6z4ElhpEHOMJ9h4nni6Ytv4lPgg/v68MFbOa/p3V1A2ABvEkg3pq7th/2XW9Aq/RMXuhppV71FtqFVRUH0BHRobozAK2yFdwwskYjU5E4MoCN7PeYyojjUi3A7tS6dFcnoLuNpJNfwjNYUD3eISG6bUWMVtB7gEJT2nSFFfc6p6Vicc3tw/NpbVlrOj0hI9cm1kIZdBvMrc8TD/qDipCMAkhdaxTwhWjkYUZMDCHLiF+a2/s62iQG3QPC1uwjmhdVKN3CyoUzj80WfacgFtaEztQ67p1GGKLREILaEVBQPbIAX6yeB2NCt2kVvKO4Q6kgTxUQ6OtZFdbmqejGpx0XXnf3R4Ch0jkl6VGnjIIW/oQ8NAYPpIXeB7keFU6q6tIhVZjwRVeLWFo3vIR35l8/+pmMCH6GhdE7zO5tgl1+y4Hb3bMqfCZNF9HDqknkOgU6sAVppvTYllxRtlI/4kzRLIxP2wJdZNCT/+12k/Y1wAM8RsxVUxK558ni30Qun4FKpwdirIB10BaP8PR7P8n7qF9+n2njoVhhjtfB/i2oZPxNF8qFo0wETAHuv3feszlaLpK87Vv8YSdClH/RQMcffbGyBBCJuXDITTuoXPq3OgmSHLI9Qik/5yQ5etnaniQL9MgSIMp2RvVCUMCdxxZ3EwNp0mKe9xGCAsyE89+W0/M4beJysMwYP1lc+iZAUd2koOMEW+b5RkgTnOvfI/x4rkr3DlBrs5q2m2Sw0UJ85/5bExZ+VBJYUUor/vj+gyupP9Swxth8ob1bcxyz98dCNWLDueOruo2Ka+yjmRHSq837uTjW9YXzKcLikBWILYIw88hCeRdjkeWpziurRQa1HC8JOF0dCefJMBOBQLsWezo8oSsWE4A//jy2LAA==) was pretty straightforward. I used a `Hash` to store the map data using `[x, y]` as an index. I struggled with some bugs around rotation, so I had to spend some time on a drawing routine and put `draw[]; sleep 0.1` after each move to visually debug it.
+
+    - [Part 2](https://topaz.github.io/paste/#XQAAAQAbEAAAAAAAAAARiAaHkimM1L5fBlrZwtMomYxm3RfC2XjBzZjy1WeNyou4a1WzITxO+y/4QAdmGDeIF6WX83M04eOQUbLLDdqJWf/kz5AYg9cFWXX3jtjJwp0vwEln644JPgLdfbWJF8iw9ckz4UoOICarIkVDg4/0Bk/Veg1pBPyseVQdCUteM+rst3Qsu5+zghuVcfjlVn349t1JSmPcQtnIAZkIJA51d33LXEH+Og+XjVebnJGrLDQcAa4RQbK9sOlwPuBxrpBFbe8NTXQsDaNb0n8twlgWFP+WXOxa98obN4YelbJYKO4YMl3OS80jMf+tU6uFNZy0S9cf7EkqIctihGS3FsLOmkQCB/m2Z9iFkrOa/9ixMWyMm+sGuJUJ7LL4z2RwPxcZh8QZPmfiBsRBOezBG+MMC6OCQPJF8u2xoYNwEE6C+SrodXhQXKETVrpb4PoaDT2KRJKpKtMxe7Vg30ohzbfkBEaL5uOy4qVTiDfjX/0b50qzYMFOgva46ArC2AevOsLAe94RB2Q1YEHC9TvKdtVDBKK/WOjho/8PBHdNSvqQQU2qu3MIOrhQgqfd0scteYp/hx0+FZGLPf/AXgSMp9cRoPGXPhRAoFpQRSQ1nDtThE+vxShWct4VEPoo31G5aN9cxHepIga4rQ5Pw+oIb6ELD52Bf6iutU08Azvhuk3WwtBt38ARv2vxhNISz0yDhVtit1HutilqKN/VSn1nIFR1F8+IwNmKQFwUuRkEIae8kwDtVuYyihAYlG1//OVJOk0a0qQse1Bl06XpQrR5auvkVQAO4CN1zJgMEjXW6CuXN4jQEKh6kCK0VjSi39JFqyGirMNcECPolE9sM628WPW0uDCCCGswthJ1zrsdg9zO7I9iLnzkjOMVGwSRLWuT7eWM8X4FT4kxSRbb6DWtj5ALr/hJhEBp2u037vwqh6IeNAfhMp9GW28vfBKSjfVOqLi39LKWgQI7+JCxLRG1B6Rf7minoiC9sDAF946YDOogTTSapxiflgZi8j7uT0msFW3YHXs4pU6v2sy1PO+XaAUPnNgTOyXxZoJcLGFvlCKFgG915IwuvGd9GZGIeTCFGHQyUvvcOnvTlH+CYB3DrzzhE98l6FCR43vdKNQFit/jxIUswt+OmhwWktq35CQLRFUY8peI21WkXMmjh64OKGjfwzsp/Axz3br3J0cyNgMJvZJH91OA8UeWE5GTfF0kp0jN/n59VqDq1s1k57yKKh/HkqvfxX19diN6jknzsTt+cXjF0Jp0wcEyp2d2HXd1kHzFideRFdgQdSPGWIzIyLTyXejB0i0wgZGDqH3LVgAcuw0oLx5ZCEfCH/0SbbnO68iUwNzu/bAGzKdR9tcmInXvTEc7WjRmF17gf8n+iUJid5D9HoU+8WThGNoMnJn3+flmO3qI+ECIVm8YtF9sJag7Mr6rM1i8JwzyCqP3u/7XKr2u8TZN2CF5lPH4jEpmESqU8TR+HpxmNWA6zHtLds4C4jqE6bqQp/kxBMeciW868lupI4ErInBxYmIEE2bLHIDZlQNWzmcywez7WR1fYcHfeZSRaygzhHPo91EMiBMpdsurAHB7mseQJb0Nost9WZ64HyMLCOmTxt5wn/XlxhhYVKuaPIeJI+7/eH3jb1Nph3iIjBsuS8LrdPDA1uRzH7KPNT2IHUJkYKDvdsP3CuTloSrLNYa9j964LjS1aOWJLqewkF7UtrkgcJc1g5y9Av5uv5xIrojslAv3y71h8eVF7EXBmiBsXCtfcl4hhHSd+eLSyD81Y4sGf/zLbzI=) I [created a physical box](https://www.reddit.com/r/adventofcode/comments/zseeth/2022_day_22_part_2_my_workspace_after_solving/) and created a mapping for each side of the cube, which is then used to calculate the wrapping. Part 2 does not handle example input (because creating that map was tedious).
+
+    Here’s how the map looks like
+
+    ```ruby
+    # origin: the top left corner of unfolded coordinates (divided by 50)
+    # up/down/left/right:
+    # [0]: which side to appear on when going through that edge
+    # [1]: how many 90deg clockwise rotations to perform
+    $cube_data = {
+      A: { origin: [1, 0], up: [:F, 1], down: [:C, 0], left: [:E, 2], right: [:B, 0] },
+      B: { origin: [2, 0], up: [:F, 0], down: [:C, 1], left: [:A, 0], right: [:D, 2] },
+      C: { origin: [1, 1], up: [:A, 0], down: [:D, 0], left: [:E, 3], right: [:B, 3] },
+      D: { origin: [1, 2], up: [:C, 0], down: [:F, 1], left: [:E, 0], right: [:B, 2] },
+      E: { origin: [0, 2], up: [:C, 1], down: [:F, 0], left: [:A, 2], right: [:D, 0] },
+      F: { origin: [0, 3], up: [:E, 0], down: [:B, 0], left: [:A, 3], right: [:D, 3] }
+    }
+    ```
+  :replies:
+  - :author: riffraff
+    :url: https://www.reddit.com/r/adventofcode/comments/zsct8w/2022_day_22_solutions/j17ng8x/
+    :body: oh, incrementing both in one go is clever, I wish I had thought of that.
+    :replies: []

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

@@ -0,0 +1 @@
+--- []

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

@@ -0,0 +1,96 @@
+---
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1gv7tr/
+  :body: |-
+    [Ruby](https://github.com/jstanley0/advent-2022/blob/main/24.rb) 369/332
+
+    This one was fun! Figuring out a trick that would let me treat this like other A\* searches I've done in the past was very rewarding. Essentially instead of operating on a fixed map, each search state stores a time value and calculates what the map will look like at decision time. Each blizzard's location is computable at any arbitrary time _t_ using modulo math. \>!it helps that there are no vertical blizzards in the entry/exit columns.!\< Maps are memoized for performance. I probably could have saved some memory had I realized the map state starts repeating, but it performs well enough (part 2 takes about 2 seconds in total).
+  :replies: []
+- :author: Elavid
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1gwew0/
+  :body: |-
+    ## [Ruby](https://github.com/DavidEGrayson/adventofcode/blob/434f2b4693f1e1b1b4add4b279c69acc4b3fde65/2022_24/advent.rb), 1107/988, 85 lines
+
+    I did a pathfinding algorithm with a priority queue and a heuristic (current time plus manhattan distance to current goal) and it took **30.1&nbsp;seconds** to solve part 2. I think the code is very clean and elegant, **but does anyone know how I can make it faster?**
+
+    **It is not important to notice that the blizzard positions are periodic.** (I did notice it and take advantage of it, but realized later that it didn't matter.) For my input, the period was 600 minutes but the solution was 807 minutes, so the fact that it was periodic only saved me a tiny bit of memory and CPU time when precomputing valley maps.
+
+    The important thing is that you somehow precalculate or memoize the blizzard positions so you don't have to iterate through every blizzard whenever you are considering which coordinates to move to next.
+
+    Another observation that helped me is that you should **solve part 2 by just doing the same search you did in part 1, but doing it three times with different parameters**. There are no blizzards passing through the start or end points, so you always want to reach those points as fast as possible. (You can always spend some time waiting _after_ you get there.)
+  :replies:
+  - :author: lbl_ye
+    :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h65q2/
+    :body: |-
+      for faster code you must change to simpler algorithm
+
+      time is wasted in inserting in correct order in a sorted queue and fetching many many times the correct "phase"
+
+      also every next state has time+1
+
+      it would be simpler if you stepped for each minute, and computed/fetched "phase" one time only for all states and moved all states together to time+1
+    :replies:
+    - :author: Elavid
+      :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h79r4/
+      :body: |-
+        Wow, it's right! The code is taking about 2 seconds now if I do a simple breadth-first search:
+
+        ```ruby
+        def find_path(time, start, goal)
+          frontier = [start]
+          while true
+            new_frontier = Set.new
+            return time if frontier.include?(goal)
+            frontier.each do |coords|
+              new_frontier.merge possible_next_coords(time, coords)
+            end
+            time += 1
+            frontier = new_frontier
+          end
+        end
+        ```
+      :replies: []
+- :author: sigmazero13
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h33hm/
+  :body: |-
+    **Ruby**
+
+    This is my first time posting a solution, because (to pat myself on the back a little bit), I was happy with being able to come up with a solution that ran relatively quickly and wasn't too complex.
+
+    [https://pastebin.com/ytRauQv6](https://pastebin.com/ytRauQv6)
+
+    You can get Parts 1 and 2 with this - the part 1 answer is simply the first "goal" output.
+
+    I was trying to figure out a good way to keep track of all the states for a good A\* search, but instead, I decided to try it another way. This may not work for much larger scales (probably would run out of memory), but what I did was basically track all possible positions for the Expedition at each time step. Early on, this set is pretty small (for the first minute, there's only two options: staying put, or moving down). To do this, I basically calculate the next minute's blizzard movements/configuration, then for each of the "current" possible positions, I check to see which of the 5 possible moves are legal, and add them to a set. This way, the growth of each time step is pretty manageable (for my input, the max number of possibilities was only a bit higher than 1100 (for each leg).
+
+    The only data I have to store with each iteration are: The blizzard grid, and the current set of possible positions. (It would take a little more, of course, if I tracked the exact path, but that wasn't needed for this).
+
+    The grid was basically just an array, where the walls were a static '#', and every other space was an array of the blizzards at that space (which could be an empty array). Easy to check for Expedition collisions.
+
+    Anyway, didn't make the leaderboard (it took me a bit to come up with this idea), but I'm still proud of my solution (even if it's probably very similar to everyone else's...)
+
+    EDIT: Forgot to mention: running part 2 takes about 4.5s. So about 1.5 seconds per leg.
+  :replies:
+  - :author: johnpeters42
+    :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h5vpx/
+    :body: I tried to approach it that way, but it seemed to slow down by a lot more than what you describe, up to where I killed it and went back to the drawing board. I'm vaguely curious how far off the mark I really was (I ended up using A\* instead).
+    :replies:
+    - :author: sigmazero13
+      :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1j2ivm/
+      :body: Can you post your code? Maybe I can help see what might be slowing it down
+      :replies:
+      - :author: johnpeters42
+        :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1jle0s/
+        :body: I didn't keep a copy. I think maybe I was wasting time on BFS backward from the end location at any possible blizzard state, rather than forward from t = 0.
+        :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1h7cxs/
+  :body: |-
+    [Ruby](https://github.com/globalreset/advent_of_code_2022/blob/main/day24/dayTwentyFour.rb)
+
+    For part 1, I did a simple BFS and simulated the entire board of blizzards every minute (caching the result for that minute). In part 2, this was taking way too long. So I realized that I'm simulating the entire board when I only care about the row/col the expedition is on, plus/minus one row/col. So I rewrote it to create a lookup for all of the blizzards indexed by their row/col and their direction. Then when I wanted to check whether a position was open, I got only the relevant blizzards, shifted them by the amount of time that had passed, and checked for collision. Whole thing runs both parts in 30s.
+  :replies: []
+- :author: crazywulf
+  :url: https://www.reddit.com/r/adventofcode/comments/zu28ij/2022_day_24_solutions/j1hbbuv/
+  :body: "[Ruby](https://gist.github.com/rolfschmidt/a4cb3722b9339ea4691d586a43d09f78), 12 sec for both parts."
+  :replies: []

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

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