advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,98 @@
+---
+- :author: ywgdana
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j059jee/
+  :body: |-
+    **F#**
+
+    I opened the input file and grumbled in jealously at the Python and Ruby kids with their fancy-pants eval() function and it never once crossed my mind that I could use a json parser... So, hand-rolled recursive parser for me, which had me scratching my head a bit with F#'s type system to have a discriminated union that could be either an Int or a list of Ints and/or Lists.
+
+    For part 2, I just wrote what is probably charitably described as a parody of an Insertion Sort...
+
+    [The code at github!](https://github.com/DanaL/AdventOfCode/blob/main/2022/Day13.fsx)
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j00xujm/
+  :body: |-
+    # Ruby (feat. monkey patching)
+
+    ```ruby
+    (a = [Integer, Array]).each{ |cl| cl.tap{_1.alias_method(:I_LOVE_RUBY, :<=>)}.define_method(:<=>) { |other| (a - [cl])[0] === other ? [self].flatten(1) <=> [other].flatten(1) : self.I_LOVE_RUBY(other) } }
+    STDIN.each_slice(3).map{ |x| x.map{eval(_1)} }.tap{ |x| p x.map{(_1 <=> _2) < 0}.unshift(nil).each_with_index.select(&:first).map(&:last).sum }.then{ |x| p (D = [[[2]], [[6]]]).map{ |d| (x.flatten(1).compact + D).sort.index(d) + 1 }.reduce(:*) }
+    ```
+
+    I have created something hideous.
+
+    Goal was to use Ruby's built-in `<=>`/`sort` with as few modifications as possible. Secondary goal was ~~a mistake~~ to minimize line count without semicolons. Unfortunately, there are some `tap` and `then` that feel a bit too much like using semicolons; anyone have ideas on how to get rid of those without adding more lines?
+  :replies: []
+- :author: _liquidlemon
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j00nrhb/
+  :body: |-
+    [Ruby](https://github.com/LiquidLemon/advent-of-code/blob/master/2022/13.rb) (759/701)
+
+    A little cleaned up over my initial solution but nothing crazy. Just made it more idiomatic.
+
+    Really happy I made a function that can be passed to `Array#sort` straight away. Also that part pretty much worked first try, I just had the semantics flipped.
+  :replies:
+  - :author: BluFoot
+    :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j00qap2/
+    :body: Nice, I like the use of `<=>`
+    :replies:
+    - :author: _liquidlemon
+      :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j00reu1/
+      :body: I had an if with 3 clauses but then I realized there's literally a built in operator for this thing, so why not just use it.
+      :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j00puac/
+  :body: |-
+    **Ruby** 1936/1742
+
+    Using `eval` feels like cheating, parsing was very easy. I lost 10 minutes because I originally misread the sorting instructions and had to read it over several times to realize my mistake.
+
+    ```ruby
+    pairs = input.split("\n\n")
+
+    def ordered(a, b)
+      if a.class == Integer && b.class == Integer
+        return a > b ? 0 : b > a ? 1 : nil
+      else
+        a = [a] if a.class != Array
+        b = [b] if b.class != Array
+        l = [a.length, b.length].min
+        (0...l).each{|i| return ordered(a[i], b[i]) if ordered(a[i], b[i])}
+        return a.length > b.length ? 0 : b.length > a.length ? 1 : nil
+      end
+    end
+
+    good_indices = pairs.each_with_index.map do |pair, index|
+      x, y = pair.split("\n").map{eval(_1)}
+      ordered(x, y) * (index + 1)
+    end
+
+    sorted_pairs = pairs.map{_1.split("\n").map{|l| eval(l)}}.reduce(&:+).concat([[[2]], [[6]]]).sort{|a, b| ordered(b, a)*2 - 1}
+    puts "Part 1: #{good_indices.reduce(&:+)}"
+    puts "Part 2: #{(sorted_pairs.find_index([[2]]) + 1) * (sorted_pairs.find_index([[6]]) + 1)}"
+    ```
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j00pxcv/
+  :body: |-
+    [Ruby](https://github.com/acornellier/adventofcode/blob/master/2022/13.rb)
+
+    Nice use-case for pattern matching
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j01wtnt/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/13)
+
+    Video Walkthrough: [YouTube](https://youtu.be/hpd8cxPfjbY)
+  :replies: []
+- :author: tobyaw
+  :url: https://www.reddit.com/r/adventofcode/comments/zkmyh4/2022_day_13_solutions/j02o38q/
+  :body: |-
+    Ruby
+
+    https://github.com/tobyaw/advent-of-code-2022/blob/master/day\_13.rb
+  :replies: []

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

@@ -0,0 +1,32 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06mkyf/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/14)
+
+    Video Walkthrough: [YouTube](https://youtu.be/PTmSGQnGoXM)
+  :replies:
+  - :author: mizunomi
+    :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06qhj0/
+    :body: Well done with the solution, but please, as suggested, do not upload your inputs to public repositories.
+    :replies:
+    - :author: skagedal
+      :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j06zveq/
+      :body: Where is this suggested? I've read through the posting rules but probably missed something. Or is it suggested somewhere on the AoC site itself..?
+      :replies:
+      - :author: mizunomi
+        :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j075a64/
+        :body: |-
+          This is visible in the subreddit wiki. Usually, the moderator reminds posters about this.
+
+          [Link](https://www.reddit.com/r/adventofcode/wiki/troubleshooting/no_asking_for_inputs/)
+        :replies: []
+- :author: mathem17
+  :url: https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j05q56v/
+  :body: |-
+    [Ruby](https://github.com/jzhang113/adventofcode/blob/01b815bbd93a405f590095393867beed301cd3db/2022/solutions/14.rb) 2010 / 3400
+
+    I spent 15 or so minutes on part 2 wondering why my answer was wrong, only to realize I made the map too small.
+  :replies: []

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

@@ -0,0 +1,110 @@
+---
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0ed50d/
+  :body: |-
+    Ruby, Part 2.
+
+    This is a variation of the intersecting lines approach.Its looks for "sensor diamonds" which are separated by a single space. This assumes there are only four such sensors (so it will not work with test input, as it needs more filtering).One pair forms a "forward" gap, and another one a "backward". Intersection of the gaps gives as the required position. Just a one sensor from the pair is enough to derive the coefficients of the line equations and solve for coordinates.
+
+    ```ruby
+    # frozen_string_literal: true
+
+    file = File.open('input.txt')
+    lines = file.readlines.map(&:chomp)
+
+    sensors = {}
+
+    lines.each do |line|
+      sensor, beacon = line.split ':'
+      sensor_coords = sensor.split('at').last.split(',').map { |c| c.split('=').last.to_i }
+      closest_beacon_coords = beacon.split('at').last.split(',').map { |c| c.split('=').last.to_i }
+      sx, sy = sensor_coords
+      bx, by = closest_beacon_coords
+      d = (bx - sx).abs + (by - sy).abs
+      sensors[sensor_coords] = d
+    end
+
+    sensors_coords = sensors.map { _1.first }
+
+    forward = []
+    backward = []
+
+    sensors_coords.combination(2).each do |a, b|
+      ax, ay = a
+      bx, by = b
+      da = sensors[a]
+      db = sensors[b]
+      if (ax - bx).abs + (ay - by).abs == da + db + 2
+        if (ax < bx && by > ay) || (ax > bx && by < ay)
+          forward << a
+        else
+          backward << a
+        end
+      end
+    end
+
+    a = forward.first
+    ax, ay = a
+    d = sensors[a]
+    cf = ax + ay - d - 1
+
+    b = backward.first
+    bx, by = b
+    d = sensors[b]
+    cb = bx - by + d + 1
+
+    x = (cf + cb) / 2
+    y = (cf - cb) / 2
+
+    puts x * 4_000_000 + y
+    ```
+  :replies: []
+- :author: kateba72
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0atlef/
+  :body: |-
+    ## Ruby ~13 ms
+
+    ```ruby
+    Day 15
+                       user system total real
+    Setup 0.000008 0.000004 0.000012 ( 0.000007)
+    Input parsing 0.000103 0.000042 0.000145 ( 0.000145)
+    Part 1 0.000090 0.000037 0.000127 ( 0.000128)
+    Part 2 0.012714 0.000296 0.013010 ( 0.013050)
+    ```
+
+    I looked at the numbers for part 2 and decided that I had to do a lot of optimizing, so I optimized the algorithm, maybe a bit too much. Looking back at the time for Part 1, the naive brute force solution would have taken ~10 minutes, so if I wanted to optimize for quickest solution, that would have been the better way.
+
+    For Part 2, I used a diagonal coordinate system to turn the sensor diamonds into squares. Then I only checked the lines where a diamond started or ended.
+
+    [https://github.com/Kateba72/advent\_of\_code/blob/main/2022/day15.rb](https://github.com/Kateba72/advent_of_code/blob/main/2022/day15.rb)
+  :replies:
+  - :author: captainAwesomePants
+    :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0audhv/
+    :body: Love the diagonal coordinates!
+    :replies: []
+- :author: mathem17
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0alfzg/
+  :body: |-
+    [Ruby](https://github.com/jzhang113/adventofcode/blob/d95083d71d99277c0cac5b4ba2b07d6cb58df892/2022/solutions/15.rb) 953/408
+
+    For part 2, I abused the fact that the problem only has one unique solution, meaning:
+
+    1. If we check a line and find it is covered by a single range, we can assume the whole line is covered and it isn't the right row
+    2. If we find a line covered by 2 disjoint ranges, there is a gap, which must be the point we are looking for
+
+    This mean we can work entirely with ranges, which is much faster than enumerating all the possible points. (Technically, the point could be on the edges, which would result in one range not covering the whole row, but I didn't run into that in my input)
+  :replies: []
+- :author: akanet
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0bexon/
+  :body: 'I spent some time trying to think of a very elegant, simple, and fast algorithm in Ruby. I''m very pleased with this result: [https://twitter.com/fulligin/status/1603369386085036032/photo/1](https://twitter.com/fulligin/status/1603369386085036032/photo/1), which basically finds the y-intercepts for all lines drawn on the map as if they were infinitely long, and then simply checks each of the rows for the missing beacon.'
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zmcn64/2022_day_15_solutions/j0cral9/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/15)
+
+    Video Walkthrough: [YouTube](https://youtu.be/EWLwgLgRFjc)
+  :replies: []

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

@@ -0,0 +1,49 @@
+---
+- :author: akanet
+  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0tmzbw/
+  :body: |-
+    After long thought, I've got my [Ruby solution](https://gist.github.com/vincentwoo/db6cf426bc3f5f6a23ad21e89315c383) running in a few seconds. I tried lots of different tricks, like running each search independently of the other on different subsets of nodes, but eventually got a full search working with both agents. A few things that were important were conceiving of each valve opening of having a total upfront value based on the current time, modelling the whole graph as just direct pairs between all valves, building in the opening time into those edges, and most importantly, having a good estimation function for being able to early terminate subtree searches. For example, if you have [20m, 10m] left for your agents, you can calculate an upper bound of pressure that can be released by looking at the minimum edge lengths remaining for each unvisited valve, and multiplying each of those valve values by the highest of your agent times, while decrementing that time by that minimum edge length.
+
+    I got 48th on part one, and 1935th on part two, lmao.
+  :replies: []
+- :author: ingOmar
+  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0ns731/
+  :body: |-
+    I was stumped on this until I reread Prof. O'Neil's comment a few more times along with his Perl code. And then I finally got it, and solved part 1 using a straightforward BFS in an iterative loop.
+
+    I couldn't figure out how to sync both players in part 2, and then moved to reducing the search space with Floyd-Warshall. Now because the graph is a clique of positive-valued nodes, with a few reachable from "AA" (but none of them pointing back to it), there's no point traversing from one node to another without opening its valve, so I can include the time to open a valve in the distance graph.
+
+    Then I realized that the part 1 solution can reduce to a straightforward recursive function, covered here:
+
+    [Ruby code](https://pastebin.com/hCYXAwD1)
+
+    There's no need to save any state -- it's all carried in the childNode array A, and by building a graph where the cost of going to a node includes opening its valve. Other people have said this as well.
+
+    Part 1 took under 0.500 sec on an 8-year-old macbook, so I didn't bother looking for an optimization.
+
+    For part 2, I ended up partitioning the post-Floyd-Warshall graph using `Array#combination(n)` where `n` was between 1/3 and 1/2 the size of the positive-flow nodes. Pre-calculation showed that (15!/5!) + (15!/6!) + (15!/7!) =\> 8437. Worst case this would take `0.500 * 8437 msec` =\> ~70 minutes, but it was all done in 20 minutes (and the solution was found in the most evenly balanced partition of 7 and 8 nodes).
+
+    Am I doomed to spend retirement doing programming puzzles (not that I'm anywhere near there yet)? If so, I know I'll be coming back to part2 to work out a faster solution. Please don't delete this thread for another 30 years.
+  :replies: []
+- :author: damyvv
+  :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0gkcxc/
+  :body: |-
+    Ruby Part 1 and 2 have a combined runtime of **278ms**.
+
+    The [code](https://github.com/damyvv/advent-of-code-2022/blob/master/solutions/day16.rb) is horrible, but performance is great.The basic idea of the algorithm is to consider all the valves we can move to. We compute how long it will take to move to a valve, and we also precompute how much pressure will be released in total by this valve using the remaining time. Then, if there are paths that have an equal distance, we only have to consider the path that has the highest potential pressure release. This drastically reduces the iterations needed, hence the low runtime. Also, the distances are not precomputed, but they are cached. This is more efficient, since we don't need all paths (for example we can skip all paths that have 0 flow rate, as we will never move to them, only pass them).
+  :replies:
+  - :author: Laugarhraun
+    :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0goxqz/
+    :body: |-
+      Your solution does not look correct.
+
+      > if there are paths that have an equal distance, we only have to consider the path that has the highest potential pressure release.
+
+      Highest potential _only for this valve_, right? But moving to the other location might have led you to more close-by high-pressure valves and would have been better.
+
+      Your solution happens to work for your specific input, but it's not a correct solution.
+    :replies: []
+  - :author: Healthy-Chemistry664
+    :url: https://www.reddit.com/r/adventofcode/comments/zn6k1l/2022_day_16_solutions/j0gmv8g/
+    :body: I tried your code and it didn't produce the right answer for me?
+    :replies: []

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

@@ -0,0 +1,17 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0p56hx/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/17)
+
+    Video Walkthrough: [YouTube](https://youtu.be/uwQoa2xkbfA)
+  :replies: []
+- :author: SnooConfections2453
+  :url: https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0maq3b/
+  :body: |-
+    140 lines of readable ruby code. Runs in a bit over half a second.
+
+    [https://github.com/ciscou/aoc/blob/master/2022/17.rb](https://github.com/ciscou/aoc/blob/master/2022/17.rb)
+  :replies: []

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

@@ -0,0 +1,111 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0uweyj/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/19)
+
+    Video Walkthrough: [YouTube](https://youtu.be/2L8gHiNnZ9w)
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0s1vh0/
+  :body: |-
+    Ruby, part 2. But it is annoyingly slow–takes about 12 minutes on my machine. Is it possible to speed it up without changing the approach?
+
+    ```ruby
+    # frozen_string_literal: true
+
+    require 'set'
+
+    file = File.open('input.txt')
+
+    @cubes = file.readlines.map(&:chomp).map { _1.split(',').map(&:to_i) }
+
+    @min_x, @max_x = @cubes.map { _1.first }.minmax
+    @min_y, @max_y = @cubes.map { _1[1] }.minmax
+    @min_z, @max_z = @cubes.map { _1.last }.minmax
+
+    @offsets = [[0, -1, 0], [0, 1, 0], [1, 0, 0], [-1, 0, 0], [0, 0, 1], [0, 0, -1]]
+
+    def outside(cube)
+      cx, cy, cz = cube
+      !(cx.between?(@min_x, @max_x) && cy.between?(@min_y, @max_y) && cz.between?(@min_z, @max_z))
+    end
+
+    def adjacent(cube)
+      x, y, z = cube
+      @offsets.each.map { [x + _1.first, y + _1[1], z + _1.last] }
+    end
+
+    def exposed(cube)
+      seen = Set.new
+      search_queue = Queue.new
+      search_queue.enq(cube)
+
+      until search_queue.empty?
+        current_node = search_queue.deq
+        next if seen.include?(current_node)
+
+        seen.add(current_node)
+        next if @cubes.include? current_node
+
+        return true if outside(current_node)
+
+        adjacent(current_node).each do |neighbour|
+          search_queue.enq(neighbour)
+        end
+      end
+      false
+    end
+
+    result = 0
+    @cubes.each do |cube|
+      x, y, z = cube
+      @offsets.each do |offset|
+        ox, oy, oz = offset
+        result += 1 if exposed([x + ox, y + oy, z + oz])
+      end
+    end
+
+    print("#{result}\n")
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0ti4hn/
+    :body: 'Ok, to speed up 100 times: use a set to store cubes instead of an array.'
+    :replies: []
+- :author: whezya
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0ryg57/
+  :body: |-
+    **Ruby**
+
+    [https://github.com/rbellec/advent\_of\_code\_2022/blob/main/app/daily\_problems/day\_18.rb](https://github.com/rbellec/advent_of_code_2022/blob/main/app/daily_problems/day_18.rb)
+
+    I did not found any Ruby solution yet in thread, so here is mine.
+
+    I never used a flood algorithm before, so this is my first attempt, benchmark gave me 2 sec on my computer. [Readme](https://github.com/rbellec/advent_of_code_2022/blob/main/README.md) explain how to use it. Would be happy to discuss about it.
+  :replies: []
+- :author: SwampThingTom
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0qht6f/
+  :body: |-
+    I'm solving each of this year's problems in a different language, roughly in the order in which I learned them.
+
+    Today's solution is in Ruby.
+
+    https://github.com/SwampThingTom/AoC2022/tree/main/18-BoilingBoulders
+  :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/zoqhvy/2022_day_18_solutions/j0op0zl/
+  :body: |-
+    _Ruby_
+
+    my part 1 solution is pretty compact:
+
+    ```ruby
+    cubes = ARGF.map { _1.split(',').map(&:to_i) }
+    puts 6 * cubes.size - 2 * cubes.combination(2).count{ |a, b| a.zip(b).sum{(_2-_1).abs} == 1 }
+    ```
+
+    for part 2 I plotted the thing in 3D ASCII art, did a flood fill from outside the corner, collected all the cubes that weren't filled, and subtracted their surface area (using my solution from part 1) from the total
+  :replies: []

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

@@ -0,0 +1,24 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j142h8c/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/19)
+
+    Video Walkthrough: [YouTube](https://youtu.be/FdZ_vpf-VEU)
+  :replies: []
+- :author: akanet
+  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j0tkaz7/
+  :body: |-
+    [Ruby](https://topaz.github.io/paste/#XQAAAQCBBAAAAAAAAAAlkUd1JxEvDhwoUT5C66Qze8FtdpxEzJYhvPke6qNjV4PA2OeOLQPreA1+6lfcYrgKm8Gq8wrgh9XN9tGh8PMAOkjwJbmMaPbeGa2JFbYbiQ9McQIo3cw3qvh1Ji/22fPb0wr9vMpep2wgEA1+U4iQ3Crqe3cPNymc83HiUEohFqNv8Xg552dPBw4BR0Zse85imqqc402jEEOFD+9eBeF78t17Gb7iPGWpbsLJMkhOmVDskfeJauN0Klgg92Ii31gLjD8SzUCMtf7r8k+cqVxs3JWlHxj77Ym79mEJ3EElGn7vHRaEAyCvRMW2+zv2JmPLdTAUbxpncHZRgO3sfqfgks74ao6TpJCHN0uvp5ZZQ5nK2S5xWa8tjet0lpE1TSzA6hZI6xWrY1c35XuBQjaAKus+VJb/2T9CpbzT/n8Eb3FtjdpAbaXrHJs/30B8y7ZlyebOsE4Nxe3q/z6Bd7Wa4N3csq8aljVrp3ZJgqMTKxW6pyPMmfdE2fQ/gGoIR5RDh7/br3yFbpubCzFSR1k0WbW8j/t37lS/O4qw2/xwwEqaAt3tyMz82sWehuuJWPY5WF9YyZ4WXTY9Tl0l+vEo3VcZ1xv1isgwwJarX/XUEalpLaT+Mv8LH614rIMpIGB9NlLS0zM32BNKpt7/+fl6OA==), 777/485.
+
+    Here's a very elegant and terse Ruby solution that runs quickly with only one, incredibly hacky optimization: do BFS search but rank each successor generation by their resources and robots, from geodes down to ore, and just keep the 5000 best ones. This is sufficient and sort of a marvel to behold.
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/zpihwi/2022_day_19_solutions/j0v1i6m/
+  :body: |-
+    [Ruby](https://github.com/globalreset/advent_of_code_2022/blob/main/day19/dayNineteen.rb)
+
+    Don't see a lot of Ruby posts popping up in here, so thought I'd toss mine in. Tried to format it in a readable fashion with lots of comments. Looks like most folks, I did a BFS of the possible states. I spent a while trying to get some caching working, but couldn't figure out what I was doing wrong. So my main speedups are mainly limiting when we build bots and when we hoard. Lots of trial and error to see what optimizations sped it up and what constraints led me to wrong answers. Final result runs in about 30s for both parts.
+  :replies: []

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

@@ -0,0 +1,127 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j18nj2y/
+  :body: |-
+    Ruby
+
+    Code: [Github](https://github.com/careyi3/aoc_2022/tree/master/solutions/20)Video Walkthrough: [YouTube](https://youtu.be/szXQTRybPAI)
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j12cr45/
+  :body: |-
+    **Ruby** , with rotating arrays:
+
+    ```ruby
+    $decryption_key = 1; $times_to_repeat = 1 # Part 1
+    $decryption_key = 811589153; $times_to_repeat = 10 # Part 2
+    data = $stdin.read.lines.map(&:to_i).each_with_index.map { |n, i| [n * $decryption_key, i] }
+    (data.dup * $times_to_repeat).each do |n, i|
+      data.rotate! data.find_index { |_, j| j == i }
+      value, _ = data.shift
+      data.rotate! value
+      data.unshift [value, i]
+    end
+    data.rotate! data.find_index { |n, i| n == 0 }
+    p data[1000 % data.length][0] + data[2000 % data.length][0] + data[3000 % data.length][0]
+    ```
+  :replies: []
+- :author: whezya
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j10t1i9/
+  :body: |-
+    **Ruby**
+
+    After deciding yesterday "_Hey, this is the perfect problem to write a "parsing with treetop" tutorial_" and finally not even touch the problem (yep, I make theses kind of choices). I decided to do an "Asap solution" for today problem.
+
+    I have multiple ideas to optimize it (linked list or doing arithmetics on indices only) and may try later but the current solution in o(n^2) runs in 6 seconds for problem 2 and is quite simple to understand.
+
+    https://github.com/rbellec/advent\_of\_code\_2022/blob/main/app/daily\_problems/day\_20.rb
+  :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xw35j/
+  :body: |-
+    # Ruby, 437/334
+
+    for part 1 I implemented a lazy inefficient method of keeping track of which number to move next: I just stored it in an array alongside its original index, and found the number by index before moving it.
+
+    I was shocked that this laziness still worked in part 2 with minimal code changes.
+
+    ```ruby
+    data = ARGF.readlines.map(&:to_i)
+    data = data.each_with_index.map { |n, i| [n * 811589153, i] }
+
+    10.times do
+      data.size.times do |n|
+        i = data.find_index {_2 == n}
+        v = data.delete_at(i)
+        data.insert((i + v[0]) % data.size, v)
+      end
+    end
+
+    i = data.find_index { _1[0] == 0 }
+    x = data[(i + 1000) % data.size][0]
+    y = data[(i + 2000) % data.size][0]
+    z = data[(i + 3000) % data.size][0]
+    p x, y, z, x+y+z
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0yin0g/
+    :body: |-
+      Exactly the same idea to use the number + original position.
+
+      There is a guy who uses Python and often uses complex numbers to store information. I wonder if he used them today, seems to fit well :)
+    :replies:
+    - :author: 4HbQ
+      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0yxzqw/
+      :body: |-
+        [Maybe](https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyug6hl/)[I](https://www.reddit.com/r/adventofcode/comments/zgnice/2022_day_9_solutions/izhzxb6/)[am](https://www.reddit.com/r/adventofcode/comments/zjnruc/2022_day_12_solutions/izw63we/)[that](https://www.reddit.com/r/adventofcode/comments/zli1rd/2022_day_14_solutions/j061f6z/)[guy](https://www.reddit.com/r/adventofcode/comments/znykq2/2022_day_17_solutions/j0kdnnj/)?
+
+        I did consider it, but plain tuples were nicer today. The complex numbers really shine when you can do mathematical operations on them, like adding coordinates etc.
+
+        In case you're interested, it does work and looks like [this](https://topaz.github.io/paste/#XQAAAQADAQAAAAAAAAA8HMAC0B10JGvJxk1ICqx0YTnnfz/f4KkcTEpfucim8ULWQSRYZBfXObTE2OdlMYGbQsY7+p1vB9dTESMHaog9kTvMa09i7wJBCx3J5GHdmWv98l/yxeHO65EExHVDflnmMdr0EygoA80iMjB2s7L6j8Tyo0WuMGummilYRJx1sJT+ptMYHKLSDQP/6DLmiXSNjNvx4HBrHWGB5W7K/8MkepJ8LYJK0gRTKP/Q5KxSJWG5b0+gBdrhpx/EqiylybH/+LazgA==).
+      :replies:
+      - :author: "[deleted]"
+        :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0z6eiz/
+        :body: |-
+          That guy: [https://www.youtube.com/watch?v=w9Sk7lvyGZI](https://www.youtube.com/watch?v=w9Sk7lvyGZI) :)
+
+          No complex numbers today, a linked list :(
+        :replies: []
+    - :author: jstanley0
+      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j114qpe/
+      :body: ooh, putting the original index in an imaginary part is delightfully perverse. I love it
+      :replies: []
+  - :author: Elavid
+    :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xyhwz/
+    :body: |-
+      I used Ruby too! I used a doubly-linked list where each node is a hash that contains the value, and links to the previous and next nodes. Each node also contains an extra pointer to the node that was originally after it in the input ~~(I didn't realize the input numbers would be unique, like you did)~~.
+
+      Your code runs in 7.0 s on my machine, and my code is only slightly faster at 6.4 s.
+
+      I thought my approach should be faster than the simple array style because it requires very little writing of data, but I guess I'm getting slowed down by having a big data structure that I have to read a whole lot. I have to traverse through nodes one at a time to find my insert positions every time I move a node.
+    :replies:
+    - :author: jstanley0
+      :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0xzk4s/
+      :body: My solution doesn’t depend on the numbers being unique. Are they? I just paired each number with its original position and searched for that to find which number to move. I’m sure it could have been done more efficiently but I was up very late doing the previous problem…
+      :replies:
+      - :author: Elavid
+        :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0y1df3/
+        :body: Oh yeah, you're right.
+        :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/zqezkn/2022_day_20_solutions/j0y2lsg/
+  :body: |-
+    # Ruby
+
+    Managed to fit my code into a half punchcard without making it completely unreadable (maybe only 60% unreadable [`n % 71` hehe])
+
+    ```ruby
+    [1, 811589153].each{|n|
+      a = File.readlines('20.in').each_with_index.map{[_1.to_i * n, _2]}
+      (n % 71).times{a.size.times{|i| a.insert(
+        ((j = a.index{_1[1] == i}) + a[j][0]) % (a.size - 1), a.delete_at(j))}}
+      p [1, 2, 3].map{|x| a[(a.index{_1[0] == 0} + x * 1000) % a.size]}.sum{_1[0]}}
+    ```
+
+    It's slow, takes 5 to 6 seconds on my machine.
+  :replies: []