advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,136 @@
+---
+- :author: icyFur
+  :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homktk6/
+  :body: |-
+    Ruby Dijkstra solution
+
+    [Part One](https://getsturdy.com/advent-of-code-2021-uoeIDQk/browse/day15/kiril/solve.rb)
+  :replies: []
+- :author: kateba72
+  :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/honpqzq/
+  :body: |-
+    **Ruby** (the second time I'm posting this, because the first solution didn't work for all inputs)
+
+    I implemented A\*, but I noticed that manhattan distance isn't a good metric for this problem, because it is 1/5 of the actual cost in most cases. This causes the code to visit almost all nodes either way, so I tried to come up with a better solution.
+
+    My [first solution](https://github.com/Kateba72/advent_of_code/blob/c02e1660be259b78da6d5d6208a28d1aa1deaa69/2021/15.rb#L76) was fast, but overestimated the cost for some inputs, which led to incorrect values for some inputs, so I kept looking for a better distance estimation and found this:
+
+    ```ruby
+    def calculate_distance_estimates(map)
+      @distance_estimates = []
+      last_row = map.size - 1
+      last_column = map[0].size - 1
+      last_diagonal = last_row + last_column
+
+      (0..last_row).each do |row| # initialize the @distance_estimates array
+        @distance_estimates[row] = []
+      end
+      @distance_estimates[last_row][last_column] = map[last_row][last_column]
+
+      (0 .. last_diagonal-1).reverse_each do |diagonal|
+        diagonal_value = Float::INFINITY
+        column_range = [0, diagonal - last_row].max .. [last_column, diagonal].min
+
+        column_range.each do |column|
+          row = diagonal - column
+          this_point_estimate = @distance_estimates[row][column] = [
+            @distance_estimates[row][column + 1] || Float::INFINITY,
+            @distance_estimates[row + 1]&.at(column) || Float::INFINITY,
+            diagonal_value + 2
+          ].min + map[row][column]
+          diagonal_value = diagonal_value + 2 < this_point_estimate ? diagonal_value + 2 : this_point_estimate
+        end
+
+        diagonal_value = Float::INFINITY
+        column_range.reverse_each do |column|
+          row = diagonal - column
+          this_point_estimate = @distance_estimates[row][column] = [
+            @distance_estimates[row][column],
+            diagonal_value + 2 + map[row][column]
+          ].min
+          diagonal_value = diagonal_value + 2 < this_point_estimate ? diagonal_value + 2 : this_point_estimate
+        end
+      end
+    end
+    ```
+
+    Hints for non-rubyists trying to read the code: - (int..int) is a range that includes the values on both ends - ruby arrays return nil (the equivalent of none/null) when accessing an index out of bounds, so the edge cases are taken care of
+
+    This assigns every point on the map a value that estimates the cost from this node to the end. This value is the cost of the point plus the minimum of - the estimated distance from the point one below - the estimated distance from the point one to the right - the minimum of the estimated costs of all points on the same diagonal plus the manhattan distance to that point
+
+    This function allowed me to cut runtime from 5.2 seconds to .75 seconds and visits less than 1/10 of the points that A\* would visit.
+
+    Full code [here](https://github.com/Kateba72/advent_of_code/blob/main/2021/15.rb) if someone is interested
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/honys08/
+  :body: |-
+    [Pretty straightforward A\* in Ruby](https://github.com/daniero/code-challenges/blob/master/aoc2021/ruby/15.rb#L5) using PQueue.
+
+    Started implementing a clever lazy grid thing for part 2 to put into the logic from part 1, but couldn't be bothered in the end, so:
+
+    ```ruby
+    large_grid = 5.times.flat_map { |ny|
+      input.map { |row|
+        5.times.flat_map { |nx|
+          row.map { |risk|
+            new_risk = risk + ny+nx
+            new_risk -= 9 while new_risk > 9
+            new_risk
+          }
+        }
+      }
+    }
+    ```
+  :replies: []
+- :author: groys
+  :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homgp6o/
+  :body: |-
+    [Ruby Solution without Dijsktra](https://github.com/groys/AOC/blob/main/2021/day15.rb)
+
+    General intuition is to start from the bottom right corner and build up the risk matrix
+
+    1. Maintain $d which captures the risk of traversing from i,j to right bottom
+
+    2. Start from the bottom right corner. Maintain queue of vertexes that you encounter
+
+    3. Relax (CLRS concept) each non-diagonal edge you encounter and queue the vertex if its $d changes
+
+    4. mind the 0, 0 vertex to not add its cost
+  :replies:
+  - :author: Tankznor
+    :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homl7qa/
+    :body: I was thinking to start at the end, but does it really matter? Ended up with a dynamic programming solution starting at the top.
+    :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homt4gf/
+  :body: |-
+    [Ruby](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/15/chitons.rb) (295/399)
+
+    Saw the problem, immediately went to dig up the Dijkstra's implementation (including a [basic priority queue implementation](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/lib/priority_queue.rb)\*) that I made a few weeks ago while solving day 22 from 2018 (I didn't hear about AoC until 2019). The thing that took me the most amount of time today was deciding on a nice algorithm to extend the map for part 2 (and also skimming past the fact that 9 should roll around to 1 and not 0 in that process)...
+
+    \*) Yes, I know that implementation isn't super effective, but it does the job. Not much slower than other implementations I've tried, and it doesn't require any external libraries.
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/hom7063/
+  :body: |-
+    **Ruby** : 14:12/59:50, 703/1949
+
+    Here's a [recording](https://youtu.be/A_PP3rHyLkc) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec15.rb). I usually stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    Ugh. Like many of you, I also initially assumed the path could only go down or right, but I didn't figure that our until ~45 minutes in. DEFINITELY should have been made clearer in the instructions. My Part 1 worked just going right and left!
+
+    Initial dynamic programming for Part 1 went not very well, and then my Djikstra half-implementation went even worse - wasn't really sure how to use a heap in Ruby.
+  :replies:
+  - :author: four_father
+    :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homacx8/
+    :body: recording works but the github is a 404. did you forget to push?
+    :replies:
+    - :author: CodeIsTheEnd
+      :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homhn7l/
+      :body: Oops, thanks, fixed.
+      :replies: []
+  - :author: phord
+    :url: https://www.reddit.com/r/adventofcode/comments/rgqzt5/2021_day_15_solutions/homjx56/
+    :body: I noticed the part 1 example was solveable with only right and down, but I assumed that was because of the size and the easing us in. I knew part 2 was going to bring the variety. Actually I was worried they were going to add diagonals.
+    :replies: []

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

@@ -0,0 +1,274 @@
+---
+- :author: weiss_i_net
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/houksni/
+  :body: |-
+    **Ruby**
+
+    Sorta proud that it turned out this concise on the first try. That allowed me to do the second part really quickly.
+
+    ```ruby
+    $version = 0
+
+    def parse_packet(packet)
+      packet_version = packet.shift(3).join.to_i(2)
+      $version += packet_version
+      type_id = packet.shift(3).join.to_i(2)
+
+      if type_id == 4 # literal packet
+        msg = []
+        while packet.shift == "1"
+          msg.append(*packet.shift(4))
+        end
+        msg.append(*packet.shift(4))
+        return [msg.join.to_i(2), packet]
+
+      else # operator
+
+        # length type == bits
+        if packet.shift == "0"
+          packet_len = packet.shift(15).join.to_i(2)
+          sub_packet = packet.shift(packet_len)
+          result = []
+          until sub_packet.empty?
+            sub_result, sub_packet = parse_packet(sub_packet)
+            result << sub_result
+          end
+
+        # length type == packet count
+        else
+          packet_count = packet.shift(11).join.to_i(2)
+          result = []
+          packet_count.times do
+            sub_result, packet = parse_packet(packet)
+            result << sub_result
+          end
+        end
+
+        case type_id
+        when 0; return [result.sum, packet]
+        when 1; return [result.reduce(&:*), packet]
+        when 2; return [result.min, packet]
+        when 3; return [result.max, packet]
+        when 5; return [result.reduce(&:>) ? 1 : 0, packet]
+        when 6; return [result.reduce(&:<) ? 1 : 0, packet]
+        when 7; return [result.reduce(&:==) ? 1 : 0, packet]
+        end
+      end
+    end
+
+    input = ARGF.read.strip.chars.map{|c| c.hex.to_s(2).rjust(4, "0").chars}.flatten
+
+    puts "Part 2: #{parse_packet(input).first}"
+    puts "Part 1: #{$version}"
+    ```
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hor34iu/
+  :body: |-
+    **Ruby** : 16:44/51:50, 37/773
+
+    Here's a [recording](https://youtu.be/A5AqhdjhxNU) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec16.rb). I usually stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    My best leaderboard spot, by far!
+
+    Man, this one was really a test in reading comprehension. Took a while to understand what was going on and figure out what parts I actually needed to do for Part 1 vs Part 2.
+
+    Part 2 was pretty fun! It took me a while I needed to subtract the bits from EVERYTHING in the ancestor stack and then that I might need to pop multiple things off that stack. Great problem with a bunch of separate insights.
+  :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hor9ent/
+  :body: |-
+    **Ruby**
+
+    We begin by parsing the hex input into binary, taking care to use [Kernel#sprintf](https://ruby-doc.org/core-3.0.0/Kernel.html#method-i-sprintf) to pad with leading zeroes.
+
+    ```ruby
+        data = open("input").read.chars.map{sprintf('%04b', _1.to_i(16))}.join("")
+    ```
+
+    Next, three methods to help us parse the input. `parse_packet` is the main function, which calls `parse_literal` if it's a literal value, and `parse_several_packets` if it's an operator.
+
+    Each of these returns a `version_sum` (for Part 1), a `value` (for Part 2), and a `remainder` (what's left of the string, which then becomes the argument for the next packet to be parsed).
+
+    ```ruby
+    def parse_literal(str)
+      output = ""
+      counter = 0
+      str.chars.each_slice(5) do |group|
+        output << group[1..4].join("")
+        counter += 1
+        break if group[0] == "0"
+      end
+      return {version_sum: 0, value: output.to_i(2), remainder: str[5 * counter..]}
+    end
+
+    def parse_packet(str)
+      version = str.slice!(0, 3).to_i(2)
+      id = str.slice!(0, 3).to_i(2)
+      if id == 4
+        result = parse_literal(str)
+      else
+        mode = str.slice!(0) == "0" ? "bits" : "subpackets"
+        num_of_bits_or_subpackets = mode == "bits" ? str.slice!(0, 15).to_i(2) : str.slice!(0, 11).to_i(2)
+        result = parse_several_packets(str: str, code: id, count: num_of_bits_or_subpackets, method: mode)
+      end
+      return {version_sum: version + result[:version_sum], value: result[:value], remainder: result[:remainder]}
+    end
+
+    def parse_several_packets(str:, code:, count:, method:)
+      versions = []
+      values = []
+      if method == "subpackets"
+        count.times do
+          result = parse_packet(str)
+          versions << result[:version_sum]
+          values << result[:value]
+          str = result[:remainder]
+        end
+      else # Known number of bits
+        part = str.slice!(0, count)
+        until part.empty? do
+          result = parse_packet(part)
+          versions << result[:version_sum]
+          values << result[:value]
+          part = result[:remainder]
+        end
+      end
+      case code
+      when 0 then value = values.sum
+      when 1 then value = values.reduce(&:*)
+      when 2 then value = values.min
+      when 3 then value = values.max
+      when 5 then value = values[0] > values[1] ? 1 : 0
+      when 6 then value = values[0] < values[1] ? 1 : 0
+      when 7 then value = values[1] == values[0] ? 1 : 0
+      end
+      return {version_sum: versions.sum, value: value, remainder: str}
+    end
+    ```
+
+    Then we just have to call the `parse_packet` method, and use `version_sum` and `value` as solutions for Parts 1 and 2 respectively:
+
+    ```ruby
+    p parse_packet(data)
+    ```
+  :replies: []
+- :author: madethemcry
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hosv3us/
+  :body: |-
+    # RUBY
+
+    [georgiee/advent-of-code-2021/day-16 (GitHub)](https://github.com/georgiee/advent-of-code-2021/tree/main/day-16)
+
+    [[Part 1](https://github.com/georgiee/advent-of-code-2021/blob/main/day-16/day-16-part1.rb) |[Part 2](https://github.com/georgiee/advent-of-code-2021/blob/main/day-16/day-16-part2.rb)]
+
+    # Notes
+
+    This was kind of straight forward for someone who participated in AoC 2019 where each day was part of building the famous [intcode computer](https://adventofcode.com/2019/day/2). Ruby also helps a lot in processing data streams and converting forth and back the data in hex, binary & friends. I think that is often extra legwork in many languages, isn't it?
+
+    After two frustrating days I had a great success today. The ruby code just reads beautiful ❤️
+  :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hoqx7pb/
+  :body: |-
+    [Ruby](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/16/decode.rb) (114/114)
+
+    Personal best ranking wise today (while my day job is programming, I'm not a professional _competitive_ programmer), just 46 seconds from top 100 on part 1 and 78 seconds on part 2. :D Might be caused by my inexplicable love for parsing... :P
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hoqy08b/
+  :body: |-
+    Ruby
+
+    ```ruby
+    line = gets.split("\n")[0]
+
+    packet = line.hex.to_s(2).rjust(line.size * 4, '0')
+    i = 0
+
+    read_field = ->(length) { packet[i, length].to_i(2).tap { i += length } }
+
+    parse_packet = -> do
+      version = read_field.call(3)
+      type_id = read_field.call(3)
+
+      if type_id == 4
+        value = ''
+        loop do
+          leading = packet[i]
+          value += packet[i + 1, 4]
+          i += 5
+          break if leading == '0'
+        end
+        return value.to_i(2)
+      end
+
+      length_type_id = read_field.call(1)
+
+      packets = []
+      if length_type_id == 0
+        stop = i + read_field.call(15)
+        packets << parse_packet.call until i >= stop
+      else
+        read_field.call(11).times { packets << parse_packet.call }
+      end
+
+      case type_id
+      when 0
+        packets.sum
+      when 1
+        packets.inject(:*)
+      when 2
+        packets.min
+      when 3
+        packets.max
+      when 5
+        packets[0] > packets[1] ? 1 : 0
+      when 6
+        packets[0] < packets[1] ? 1 : 0
+      when 7
+        packets[0] == packets[1] ? 1 : 0
+      end
+    end
+
+    p parse_packet.call
+    ```
+  :replies: []
+- :author: erikw901
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hosd6b5/
+  :body: |-
+    # Ruby
+
+    - [part1.rb](https://github.com/erikw/advent-of-code-solutions/blob/main/2021/16/part1.rb)
+    - [part2.rb](https://github.com/erikw/advent-of-code-solutions/blob/main/2021/16/part2.rb)
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/rhj2hm/2021_day_16_solutions/hotgu7a/
+  :body: |-
+    # [Ruby](https://github.com/daniero/code-challenges/blob/master/aoc2021/ruby/16.rb)
+
+    Spent absolutely forever on part 1 today, misinterpreting the text, getting off-by-one errors etc etc. However I'm quite please that I could solve part 2 quite quickly after that:
+
+    ```ruby
+    def calculate_value(packet)
+      case packet.type
+      when 0
+        packet.sub_packets.sum(&method(:calculate_value))
+      when 1
+        packet.sub_packets.map(&method(:calculate_value)).reduce(:*)
+      when 2
+        packet.sub_packets.map(&method(:calculate_value)).min
+      when 4
+        packet.value
+      when 3
+        packet.sub_packets.map(&method(:calculate_value)).max
+      when 5
+        packet.sub_packets.map(&method(:calculate_value)).reduce(:>) ? 1 : 0
+      when 6
+        packet.sub_packets.map(&method(:calculate_value)).reduce(:<) ? 1 : 0
+      when 7
+        packet.sub_packets.map(&method(:calculate_value)).reduce(:==) ? 1 : 0
+      end
+    end
+    ```
+  :replies: []

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

@@ -0,0 +1,139 @@
+---
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/ri9kdq/2021_day_17_solutions/howcwik/
+  :body: |-
+    **Ruby** (runtime: 40 us / 90 ms)
+
+    Happily, the syntax used in the input is identical to Ruby's range syntax\*, so we can use `eval` to parse the ranges literally:
+
+    ```ruby
+    xrange, yrange = open("input").read.split(",").map{eval(_1.split("=").last)}
+    ```
+
+    First a couple math formulas which will really help us:\*\*
+
+    ```ruby
+    def triangular(n) = n * (n + 1) / 2
+    def loc(init_velocity, steps) = steps * ((init_velocity + (init_velocity - steps + 1)) / 2.0)
+    ```
+
+    _Triangular_ gives us the n-th triangular number, which is useful because for an initial x-velocity _n_, the projectile will start falling vertically when it reaches x = _n_-th triangular number.
+
+    _Loc_ gives us the position of an object launched at an initial velocity after _steps_ units of time. We can use this for both the x- and y-coordinates of the projectile.
+
+    Next, a method that returns an array of all the possible initial x-velocities which will allow the projectile to enter the target area.
+
+    ```ruby
+    def possible_x(xrange)
+      [*1..xrange.max].filter{|init_x| [*1..init_x].any?{xrange === loc(init_x, _1)}}
+    end
+    ```
+
+    Then, a method that lets us know, given an initial x- and y-velocity, whether the projectile will hit the target area:
+
+    ```ruby
+    def target_hit?(init_x, init_y, xrange, yrange)
+      (0..999).each do |steps|
+        x = steps >= init_x ? triangular(init_x) : loc(init_x, steps)
+        y = loc(init_y, steps)
+        return true if xrange === x && yrange === y
+        return false if xrange.last < x || yrange.first > y # We're past the target - stop checking!
+      end
+      false
+    end
+    ```
+
+    Now we're ready to solve. A few other comments have already gone into the details on why that shortcut works for Part 1. I added code to account for an edge case when it doesn't.
+
+    ```ruby
+    if [*1..xrange.min].any?{xrange === triangular(_1)} # I suspect everyone's puzzle input satisfies this, so use the shortcut
+      puts triangular(yrange.min)
+    else
+      max_init_y = possible_x(xrange).map{|init_x| [*yrange.min..yrange.min.abs].filter{|init_y| target_hit?(init_x, init_y, xrange, yrange)}.max}.max
+      puts triangular(max_init_y)
+    end
+    ```
+
+    For Part 2, we take the array of possible initial x-velocities, loop over all possible y-velocities, and tally up the number of unique velocity values.
+
+    ```ruby
+    puts possible_x(xrange).sum{|init_x| [*yrange.min..yrange.min.abs]
+      .filter{|init_y| target_hit?(init_x, init_y, xrange, yrange)}.count}
+    ```
+
+    \* IIRC, AoC is written in Perl, so Eric probably just used the Perl range syntax - just so happens that Ruby copied Perl's syntax for ranges
+
+    \*\* Written as end-less methods, which only work in Ruby 3.0+. Earlier versions required you to end a method declaration with `end`.
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/ri9kdq/2021_day_17_solutions/hovte54/
+  :body: |-
+    **Ruby** 164 bytes
+
+    ```ruby
+    x=y=n=0
+    gets[13..].split(', ').map{eval _1}
+    u=x.max
+    v=y.min
+    1.upto(u){|c|v.upto(u){|d|e=c
+    a=b=0
+    (a+=e
+    b+=d
+    e-=e<=>0
+    d-=1
+    (n+=1;break)if x===a&&y===b)until b<v}}
+    p n
+    ```
+  :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/ri9kdq/2021_day_17_solutions/how2kzp/
+  :body: |-
+    [Ruby](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/17/trickshot.rb) (1598/1502)
+
+    Was a bit slow today, but did some math to minimize the search space after getting my answers right. All my math is (or at least should be) explained in comments in my code:
+
+    - x velocity outside [[round(sqrt(x\_min\*2))](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/17/trickshot.rb#L40-L43), [x\_max](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/17/trickshot.rb#L44-L46)] will never be in range.
+    - y velocity outside [[y\_min](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/17/trickshot.rb#L48-L50), [-y\_min-1](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2021/17/trickshot.rb#L14-L18)] will never be in range.
+
+    Curiously ended up submitting the answer for some other input in part 2 at one point when my search space was too small...
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/ri9kdq/2021_day_17_solutions/how8snj/
+    :body: "[removed]"
+    :replies:
+    - :author: firetech_SE
+      :url: https://www.reddit.com/r/adventofcode/comments/ri9kdq/2021_day_17_solutions/howfmtg/
+      :body: If it makes you feel better, I didn't realize that until I read it here :P
+      :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/ri9kdq/2021_day_17_solutions/hovpzcn/
+  :body: |-
+    Today is easier than the past 2 days... done by crude simulation + brute force.
+
+    ```ruby
+    # Ruby, 82 / 31
+    target = gets.scan(/target area: x=([^,]+), y=([^,]+)/)[0].map { eval _1 }
+    p target
+
+    simulate = -> dx, dy {
+        hit, x, y, y_max = false, 0, 0, 0
+        loop do
+            x += dx
+            y += dy
+            dx -= dx > 0 ? 1 : dx < 0 ? -1 : 0
+            dy -= 1
+            y_max = y if y > y_max
+            if target[0].include?(x) && target[1].include?(y)
+                hit = true
+                break
+            end
+            break if y < target[1].min
+        end
+        [hit, x, y, y_max]
+    }
+
+    all_possibilities = (-100..400).to_a.product((-100..100).to_a).map { |dx, dy| simulate[dx, dy] }.filter { _1[0] }
+    p all_possibilities.map { _1.last }.max
+    p all_possibilities.count
+    ```
+  :replies: []

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

@@ -0,0 +1,105 @@
+---
+- :author: Frakols
+  :url: https://www.reddit.com/r/adventofcode/comments/rizw2c/2021_day_18_solutions/hp3jadg/
+  :body: |-
+    # Ruby
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAqDwAAAAAAAAA0m4poOBNUDQxDypsC1yr/AYVeQd2XqWHx/Up5/oq2huy31nQ1N2BX0gZ2cccVPEP7L+8wgvKwF7usZRog96EPl6p5hIisI3S+Wnvl0Zt/uWiwWAK7Aqodvozelii07/icWlG2GDtMUcPvnt55MviV12D9ACEO51IdlfNvOiZminvCfFqHG5HfCC2y+Iap0ReWj8Kuzte2hbOa2fsTtVUFFb/W+tQIXFXyie9Sl2N+6ch6C/Fc7I45rEuYVSp4y1uOrPTxx/kE/iGQiraTO6PfkqYrrVj/9h8HMNojy78k87skKdEXdu/ZWe/iOqnyOJX7dQ158yF3G17RnoGtGsAqe0dJjAFqlllkgq+0OSwtddmb2311VEkS27m5nXK5bzrM/lDhrZ3rmtzR4d36L5RT/9RiTBnfF6vUTuB+C2vSmhFy13Mkub/KhFw2IuQzoVmG2h01ygfFc7lNN+4q9VCIR7gtqcT9mSXY9W+fVheRU1tEvvstIQoglWd2104Yn1VOGiA84SmxY+dlLT156CU4gqX8t1ZSq/IyVpcz3YP8fI1lHY4zxVHWAvMMMM+fFMG7OirQwoeLXAwGajUqg45VlypOYvU3L8Ed51Moy2m7e5g4aN3nsf7GsCwkBNRh4pRr+mpcyIclWTiwPX+EWnHYjMw6z5MmHbnb9UtYpPf8soe6MTU00iJlq4e7ylap5mIhD3vGb8IVJaZN9nNG7QFaQWQ4kJVgTzalcPIW202FvgAq5Z+yGU++UoX5jou+h8EXwWbwCgSvz0wFy3/shq/6tXQ3nHh73QW+wtv3mhQtvm5BUEWWrjXZXaYn+06omDKuCW5en+Ym2Lns2qHWAgGyvrjKi2W2ZJsof9XAsRjOJSBWxADjU6T4YZW99CtP2YVjjw6N510b8mu6O0Q51/9AIyqG6UubPLk6//uYTCi3fLn0VXeYCfZ6s3rAz1kW6da8WiygH1LYTKxAwzh007gjz6nvuCUXgT9zSIbyOoOAG8Z80k/m83SOHi3pP7M9F2WrvfQkTfljvnsWrCrPp1bUJUhpjzR3XXLJCsnQ3K6FjO3QKj40crIWY9jDkFB6/r6CYp7KpOcK7AUSO03fK7IfbNqYXkILg/tuPXXxyOfNbX951dHjkuD596arOPGm2Fq1m1qTj9XeSme6hPYL6HHPMbDoq50+Rv3gQ9zHFXJwy+aI83sZWkzAn6CTuWI0ZnWE2oa6gqG2rIgFzGJVxqgcNUEUnxNKzH9Fqs9tN1olcMFUpq/br+J34NLAMyN448Q2Cx5iL2KKvI6GQ6I/1L16To7Ib13SEpARpzwgIe0JW2+rPKd+de3YXIEu/AbQ/wPtHBK7BY7anQ6sOCX2Wh+NiHsazkAfx+B4zNQ6UOuSwyTS5Tx1sS8bHeUJrJ9LAJJTvjUjRBEFz+gp/vvSLIY=)
+  :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rizw2c/2021_day_18_solutions/hp18eju/
+  :body: |-
+    **Ruby**
+
+    My basic idea was to turn each snailfish number into an array of complex numbers _a+bi_, where _a_ is the number and _b_ is the depth (number of brackets the number is enclosed by). For example: `[[[1, 2], 3], 4]` would be encoded as `[1+3i, 2+3i, 3+2i, 4+i]`
+
+    ```ruby
+    def snail_parse(str)
+      counter = 0
+      output = []
+      str.chars.each do |char|
+        if char.match?(/\d/)
+          output << char.to_i + counter.i
+        elsif char == "["
+          counter += 1
+        elsif char == "]"
+          counter -= 1
+        end
+      end
+      output
+    end
+    ```
+
+    Then, I know we have to explode any number where `b >= 5` and split any number where `a >= 10`. So we can write methods to explode and split at a given index, and get the magnitude of a snailfish number:
+
+    ```ruby
+    def explode(arr, ind)
+      first, second = arr.slice(ind, 2)
+      arr[ind - 1] += first.real if ind != 0
+      arr[ind + 2] += second.real if arr[ind + 2]
+      arr.delete_at(ind)
+      arr[ind] = 0 + (first.imaginary - 1).i
+    end
+
+    def split(arr, ind)
+      arr.insert(ind + 1, (arr[ind].real / 2.0).round + (arr[ind].imaginary + 1).i)
+      arr[ind] = arr[ind].real / 2 + (arr[ind].imaginary + 1).i
+    end
+
+    def get_magnitude(arr)
+      loop do
+        max_depth = arr.map(&:imaginary).max
+        break if max_depth == 0
+        ind = arr.index{ _1.imaginary == max_depth}
+        arr[ind] = 3 * arr[ind].real + 2 * arr[ind + 1].real + (arr[ind].imaginary - 1).i
+        arr.delete_at(ind + 1)
+      end
+      arr.first.real
+    end
+    ```
+
+    Then we can add two snailfish numbers and loop until it's reduced:
+
+    ```ruby
+    def snail_add(a, b)
+      joined = a.dup.concat(b).map{_1 + 1.i}
+      loop do
+        index_to_explode = joined.index{_1.imaginary >= 5}
+        if index_to_explode
+          explode(joined, index_to_explode) and next
+        end
+        index_to_split = joined.index{_1.real >= 10}
+        if index_to_split
+          split(joined, index_to_split) and next
+        end
+        break
+      end
+      joined
+    end
+    ```
+
+    Now we can solve the problem with:
+
+    ```ruby
+    data = open("input").each_line.map{snail_parse(_1)}
+    puts get_magnitude(data.reduce{snail_add(_1, _2)}) # Part 1
+    p data.permutation(2).map{|a, b| get_magnitude(snail_add(a, b))}.max # Part 2
+    ```
+  :replies:
+  - :author: fcd12
+    :url: https://www.reddit.com/r/adventofcode/comments/rizw2c/2021_day_18_solutions/hp19caa/
+    :body: that is actually such a cool way of solving this problem :)
+    :replies: []
+  - :author: shandley256
+    :url: https://www.reddit.com/r/adventofcode/comments/rizw2c/2021_day_18_solutions/hp2e3az/
+    :body: Never would have thought of doing it this way - super creative!
+    :replies: []
+- :author: BaseSlow3701
+  :url: https://www.reddit.com/r/adventofcode/comments/rizw2c/2021_day_18_solutions/hp0w9e4/
+  :body: |-
+    Ruby
+
+    One of my favorite so far! I wasn't particularly fast, but it was a fun one.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQD8DAAAAAAAAAAzGknWt5Bv2qwBBozphszPdvu77G/FdUXkM9u9Z7DgTBBQoSfvgvujXFLU1IslSNaoKbUy+LA1IzpsDY3QteDetE0jXYAExKKqAwQSUVj8tGFKkXxKp+aH9rskgAzi3RarQ9WefYCjoUaT0UHFR/GFihvcl9ApiKD3O5HqnJ9VLkjPPXVzUhlCT2fKISfDS5HoGthcSxu62xMm3Kl78gyft3SdI5jlBkUIdVzL8awhMbMQnbRYb7AGi6p3a4jGOmM2td9uKXuijb4B99PQuZ1AXJBEb8TTVa+zbHZNd4iUbXHsqTQxE+3MBwhaq2AWycRagvgmEc7XiPJbEBPJD6ZasXGLbrXuXfAvmuMvyOG2eUwE/OiRmy0ZPzAg+OAsqUXnFHFcmzy1cy/rGlgRLKGaFbxG/yxeKiZKfux1/Y/CW/U+NzGSiYxQEbvyRw3C1AsMuq5ZM1i3MJFZvbDieV5qX6D5ERGIWESIteYKtKyyS2JKSqzBMlo67HaBoaXppQJaGetuYPCJ1bdcZu2GhEfsw8CsLwB1Txigd14scihE1pWSWkggRKek9xtD+nn1PMqf6TPE3ivwfZ68hnT1vynJSEVUo0VO8qY2ktwKEc4tvimgA2e2x+TlaKHQiYM5xNZmAphWkaGwa2gfi3Xx/wWH3bbo597yKFLEs5NMQyZYvbAyCdNrkSPU0wFbaLxXsxMngMfKvipHsfQ/1vb5D1fvJ5JKdjytNFGbSMh4ESWjept7ULurZHMIOVpNTni7UyQFpif44snbpqAQYi1RbiiKvnR3UCBzvHxIjNLRy80PWNqOeiDX//hcXshVUqfOob1MiwdxQs1quLaIPEddDK8CCGY1UkHREoYEGjdnehvuRjZhhA+otvzlJHYZf2BG2e/C+teXeB8QPT9Ih0OIRTkfLWyG3O5p3W7bn9sywvnTRN3Zkkx93eQNUkbi+CDiBzEnuVGp2xkB20iMS0FpF+WRKbTve1pB+Yn7VU2wJoHsZU7zLKR9jgfpP18HO+VPY5Mrk52kzNE+Zsj0gr9IYg3cWirGTZK2XGWlA2qQ7xDxPPTKvEK53U+uqfI++WWRedS6qcP3P0Az59iwy6ja1kivYyukhqbW+nt7HwZDnmbq0wFp3z9JhDwJ3uuxIlZsE0acLgruda5QX1PrrUSWyKNt60eof/C5rXqNh7e2xAqsWVwMjXUH2x2dh0+JCPO8ygv6fwflKs1ciS8IFw1mhDNCwu9sWnT+qEQjFl2Ozow6fQVb2VVdXvqhWZFfDGKCDTFTgtATSsLXhoi+xJo3ZpKJhwThlPLllZqvkbqlyUMhQiZx77tg2GPv2SC6WVnsyo44cPhscqIyfGLIdtK3tTtu79PbPKcVxa4TriTiNmsxFdCuFdc5/om2+rEIu7/+vmJRPMH/XBjHAA==)
+  :replies: []