advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,183 @@
+---
+- :author: SolarBear
+  :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izlyjk3/
+  :body: |-
+    Ruby solution! I'm not TOO ashamed, this time.
+
+    https://github.com/SolarBear/AdventOfCode2022/blob/main/day9.rb
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izkb13t/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/9)Video Walkthrough: [YouTube](https://youtu.be/_OyCRuCSas0)
+  :replies:
+  - :author: TailorSubstantial863
+    :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izkx7wp/
+    :body: |-
+      Another Ruby solution.
+
+      https://github.com/JeffreyMPrice/adventofcode/blob/main/day09/day09.rb
+    :replies:
+    - :author: careyi4
+      :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izkz1zo/
+      :body: Very clean! Nice one
+      :replies: []
+    - :author: SolarBear
+      :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izlyx66/
+      :body: |-
+        Here's mine! https://github.com/SolarBear/AdventOfCode2022/blob/main/day9.rb
+
+        It would need a bit of love: it kind of uses an array of knots, kind of uses knots as a linked list... it should do one or the other, but not both.
+      :replies: []
+- :author: sezvar
+  :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izhuxry/
+  :body: |-
+    Ruby, 1881/665
+
+    See that `dup`? Missing that `dup` cost me about ten minutes of debugging; I was so sure that I couldn't possibly have misinterpreted how the rope moves. Be warned kids, mutation kills.
+
+    ```ruby
+    require 'set'
+
+    $stdout = File.open('aoc.out', 'w')
+
+    tail_visited = Set.new
+
+    input = File.open('aoc.in') do |f|
+      f.readlines.map do |line|
+        dir, count = line.split
+        count = count.to_i
+        [dir, count]
+      end
+    end
+
+    $head = [0, 0]
+    $tail = [0, 0]
+    tail_visited << $tail.dup
+
+    def sign(x)
+      return 0 if x.zero?
+      x / x.abs
+    end
+
+    def update_tail!
+      dx = $head[0] - $tail[0]
+      dy = $head[1] - $tail[1]
+
+      if dx.abs >= 2 || dy.abs >= 2
+        $tail[0] += sign(dx)
+        $tail[1] += sign(dy)
+      end
+    end
+
+    input.each do |dir, count|
+      count.times do
+        case dir
+        when 'L'
+          $head[0] -= 1
+        when 'R'
+          $head[0] += 1
+        when 'U'
+          $head[1] += 1
+        when 'D'
+          $head[1] -= 1
+        else
+          fail
+        end
+
+        update_tail!
+
+        tail_visited << $tail.dup
+      end
+    end
+
+    p tail_visited.size
+    ```
+  :replies:
+  - :author: ignurant
+    :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izi54bp/
+    :body: |-
+      I had a very similar `dup` deal on day 7 with
+
+      ```ruby
+      while(path.any?)
+        directories[path.dup] += size
+        path.pop
+      end
+      ```
+
+      I was surprised by that, since changing the shape of the array changes the `#hash`. But obviously the key is an object, not a value. It still seemed weird.
+
+      As an example:
+
+      ```ruby
+      [18] pry(main)> a = [1,2,3]
+      => [1, 2, 3]
+      [19] pry(main)> h = {}
+      => {}
+      [20] pry(main)> while a.any?
+      [20] pry(main)* h[a] = true
+      [20] pry(main)* a.pop
+      [20] pry(main)* end
+      => nil
+      [21] pry(main)> h
+      => {[]=>true, []=>true, []=>true}
+      [23] pry(main)> h[[]]
+      => nil
+      ```
+
+      Look at that freaky hash up there.
+
+      As they say: Be warned kids, mutation kills.
+    :replies: []
+  - :author: inolongerwishtotry
+    :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izm0lfe/
+    :body: I just realized I needed to pass a block to `uniq` and it resolved my bug... THANK YOU
+    :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izhyetz/
+  :body: "[Ruby](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2022/09/ropesnake.rb) 3006/1518\n\nFor part 2, I just split out my tail movement code to a function, then called it repeatedly for every new tail part (with the previous part as its head). When it came to test it, I ran it on the first example, got a 1, read the \"However, _be careful_\" warning, thought \"what could possibly go wrong?\", ran it on the real input and submitted the output. It turned out to be correct. First after that I realized there was a second example I could have tested...\n\nAfter writing more bugs than code yesterday, this was a breath of fresh air. Not really sure what \"new types of motion\" I accidentally covered in my part 1 solution. \U0001F605"
+  :replies:
+  - :author: 1234abcdcba4321
+    :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izhzvdo/
+    :body: The additional types of motion are based around the tail segments that the next segment is chasing being able to move diagonally, which can create situations that a part 1 solution _might_ not account for. (Any decently well made one does account for them, though.)
+    :replies:
+    - :author: firetech_SE
+      :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izi1ko2/
+      :body: Ah, of course. Makes sense.
+      :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izi3fqk/
+  :body: "[Ruby](https://tzarnal.github.io/Opal/#XQAAAQAlBAAAAAAAAAAxmwhIY/U/ZyqQORTuuCkhUaJHymoHcK+ag4DNMs9AcDinEHOmK5LYbr2irf14mpRy7XH4aFkguAJ0VImzcC3PbG//tWeXQPunctFFU5pHUDn58H0bLGNOFQy5fk5OG5G/d6TnOoZBl2Y8BgF4PvU13h7AKHJGMak94aVLleIYywAthnkCahGktGIBTaPwOiNFcHZ6SWWhSChWdhuguBXSFxhlffvj6+GdaZzD1rVwiC/zX0+swSeP1z+A8256l9hXaVqkURcVNpox2SMo2nBKviB+DQCIbyMxTFx5ft9Xp+xeHrFRqGE8RMkXPx2kZKEHSZi5bpEHvwienEAPrVgRfatlRCIihZ7h4j0Hw4aPRkfresCHuHDJILhn4tkE4t0f2BgoMJZx5Bv28TM4Zp1oUatnw/dQsb2QZdZr1PE1F5vpggEKyvXZR8dBnkfFas7BJRgFcF82MUQ3ywmHussE20YMs0+7YbbfBEMMS8oyP366IpOlMLPNbPVE/9cczesMGl5DwVClQiBOotAjg4xEPQefUDVNl5p0m9pPmUGz5ZdbMY+LYQGsZWXK2WZTGKQoRL4p4reIVnYYrDV+7sFfLftoK+NkszYJi+CQ2c4cFMhFyxKpDh9SKhgFg3e/B2wchp6HUWpeQRocd4DD7C66QpH/UivSAA==)"
+  :replies: []
+- :author: lemon-761
+  :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izit8h1/
+  :body: |-
+    Don’t see too many Ruby solutions: [github](https://github.com/timle8n1/aoc/blob/main/aoc2022/day9/solve.rb)
+
+    Pretty happy with this. Original part 1 didn’t account for the head being able to move diagonally and was much more verbose. Kept refactoring until I got it pretty tight.
+
+    Drawing a picture of a head knot move versus what the tail know should do helped me understand better and apply clamp.
+  :replies:
+  - :author: f4780y
+    :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izj19tz/
+    :body: Results are out by +2 from the correct answer for both parts for my input.
+    :replies:
+    - :author: lemon-761
+      :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izk02t5/
+      :body: Hmm works fine on both samples and my input file. I’d be happy to try your input.
+      :replies:
+      - :author: f4780y
+        :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izkjhpl/
+        :body: No worries - I've messaged you my input file. Interested to hear if it passes or not, but only if you have time.
+        :replies:
+        - :author: lemon-761
+          :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izmqlk2/
+          :body: I got your same values with that input - maybe clone the repo - I'm also on an older version of ruby? shrug
+          :replies: []
+    - :author: lemon-761
+      :url: https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izk0ui6/
+      :body: I grabbed another account and it solved both of those parts also.
+      :replies: []

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

@@ -0,0 +1,202 @@
+---
+- :author: Zaorhion_
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/j0yt14w/
+  :body: |-
+    Ruby
+
+    [My Solution](https://github.com/Eric-Philippe/Advent-Of-Code-2022/tree/master/Day10%20%5BRuby%5D%20%F0%9F%A7%A3)
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izqd2az/
+  :body: |-
+    Ruby, golfed to 118 bytes
+
+    ```ruby
+    x=1
+    c=[]
+    $<.flat_map(&:split).map(&:to_i).map{c<<((-1..1)===c.size%40-x ??#:?.)
+    x+=_1}
+    c.each_slice(40){puts _1.join}
+    ```
+  :replies:
+  - :author: ulysse_bn
+    :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/j0i98y7/
+    :body: |-
+      With a few tweaks, I could get that to 95:
+
+      ```ruby
+      x=1
+      c=[]
+      `dd`.split.map{c<<((c.size%40-x).abs<2??#:?.)
+      x+=_1.to_i}
+      c.each_slice(40){puts _1*""}
+      ```
+    :replies: []
+- :author: ffrkAnonymous
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izq2ga7/
+  :body: |-
+    Ruby
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDyDAAAAAAAAAARiAlH8dxNBu7dkgwpusw3/1N9B7LsXMI7hyVChWl1esX/VYUvuckt47qc849AGx2bqC6Mz07VInqrh3fdXd92YZTCHSzBE8XopyTxka4/oOzZYsQ+KGJ2cLwIzojbME86YAwdrNT8Puftw7LJwH51GadTyGre6JLt9v/reEj5+JHk5MkBl72dNY1Zb0zBfZibFPiyDBF8gHuROlLfvXJbgP8Y1DkSGpHAxVhoLEiJQKQhTejPo9+1qmw9/PtvltU/I6vyt+nvThoCY+fpgeZul0rWRmS7ApN0revGl8fjNMRcpJW/FAtQcL55GucsM86DQVy7eOtx9kUM22X9IlIHMF8QaQ60WDe+6J3CfhNNHLH1tVcRLRuNBhqh6xoliJAtZgsuomZNeGgw4ugoXh/I8HUeCP5V4WXaaHm613b8XfJOPRfj9Q3xDIn12Uz9keFCnd/TuF6HeMhKmT+HC1C788qks8T8ScoUp58/p5gbyvKa/sIMCIk8EI7DiyiVoJjqsvzehAzBqMJOGQRl5S+9pkF9vSgnLBv4TdS4KDAXglhWTCjG/UlOqfWBQ26oWPdzlbI6NAVD20W+uhB+u3nljFbk12Khd6GPMgKgVCPoaJhHRpnc2z2kEvgZrA7Vb4JvVGJh4Z/s9PiCpUBTSETWn6QSGnDbRH8pJyZeZDTBZb2yKzNUENUPOUQVd1wF4Uw0GYV2ZhF7baehxM9SwHq6etxwpDiXBKRHt2lPqoMnkAguVB547jGhNl3oheoK+j1hKC0JkLnj3jN6mOKuWitcq0SCXLa5f96JHFZQJalun3a6LG0O/GTh9tPIWy6jJLHcfZejSE5jLU0YeweOa9clW2Uh6tF1N0iTtGao5ch/nJqrSmiUlybcCz09RLMS+eEZmWGR4K7y1GHx99djzwpMMgRT7x96z+owoUn9MVER85Vs+DKj6MqB3SeClUk/hEIcspAIo1yJoyqDb7olkiDVnDAMv8wjmnP5BfQRUzruW8feZALaYA+NGlf+LbeDgyzTFf7t9ojdyKRxT/3zJndMyxdPoDd2hJidiQvetbsERer6HzhMvd33+o77qtLXEIFm+02W6Ax6bQa+Exce75WdT1DO0YGUsS9Zyx65ZAxDt6B39b5RfYumACwDGDJ2J5OXuua20CdMaZv8kunF+KiDE2nitq14JXDhzQTCq5syVm1PTcHBVmRV27CSu93YttDn200ml73MFke/isevld+JKab/8p87oQ==)
+
+    This one was fun, and straight forward. Didn't know how to do it using TDD though.
+  :replies: []
+- :author: tobyaw
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/iznvdim/
+  :body: |-
+    Ruby
+
+    https://github.com/tobyaw/advent-of-code-2022/blob/master/day\_10.rb
+
+    ```ruby
+    h = File.readlines('day_10_input.txt', chomp: true)
+            .each_with_object([1]) do |i, a|
+      a << a.last
+      a << (a.last + i.split.last.to_i) if i.start_with? 'addx'
+    end
+
+    puts 20.step(by: 40, to: 220)
+           .sum { |i| i * h[i - 1] }
+
+    240.times
+       .map { |i| (h[i] - (i % 40)).abs < 2 ? '#' : '.' }
+       .each_slice(40) { |i| puts i.join }
+    ```
+  :replies:
+  - :author: f4780y
+    :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izomns8/
+    :body: Very nice!
+    :replies: []
+- :author: shandley256
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izn73dg/
+  :body: |-
+    **Ruby Solution**
+
+    You can generalise the logic to adjust the value of x and the current cycle, then use a lambda to encapsulate the needed steps for part 1 and part 2.
+
+    Using the "full block" character █ instead of # makes for much more readable output:
+
+    Full Solution: [https://gist.github.com/seanhandley/0f3b78a7c17a459485913692a9296cb1](https://gist.github.com/seanhandley/0f3b78a7c17a459485913692a9296cb1)
+  :replies: []
+- :author: SolarBear
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izo3w5h/
+  :body: |-
+    **Ruby**
+
+    That was a fun one!
+
+    https://github.com/SolarBear/AdventOfCode2022/blob/main/day10.rb
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izoa8oc/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/10)
+
+    Video Walkthrough: [YouTube](https://youtu.be/_4BCotKM01U)
+  :replies: []
+- :author: SnooConfections2453
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izoqvu7/
+  :body: |-
+    I'm having a lot of fun doing ruby one liners. Today's solution is great IMO:
+
+    ```ruby
+    x,c,s=1,0,0;File.readlines('10.txt').each{_,a=_1.split;2.times{print (c%40-x).abs<2?"#":" ";c+=1;s+=c*x if(c-20)%40==0;puts if c%40==0;!a&&break};x+=a.to_i};p s
+    ```
+  :replies: []
+- :author: mathem17
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izmnv6i/
+  :body: |-
+    Ruby 3638/2800: [Code](https://github.com/jzhang113/adventofcode/blob/6e9fa80f9d96d88d5e9faa8867812e886c10e036/2022/solutions/10.rb)
+
+    Spent a bit too long in part 1 wondering if clock edges would matter, but got rewarded in part 2 for just dumping stuff to instance variables lol
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izmrrwj/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    instructions = DATA.each_line.map(&:chomp).reject(&:empty?)
+
+    regx = 1
+    buffer = []
+    readings = []
+
+    A = 6.times.map { 40.times.map { "." } }
+    A[0][0] = "#"
+
+    def draw
+      A.map(&:join).join("\n")
+    end
+
+    def mark(regx,row,col)
+      if (col - regx).abs <= 1
+        A[row][col] = "#"
+      end
+    end
+
+    (0..).each do |i|
+      row = i / 40
+      col = (i % 40)
+
+      readings << regx * i if (i+20) % 40 == 0
+      break if instructions.empty? && buffer.empty?
+      break if i > 240
+
+      if buffer.any?
+        regx += buffer.shift
+        next
+      end
+
+      mark(regx,row,col)
+
+      case instructions.shift.split
+      in ["noop"]; nil
+      in ["addx", c]; buffer << c.to_i
+    end
+
+    puts readings.sum
+    puts draw
+
+    __END__...
+    ```
+  :replies: []
+- :author: RedWingedJerBear
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izmww0q/
+  :body: |-
+    [ruby](https://github.com/jwhite-bh/advent-of-code/blob/main/2022/advent_day_10.rb)
+
+    Feel okay about this code
+  :replies: []
+- :author: kwitczak
+  :url: https://www.reddit.com/r/adventofcode/comments/zhjfo4/2022_day_10_solutions/izmwxv0/
+  :body: |-
+    **Ruby**
+
+    Too many loops, it can be further optimized.
+
+    ```ruby
+    instr_cycles = { 'addx' => 2, 'noop' => 1 }
+    x = [1]
+
+    File.readlines('day10.txt').each do |l|
+      instr, value = l.strip.split
+      cycles = instr_cycles[instr]
+      1.upto(cycles) do |c|
+        x << (c == cycles ? x.last + value.to_i : x.last)
+      end
+    end
+
+    signals = [20, 60, 100, 140, 180, 220].map { |i| x[i - 1] * i }
+    p "Part 1: #{signals.sum}"
+
+    p "Part 2:"
+    x.each_with_index do |s, i|
+      position = i % 40
+      print ((s - 1..s + 1).to_a.include?(position) ? '#' : '.')
+      print "\n" if position == 39
+    end
+    ```
+  :replies: []

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

@@ -0,0 +1,209 @@
+---
+- :author: tobyaw
+  :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/izsmy5e/
+  :body: |-
+    Ruby
+
+    https://github.com/tobyaw/advent-of-code-2022/blob/master/day\_11.rb
+
+    ```ruby
+    [{ rounds: 20, div: 3 }, { rounds: 10_000, div: 1 }].each do |part|
+      monkeys = File.read('day_11_input.txt').split("\n\n").map do |i|
+        i = i.split("\n")
+
+        {
+          items: i[1].scan(/\d+/).map(&:to_i),
+          oper: i[2].scan(/[+*]/).first.to_sym,
+          param: i[2].scan(/\d+$/).map(&:to_i).first,
+          test: i[3].scan(/\d+$/).first.to_i,
+          pass: i[4].scan(/\d+$/).first.to_i,
+          fail: i[5].scan(/\d+$/).first.to_i,
+          inspections: 0
+        }
+      end
+
+      lcm = monkeys.map { |i| i[:test] }.reduce(:lcm)
+
+      part[:rounds].times.each do
+        monkeys.each do |monkey|
+          monkey[:inspections] += monkey[:items].size
+
+          while (i = monkey[:items].shift)
+            param = monkey[:param] || i
+            i = (i.method(monkey[:oper]).call(param) / part[:div]) % lcm
+
+            target = (i % monkey[:test]).zero? ? monkey[:pass] : monkey[:fail]
+            monkeys[target][:items] << i
+          end
+        end
+      end
+
+      puts monkeys.map { |i| i[:inspections] }.max(2).reduce(:*)
+    end
+    ```
+  :replies: []
+- :author: SnooConfections2453
+  :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/izrxt9y/
+  :body: |-
+    Golfed ruby (using eval)
+
+    Part1:
+
+    ```ruby
+    m=File.readlines('11.txt').chunk{_1=="\n"&&nil}.map{|_,c|_,s,o,*t=c;[s.split(": ").last.split(", ").map(&:to_i),o.split.last(3).join,t.map{_1.split.last.to_i},0]}
+    20.times{m.each{|k|until k[0].empty?do w,o,t=k;old=w.shift;l=eval(o)/3;m[l%t[0]==0?t[1]:t[2]][0]<<l;k[3]+=1end}}
+    p m.map(&:last).max(2).reduce(:*)
+    ```
+
+    Part2:
+
+    ```ruby
+    m=File.readlines('11.txt').chunk{_1=="\n"&&nil}.map{|_,c|_,s,o,*t=c;[s.split(": ").last.split(", ").map(&:to_i),o.split.last(3).join,t.map{_1.split.last.to_i},0]}
+    z=m.map{_1[2][0]}.reduce(:*)
+    10000.times{m.each{|k|until k[0].empty?do w,o,t=k;old=w.shift;l=eval(o)%z;m[l%t[0]==0?t[1]:t[2]][0]<<l;k[3]+=1end}}
+    p m.map(&:last).max(2).reduce(:*)
+    ```
+  :replies:
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/j0n45gv/
+    :body: |-
+      Very nice.
+
+      `while k[0].any?`saves 2 bytes over`until k[0].empty?`
+    :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/izrf5b5/
+  :body: |-
+    over engineered OO solution in ruby
+
+    ```ruby
+    Worry = Struct.new(:value) do
+      def update(op, normalizer)
+        tmp = op.call(value)
+        tmp = normalizer.call(tmp)
+        self.value = tmp
+      end
+    end
+
+    Monkey = Struct.new(:name, :items, :operation, :test_divisor, :next_monkey, :_count) do
+      def process_all_items(monkeys, normalizer)
+        while items.any?
+          self._count ||= 0
+          self._count += 1
+
+          next_item = items.shift
+          next_item.update(operation, normalizer)
+
+          test_condition = next_item.value % test_divisor == 0
+          pass_to = next_monkey.call(test_condition)
+
+          monkeys[pass_to].items << next_item
+        end
+      end
+    end
+
+    def solve(monkeys, normalizer, iterations)
+      iterations.times do |round|
+        monkeys.each do |name, monkey|
+          monkey.process_all_items(monkeys, normalizer)
+        end
+      end
+      a, b = monkeys.values.max_by(2) { |k| k._count }
+      a._count * b._count
+    end
+
+    def solve_easy(input)
+      solve(input, ->(v) { v / 3 }, 20)
+    end
+
+    def solve_hard(input)
+      solve(input, ->(v) { v % (2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 29) }, 10_000)
+    end
+    ```
+
+    I got stuck trying to keep track of all the factors in an array for a long time...
+  :replies: []
+- :author: 6f937f00-3166-11e4-8
+  :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/izrp9w3/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    def parse(path)
+     File.read(path).strip.split("\n\n").map do |monkey_desc|
+        lines = monkey_desc.split("\n")
+        {
+          id: lines[0].sub('Monkey ', '').sub(':', '').to_i,
+          items: lines[1].sub(' Starting items: ', '').split(', ').map(&:to_i),
+          operation: lines[2].sub(' Operation: new = old ', '').then do |op|
+            next [:pow, 2] if op == '* old'
+            (cmd, val) = op.split(' ')
+            [cmd.to_sym, val.to_i]
+          end,
+          test_divisor: lines[3].sub(' Test: divisible by ', '').strip.to_i,
+          if_true: lines[4].sub(' If true: throw to monkey ', '').to_i,
+          if_false: lines[5].sub(' If false: throw to monkey ', '').to_i,
+          inspections: 0
+        }
+      end
+    end
+
+    def part_one(monkeys)
+      20.times do
+        monkeys.each do |monkey|
+          monkey[:inspections] += monkey[:items].length
+          monkey[:items].each do |initial_level|
+            level = initial_level.send(*monkey[:operation]) / 3
+            throw_to = (level % monkey[:test_divisor]) == 0 ? monkey[:if_true] : monkey[:if_false]
+            monkeys[throw_to][:items].push(level)
+          end
+          monkey[:items] = []
+        end
+      end
+      monkeys.map { |m| m[:inspections] }.sort.reverse.take(2).inject(&:*)
+    end
+
+    def part_two(monkeys)
+      common_divisor = monkeys.map { |m| m[:test_divisor] }.inject(&:*)
+
+      10000.times do
+        monkeys.each do |monkey|
+          monkey[:inspections] += monkey[:items].length
+          monkey[:items].each do |initial_level|
+            level = initial_level.send(*monkey[:operation]) % common_divisor
+            throw_to = (level % monkey[:test_divisor]) == 0 ? monkey[:if_true] : monkey[:if_false]
+            monkeys[throw_to][:items].push(level)
+          end
+          monkey[:items] = []
+        end
+      end
+
+      monkeys.map { |m| m[:inspections] }.sort.reverse.take(2).inject(&:*)
+    end
+
+    puts "part one test.txt", part_one(parse('test.txt'))
+    puts "part one input.txt", part_one(parse('input.txt'))
+    puts "part two test.txt", part_two(parse('test.txt'))
+    puts "part two input.txt", part_two(parse('input.txt'))
+    ```
+  :replies: []
+- :author: shandley256
+  :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/izryg6k/
+  :body: |-
+    **Solution in Ruby**
+
+    [https://gist.github.com/seanhandley/9babceb01ed2890a3b390b80e0b2d046](https://gist.github.com/seanhandley/9babceb01ed2890a3b390b80e0b2d046)
+
+    The key to getting reasonable performance in part 2 is here:
+
+    https://gist.github.com/seanhandley/9babceb01ed2890a3b390b80e0b2d046#file-advent11-2-rb-L90-L95
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zifqmh/2022_day_11_solutions/izs7yis/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/11)
+
+    Video Walkthrough: [YouTube](https://youtu.be/k-c_TJ0j0W8)
+  :replies: []

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

@@ -0,0 +1,17 @@
+---
+- :author: tobyaw
+  :url: https://www.reddit.com/r/adventofcode/comments/zjnruc/2022_day_12_solutions/izzcvai/
+  :body: |-
+    Ruby
+
+    https://github.com/tobyaw/advent-of-code-2022/blob/master/day\_12.rb
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zjnruc/2022_day_12_solutions/izxaq13/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/12)
+
+    Video Walkthrough: [YouTube](https://youtu.be/ix_KDbXvc3E)
+  :replies: []