advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,201 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdcswsg/
+  :body: |-
+    Fun today messing with pattern matching... Partial manual for part 2, but still fast etc.
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/14)[Video Walkthrough](https://youtu.be/Ta9mF9YuLBg)
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdbokqb/
+  :body: |-
+    No half-punchcard-sized solutions for both parts yet? Here's one
+
+    ```ruby
+    a = STDIN.readlines.map{ _1.chomp.chars }; def r(a) = a.reverse.transpose
+    def f(a) = a.map{ |r| r.chunk{ _1 == ?# }.map{ _1.last.sort }.flatten }
+    def l(a) = a.map{ |r| r.each_with_index.map{ _1 == ?O ? _2 + 1 : 0 }.sum }.sum
+    p l f r a; 4.times{ a = f r a } until i = ((c ||= []) << a)[0..-2].index(a)
+    p l r c[((1_000_000_000 - i) % (c.size - 1 - i) + i)]
+    ```
+
+    `r()` for "rotate", `f()` for "fall", and `l()` for "load".
+
+    North is to the right!
+
+    To get the rocks to roll, this program `chunk`s each line into continuous `#` and non-`#` runs, then sorts the contents of each run. This moves the `O`s to the right of the `.`s and keeps the `#`s in place.
+
+    Execution time on a Snapdragon 865 is 3.2 seconds. Adding `# frozen_string_literal: true` at the top of the file reduces that by ~10%.
+
+    Here's a drop-in replacement for `f()` that reduces total runtime to under 0.9 seconds: [paste](https://topaz.github.io/paste/#XQAAAQAsAQAAAAAAAAAyGUj/Tv+WAV3g/Epryrh8/EkGcaOk2Vq/TzdNF3JIxxliAwe73NuADxZL1UqbLlDPlP1BSWDzX265F9rQceiT3VKKrtzFhN9hkWUz4uKRVnQjVjpCKH8tY8Wr/O/SEUYEG8n2FVbUu5kXHqJF8e6AzlrpGOvaPDZw+3Dn7PaKB43Uf1qd6KfmhX6hDA/1Ih8giCPGvQs7UaBiguCuIWFDCkdloSHE5qxaFd1VXAASaq+NmGwf/7WTyQA=) — very straightforward; just remembers where the next rock should roll to as it iterates through each line. `.`s get replaced by `nil`s because it's a little faster that way. Converting all the single-character strings to integers to begin with saves another ~10% on runtime.
+  :replies: []
+- :author: glebm
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdadna3/
+  :body: |-
+    Both parts start with `tilt_north` and `north_load` functions:
+
+    ```ruby
+    def tilt_north(data)
+      data = data.map(&:dup)
+      (0...data.size).each { |y|
+        (0...data[0].size).each { |x|
+          next unless data[y][x] == 'O'
+          new_y = (0...y).reverse_each.lazy.
+            take_while { data[_1][x] == '.' }.reduce { _2 }
+          if new_y
+            data[new_y][x] = 'O'
+            data[y][x] = '.'
+          end
+        }
+      }
+      data
+    end
+
+    def north_load(data)
+      (0...data.size).lazy.filter_map { |y|
+        (0...data[0].size).lazy.filter_map { |x|
+          data.size - y if data[y][x] == 'O'
+        }.sum
+      }.sum
+    end
+    ```
+
+    Part 1:
+
+    ```ruby
+    data = $<.readlines(chomp: true)
+    puts north_load(tilt_north(data))
+    ```
+
+    Part 2:
+
+    ```ruby
+    def transpose(data) = data.map(&:chars).transpose.map(&:join)
+    def reverse(data) = data.reverse
+
+    def tilt_south(data) = reverse tilt_north reverse data
+    def tilt_west(data) = transpose tilt_north transpose data
+    def tilt_east(data) = transpose reverse tilt_north reverse transpose data
+    def cycle(data) = tilt_east tilt_south tilt_west tilt_north data
+
+    def cycles(data, n)
+      seq = [data]
+      cycle_begin = 0
+      loop do
+        data = cycle(data)
+        idx = seq.index(data)
+        if !idx.nil?
+          cycle_begin = idx
+          break
+        end
+        seq << data
+      end
+      return seq[n] if n < cycle_begin
+      seq[cycle_begin + ((n - cycle_begin) % (seq.size - cycle_begin))]
+    end
+
+    data = $<.readlines(chomp: true)
+    data = cycles(data, 1000000000)
+    puts north_load(data)
+    ```
+
+    In part 2, we define `tilt_south/west/east` in terms of `tilt_north`, transposition, and reversal. We then cycle until we find a configuration that we've seen before, indicating a repeating pattern.
+
+    https://github.com/glebm/advent-of-code
+  :replies:
+  - :author: globalreset
+    :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdafdnz/
+    :body: I had no idea lazy enumerations were a thing in Ruby. Love this about AoC, just finding out about unique language features that I wouldn't otherwise see.
+    :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdad6l7/
+  :body: |-
+    3905/1478
+
+    My solution wasn't too hard in Ruby, the brute force for part 2 took 13 seconds. I need to find someone who made a tutorial on how they find, and utilize, the cycle information in this. Is it just 'cache the state after every iteration and when you find a full cycle that matches a previous cycle, the number of cycles between them is your cycle count'? Then you just skip X times those numbers of cycles to get you close to the end and simulate the rest?
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/14/solution.rb)
+  :replies:
+  - :author: e36freak92
+    :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdaf7h4/
+    :body: I stored cycle start and cycle length, then the result is the load from cycle loop\_start + ((total\_cycles - loop\_start) % loop\_len).
+    :replies: []
+  - :author: schveiguy
+    :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdag59k/
+    :body: |-
+      The way to find cycles is to use Floyd's Tortoise and Hare algorithm: [https://en.wikipedia.org/wiki/Cycle\_detection](https://en.wikipedia.org/wiki/Cycle_detection)
+
+      That tells you that there _is_ a cycle, and then you need to measure the cycle by running it once.
+    :replies:
+    - :author: globalreset
+      :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdahfp4/
+      :body: It's hard to figure out how Floyd's applies to these grid states. But I'll chew on this a bit and see if I can make the connection.
+      :replies:
+      - :author: schveiguy
+        :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdc1k8j/
+        :body: You compare the entire grid (at least that's what I did). Remember, you are just running the same algorithm, on one grid you run it 2x per step, on the other you run it 1x. then compare at each step and see if they are equal -- this means there's a cycle. It's cheap enough because you are comparing what, like 100 strings? If there wasn't a cycle, yeah, it would be super inefficient, but once you get the cycle, you can stop and skip to the end!
+        :replies:
+        - :author: globalreset
+          :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdffpla/
+          :body: Ah! I get it. Run 2 different grids at different rates until they match let's you skip all the storage, so you're only ever storing one grid for the tortoise rate and one for the hare rate. Thanks for clarifying! That's going to come in handy.
+          :replies: []
+  - :author: globalreset
+    :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdaez2b/
+    :body: okay, tried what I thought the trick might be and dropped 10 seconds off my runtime. 3 seconds is still pretty slow, but my rock moving is probably not the most efficient solution either.
+    :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdagghb/
+  :body: |-
+    165/776
+
+    Reminds me of the one last year. First version was a bit messy, this one is cleaner.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQCmAwAAAAAAAAAyGUj/TzqOZqu+85MIr+7I2PN0WUff+HeS/WSf1Fe62O1gtVpl8OjMxtl/mhz9FSocwvtz4RdGpsL1Re/3qZhzm9C3LM7XtpH3TBE91Whglx5p6C36lD9FCX71oyeCcfUQ0nIPQX85mZYeDnmO9pRJ3lS5xFaBMRozGIgacXXv/TS7kWytUCvfMtvJ/nMhTMalZbD21+steDVdBSwziMIX8n+/kJfukSfyHRs+x2B/jUgpeDZ/TluULjsq6RkPkALQ2Vc6twgYgUZvmcDg3+Y3iz5aAupStQHtkxAC8YQOtSe5W3sWEMKvsO31XQH2RZv41gkyn+IiRN00boU5SvRNrKrW0WLfK+SFRzZTP+WLgzHpNQaE+jeEyObrGaNC0kWiPE7oH3TT11GazIZUfEZr6axFqiTpqi6ArDslX5lIrVPmVfytbjQFfV/T+mJHeu4/JgLHwaMoehSjZZsJey/DVwkqdWmfUroBMSQFQMC25UVo30y1dcdOosZGpxPSh4w68w3t/T2K59YyY7yaoJACT7s6iHQZN6rLszUis2aA+2NFhs6Wj1FSohX87BkOADPHsodB+Nsi8erZLeW3apbCKG4PJBc+0f2rR0U=)
+  :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdauk3g/
+  :body: |-
+    [Language: Haskell]
+
+    Ruby solution runs in 200 ms, and Haskell in 50 ms. Both implementations represent the grid as a pair of (height\*width)-bit integers (one for the blocks, one for the rocks) and use bit-shifting to determine which rocks can move and move all movable rocks simultaneously. This is the same technique as is used to make the fast 2021 day 25 and 2022 day 23 solutions.
+
+    Ruby: [14_parabolic_reflector\_dish.rb](https://github.com/petertseng/adventofcode-rb-2023/blob/master/14_parabolic_reflector_dish.rb)
+
+    Haskell: [14_parabolic_reflector\_dish.hs](https://github.com/petertseng/adventofcode-hs-2023/blob/master/bin/14_parabolic_reflector_dish.hs)
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18i0xtn/2023_day_14_solutions/kdc1uax/
+  :body: |-
+    Nothing special from me today I guess
+
+    clockwise rotations are done with reverse.transpose
+
+    after that I can always drop in the same direction by using a quick&dirty regex in a while loop
+
+    After each cycle I check if the load has been seen in the history already, and break the loop when the history repeats the first time
+
+    Takes about 3.5s to complete
+
+    ```ruby
+    m = $<.map(&:chars)
+    getload = -> { _1.map.with_index { |b, i| b.count('O') * -~i }.sum }
+    drop = -> { _1.gsub!(/(O+)(\.+)/, '\2\1') while _1.include?('O.'); _1 }
+    hist = []
+
+    loop do
+        4.times do |i|
+            m = m.reverse.transpose.map { drop[_1.join].chars }
+            puts "Part1: #{getload[m.transpose]}" if hist.empty? && i == 0
+        end
+
+        hist << load = getload[m.reverse]
+        si = hist[..-2].rindex(load)
+        len = hist.size - 1
+        next unless si && hist[si..-2] == hist[2 * si - len...si]
+
+        len -= si
+        puts "Part2: #{hist[si + (1_000_000_000 + ~si) % len]}"
+        break
+    end
+    ```
+  :replies: []

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

@@ -0,0 +1,248 @@
+---
+- :author: Alkyonios
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdjwijt/
+  :body: |-
+    [Solution](https://topaz.github.io/paste/#XQAAAQBVBwAAAAAAAAAxmwhIY/VDibXTN1fVPjOQKOvNhTjhh6MlGoy6ibz1iEMOgACrQ5UT6jZCV2MNYRyRjfcPzt7zUln0NoxniFxfK850joUc7UXz65mcQykbFCHKmeB61AlecR4ZUlQWWWT5eePwbOgiMawUdgPMHezxMAPYChpDRZ/18RsF1kYif2mAW7rsyEgP+UPKjWdJC74VBzSlGDTZDhK1wqGSa6+uCaZApJ8LmfyHImGYOYTxTLpigPYtwUceSRKpR3dDeKUD2wruV9tPiMV5ffbcH/yeV4AvkxgQ9FzG7L5oiyNhyytH8ZdeM0cekBIaR7UYumuD+8L2UPCvNowUppzTrzaVynz+K89qyeBizCH9TuoMFPt1IccNJbe7rQSH848ec8FniInEUdSImWUpuFG5YWaKLq3JMBCUAnclPMOIxWF8M7F1L5V9AOJP1dT6jiEqejOT/gvuwVUM0lbyUntFRgCnRHBYml7uCGQwlu17rGIO+om4mqhWctvmj7132imC8Ks+zbGeGVhVxfJmZLoY+zWT5Bvn+vbHI/GjUPd9anMiMXU33GDBUnPbUBmgMAxmTXqNbIM08uJCXqYgLk4bfQIJEtKgXiG4jW79DRcvHVo+s3e60h0Z8QFpKUxeqsv6xtdAMY5PGfEoGZaOO7m9jP1c1RJVJXlv9lkaYs2gmZMagoG0d+KQ57epRi88OYvkW5P2SPhOXpssz1jyDH5W+mLF9dcNE1hQocbMkQlhQefFxLiWjGhNPZqay9LsUYpwf+4MMgf0vtLaUDkS9l1bAwLLt67egX7s/0g0nQA=)
+
+    It took an embarrasing amount of time to figure out what "relevant box" meant in part 2, otherwise smooth sailing.
+  :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdj3gsa/
+  :body: |-
+    [Part 2](https://github.com/SleepingInsomniac/adventofcode2023/blob/master/2023-12-15/part_2.rb)
+
+    ```ruby
+    sequence = File.read(File.join( __dir__ , 'input.txt')).chomp
+      .split(',')
+      .map { |s| s.split(/(=|-)/) }
+      .map { |s| s[2] = s[2].to_i if s[2]; s }
+
+    class Hashmap
+      def initialize = @boxes = Array.new(256) { {} }
+      def hash_value(string) = string.chars.reduce(0) { |v, c| ((v + c.ord) * 17) % 256 }
+
+      def perform(key, op, value = nil)
+        case op
+        when '=' then @boxes[hash_value(key)][key] = value
+        when '-' then @boxes[hash_value(key)].delete(key)
+        end
+      end
+
+      def focusing_power
+        @boxes.map.with_index(1) { |b, i| b.values.map.with_index(1) { |v, bi| v * i * bi } }
+          .flatten.reduce(0) { |total, v| total + v }
+      end
+    end
+
+    h = Hashmap.new
+    sequence.each { |instruction| h.perform(*instruction) }
+
+    puts h.focusing_power
+    ```
+
+    Is it cheating to use a hash map in the hash map implementation? haha.
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfzzzq/
+  :body: |-
+    Already put up a solution, but this one deserves its own comment
+
+    ```ruby
+    def h(s) = s.chars.reduce(0){ |a, x| (a + x.ord) * 17 % 256 }
+    p STDIN.read.chomp.split(?,).tap{ p _1.map{ |s| h s }.sum }
+      .group_by{ h _1[/\w+/] }.map{ |k, v| (k + 1) *
+      (v * ' ').scan(/(\b[a-z]+)=(?=(?:.+\b\1=)?(\d+))(?!.+\b\1-)/)
+      .uniq.each_with_index.map{ _1[1].to_i * (_2 + 1) }.sum }.sum
+    ```
+
+    Who needs data structures when you can `Regexp`!?
+
+    ```ruby
+    /(\b[a-z]+)=(?=(?:.+\b\1=)?(\d+))(?!.+\b\1-)/
+    1(\b[a-z]+)=
+    2 (?=(?:.+\b\1=)?
+    3 (\d+))
+    4 (?!.+\b\1-)
+    ```
+
+    1. Capture the first available lens label that's followed by `=`.
+    2. Positive lookahead: Search as far as possible (`.+` is greedy) for a matching lens label + `=`.
+    3. If (2) exists, capture all consecutive digits following its `=`. If not, just capture the digits after the first `=`.
+    4. Negative lookahead: If there are any instances of the label followed by `-` after the first `=`, the match is invalidated and the regex looks for another label.
+
+    `.scan` finds all matches of the regex. For example, `"aa=1 aa=2 aa- os=4 aa=6 os=5"` becomes `[["os", "5"], ["aa", "6"], ["os", "5"]]`. `.uniq` preserves order of the first instance of each element, deleting the second `["os", "5"]`, but the first one already has the `"5"` due to the positive lookahead. All the `aa`s before the `aa-` get ignored due to the negative lookahead.
+  :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfea3e/
+  :body: |-
+    Part 1 Solution
+
+    ```ruby
+    sequence = File.read(File.join( __dir__ , 'input.txt')).chomp.split(',')
+
+    t = sequence.reduce(0) do |total, string|
+      current_value = 0
+
+      string.chars.each do |char|
+        current_value += char.ord
+        current_value *= 17
+        current_value %= 256
+      end
+
+      total + current_value
+    end
+
+    puts t
+    ```
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfpx7r/
+  :body: |-
+    Easy half-punchcard day again
+
+    ```ruby
+    l = STDIN.read.chomp.split(?,).map{ _1.split(/\b/) }
+    def h(s) = s.chars.reduce(0){ |a, x| (a + x.ord) * 17 % 256 }
+    p l.map{ h _1.join }.sum; p l.group_by{ _2; h _1 }.map{ |k, v|
+      a = {}; v.each{ _3 ? a[_1] = _3 : a.delete(_1) }
+      (k + 1) * a.each_with_index.map{ _1[1].to_i * (_2 + 1) }.sum }.sum
+    ```
+
+    - I'm still a bit disappointed with how long my part 2 code is here. Surely there's a shorter way to do it...
+    - I used a funny trick for parsing the commands. `split(/\b/)` splits on word boundaries, so `"aa=0"` =\> `["aa", "=", "0"]` and `"aa-"` =\> `["aa", "-"]`. This means I can just check for the existence of the third element in the array (`_3 ? ...`) to decide what to do.
+    - Ruby guarantees Hashes stay in order, so no extra ordering code needed for that part of the problem statement.
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdg8a2m/
+  :body: |-
+    Mercifully easier than the last few days!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/15)
+
+    [Video Walkthrough](https://youtu.be/cVG4S9MZ_pg)
+  :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdgbuzp/
+  :body: |-
+    ```ruby
+    input = $<.read.tr("\r\n", '').split(',')
+    hash = ->(l) { l.bytes.reduce(0) { (_1 + _2) * 17 % 256 } }
+
+    boxes = {}
+    input.map do |l|
+        lbl, op = l.split(/[=-]/)
+        box = boxes[1 + hash[lbl]] ||= []
+        i = box.index { _1[0] == lbl } || box.size
+        op ? box[i] = [lbl, op.to_i] : box.delete_at(i)
+    end
+
+    puts "Part 1: #{input.sum(&hash)}"
+    puts "Part 2: #{boxes.sum { |(i, b)| i * b.map.with_index.sum { |l, j| -~j * l[1] } }}"
+    ```
+  :replies: []
+- :author: RelativeLead5
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdgoi4d/
+  :body: |-
+    PARTS 1 & 2
+
+    ```ruby
+        sequence = File.read('input.txt').split(',')
+
+        # part 1
+        def hash(s)
+          s.chars.reduce(0){ (_1 + _2.ord) * 17 % 256 }
+        end
+
+        p sequence.map{hash(_1)}.sum
+
+        # part 2
+        # Fortunately Ruby will keep the ordering of hashes for us
+        #
+        boxes = {}
+        (0..255).each{|i| boxes[i] = {}}
+
+        sequence.each do |step|
+          if step.chars.last == '-'
+            label = step[0..-2]
+            boxes[hash(label)].delete(label)
+          else
+            label, lens = step.split('=')
+            boxes[hash(label)][label] = lens.to_i
+          end
+        end
+
+        p boxes.map{|no, lenses|
+          (no + 1) * lenses.each_with_index.map{|s,i| (i+1) * s[1]}.sum
+        }.sum
+    ```
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfg60v/
+  :body: |-
+    This was straight-up a reading comprehension problem. I probably wasted 2 minutes on part 1 because I couldn't accept how easy it was. And another 10 minutes on part 2 because I had no clue what it was trying to say with the boxes and focal lengths. I eventually got there.
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/15/solution.rb)
+  :replies: []
+- :author: Unhappy_Adeptness_93
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfk34a/
+  :body: |-
+    [Github solution](https://github.com/andyAtChime/advent_of_code/blob/solutions-2023/2023/code/day_15.rb)
+
+    This was real easy, once I grokked the prompt. Bummed there's no scale problem to solve today, but nbd, off to bed!
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfk8om/
+  :body: |-
+    Pretty straightforward IMO. Only took a few minutes and got it right on the first try, which is rare for me. Ruby makes these problems real easy.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDwAQAAAAAAAAAyGUj/TxK9OVMABPZ1+6kdVpmDcy636sJnvuQ9xEHSh/N4El930DvPBYXafRaInATDNw2+ta4UMyG+hWEGO6MiAJhm2q6S+1NEgtkb+fLJFq4o5ckQ4k7+Tx+GYY8nM2FwbmHCyI2LkahpnEkJQjXbe0JAuXfY5374G/77MhHYKWaGolc3iin/X3Juh/aZYZM1yZxV1Cvz2xxtcSq4eKaTmn6DShqcO2cSrBb/xY9sMP1AnEqkGoinghLyKAzAAT1/4vuPQgFy2s27VtuA1Mpv5u26wChELg8o3Ugu47DSK01+fv3cj4JOMMIKECz8IhA9gne+/5VybgP0aLo0pUbtPBeA/+2vhcNVnqqACmP67NCHRChqsN083MIUHf1Nec97XNVTlQy3WkYhwyfgDJqT/uSOF1VVjJAZm53mmWj7tQY0dVCP+0JlpA==)
+  :replies: []
+- :author: Annual-Management613
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdftvfj/
+  :body: |-
+    ```ruby
+    # frozen_string_literal: true
+
+    class DayFifteen2023
+      def self.part_one(lines)
+        lines.sum { |line| line.split(",").sum { |step| calculate_hash(step) } }
+      end
+
+      def self.part_two(lines)
+        boxes = Hash.new { |hash, key| hash[key] = {} }
+        lines.first.split(",").each_with_object(boxes) do |step, acc|
+          label, sign, focus = step.split(/([=|-])/)
+          box = calculate_hash(label)
+          acc[box].delete(label) if sign == "-"
+          acc[box][label] = focus.to_i if sign == "="
+        end
+
+        boxes.sum do |box_id, lens|
+          lens.values.each_with_index.sum do |value, index|
+            ((box_id.next) * (index.next)) * value
+          end
+        end
+      end
+
+      class << self
+        def calculate_hash(label)
+          label.chars.reduce(0) do |acc, digit|
+            acc = ((acc + digit.ord) * 17).remainder(256)
+            acc
+          end
+        end
+      end
+    end
+    ```
+  :replies: []
+- :author: stanimirov
+  :url: https://www.reddit.com/r/adventofcode/comments/18isayp/2023_day_15_solutions/kdfxje1/
+  :body: |-
+    part 1 (76 characters):
+
+    `p File.read(?i).strip.split(?,).sum{|s|s.chars.inject(0){(_1+_2.ord)*17%256}`
+
+    part 2 (325 characters):
+
+    `p File.read(?i).strip.split(?,).map{|s|[s.scan(/\w+/)[0].chars.inject(0){(_1+_2.ord)*17%256},s.tr(?-,?=)]}.each_with_object(Hash.new{_1[_2]=[]}){|b,h|h[b[0]]<<b[1]}.transform_values{|v|v.map{_1.split(?=)}.each_with_object({}){|(l,f),h|f ? h[l]=f.to_i : h.delete(l)}.values}.map{|i,l|l.map.with_index{(1+i)*(1+_2)*_1}.sum}.sum`
+  :replies: []

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

@@ -0,0 +1,50 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdn3qv8/
+  :body: |-
+    Simple enough one for today, relatively easy part 2 aswell!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/16)
+
+    [Video Walkthrough](https://youtu.be/v6RRjYtKZp0)
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdku2vm/
+  :body: |-
+    I had to visualize in order to debug my implementation, as always. Fun vector math in there.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBtAwAAAAAAAAARiAtiSZmv5W81CEWn2ldCAgetNtQcNTWMJW3x9RERU/qSgOgOyl0i2EBY2pG2rjun37SjK/wfQuoGDrY0vbfaYJlby+LJV3hN04Vzt7BkwuWUXe0hvtn0T3oedYSccPBPc/EquONkD0ayk2xic/8FQU+MC9qv0E+H+A8M6MGXUoqY0gQrfBT6DOgx4CYECRm7MuGpsJ2ustySNRuaAJJVmE6bptToK0/b/KwkzChYrUxzjPmNtA4v/zBSykwYkNlu3Yge/12O+TX4VIzwFr/fiovveuMItj/Y3o1TG+d3RemXhHdLHOvjTfeVp+30c7DVWXb9s/p4Ac1KZirbOLMfvuxDk7X+UhZmpObQja54oaxrEtwqykMRsUtaH6TMEm7QT5jf3i7jpopy3RSyzRvZBHBB+H9b/B5zYNA1ULULbgKaLGOtoRdfvPW0yVKtXjzbFAjiCfoYam/x4gsH4FNvam/SHHOwefPJl7+GWMx0RiMtilg2BQ2wlRlKsczt46+ozrHIykZbNF/gvt3eXayEYii3e4LGNdgs2xXTnqw/s6Jjb4nOCnoqHXZ0ycv2auM/Zti9BHDi22aBHX5b2QET/b3OvA==)
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdl0q2i/
+  :body: |-
+    Spent so long debugging this. I was immediately very happy with my solution. Short and efficient enough. But I had a bug in part 1 until I figured out that I should start one space off the map for how my routine was written. Then in part 2 it turned out that starting one space off the map made a lot of sense.
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/16/solution.rb)
+  :replies: []
+- :author: RelativeLead5
+  :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdmb639/
+  :body: |-
+    PARTS 1 & 2
+
+    [pastebin](https://pastebin.com/E60df0LL)
+  :replies:
+  - :author: selbysaurus_
+    :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdmvwl4/
+    :body: How fast was this for part 1?
+    :replies:
+    - :author: RelativeLead5
+      :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdngqru/
+      :body: Around 10-12 milliseconds on my mac m1.
+      :replies:
+      - :author: selbysaurus_
+        :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdoc3nc/
+        :body: |-
+          Yikes! Mine was taking just over 10 seconds, and after much refactoring I realised the difference was your use of `Set` instead of an array for storing the visited points. One quick change and I'm faster by a factor of 1000.
+
+          Time to go and read up about sets, I think!
+        :replies:
+        - :author: RelativeLead5
+          :url: https://www.reddit.com/r/adventofcode/comments/18jjpfk/2023_day_16_solutions/kdouu7f/
+          :body: Yep, quite the difference and the number of visited nodes isn't even that large but searching arrays is pretty slow.
+          :replies: []

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

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

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

@@ -0,0 +1,75 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18l0qtr/2023_day_18_solutions/kdxofxy/
+  :body: |-
+    More or less a day 10 repeat!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/18)
+
+    [Video Walkthrough](https://youtu.be/oZDYH-c4_3c)
+  :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/18l0qtr/2023_day_18_solutions/kdxk8y7/
+  :body: |-
+    For part 1, I just did a flood fill. I thought "Ordinarily they'd probably say multiply each dig distance by a billion in part 2, but this time there are colors and they're not used in part 1, so they've gotta be involved in the second part!"
+
+    I did not imagine that those large distances were hiding _in_ the purported colors. Well played, Eric.
+
+    For part 2, I gathered the polygon edges into horizontal and vertical line segments, organized by Y coordinate. I then scanned from top to bottom, covering the Y coordinate of every row that contained a horizontal line, and scanning once for all rows vertically between horizontal lines, multiplying by the number of rows covered.
+
+    Scanning went as follows:
+
+    - for vertical lines crossing this Y coordinate, I enter and exit the polygon on pairs of X coordinates as I scan from left to right, adding up the area covered while inside
+    - for horizontal lines on this Y coordinate (which are sorted by starting X and processed alongside the vertical line intersections), I add the width of the line and consider whether the intersecting vertical lines go in different directions (one up, one down):
+      - if they do, we will cross from interior to exterior or vice versa after processing this line segment
+      - otherwise, we will not
+
+    My code is more complicated than those who knew the Shoelace Formula and Pick's Theorem (which I somehow failed to learn on day 10 but will definitely keep in my quiver for next time around!), but the concept was clear enough in my head that the [code](https://github.com/jstanley0/advent-2023/blob/main/18.rb) worked perfectly on the first run.
+
+    Note that this code processes the part 1 input twice, with the flood fill and the scanning algorithm, as a sanity check.
+  :replies: []
+- :author: GMarshal
+  :url: https://www.reddit.com/r/adventofcode/comments/18l0qtr/2023_day_18_solutions/kdv3ktc/
+  :body: |-
+    2681/2823
+
+    Posting because no one seems to be posting ruby anymore! This was a struggle and i had to google a bunch of things about polygons.
+
+    [part 1](https://gist.github.com/thecog19/96f5a59e8780fec77d8d92f232770240)
+
+    [part 2](https://gist.github.com/thecog19/64bd518b3c3c9b525f3b705fd1ca58c6)
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/18l0qtr/2023_day_18_solutions/kdv3r5y/
+  :body: |-
+    (Part 2)
+
+    ```ruby
+    input = File.read("2023/18/input2.txt")
+                .split("\n")
+                .map{|l| l.scan(/#(.{5})(.)/).to_a.flatten}
+                .map{|l,d| [l.to_i(16), d]}
+
+    length = input.sum(&:first)
+
+    dir = { "3" => 0-1i, "0" => 1+0i, "1" => 0+1i, "2" => -1+0i}
+
+    pos = 0+0i
+    path = []
+
+    input.each do |l,d|
+      path.unshift pos += dir[d] * l
+    end
+
+    puts path.each_cons(2).sum{ |a,b|
+      (b.real - a.real) * (b.imag + a.imag) >> 1
+    } + (length / 2) + 1
+    ```
+  :replies: []
+- :author: RelativeLead5
+  :url: https://www.reddit.com/r/adventofcode/comments/18l0qtr/2023_day_18_solutions/kdvvg9u/
+  :body: |-
+    Pretty straightforward. I really thought the colors were going to mean something more doing part 1, so I started thinking about how I might generalize for part 2, lol.
+
+    Parts 1 & 2: [Pastebin](https://pastebin.com/8vHYczGc)
+  :replies: []

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

@@ -0,0 +1,92 @@
+---
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/18ltr8m/2023_day_19_solutions/ke5y75c/
+  :body: |-
+    (Part 2)
+
+    ```ruby
+    workflowsInput, _ = File.read("2023/19/input2.txt").split("\n\n")
+
+    @workflows = { "A" => ["A"], "R" => ["R"] }
+
+    workflowsInput.split("\n").map do |w|
+      name, rules = w.scan(/(.+){(.+)}/).flatten
+      @workflows[name] = rules.split(?,)
+    end
+
+    def solve(list, ranges)
+      current, rest = list.first, list[1..]
+
+      return ranges.map(&:size).reduce(&:*) if current == ?A
+      return 0 if current == ?R
+      return solve(@workflows[current], ranges) unless current.include? ?:
+
+      attr, comp, value, target = current.scan(/(.)([<>])(\d+):(.*)/).flatten
+      ix = "xmas".index(attr)
+      value = value.to_i
+      lower = comp == ?<
+
+      r, cr, rr = ranges[ix], ranges.dup, ranges.dup
+      cr[ix] = lower ? r.min..value-1 : value+1..r.max
+      rr[ix] = lower ? value..r.max : r.min..value
+
+      solve(@workflows[target], cr) + solve(rest, rr)
+    end
+
+    print solve(@workflows["in"], [1..4000] * 4)
+    ```
+  :replies:
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/18ltr8m/2023_day_19_solutions/ked1kfe/
+    :body: This is what I have been trying to do but couldn't work out how. Good job.
+    :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18ltr8m/2023_day_19_solutions/ke2pze2/
+  :body: |-
+    Fun one today, similar appraoch to contract large numbers using ranges as was used in a previous solution this year.
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/19)
+
+    [Video Walkthrough](https://youtu.be/ck-owPcU5pA)
+  :replies: []
+- :author: grimlyforming
+  :url: https://www.reddit.com/r/adventofcode/comments/18ltr8m/2023_day_19_solutions/ke2bt2u/
+  :body: |-
+    I know an instruction-set emulation with conjunction/disjunction problem when I see it, but I needed about 2 hours to figure out what to do. The key insight came when I jotted down the constraints, hoping for an inductive epiphany.
+
+    Let R1 denote a hash of 4 ranges, initially { x: (1..4000), m: (1..4000) }
+
+    So f(R1, "A") = R and F(R1, "F") = nil
+
+    Then with a condition: F(R1, "<condition>R,A") =&gt; count(R11) + count(R12)</condition>
+
+    More concretely, F(R1, "a\>1716:R,A") =\> count({a(1717..4000)...}
+
+    and that lnx rule: F(R1, "m\>1548:A,A") =\> count({m:(1549..4000),...}) + count({m(1..1548)...} = count(R1)
+
+    So every step needs to return two lists of ranges: the one that it operates on (either Accept, Reject, or call a further function), and then the complementary list of ranges that don't meet the criteria.
+
+    So now I can get a statement for a rule like qs:
+
+    F(Rx, "s\>3448:A,lnx") =\> count({s:(3449..4000) intersect Rx.s, ...}) + F['lnx']({s(1..3448) intersect Rx.s, ...})
+
+    Evaluate F['in'](R1) and when it finally returns, that's the answer.
+
+    https://pastebin.com/rn1VWhG4
+  :replies: []
+- :author: GMarshal
+  :url: https://www.reddit.com/r/adventofcode/comments/18ltr8m/2023_day_19_solutions/ke06v22/
+  :body: |-
+    1855/1545
+
+    [part1](https://gist.github.com/thecog19/851948b144d945d5b29c05da4d922543)[part2](https://gist.github.com/thecog19/970698333714c3cd7338eb7d2697b83d)
+
+    A pretty neat solution involving range math. Its very verbose but I like that its understandable. Essentially each \> or \< is a split operation that divides the range.
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18ltr8m/2023_day_19_solutions/ke0czap/
+  :body: |-
+    I nearly leapt from my chair when my part 2 worked first try (well, after it parsed cleanly). Skimming around here, I worry I might've over-complicated it, but I went with a DP-like solution where I explored every path that got me to an A, trimming down my 'xmas' ranges as I passed through each piece of each rule. And it came out pretty readable for me, so I'm happy with it.
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/19/solution.rb)
+  :replies: []