advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,315 @@
+---
+- :author: icyFur
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/ho9vhch/
+  :body: My solution in [Ruby](https://getsturdy.com/advent-of-code-2021-uoeIDQk/browse/day09/kiril/solve.rb)
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hntirld/
+  :body: |-
+    **Ruby** : 4:44/10:20, 248/94!
+
+    Here's a [recording](https://youtu.be/MCabDS_Rduw) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec09.rb). I usually stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    Barely snuck on the leaderboard!
+
+    I fumbled around for 10 seconds at the start trying to view my input. That was bad.
+
+    In Part 1 I missed the "risk level = 1 plus its height" (as I'm sure did many others), then lost 10 seconds waiting to be un-timed out. I gotta learn how to scan the instructions better!
+
+    Part 2 was fun. Good, quick, easy to understand solution, and I was able to debug pretty quickly. I treated points outside of the cave as having a height of 10 and that worked well!
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hnu6cc0/
+  :body: |-
+    Ruby
+
+    [https://github.com/sreedevk/advent-of-code/blob/main/ruby/2021/day9/main.rb](https://github.com/sreedevk/advent-of-code/blob/main/ruby/2021/day9/main.rb)
+
+    `Benchmark 1: ruby main.rb data.txt`
+
+    `Time (mean ± σ): 447.9 ms ± 51.6 ms [User: 446.4 ms, System: 50.6 ms]`
+
+    `Range (min … max): 396.0 ms … 579.9 ms 10 runs`
+  :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hnwljmj/
+  :body: |-
+    **Ruby** Pt 2:
+
+    I quickly hooked up to the idea that "basins are anything that's not a 9". I see other solutions using `scipy.ndimage.measurements.label`... That's crazy. That's what I was going for in theory, but I still had to do the work of detecting the barriers. Pretty cool, you Python folks! Looking forward to seeing the more interesting ways of parsing room groups out there. Cheers!
+
+    ```ruby
+    class Room
+      attr_reader :x, :y
+
+      def initialize(x:, y:)
+        @x, @y = x, y
+      end
+
+      def location() = [x, y]
+      def up() = [x, y - 1]
+      def down() = [x, y + 1]
+      def left() = [x - 1, y]
+      def right() = [x + 1, y]
+      def neighbors() = [up, left, down, right]
+    end
+
+    class World
+      attr_reader :rooms
+      attr_reader :big_beefy_basins
+
+      # Parse the input board, essentially delimiting rooms by '9'.
+      # A "basin" is anything that isn't a 9.
+      # If we build a hash of "things not 9" we can explore it.
+      # We can also delete rooms in realtime so they don't get
+      # "re-explored" which is kind of neat.
+      #
+      # For easy exploration, we'll use the `[x,y]` coords as hash keys.
+      #
+      def initialize(board)
+        @rooms = {}
+
+        board.split("\n").each.with_index do |line, y|
+          line.chars.each.with_index do |val, x|
+            rooms[[x, y]] = Room.new(x: x, y: y) if val != '9'
+          end
+        end
+
+        @big_beefy_basins = Array.new(3) { 0 }
+      end
+
+      def solve!
+        rooms.each do |(x, y), room|
+          basin = explore(room).uniq.size
+
+          if big_beefy_basins.first < basin
+            big_beefy_basins.shift
+            big_beefy_basins.push(basin).sort!
+          end
+        end
+
+        big_beefy_basins.reduce(&:*)
+      end
+
+      private
+
+      def explore(room, basin=[])
+        return basin if room.nil?
+
+        basin << rooms.delete(room.location)
+
+        room.neighbors.map do |x, y|
+          explore(rooms[[x, y]], basin)
+        end.flatten
+      end
+    end
+
+    pp World.new(File.read('input.txt')).solve!
+    ```
+
+    Edit:
+
+    **Ruby** Pt 1:
+
+    I had to go back to my Pt 1 after being further informed on pt 2. It had a world-wrapping bug that didn't affect the answer (but could have), and I just didn't like it. After a little more experience in Pt 2, I much rather liked iterating the world as a hash rather than a 2d array.
+
+    ```ruby
+    UPPY_DOWNY_LEFTY_RIGHTY = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+
+    board = File.read('input.txt').split("\n").flat_map.with_index do |line, y|
+      line.chars.map.with_index do |char, x|
+        {[x, y] => char.to_i}
+      end
+    end.reduce(&:merge)
+
+    board.default = 10 # A number higher than 9. (For the borders.)
+
+    risk_level = 0
+
+    board.each do |(x, y), val|
+      next if val == 9
+      next if UPPY_DOWNY_LEFTY_RIGHTY.any? {|⇦⇨, ⇧⇩| board[[x + ⇦⇨, y + ⇧⇩]] < val }
+      risk_level += val + 1
+    end
+
+    puts risk_level
+    ```
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hntgbwa/
+  :body: |-
+    Ruby, 67 / 55
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDJAwAAAAAAAAARiAbIwVXFxjAJKCgB3XuvqFqcG1u2nFyKfOqMPC6IRbYYVooBadbDR3bGudRj1E5Kj3A0Gh2/dz49GQbP40Bk/9/bqTdiPLYoyr3Goio85AfDrPub7eZWCQP2mnut8d97tN7rClR4honQkOh6WPDi+RnfSgYuVjAcWiWiA7llRgzZ0WhB2AHEgjZmvSWlTJLOppbeTMP4INxS/YTokgH3RLVSgnJF3KNdrZEqAtzln0w5H9LNI9dqKCCkowW9ikwyHimp4CFxLIaOemtzuM5iSyW18G/mKNALSCdlvaXmYs06ErZLhBlZAJLFYHgKwDFKYDIjB/HJmOgBRhIjdgkAu/ivq9z3mOWmj5Qj/lKD5NjlRuESyypwDH4rW43hz3YV/hB0d6s9jkN6yYQWd7o3kRMJtY61VW4zanowgbbbafu1vgAQS48VGZcDw06yvnbhvoJKatE9QOUsUFLfo17AsDWPZw2EgZEYOLG/t5iRqSCxlVyytU4gIhTJCCMwtQzDq03BMDJl3gGep+AP5ofWRA0yhEGYRiEL8ddrRQf9l0Y9)
+
+    I was in a hurry and wasn’t able to think of `h.times.to_a.product(w.times.to_a)` so I just write two-level for loops `(0...h).each do |i| (0...w).each j |i| …; end end`. GitHub Copilot helped a lot in preventing silly mistakes (I usually use the wrong variables when writing for loops).
+  :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hntiico/
+  :body: |-
+    [Ruby 906/854](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/09/basins.rb)
+
+    I felt I was unusually slow today, but still ended up in top 1000 for both parts (only second time that has happened this year). I guess having implemented BFS umpteen times (not complaining, I like BFS) for all the previous years has made me well prepared. :D
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hntkb9y/
+  :body: |-
+    ### Ruby
+
+    Extremely not fast tonight.
+
+    ```ruby
+    @data = DATA.each_line.map { _1.chomp.chars.map(&:to_i)}
+
+    XY = Struct.new(:x, :y, :val) do
+    end
+
+    xys = []
+
+    @data.each.with_index do |r, i|
+      r.each.with_index { |c, j| xys << XY.new(j, i, c) }
+    end
+
+    basins = [[]]
+    checked = []
+    risks = []
+    xys.each do |xy|
+      x, y = xy.to_a
+      surrounding = [
+        xys.find { _1.x == x - 1 && _1.y == y },
+        xys.find { _1.x == x && _1.y == y - 1 },
+        xys.find { _1.x == x + 1 && _1.y == y },
+        xys.find { _1.x == x && _1.y == y + 1 }
+      ].compact
+      risks << if surrounding.all? { _1.val > xy.val }
+                 xy.val + 1
+               else
+                 0
+               end
+
+      next if xy.val == 9 || checked.include?(xy)
+
+      to_check = [xy]
+      until to_check.empty?
+        to_check -= checked
+        next if to_check.empty?
+
+        checking = to_check.shift
+        x, y = checking.to_a
+        surrounding = [
+          xys.find { _1.x == x - 1 && _1.y == y },
+          xys.find { _1.x == x && _1.y == y - 1 },
+          xys.find { _1.x == x + 1 && _1.y == y },
+          xys.find { _1.x == x && _1.y == y + 1 }
+        ].compact
+
+        basins[-1] << checking.val
+        checked << checking
+        to_check << (surrounding - checked).filter { _1.val < 9 }
+        to_check = to_check.flatten.uniq
+      end
+      basins << []
+    end
+
+    pp risks.compact.sum
+    pp basins.map(&:count).sort.reverse.first(3).reduce(&:*)
+
+    __END__
+    ```
+  :replies:
+  - :author: scarfaceDeb
+    :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hntoxi6/
+    :body: Interesting.. you did it without using any recursion
+    :replies: []
+- :author: scarfaceDeb
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hnto9ze/
+  :body: |-
+    **Ruby**
+
+    That was one of the best puzzles so far. I had a lot of fun solving it.
+
+    ```ruby
+    points =
+      hmap.map.with_index do |row, i|
+        row.map.with_index do |col, j|
+          adjacent = [
+            (hmap[i - 1][j] if i > 0),
+            (row[j + 1] if j < last_col),
+            (hmap[i + 1][j] if i < last_row),
+            (row[j - 1] if j > 0)
+          ]
+
+          [adjacent, [i, j], col]
+        end
+      end
+
+    lowest = points.flatten(1).select { |adj, _, col| adj.compact.min > col }
+    ans = lowest.map(&:last).sum { _1 + 1 }
+
+    puts "Answer 9.1: #{ans}"
+
+    def flows(points, basin, i, j)
+      return basin if basin.include?([i, j])
+
+      adj, _pos, num = points[i][j]
+      t, r, b, l = adj
+
+      basin << [i, j]
+      basin = flows(points, basin, i - 1, j) if t && t != 9
+      basin = flows(points, basin, i, j + 1) if r && r != 9
+      basin = flows(points, basin, i + 1, j) if b && b != 9
+      basin = flows(points, basin, i, j - 1) if l && l != 9
+      basin
+    end
+
+    basins = lowest.map { |_, pos, _| flows(points, Set.new, *pos) }
+    ans2 = basins.map(&:size).max(3).reduce(:*)
+    ```
+
+    https://github.com/scarfacedeb/advent-of-code/blob/master/2021/day9/run.rb#L11-L51
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hntpfx8/
+  :body: |-
+    Ruby 1178/7093
+
+    Really struggled with this one. For some reason, I got it in my head that all points in a basin had to be less than all their neighbors (except the ones already visited). I don't know, it worked on the sample but not the real data.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQCEAwAAAAAAAAA5GUqKNoFH6SMqoVC09YUYkw2S+mIMHB1CSWV0VTWnX51e2y38yPqPFYGVMviZ8FB5y/cUcsDLuOHhkKbbmFYqG9sheuX5AEAeDEPRiP+Nw37hH8iTmGu5oHBy41LsFOIs+tUoQBongxBHkrf8yx5NtMifXoJotBBCd49DRK8jPUyZSriOjwAEWapdv/aLvzjCn4M1CDQKnzUBAVp138+jc3ruOfGlrPNYgWFzac/8RWzP30ilKn+FFIYamX/hgZvIn9IYRuXwhrVgxzjYMXaAkKSl/Lg8ST3V0UesQYF8crHoOhvToAVXR1mxfsrJVEw1GZxiQDpcmpX2qwy5q/A0aLyopQBc+WmhiVSPOPrI9OjpkzETcdPH03Dffq35kr2VxpjxxTmC7JfVTHZXunkTfDt5dlPtfqJG1tGXoRW/RYJoCpmUQrIUx+UkWl4wgr2pvG/gHq1DeWJcuKBl4BILH4eIpc9kZ5/9+hvz1mJk76TT33kx/lwdW0/c+ajTuOfZ8lBI58MDQaTtfsHwnOClghazEe+AaHwqRW3/UZJ8RXUlSF9OKEFNS6AVPMoQJ5yZERcUy166GDeuUEDpWtuxByxFKuglawdbIIOu1bbiurkSOBbXLJM4DSDIbqf5OVdC3MX/9pM9mg==)
+  :replies: []
+- :author: weiss_i_net
+  :url: https://www.reddit.com/r/adventofcode/comments/rca6vp/2021_day_9_solutions/hnuj3ye/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    grid = ARGF.readlines.map{|x| x.strip.chars.map(&:to_i)}
+
+    basin = Hash.new(0)
+
+    grid.each_with_index do |row, x_start|
+      row.each_with_index do |cell, y_start|
+        next if cell == 9
+
+        nextp = [x_start, y_start]
+        while nextp
+          x, y = nextp
+          nextp = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+            .map{|dx, dy| [x+dx, y+dy]}
+            .filter{|nx, ny| nx.between?(0, grid.size-1) && ny.between?(0, grid[0].size-1)}
+            .filter{|nx, ny| grid[nx][ny] < grid[x][y]}
+            .first
+        end
+
+        basin[[x, y]] += 1
+      end
+    end
+
+    puts "Part 1: #{basin.keys.map{|x, y| grid[x][y] + 1}.sum}"
+    puts "Part 2: #{basin.values.sort[-3..].reduce(:*)}"
+    ```
+
+    The idea is to walk down the slope for every point. This takes constant time, since you need to take at most 9 steps.
+
+    Since I'm new to ruby, please feel free to point out any ruby-idiomatic improvements.
+  :replies: []

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

@@ -0,0 +1,154 @@
+---
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/htakj5o/
+  :body: |-
+    # Ruby
+
+    [https://gist.github.com/Clashbuster/d2f7dc3246f109b987a278d98197c6f0](https://gist.github.com/Clashbuster/d2f7dc3246f109b987a278d98197c6f0)
+  :replies: []
+- :author: icyFur
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/ho9vo1a/
+  :body: Stack solution in [Ruby](https://getsturdy.com/advent-of-code-2021-uoeIDQk/browse/day10/kiril/partone.rb)
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnyezvj/
+  :body: |-
+    **Ruby** 181 bytes
+
+    I can't find a way to shorten the mapping in the first line...
+
+    ```ruby
+    t={?(=>?),?[=>?],?{=>?},?<=>?>}
+    x=$<.filter_map{|l|
+    s=[]
+    c=1
+    l.chop.chars{t[_1]?s<<_1:t[s[-1]]==_1 ?s.pop: c=nil}
+    f=0
+    s.reverse.map{f=5*f+' ([{<'.index(_1)}
+    c&&f}
+    p x.sort[x.size/2]
+    ```
+  :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnyaxxl/
+  :body: |-
+    **Ruby**
+
+    Didn't want to deal with matching special characters, so `String#tr` to the rescue so I could use uppercase/lowercase letters instead.
+
+    ```ruby
+    data = open("input").each_line.map{_1.strip.tr("()[]{}<>", "AaBbCcDd")}
+
+    def score(line, part2)
+      stack = []
+      part1_scores = {"a" => 3, "b" => 57, "c" => 1197, "d" => 25137}
+      part2_scores = {"a" => 1, "b" => 2, "c" => 3, "d" => 4}
+      line.chars.each do |char|
+        if char == char.upcase
+          stack << char.downcase
+        elsif char == stack.last
+          stack.pop
+        else
+          return part2 ? 0 : part1_scores[char]
+        end
+      end
+      return part2 ? stack.reverse.reduce(0){|acc, val| acc * 5 + part2_scores[val]} : 0
+    end
+
+    puts data.map{score(_1, false)}.sum
+    part2_arr = data.map{score(_1, true)}.filter{_1 > 0}
+    puts part2_arr.sort[part2_arr.count / 2]
+    # Yes, this works because integer division rounds down, so for a 5-number array this will find index 2 (the 3rd element)
+    ```
+  :replies: []
+- :author: scarfaceDeb
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnye6zt/
+  :body: |-
+    **Ruby**
+
+    I smelled a stack pattern from a mile away after I saw the input :D
+
+    ```ruby
+    lines = read_input
+
+    invalid = []
+    opening = "([{<".chars
+    closing = ")]}>".chars
+    pairs = closing.zip(opening).to_h
+    prices = closing.zip([3, 57, 1197, 25137]).to_h
+    values = opening.zip([1, 2, 3, 4]).to_h
+
+    scores =
+      lines.map { |line|
+        stack = []
+
+        line.each_char do |ch|
+          case ch
+          when *opening
+            stack << ch
+          when *closing
+            next if stack.pop == pairs[ch]
+            invalid << ch
+            stack << :invalid
+            break
+          end
+        end
+
+        next if stack.last == :invalid
+
+        stack.reverse.reduce(0) { |sum, ch|
+          sum * 5 + values.fetch(ch)
+        }
+      }.compact
+
+    ans = invalid.map { prices[_1] }.sum
+    ans2 = scores.sort[scores.size / 2]
+    ```
+  :replies: []
+- :author: Spock_42
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnywep4/
+  :body: |-
+    This is my Ruby solution to Part 2. Part 1 is similar, just a different scoring pattern. Just learning Ruby for the first time via AoC, so any C&C is appreciated.
+
+    ```ruby
+    def find_incomplete(line)
+      brackets = { '(' => ')', '[' => ']', '{' => '}', '<' => '>' }
+      stack = []
+      line.each_char do |c|
+        stack.append(c) if brackets.keys.include?(c)
+        (c == brackets[stack.last] ? stack.pop : (return [])) if brackets.values.include?(c)
+      end
+      stack.map { |c| brackets[c] }.reverse
+    end
+
+    def autocomplete_score(file)
+      scores = { ')' => 1, ']' => 2, '}' => 3, '>' => 4 }
+      lines_to_score = File.readlines(file).map { |l| find_incomplete(l) }.select(&:any?)
+      all_scores = lines_to_score.map { |line| line.inject(0) { |score, char| (5 * score) + scores[char] } }
+      all_scores.sort[(all_scores.length - 1) / 2]
+    end
+    ```
+  :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnzgtbl/
+  :body: |-
+    I've found the last two days to be a bit of a slog, so I felt recharged that this one was straightforward (at least for my skillset). I rather enjoyed the decoy sample answer in Pt. 1 -- My thought was "oohhhohooo!! You're bringin' it now!!!!"
+
+    [Ruby Pt. 1](https://tzarnal.github.io/Opal/#XQAAAQCdAQAAAAAAAAAoE8VAZTehaYnyuwTEaiO9AUDb7/ag2JLRSAd+7vIQ9W0fVJObjAbKNtBfBOvfYp/6xzM2fkqGxqyc6jO/F/PNxIHgnbb2ujIjP/S2/pFvCRSIPCh/bXducVnth7ubK9uI+TmdWCpwdPhjd0TwvmXTE7ODxlC8njyvAGFkHmVzfmnjkpbJYPEkPbwQMY4ZJ++5wJy8BGKLklFWmcdZ1zytUh88jFkec1+0yfxBqXtjWorHIau2R97juOhDLQ4k1ZWAG4tGZ5m7jDv2BaGvpRuI00oVyJTexyY+GRRfTZoxiY+O3fF1ntccDFXAkAH9gJ0Z)
+
+    [Ruby Pt. 2](https://tzarnal.github.io/Opal/#XQAAAQA3AgAAAAAAAAAoE8VAZTehaYnyuwTEaiO9AUDb7/afhxrRSAd9icyTM7XPlxTtju/5+jsKCkzkv04DoByTRxGROD4qLI5UATpNcGmondUpNWtajrRddQxTip90X2bBWlszn2h/fNUPz2qXseqes5e7KHuniHH80b/Yc9AHgpmyg50G2/yUDzH4jETOs7I/PnrJCAC34SApsl/bIrNjpJcVrOXnCuuY+Ef5QcevxBZiLYiMVE3RXSG5ckZ9527ttVO1A811aIiqHq2ueJ2IwC+PAzO3IXQDmChIoD9lsrShdx7yqRDstYqFlaGjb8RcHkhXyqvuRvhCmiaraAyQaU5yFHMWxBZB1rX6zscUgaTNiUOYFr7i4gksOBD2Lfu9N922uzpzC3jnG6qhIereIv6th4ihmORZ2buUV5L/8DjY3Q==)
+  :replies: []
+- :author: ndnenkov
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnzwb46/
+  :body: |-
+    **Regex (Ruby)**
+
+    https://gist.github.com/ndnenkov/3e003f0ea8b91b91d8e6c8351bdfefe8
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/rd0s54/2021_day_10_solutions/hnyad2r/
+  :body: |-
+    Ruby 1094/951
+
+    [paste](https://topaz.github.io/paste/#XQAAAQB3BQAAAAAAAAARiAqGkkN7pOxE/4M3sJZUrRlm2vbNF2CzIuf8FMADnFAgSDD1IQ95887rsT6Jozm9DFRxiVUP64wIO2vYTZ8hNH6zqsq/NA6A8z1XFuOIEaAU+UeKgm7dfiYFKtr9VIvWKm6oxgvHme1AD2LVXNKDZFsBY43n5I6+Ok1vWi64ehhtkJWtEL2sfhxixfO9SazHel/3KZyCLmYsYIejNp8vfar9E8VphsQX/WL9cghqEl2bf4X407HcdRR4rhxzVGrBBoz1oDCdl06gBWj80I9XQcDuyyXVJV7P4nbRmyhmazOOg+A1TKess8lqI2/Z3MBNSChgA2KjgcIll2rEfCcQQm7RxNKVwvz04TOnhQj/Maea+0ASL4DiPsn9g0n7IqkwO6JLjWkqXKS3scYOXmFqxmGB4sQUenfmJz4/LPn3xrEcLXpZ77bakqQsstX5HGTabvPfEEJSP0sTl5am/47MKK8P2sXJxIxIkTevg1NhPkQBG0BlNcp9i5PMV56IBUd1DpuhnjAsMMhCm9AI8cvlSJR4In1afruIgl5rjP6Mv26BGHaRRLaa0hs0kXi9+Clpj/n+b0gE)
+  :replies: []

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

@@ -0,0 +1,150 @@
+---
+- :author: icyFur
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/hoaazas/
+  :body: My solution in [Ruby](https://getsturdy.com/advent-of-code-2021-uoeIDQk/changes/47771b9e-e206-47cc-92c7-79688a38d96b)
+  :replies: []
+- :author: scarfaceDeb
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho3f5kw/
+  :body: |-
+    **Ruby**
+
+    My code is becoming more and more procedural. It’s probably some bad influence from colleagues who went with go and rust :D
+
+    ```ruby
+    ADJACENT = [-1, 1, 0].repeated_permutation(2).reject { _1 == [0, 0] }.sort
+
+    octos = read_input
+
+    def step(octos, pos, from = nil)
+      return if pos.any?(&:negative?)
+
+      energy = octos.dig(*pos)
+      return if energy.nil?
+
+      i, j = pos
+
+      octos[i][j] += 1
+
+      ADJACENT.each { step(octos, pos.zip(_1).map(&:sum)) } if energy == 9
+    end
+
+    st = 1
+    total = 0
+    rows, cols = octos.count, octos.first.count
+    octos_count = rows * cols
+
+    loop do
+      rows.times do |i|
+        cols.times do |j|
+          step(octos, [i, j])
+        end
+      end
+
+      flashing = 0
+
+      rows.times do |i|
+        cols.times do |j|
+          next if octos[i][j] < 10
+
+          octos[i][j] = 0
+          flashing += 1
+        end
+      end
+
+      total += flashing if st <= 100
+      break st if flashing == octos_count
+
+      st += 1
+    end
+
+    puts "Answer 11.1: #{total}"
+    puts "Answer 11.2: #{st}"
+    ```
+
+    https://github.com/scarfacedeb/advent-of-code/blob/master/2021/day11/run.rb
+  :replies:
+  - :author: ignurant
+    :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho48vq5/
+    :body: "`repeated_permutation` There we go! I spent like 15 minutes annoyed that I couldn’t Ruby up my directions array. I was trying varieties of `permutation` and `combinations` and zip and such. I had not previously seen _repeated_ permutation. Just what the Dr. ordered!"
+    :replies:
+    - :author: scarfaceDeb
+      :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho4h6pt/
+      :body: "Yeah, I found so many useful tricks and lesser known methods in Ruby stdlib in the last 10 days too \U0001F600"
+      :replies: []
+- :author: madethemcry
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho3d5si/
+  :body: |-
+    # RUBY
+
+    [georgiee/advent-of-code-2021/day-11 (GitHub)](https://github.com/georgiee/advent-of-code-2021/tree/main/day-11)
+
+    # Notes
+
+    This was fun and reward. Grids are kind of my nemesis in AoC. Simple enough to understand but also always asking myself for a "beautiful" solution to have the grid under fulll control.
+
+    During Day 09 (also a grid) I saw a [Ruby solution](https://www.reddit.com/r/adventofcode/comments/rca6vp/comment/hnwljmj) which read great. I searched where the "borders" of the grid are put into the equation. Nothing like that, just calculate the coordinates and put your stuff into a hash. When you try to access a "wrong" neighbor it's `nil` and you can easily skip them with `compact` on your list or whatever your use to process.
+
+    I did that today too and it feels great. In addition I used `[-1, 0, 1].repeated_permutation(2).to_a - [[0, 0]]` to created the neighbour map very easily. I created a class `Octopus` to holde the data for each octopus. In addition because it's ruby I can define great sounding words like `can_flash?`, `on?` to ask for a state or change the state with `off!` and such. Really a plelasure to write code with that. I hate the technical appearance in JavaScript where you are forced to wirte `is_` for some boolean question. This just destroys the natural readability which I love with Ruby ❤️
+
+    Anyway. Part 1 took some amount of time. And I wrote a `print` function to output my grid wayyyy to late. Until then I checked the debugger values which costs too much time. The printed grid tells me instantly what's wrong and I shoudl have done this from the beginning. Once I had this I could easily check and compare my steps with the instructions.
+
+    At some point of time I was ready to run the lights for 100 steps and magically as always the number was correct. Part 2 was really easy then. I created a new method on the `Cave`, and let it run until all lights are off. Then pick the index and we are done. This is the single addition for part 2. Nice isn't it?
+
+    ```ruby
+    def run
+        counter = 0
+        until everyone.all?(&:off?)
+          counter += 1
+          step
+        end
+
+        puts "everyone is on at #{counter}"
+    end
+    ```
+
+    I think a custom enumerator would make sense here. Then you could write like so for part 1 `cave.take(100)`and for part 2 `cave.take_while`. Both read fantastic. Time is up for today so I won't refactor that but I liked the day very much!
+  :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho3ila0/
+  :body: |-
+    I enjoyed this one quite a bit. Somewhat inspired by the DragonRuby Game Toolkit, I modeled it as a world with mobs, so pretty literally.
+
+    [Ruby pt 2](https://tzarnal.github.io/Opal/#XQAAAQAFCAAAAAAAAAAxmwhIY/VC+lD6cQOd9lyYAPDWpaReqe9sGQ0BG7rP377TcEubHCvPC0CdwEGG2DqBjJUjG9Qcu7O+lL54KYOxOEJM7AcW7Pd8w7FxmoLcR2zO1eCiO0FZqwtNsUbeQ6sWzT6C/RhB2q0AOugEPQy5xCe5GC1oGJxV01hET95B00Lw8Rg6cyqlVXgA++bbrcnY4G0Libb8Eqbxto4/CzYdUgka+xU7+1wCx+wI1mk7f5I2Pfp/7b/VRoGwr7x65ZzNo8uZBWTXrf8t9sqBe7zOcbPr7pqBzX2amlOVi86MBcXc/V8enThbmQV47A0BDbrBAam46e2k5TuYyDAybVJSMQ9Vp1dHTq+ET3W9wdNAVxcbxk6Tb8RyWBUxL0GHNij+ll5Q9vBbL7XUwc9mOewPBCIfrUD0I465DdatsUVIaMnJe1ifC4xeOG/2/mhhmGbrapJA+4tjC/DUMzu8cTyjqv9CnVsQVI4dUmqGEa8TxZczZKglrS/o69sI0hMpXOqt8Zy69NWcVCGswK6uTb4llvmlb0FG2nvfDL6TyMlMktDLIivE3xobs94pj28PvKl+GrKdicGRvG+wmcRqlozp3ps7+gxXcBSfxacDh4BM0WhBp7A1kMPgJnXcdddZ6vjOZbt1XG6FeFPw052rrKi/KJYzXlbzTucPPChFG7+x17fq0tWtlB5/r9z1iKDpzawLFyUCL8PRDGYfltcwuBcMEKQ/+MaRFTNw3cZ8sIkFmkSvGL72MJNZTcM+BnPgNNxUdCM1VW0LaLa+O9DX8SOjXJBUgb/3IO0VtEzkPJVaw5mOU2lWY7Ok8HBls4TJMvL2MQTYphhvSXzeYylc5IZYS7cHfuBxZhB0mVTwlyIwyKaj3QEMwmJA2jHYeITH8AV/WDy9B7/qY/vpr1c3swpp0NmyAw+MIsylAXCEt0wpRwegHOnCLKb2KZ4IRScn0CeY0b/aXYJ6kFEEUkcskVV+hzQ0Fyf+AOAt5ujCiQN/OK4zYsVyOhJFEt6TVVQjY4U0jgJroo5Bbl1eSg+VE66kG7jSv4fzBJtn3ddGDXiefP78KG7S)
+  :replies:
+  - :author: conthomporary
+    :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho3j7po/
+    :body: 'All right, I''ll admit it: "throw :MY\_EYES!" got a chuckle out of me'
+    :replies: []
+- :author: '442401'
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho3py2s/
+  :body: |-
+    **Ruby**
+
+    I wish I could have used a prettier way to find neighbours within bounds. I've seen some nice solutions in this thread though.
+
+    https://github.com/fig/Advent-of-Code/blob/main/2021/Day11/solution.rb
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho34hw7/
+  :body: |-
+    Ruby 746/640
+
+    [paste](https://topaz.github.io/paste/#XQAAAQD5AwAAAAAAAAA2mEpiKBEva3oI7tVd9n7D3wNtbmwq32cmfy4Y74dHhdKFKKEoq7i2+I0L99HPs2sbZTY+fHeCVZlf/VgJb0PVyQlFo+sOcvoMcZPwKTjXY2RCOfFIJZQfjmHRYyRfseBHsxipEyQ7snZdsfuICl5bp6Wkck68u4kQcM7qWcHWT1zD2Zgd7IXFshVjwpJQUdbl2HZcJ4DTLJzChhwDbRX2s84FwEx6VQD3L8z9kjLoTTtrZ7V0T8n61Ei6eBb55LAusH0b31KKCMutu37h5D6SN5CkwDMo/sMnECDyB61EI40qDMHAVkIw+xFPuUMt96gi9S69B5jdrc559kEvLTT6Q3MThRK+8XVJi6ZDf03yg/WtoSBUzyKqR3xKQVx/bF3nXdWrHdRuhLOX1iq4JT77Pr5jodum9DPDTlSaM/BmTmYti8j2MGJt/7dIAPeaUBhNVf/fqYxw)
+  :replies: []
+- :author: dhruvasagar
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho3fwjr/
+  :body: Ruby - https://github.com/dhruvasagar/comp/blob/master/adventofcode/2021/day11/day11.rb
+  :replies: []
+- :author: hrunt
+  :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho41e39/
+  :body: |-
+    **Python 3**
+
+    [Code](https://topaz.github.io/paste/#XQAAAQB1BgAAAAAAAAAQi8snifLtCATweOodUvHjXHHN4z6+DKrW2PsUJgSuNwg/WPMRCky2h8qXaT/YvgUxZadnlKD3zzMpV8G5jiVui5pHIePPjREctEChAIK1F7uQj2yXtnVyE9wXn2pcyzQ2lrcTIkltEbVFNpBQhf+eGufbDKHLfpCXHR5AFioCCHlnxHpVK6dgahqtN4Ty9Vfee2N/40LZ87h1h9uU9srtltm4PJ9oOQ//pOhCTUTM/m5L8CPka1zsaACnD4/fzodj9I8oGyPgxVdWX6FpA7nHNJMy78ypZxDTjYxTbNTE158GzR4Mi9azmkWCh+IZ0x6eohjesP9IPODhkijTvQdPP7MkmQ4m6I+P47UPLeu+bwn1l12uKqOJElxQl6rKTXM/ESaP+1hZqpnba5UWLWFeQ+q6HW0EltL+sMXSm2PRtCvNVfZErbYnTb3UcrasTABn3pP/VBEas2QIxpS379p9c8RG7bgQ3qrFeSND5GiktvByzsY96wF8p068c68+J4PWH4LuwEvNRpDapERupki7amvdUOOgXqgdMTYJnmfSLP+Gq+YIGzGvjbyZlaQKXuCIiNka9C3U3JTOeYoedC/oCTyleA+3mTYnpI+Z3KtLk98rCMXNAQrX7y0ECFF94xkqv5dEN+AGWvWCf/rJPaR8GhYCvJMwThz4doZL7YCVExeGHwWPmlOtLQwlZVGihPZW+3ORUbyWxJL4zmuOysWhVHdFa9GKuczuxhSxQed8SIciRnlhhVEib2m3ipk9eq4moam6Ugi11ky32Rf5bA0qqEqCMw+AqcQ5cUo5ygy6PlkCwrzujksFc3klJWShihWhTvMhbBc8649DU3iwi9mjaq4a1pYr2hkrj2RFKPG6H5zZXNw1GQ92ulKy0+VQu1OVl5oSyKIRJigRv/NJcv9wfEAA)
+
+    Not a lot to say about this one. For square grids like this, I find using a dictionary of (x, y) coordinates is cleaner than using nested lists. Once I built the step function to serve Part 1, Part 2 was a breeze.
+  :replies:
+  - :author: kupuguy
+    :url: https://www.reddit.com/r/adventofcode/comments/rds32p/2021_day_11_solutions/ho435k7/
+    :body: You don't need the extra parentheses `grid[(x, y)]` is cleaner if you just write `grid[x, y]`. You are right about the dict though; though I started using nested lists then quickly switched to a dict.
+    :replies: []