advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,302 @@
+---
+- :author: RewrittenCodeA
+  :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/gi7u5ad/
+  :body: |-
+    # Ruby - 1.40 s for part 2
+
+    [https://github.com/rewritten/aoc-2020-ruby-3.0.0/blob/main/lib/aoc/2020/19/solution.rb](https://github.com/rewritten/aoc-2020-ruby-3.0.0/blob/main/lib/aoc/2020/19/solution.rb)
+
+    I am quite proud of it. It only uses Set from stdlib and \*no regular expression\*. And part two is achieved just by pushing the modified rules and heating the cache to just under boiling temperature.
+
+    The solution preheats a cache of words for each rule (`Hash[Integer => Set[String]]`), up to one or more given targets (by default 0, for the second embedded example and the actual problem input up to 42 and 31).
+
+    Then the cache is frozen, and strings are checked. If the rule is in cache, the code just checks whether the string is part of the cached values. If the rule is not in cache, it is split at each point and each of the two parts is checked against the possible combinations.
+
+    The check is done using two mutually recursive methods:
+
+    ```ruby
+    # tries to match parts of the string to the corresponding indices
+    # if only one index is given, goes back to the sibling method
+    # if more than one index is given, tries to match a prefix with the sibling
+    # method and the rest of indices with this method
+    def check_sequence(string, indices)
+      case indices
+        in [index]
+          check_rule(string, index)
+        in [first, *rest]
+          (1...string.length).any? do |position|
+            check_rule(string[1...position], first) &&
+              check_sequence(string[position..], rest)
+      end
+    end
+
+    def check_rule(string, rule)
+      return @cache[rule].include?(string) if @cache[rule]
+
+      # off cache, start recursion
+      @rules[rule].any? { check_sequence(string, _1) }
+    end
+    ```
+
+    The rules are stored as an array where the values are
+
+    - for atoms, the singleton array of the atom: `[…, ["a"], …]`.
+    - for non-atoms, the alternatives as lists of indices: `[…, [[42], [42, 8]], …, [[42, 31], [42, 11, 31]], …]`.
+  :replies:
+  - :author: zxywx
+    :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/gihahxf/
+    :body: |-
+      It's a really neat solution, and you should definitely be proud of it.
+
+      But ... I'm going to be \*that guy\* ...
+
+      You said:
+
+      > and \*no regular expression\*
+
+      Except for the regular expression you use on line 30:
+
+      ```ruby
+      @input.lines.grep(/\A#{build_re(0)}\Z/).count
+      ```
+
+      And line 36:
+
+      ```ruby
+      .grep(/\A(#{build_re(42)}+)(#{build_re(31)}+)\Z/) { Regexp.last_match.captures }
+      ```
+
+      And line 43 in the function named `build_re`:
+
+      ```ruby
+      "(?:#{@strings_cache[n]&.join('|') ...
+      ```
+
+      And line 53:
+
+      ```ruby
+      definition.split(' | ').map { _1.scan(/\d+/).map(&:to_i) }
+      ```
+
+      Otherwise, you're golden!
+    :replies:
+    - :author: RewrittenCodeA
+      :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/gijlyej/
+      :body: Scanning the input data for numbers cannot really be counted though, it’s just for the initial building and not once per “real” input line....
+      :replies: []
+    - :author: RewrittenCodeA
+      :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/gijlqzy/
+      :body: Yeah. I linked to master, and after posting that comment I got a solution using a bit of regexp that was 20x faster... I should have linked to the specific commit
+      :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggeajnr/
+  :body: |-
+    # Ruby
+
+    Went the regex route
+
+    ```ruby
+    r, messages = File
+      .read(ARGV[0] || '../input/19.txt')
+      .split("\n\n")
+      .map { |chunk| chunk.lines.map(&:chomp) }
+
+    rules =
+      r.map { |line|
+        line
+          .gsub(': ', '=>[[').then { _1 + ']]' }
+          .gsub(' | ', '],[')
+          .gsub(' ', ',')
+      }
+      .join(',')
+      .then { ?{ + _1 + ?} }
+      .then { eval _1 }
+
+    def create_solver(rules)
+      Hash.new do |h,k|
+        rule = rules[k].map { |subrule|
+          subrule.map { |subsubrule|
+            String === subsubrule ? subsubrule : h[subsubrule]
+          }.join
+        }.then { |res| res.length == 1 ? res.first : "(#{res.join('|')})" }
+
+        h[k] = rule
+      end
+    end
+
+    # Part 1
+    solver = create_solver(rules)
+    inital_rule = Regexp.new(?^+solver[0]+?$)
+
+    p messages.grep(inital_rule).count
+
+    # Part 2
+    solver = create_solver(rules)
+    solver[8] = "(#{solver[42]})+"
+    solver[11] = "(?<r>#{solver[42]}\\g<r>?#{solver[31]})"
+    inital_rule = Regexp.new(?^+solver[0]+?$)
+
+    p messages.grep(inital_rule).count
+    ```
+  :replies:
+  - :author: blitznep
+    :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggeq1x2/
+    :body: |-
+      Mind blown. This is fast compared to my method recursion method and is also idiomatic ruby. TIL a lot. Thank you for sharing.
+
+      edit: Could you explain or point me to the documentation/links for this part of regex `\\g<r>?`
+    :replies:
+    - :author: el_daniero
+      :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggji4s9/
+      :body: |-
+        Thanks, glad to be of service :)
+
+        As mentioned by petercooper, this is a recursive regex, or a _subexpression call\*_. I had actually not used recursive regex before, I just knew Ruby supported it. I searched the API and found [this](https://ruby-doc.org/core-2.7.2/Regexp.html#class-Regexp-label-Subexpression+Calls), which explains it pretty well.
+
+        The first backslash is there just to escape the second one inside the string, so in a regex literal it's just `\g<r>`. `<r>` references the named group `r` from the start of the expression, `(?<r> ...)`.
+
+        If you google recursive regex it's worth noting that some other languages, for instance Perl I think, use a different syntax.
+
+        Also, If you're interested, I could mention that by having recursive capabilities, the Ruby regular expressions are by formal definition no longer regular, as they can in fact handle content free grammars too, of which the new rule 11 from part 2 of the problem is an example.
+
+        \*) edit: A subexpression call doen't have to be recursive. It could also just reference a different group/subexpression. When it references itself it is recursive. With recursive subexpression calls, to stop infinite loops, `\g<r>` has to be optional; it could be suffixed with `?` or `*`, or be on one side of a `|`.
+      :replies:
+      - :author: blitznep
+        :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggkkli3/
+        :body: "Thank you \U0001F64F"
+        :replies: []
+    - :author: petercooper
+      :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggim43k/
+      :body: |-
+        Look up recursive regex.
+
+        This is a weak, super elementary example of how it works:
+
+        ```ruby
+        a = "a1b2c3d4-test"
+        a[/(?<r>\D\d\g<r>?)/] # => "a1b2c3d4"
+        ```
+
+        The regex basically refers back to itself recursively. `(?<r>...)` gives that capture group a 'name' of 'r'. And then `\g<r>` means to recursively use the 'r' regex in that position. Thereby, a regex referring back to itself!
+
+        You can use `\g` with numbered captures, but that wouldn't work in this solution due to all the captures in the built-up regexes.
+      :replies:
+      - :author: blitznep
+        :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggkkyoe/
+        :body: Thank you for the explanation.
+        :replies: []
+      - :author: el_daniero
+        :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggjl31y/
+        :body: |-
+          `a1b2c3d4` can also be matched with a simple repetition though, `/([a-z][0-9])+/`. But if you for example wanted to match a number of non-digits followed by the exact equal amount of digits, you will need something more powerful, such as recursion
+
+          ```ruby
+          "abc123456"[/(?<r>\D\g<r>?\d)/] #=> "abc123"
+          "abcdef123"[/(?<r>\D\g<r>?\d)/] #=> "def123"
+
+          "Xabc123"[/^(?<r>\D\g<r>?\d)$/] #=> nil
+          "abc12"[/^(?<r>\D\g<r>?\d)$/] #=> nil
+          ```
+
+          edit: correction
+        :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggcshz2/
+  :body: |-
+    # Ruby
+
+    This uses the \g recursive regex matcher for rule 11 in a pretty straightforward way.
+
+    ```ruby
+    rule_lines, input = open('inputs/19.txt').read.split(/\n\n/).map { |blob| blob.split /\n/ }
+    rules = {}
+
+    rule_lines.each do |line|
+      idx, rule = line.split /: /
+      rules[idx] = rule
+    end
+
+    rules['8'] = "42+"
+    rules['11'] = "(?<e>42 \\g<e>* 31)+"
+
+    re = "^#{rules['0']}$"
+    while true
+      nums = re.scan /\d+/
+      break if nums.length.zero?
+
+      nums.each { |num| re.gsub!(/\b#{num}\b/, "(#{rules[num]})") }
+    end
+
+    re.gsub! /["]/, ''
+    puts input.count { |line| line.match? /#{re}/ }
+    ```
+  :replies:
+  - :author: firetech_SE
+    :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggd40gz/
+    :body: |-
+      I had no idea that `\g` was a thing. Spent an hour or two rewriting [my code](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2020/19/rules.rb) (also ruby) to match and traverse "by hand", which took a few seconds to run afterwards.
+
+      After seeing this, I went back and updated my Regexp based code to use `\g`, and it now finishes in milliseconds :)
+    :replies: []
+  - :author: cloudcyrex
+    :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggegvlt/
+    :body: |-
+      This may not work in certain situations.
+
+      Given, for example, a message with 6 'chunks' of 8 characters, if the
+
+      - first three chunks are from the rule 42 set
+
+      - next two chunks are from the rule 31 set
+
+      - last chunk is from neither.
+
+      Example:
+
+      abaaabbabababbbabbbbaaaaabbaabaabaabbaaaaaabbaba
+
+      Having said that, I'm likely wrong given our different inputs.
+    :replies: []
+  - :author: zxywx
+    :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/gihozz9/
+    :body: |-
+      I've been playing around with this solution. As it stands, whilst it may work for your input, it returns the wrong answer for mine.
+
+      To correct it, change your override for rule 11 like so:
+
+      ```ruby
+      rules['11'] = '?<e>42 \g<e>? 31'
+      ```
+
+      - Switching to single quotes means you don't need to escape the slash
+      - Remove the trailing + from the pattern ... that would incorrectly match 42 31 42 31 rather than 42 42 31 31
+      - Change the asterisk to a question mark after the subexpression. asterisk incorrectly matches 42 42 42 31 31 rather than matching an equal set of pairs of 42 and 31
+      - Remove the parentheses ... you don't need them
+    :replies: []
+- :author: rsthau
+  :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggc3wtl/
+  :body: |-
+    Ruby -- full CFG parser. Guess I'm too groggy to figure out the easy way.
+
+    'each\_match' takes a token number, string, and starting position as an argument, and yields the position _after_ each possible match to the token beginning with the given starting position. each\_match\_s is the same, except with a sequence of tokens as an argument. For each line we're trying to check, try\_match just sees if there are any matches to token 0, starting at position 0, which take up the entire string.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDCBAAAAAAAAAA5GUqKNoFH6SMqoVC09YUYqTc3VgNgRsmA+kQ54tbkCJFH5qw6Ng5zgPQpU/pqVsXFKSruGOUtLTYF86cuAkswmrflCnL4KaxOUJ28FE9DgZ2Q9EVlMQIaQgNcUPw1bwToR7YFflS61Mhzo3mZb5WeQKWJI/56drE7mSHcDVs7Ct4JyE7uF12SfFqXgLOW3G1qLQYCsyCXh7sgZ4VTzus79AlWE7BByzMVYsdVxECEwLlDLRAcRbDZ7p26PbUe1Zp4S+WDvc+l3QjrpSsoKSbM+uJJavBlY+DI65OwZ4ecSX8oger7lI/dH9/tUFJaxaArT1eURDVux/lCy/8nbhnDk/LV9WxiTTmnj3kDeXT5B47l1MinI2CIRlgNjIlPk3Ch0e+V+h82UyutmRv4dFbefRYGeNuiBeiyNKIAq+AShP0zAI9z/KGMBpfy8bDOoQ9dPjOEurC4s7P/dGBQ+Bi+ddvO1G9drhjsAIthWRYnex+R0AiDv1yVbWqWVjTpfg/2ejnzDLJr9LkWOBtp3ClImDC2jg2I3GQVmpfULoxTbCy2F5Tlu/gcGZ/BpqLep7kmeXUpxcYnF74hsciCL2Gtq2iwAlvMqh1aaAOTucAzMcIDNrKnhl/j0wnGFYiqC6onwbWb8OCN+rThftYb9p18l1oW/8kBHrw=)
+  :replies: []
+- :author: billiamthesecond
+  :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggc5xu6/
+  :body: |-
+    # [Ruby](https://www.billiam.org/advent-of-code/19.html)
+
+    Really struggled with part 2 but this worked, I guess? (big regex with non-capturing groups to bypass capture limit).
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kg1mro/2020_day_19_solutions/ggca0qy/
+  :body: |-
+    **Ruby:** 50:21/57:43, 1436/616
+
+    Here's a [recording](https://youtu.be/qfZPtx4Kc_k) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/a5d87b70bbc662e3ddc72f24c2e4423c0e87fb8f/2020/dec19.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    This one was lots of fun! I didn't use regexes; I just expanded rule 0 into all possible strings. This obviously was too slow, so the key improvement was checking the prefix of what I had generated so far and bailing early if it wasn't a prefix of any of the messages. Using this approach also allows solving Part 2 without any code changes!
+
+    There were a lot of wrongs paths along the way though, including trying to simply the rule map by propagating the literals up, but that barely made it any smaller. I tried memo-izing my expand function, but that didn't do anything (obviously in retrospect because it would never get called with the same arguments twice...). The final code was definitely messy, but with just a bit of cleanup I made it solve both Part 1 & 2 in ~3 seconds.
+  :replies: []

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

@@ -0,0 +1,55 @@
+---
+- :author: rundmsef
+  :url: https://www.reddit.com/r/adventofcode/comments/kgo01p/2020_day_20_solutions/giln2a5/
+  :body: |-
+    # Ruby
+
+    Although Day 20 took me a long time to implement, I'm fairly happy with the solution.
+
+    My solution delayed rotating/flipping the contents of the tile until the final orientation was known. I found corner tiles and correct tile orientations by inspecting _only_ the tile edges. I applied the correct number of flips and rotations to each tile at the very end once the correct number of flips/rotations was known.
+
+    I prioritized code readability over performance but was happy with my solution to both parts executed in around 100 ms on my 2017 laptop. Seems good enough to me :)
+
+    I wrote up a more [detailed walkthrough of my solution](https://seththomas.github.io/advent-of-code-2020) that discusses my approach. Full code and unit tests in [github](https://github.com/SethThomas/AOC/tree/master/day20).
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kgo01p/2020_day_20_solutions/ggggp78/
+  :body: |-
+    **Ruby:** 11:17/2:32:56, 32/668
+
+    Here's a [recording](https://youtu.be/Iiim5_-vfWc) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/6a12ca035e9593c79d0bf083dd3965e00c521dc7/2020/dec20.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Leaderboard for Part 1!!! I realized pretty quickly that I could just look for tiles where only two of the four edges had pairs, but then was stumped for a bit because both the edge and its flipped version actually have a pair, so actually there are four edges that have pairs, not two.
+
+    And then Part 2... I started with a corner, then filled out my grid from there, which I did in layers: Assuming I had already place a square of tiles (e.g., (0, 0) through (l, l)), I would then fill in new tiles on the right edge, on the bottom edge, then finally the bottom right corner.
+
+    Then I had to orient all the tiles. I couldn't figure out how to determine the orientation of that first corner so that everything else would be at points with positive x and y, and not negative values. I just printed out the first tile and its neighbors and manually hardcoded the rotation for that top-left tile.
+
+    To figure out how to orient each tile I just tried all possible rotations and found the one where the edges lined up with a previously oriented tile. This was much easier than trying to figure out which edge matched up and remembering how that adjacent tile had been rotated and figuring out how to rotate the current tile to match it.
+
+    I manually oriented the top left corner, then oriented the top row by looking to the left, then filled all the remaining rows by looking at the tile above.
+
+    Once all that was done I just searched for all possible rotations of the sea monster, which, relatively speaking, was a piece of cake.
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/kgo01p/2020_day_20_solutions/ggg8ecn/
+  :body: |-
+    Ruby, 947/131
+
+    Yikes. This is cleaned up, of course. At least I sped up on part 2. So much typing...
+
+    part 1: https://gist.github.com/gurgeous/e53ab8bfde12b84e026578eb41c27fe7 part 2: https://gist.github.com/gurgeous/9a515a3cf36ddffcda5db5a98b1a4468
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/kgo01p/2020_day_20_solutions/gggkf8c/
+  :body: |-
+    ### Ruby
+
+    https://github.com/Sharparam/advent-of-code/blob/master/2020/day20/solution.rb
+
+    I didn't think about the trick for part 1 unlike some others and implemented the whole grid thing from the start, which I guess helped me get part 2 done, but it still took me ages compared to previous days.
+
+    For part 2 I reuse my `Tile` class and basically construct one giant tile for the map by successively combining (shaved) tiles and then I can use the existing manipulation functions on the `Tile` class to rotate it.
+
+    I quite like the name `shave` for the method to remove edges in part 2 :)
+  :replies: []

data/data/solutions/reddit/ruby/2020/21.yml

@@ -0,0 +1,72 @@
+---
+- :author: waferthinner
+  :url: https://www.reddit.com/r/adventofcode/comments/khaiyk/2020_day_21_solutions/ggoaii0/
+  :body: |-
+    ruby
+
+    Oddly , I found this one of the hardest yet. Then I realised two important details;
+
+    1. If an allergen is named for a food, the food must contain the allergic ingredient. As a result, we can find possible allergic ingredients for each allergen by taking the intersection of ingredients in foods that have that allergen
+    2. Since an allergen is only due to a single ingredient, we can prune the list of above possible allergenic ingredients until we have a single assignment for each allergen.
+
+    This effectively amounts to the work needed for parts a and b.
+
+    ```ruby
+    # Read data
+    foods = IO.readlines("input.txt", chomp: true).map do |line|
+      line =~ /(.+)\s\(contains\s(.+)\)/
+      {i: $1.split(' '), a: $2.split(', ')}
+    end
+
+    # If a food has an allergen, it must contain the ingredient with that allergen
+    # We can get possible list of ingredients for each allergen by taking the
+    # intersection of ingredients across foods with that allergen.
+    allergens = foods.map { |x| x[:a] }.flatten.uniq.sort
+    assigned = allergens.to_h do |a|
+      ing = foods.select {|f| f[:a].include? a }
+      [a, ing.map { |f| f[:i] }.reduce(&:&)]
+    end
+
+    # part a
+    ingredients = foods.map { |x| x[:i] }.flatten
+    invalid = ingredients - assigned.map{|k,v| v}.flatten
+    are_invalid = ingredients.map { |i| invalid.include?(i) }
+    puts are_invalid.count(true)
+
+    # Since an allergen can only be caused by one ingredient, we can prune this list.
+    while assigned.values.map(&:length).max > 1
+      known = assigned.select {|k,v| v.length == 1 }.values.flatten
+      assigned = assigned.to_h { |k,v| [k, v.length > 1 ? v - known : v] }
+    end
+
+    # part b
+    puts assigned.keys.sort.map {|x| assigned[x]}.join(',')
+    ```
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/khaiyk/2020_day_21_solutions/ggkz5uk/
+  :body: |-
+    Ruby! After giving up on yesterday's grid-based challenge, this logic-puzzle-like challenge was a welcome sight! I accidentally solved part 2 while coding part 1, so that was nice and simple.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBsCAAAAAAAAAARiEJHiiMzw3cPM/1Y611SZZzCokqVQwRwyl1Nd0tAtOAWiRIn5ZSurc+2/ZCrLkze/wH456VLwZbh7wjPPYM8mnmrZxZQCom9chzXxt271vML9B4fO751L8gonl4pC7hjWNxBdL03zTrndLgcs5uOnuYKj2NLbfE0vCf6pCeCdMagMXBheJfQEmzA+jHwaxNKocYb2QZ0N+EbNIcuqGW/ze/RJjxDuQNXlvcu+DTMu4Ic+kNd2jKskq9aFqhN0DeCQqlLhqHpVqvLoYnF1k1MbhIlMv8FUuTV5j10M+CtP7wsDX1lVeGFaYyd6ts5XXW+2Wj4wrqgV3LSJR4/mKRDUW+tewyeQDfvt/xEsPid061rL5CtEweageVHs/wKumx3tNz4eD52G+50wPpbV12dsX7Nlk5BpjOudSgWavIqpTQ9sn9wIrAaf6UkIl/hkHEfU+4WXiXapjvLOhRDMKPRjDEkylLgre7Cmyy9/oKL6KLdYEt4Y0mP0T7gKMlzEUerkWnMn4xumcfEOCV3QoK4gJJdnuMIVrDUT2RL0Pj5Pt0/i4XkKjkr69V5MUDRV2SW01CTw+LgWVodqPtg0zdRmM+JTy+fFgx/kuTUAoM/Qxn3rVmLQgBMpDKMUq7Yh/mzjmC3YJ1wHD5GTIjomjVQTwFc38TiUyk+uR/XqRYkD4FUUquXMm0HKgTNoD20i9FPd1wzBDHHYHFNlPQLc32Luat8ZA7Iitf0F4aidBEqUOF4q53iFmStEhKP/Qv97uFMABd5gEVMUTdMCggPGOaSGxin/Nz30PcOiUpSsdrj779xmDaOW5R7aJVhzl9kAd9mmTxVVriCkUH6DyYZtBT58QpDe2/ziDrkf3GPXSN0Gd9DaqfQvPtn6UvQvGPPeYhGJ57SnnD4tUGvQNNDO4nk1k+BNdmXC1CXB0kR5kETmXhxFkUiEckuti1PHvszo4L2tjeQZdkUmh0kLKAfGCllWzCM/LQMpVGZ+PQ+sm8Qw9y0MBvaJB4oZBG5g7OSRWubyzBOT6SEP1v+U9pA3jd26VEPlhdLiUzaoin7rwgqbrxqQaZtQ/R4Sg6iXbANMSsp2jrR7TW5NYtutdGcNwM+SDhUDR9gUllnC1ah4jerJR687gVwjH9yy/5YRMw=)
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/khaiyk/2020_day_21_solutions/ggkbhmc/
+  :body: |-
+    **Ruby:** 9:56/16:44, 60/118
+
+    Here's a [recording](https://youtu.be/ToWx0d7bu9w) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/ad5a568ccb5d7b08baa397aea9d326ffaea853b8/2020/dec21.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Another leaderboard! I think mostly because fewer people are participating though... Seems like Eric was nice and put the extra difficult ones on the weekend, but made sure we wouldn't be up too late on work nights!
+
+    I did Part 2 by hand to find my own solution, but then implemented an actual solution. I think I was confused enough between which ones were ingredients and which ones were allergens, that doing it by hand was probably faster. My variable names were a mess.
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/khaiyk/2020_day_21_solutions/ggk96z6/
+  :body: |-
+    Ruby, 723/1530
+
+    I found tonight's description very confusing for some reason. Maybe still tired from last night's marathon. After cleanup:
+
+    https://gist.github.com/gurgeous/659116ceaf352b0ddd102ba0d27c59c9
+  :replies: []

data/data/solutions/reddit/ruby/2020/22.yml

@@ -0,0 +1,49 @@
+---
+- :author: whereflamingosfly
+  :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggpsp86/
+  :body: |-
+    [Ruby](https://pastebin.com/HVSAYhnT)
+
+    I feel pretty good about this solution. At first I was storing the full decks for the recursive rounds in part two and had a solution that took over two minutes to run. I decided to hash the combined arrays instead which _significantly_ optimized things, and then I shaved off a bit more time using a set instead of an array for the previous rounds. Now my solution for part two takes just over 6 seconds, which feels acceptable for a Ruby implementation.
+  :replies:
+  - :author: waferthinner
+    :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggq0i3l/
+    :body: Using hash was a nice trick.
+    :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggp3oou/
+  :body: |-
+    Object oriented ruby approach again! This was a nice, straightforward problem. I enjoyed working through the bugs to get to the final solution.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAtDwAAAAAAAAARiEJHiiMzw3cPM/1Y611SZZzCokqVQwRwyl1Nd0tAtOAWiRIn5ZSurc+2/XZZwdLFzVXpd/FcrKfmMWZIPV2UnFVdxhTQxt/ebU9zXTfvZ+rTSqFhE8jECd87SC4YgMWgxv0yJDws9eMV4m/v0gEmOTeZpsopAr/VHZiJJ51zav3UWUfiNXaqlgdzrTi0acWB9gDiY8BSBdpMBas/Zns7vSJneZ6E21AWetzkqKzPI/W8p0+Bp1u/Do/qGDMtaHC7yjgLYQeuj2blqrY9HJbxZ0N6qoSQ04HghGo9D9kugw3eYvYZgS28b9A0k+SCWZXRSbxAGnEGkzTvkgZrEEzfYzbcIztcxE48zjUfKRIknMB8ikAQBdVRkLfRVQ52SrQJ/YVvDHu29Y01rwB5jXbgGEOhWzJTPcghIuDQds9irRJ7JgcXADVbhXqz3uR1HCNqfedAH1Fwq2+2HcP/DFPSHAO5XFnzZdg4kvKaQzKBVSTfuIhrJ4EDlFhKHkYTWdgE0eo0WKr0lDwc1senuxfdx7oP8ekqo2wSwqkG60VFVTnZhhKwKdGMeXc/7C22lZGnNTLozq0LMz2o8HAAYBKD9OLg9qPeCN8KNXjd9I3ThVFps62hIXIalroNVRtygFX7ZXWGwaN1WW0eOfM8d6ORSspItgp88uQg1qtEbIDPSABoXz4CF78w6Kgi/AD8reiz/XvS8TQZUIrUhfFr98VQEAZFwuNGvtehidpHeUmQGScNLtOW8NZqfmm4wTrDPRP+V3dqlSY9c+QhlSAlUsKZWlapLv5Xj6x6S3ScoTjnWY6XO12W2ThRfCw2SecCHkG7OAn6lvX5cIWN4f1vtk11rtdydBPI2M6xxEyZwgDl5Gq5j9XjAHNQg7H3+sVcULhDVFDqCrI6M2xe7ojn0jK3/GeQ6oATMhGcsBwXXSHwzlAX4EtG8Wq0rSTg9YTuxhS5Na9T2FBV1TPJMo0i7TwckvsUoWCA6gd8F3mjilDnbuWYALztle7CAQj/mfc1JkHUjm2SVg+lCaGWgpS9P3G4mfAbmgjLONl/oNSUDDxWElDQOC5APAVg7D7euG8foR3ybFcNMYT/eZmYvtP4sR9EMeaQYBjHwMnd1OSiMohrikgCQnfVd5mH6gVK4Wk8WKNFMKH63JrAmX4Wj/3TjpYLIgDDR33uPxTgRgu+BLXfVHQEwWfbyBvNOZVxaacrbAEDDaSCNtIbsg2CjN6VC29whOIS78IWkMEQoJeClgNXg9wN1BoXImqpFEnwT+nGODtJeWqoQM9ROIKwiKSG/jSemdeMje0AZNv5zoLy0xWPnV50tvc+eZ4aR8DBUuedGbXr66DNup/B7L0ghzND2V/4jpvxc7nDlwCzrYRkVQs54Gx1crDBK4XnvgXdfVUPR9fJmGVm1ALmOV6/wsHIvrWoqcycDdmuc5FF8SrVropBRkaUhKD1ArjlhRx709KM2xiUGJHdaPrR2+9Mcm4L8LMp1VlO+qvzPpH8g4jBZeS8tST+8p4avczS0iQ0K1Wk+djc1rotKTxfZVAy3SSysK/XdOya4mLfEBDIyPAuFsgfUIYYd89bxNa0i/3QJR7zuuLNDFnM3uKN9WjOpCbbjQ2ynRb4uWm9J048oxNajaDerJIUyxsy7r1iIZariPeL2tZCXnN31NQBLEa/1QBfAY7cqsNTDP/3G3tr)
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggo1pa4/
+  :body: |-
+    Ruby 1579/1095
+
+    As usual, this late in the month understanding the rules was the hardest part for me. Example blunders - "this game can have lots of players", "card history travels across games", "the bit about only copying a subset of cards". Code was not hard.
+
+    https://gist.github.com/gurgeous/4fd48093861a129455f2c2c19b1b2196
+  :replies:
+  - :author: DmitryShvetsov
+    :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggolq1o/
+    :body: Looks like a Hash performs much better as the `seen` data structure than a Set
+    :replies:
+    - :author: DmitryShvetsov
+      :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggom061/
+      :body: "... actually not \U0001F914"
+      :replies:
+      - :author: gurgeous
+        :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggrilu5/
+        :body: Yeah, in most languages set is just a wrapper around hash. Pretty sure that's the case with Ruby - https://github.com/ruby/ruby/blob/master/lib/set.rb
+        :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/khyjgv/2020_day_22_solutions/ggo3uq9/
+  :body: |-
+    **Ruby:** 3:30/24:24, 30/171
+
+    Here's a [recording](https://youtu.be/Zulmt3vHx9Y) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/70e313ebd4faffc31a3c5a564f58496d04022401/2020/dec22.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Breezed through Part 1, but then was endlessly confused by non-determinism as a result of modifying arrays that I had put into sets, causing set-inclusion checks to fail. But mostly a pretty straightforward problem.
+  :replies: []

data/data/solutions/reddit/ruby/2020/23.yml

@@ -0,0 +1,47 @@
+---
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/kimluc/2020_day_23_solutions/ggv5h83/
+  :body: |-
+    Ruby/C. I did the first part in Ruby and it would've taken about 3 hours to finish the second part, so I dropped down to C for that.
+
+    [part 1 in ruby](https://topaz.github.io/paste/#XQAAAQD5AQAAAAAAAAAxnUpFZEQ7Dc9Km5XXPYqAfqlYHxmpwd9cqnG+MaZ5/0KWPVHOBS7qDwVyWWHJq+zZnJMEu4tLHYJcfRia3gbAJZFoBfzJj0NLtLGFUcTLgcJW4HT/AeeiTs5soxnjU9z8yj2UaKuxnSaAhBsbAWzNNEps12HTsLSz/uPeQnl5cEB8rk5B4cvWOqka54xW4ddnp7r6hgfy7mwbltdA0BuMxuj3bFIzj5ucz1sAU4xVmFCbFYi/BHJm7erGmrINSKGHDMKNVTprdtqcvbC8wH70qYjCYgg+YN1jjF9uThlR/HvU5GpEftPCYFUMK0UrvotS9qKfa2T/655thTVHGRHz5t2sxwKMNmRd+mcap/P9kmYNm/9QiRZX1RgcMSsHsl8vgGvb/9kcPX4=)
+
+    [both parts in c](https://topaz.github.io/paste/#XQAAAQDXDwAAAAAAAAARmknGRw8TogB3OyPPwW5K8Q8ohQvj8m6aOXY901m0ltVAO4cA2jqlC6jcYxj0IWcYk2HBZHYQjqfd9uOoZUebiNZXGU4VIogXOGZ2MWV0rJhlqCizc5XX2e+MdgaJuOhEGY3iAUS+rYJf6WAb5O4Bgxph/kHvYgFzH7LEUi7AMWuqLFfptme2dc84Lt5mt4pZPRyGG+5Ax9sW+kZgRkD6o/75JyYbXeX/pCpeBVjtkn3r7hdkF8PTGj//8fmFLaFTHNvPVu8flp+Jlz5CYTyg5MVxKSjoHvobb+BDcVyfxX0WOQ95fDUX1QLapj881l73La3bwP5/kf85N5dpwfynJ1rwBUakFQPBSAlq08H6xNw+K5YH9kCR3Wc7AosI0zOwhSNpdVBL1poHcRj6lAOAP2l62BV1B7ywfeylB0yuXVNdWVjyiIxDNXfFtXpEk8wsPEYyV7RRIYrrvElZwADPBQDfA2TS47wAZTjPZ4lvUNMbWFnHx5eWkG1d9qOfhA4bkOeYm8xiYbLhtCxxG3/HHWGmZMJoG6Wq8e8Uy/z08TfJW/mjKHS6Kpfl8jkc9volly1pngONxj1nwDU54jhr+manq6AeOUGebW/Ope/jDDNSyoh38MzyOAXtI/3fyUOXv6tI+0K+5YFkoKnnFdE/aQ+HDUkjhktKBuAlquYKh59l0R00U4XCtCg8GpiiX0XGSqNv5jKUzEN9NTlL0XRhN6GAJOIowBvemEjU53sDTUMjd1uC3L5zqT1AQOZwnMP5D1++2Lo2i1Ft3WuVTQqWXMjAJDEz1h31FhqmZKRMEmqS0ZH6yr7mtFtMMrxwjA6JzTOYeKS+knF6yA6zq46L+DAoy4fNn2qjtJaxSVDGvjcaktqZOcgh0UjLkuypbxl5nL05bjArl0LSxXeSjbQgf8IMZA8aUDAj0a//Nd4TovClds+tgSQt37frk5sfyDknylpV6fQ050NNxZ9ACeiXAqmIl5DmLVYRSPql6jUITgmCflZIBAji25isfITIRzJuJ5U9LOcHoGgrK7NoNyQdXHecHkleztU05v7XhLeTMcNjMR98WXX2gHW+xjK8KdjQE9KDrSFxM1XBTPu7zIwLUNe6BaopPL0mfeqd9f/Fr7YJhBtewf5pTEWVRRDSdQhBPAlGQwtenVryljDv2zXHujd/UO6DU+OZM2qehSLQsmefnvs6r0o5JnosWK6vIAdFN20ePORG1XrXxflhi4BwMpfumaXLnOOARg6TJneWYFD7mTxZ6h01kFN05falGqyv0E8fP10Wtk5OviRR69bJitpYahmylUDX7+ehAy6kH3UD3ldrnL14v/G6FnvVUDBezCaBQNuIo8ed/P8bgp8C4xkWaHXoCM56lp+B6rpLWJew5BrdxIZZds69Jon0GnbTfkOW9FXilERGEdFMVM7NIzIlBoR1IBaJl35WL8vkxWCkRkHKAgAdbzITjoHTZbOm9bYFG5CHFn8ayBoR6kMjzioNbBt4e2be1AvdbcO08X/xtwDtgn4X2e/SVAfqGP0XESUSwEmUMHiZ+b/I/7LuC2kmtcp3A0iMI2UUIInLk46WD852QELQkHbRAkZ2bVNTqGZcTLFPGcJo5CbUndGJAEvlHF9O1W4+6fcziNJFGDZkPtUNWwxGReqx/enfFNodq/c7hqZCM46hWZ00mHw2NjjTyAffJd41LuHlZfkQKTFs4WjkuN+vYUnip6w8Qr2k/1i6rP9im+KpoGwobv/c8Or0)
+  :replies: []
+- :author: DmitryShvetsov
+  :url: https://www.reddit.com/r/adventofcode/comments/kimluc/2020_day_23_solutions/ggs0wvz/
+  :body: |-
+    # Ruby
+
+    part 1 [https://github.com/dmshvetsov/adventofcode/blob/master/2020/23/1.rb](https://github.com/dmshvetsov/adventofcode/blob/master/2020/23/1.rb) (rank 3504)
+
+    Using `slice` and `rotate` which is obviously not efficient for rotating millions of cups for the part 2.
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kimluc/2020_day_23_solutions/ggs3970/
+  :body: 'Ruby, part 2 (rank 699): https://gist.github.com/jablan/417ba0613c922ce641c1ce20ada607e7'
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kimluc/2020_day_23_solutions/ggs4at8/
+  :body: |-
+    **Ruby:** 14:00/2:06:14, 233/1534
+
+    Here's a [recording](https://youtu.be/4TuoXaQTf6Y) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/4380a8edd9fa47feb1a7e5042af347e2fecd7fee/2020/dec23.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Ugh, debugging arbitrary linked list operations on lists with a million elements did not go well.
+
+    I made the mistake of trying to rearrange the order of the three cups, the current cup, the destination cup, and everything else, all at once. This meant I had to handle special cases when the destination cup came immediately after the three cups, or right before the current cup.
+
+    If I just read the instructions very carefully, I would have seen that it makes it clear that there are really two separate operations:
+
+    - First, remove the three subsequent cups from the list, and complete the circle with those cups removed
+    - Then, add those three cups after the destination cup
+
+    And if you just implement those two parts separately, it's really quite simple.
+
+    I also spent a lot of time getting my cup initialization to work both for a million cups, and for just the initial ten cups (which I need to test on the example).
+
+    What a struuuuuuuugle. In the constant struggle to finish the problem as fast as possible, it's hard to take a step back and reconsider your approach, especially when you always feel like you're "almost there." This is definitely one of those times where taking a break and coming back with fresh eyes would have made it go a lot faster.
+
+    Also bummed I forgot to commit my super messy initial solution before cleaning it up. :(
+  :replies: []

data/data/solutions/reddit/ruby/2020/24.yml

@@ -0,0 +1,57 @@
+---
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/kj96iw/2020_day_24_solutions/ggwp9je/
+  :body: |-
+    Ruby. This is... very slow. The last days in part two took 20-30s each to run. Tons of easy optimizations stick out to me, but I don't have time for it today. There's a URL in a comment in my part one solution to a resource I found for how to represent a hexagonal map in memory, definitely was struggling before I found that.
+
+    [part one](https://topaz.github.io/paste/#XQAAAQAzAgAAAAAAAAA5GUqKNoFH6SMqoVC09YUYn9dyScbAm+68s6htXWf25N/3txBhbUKWLTSVh6xlx7SLnupNGuugcoHGgI8/YMxkE1k6YxeabHb5Vt3XrC0XZZrjCgK+DwYmplJ1Itii/TK5vuHPALIiX8sCFIjegQ0rtekE7eet+fuQNxjvuPPXxTVs9EtjPF49w4pcV1NDYbw83R+Q6W9t06AL2l4RVXjZ+goBQ6d5XS9lrAoXd3XlzNFVP2I/oXH/LYuu1xxzLnxbEDTce1MwiRfh5l0RmKTdnuC9ek83nnYSFycyDwd/NTGNVCH3FAlPOVkzvfPpTPHNgb01GzmtKg/U3zNlCKqV3dEM5QgYPbgrnSUcHvz4FcYLpVzSVGnSGS0ATCJpYyn5HwtigdrqQlmNPlQ+637JX5vIo2XFBHWv3s4X8z+sb8rS3PbMuCxkJh3I5Dtma1HgdqL2BtxFd5hNxIP8Xri6)
+
+    [part two](https://topaz.github.io/paste/#XQAAAQCXBQAAAAAAAAA5GUqKNoFH6SMqoVC09YUYn9dyScbAm+68s6htXWf25N/3txBhbUKv7kuqyQJgJG263A4op3Z4VcdHLNOI7NZeDIyaAtKd5PwEh/MbERuAhH4yMTTAam2llbd/XtggAU8Rg/K0Wnqi92KMcpVof8b9rfKs3w10Qu8MTxTQ9frkOOnGp0Bk3mq6jJp7XKhnhqm28Ap1YaVNizqukPs15/NO61/NOYGTzPj+2+qHZjVGXqR0Z9+hWr/szKN2FoE6/fA2F0u+xHE2duw9BkY7ZD/byLm8heZ+gdbzbmeio1EY5SlEvVtDo6C4Ttf0ax10gmRSFk94m0hoMJiYS2tk3gHW9B4Wsm4moby36WnHcL2OhAzERDemeQjqluI4YG5AWU+6/JMEnBbyzVd8qHg3ev7NB+emrCChtmhIYcBHjkyu+owxlKwcUlUbq5obOdcDn1acm8SVket0YjFJJxpoHrA4ZP4SfK1U7YLJwmM8rmZEjdTz5ZWVxv/n5PqwCjskdoR5sI3Oz8TZDGVXYbr1gf7Sq2yif1HKrCvwgOsIpaW+HbfEwXIqNaQtsMeyX4Bl4VGIOhzUzH1z20FEm8I3mt/mZ5xQM/JDdfuGqEmcmKeR0NirCJ/h0ZEUf8wp7ASKA68sy9dXUj1WhKsnAfzkt8siRJ4DvDsTHAcKKKMNT0M0+0Vio8t9/K8ruruGrnoNSV+rUNvMqbyOHivA8QtPHjb5HVLimuOVuf+guwxL)
+  :replies:
+  - :author: mr_banana_lord
+    :url: https://www.reddit.com/r/adventofcode/comments/kj96iw/2020_day_24_solutions/gk87yyh/
+    :body: |-
+      faster ruby solution [https://github.com/MrBananaLord/adventofcode/tree/master/day\_24](https://github.com/MrBananaLord/adventofcode/tree/master/day_24)
+
+      I have stored only black tiles
+
+      btw I wrote also a processing script which visualized the outcome [https://github.com/MrBananaLord/processing/tree/main/adventofcode](https://github.com/MrBananaLord/processing/tree/main/adventofcode)
+    :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kj96iw/2020_day_24_solutions/ggvn5vr/
+  :body: |-
+    **Ruby:** 10:31/20:42, 314/254
+
+    Here's a [recording](https://youtu.be/FUA022PPjSM) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/dee2a66799a6eb34192d2869e98ccfb59c85c08c/2020/dec24.rb). (I've streamed myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend), and I'll finish strong tomorrow!)
+
+    Pretty tough leaderboard today. In Part 1 I didn't make the north and south directions properly opposites (I had northeast and southeast go up and down, then northwest and southwest both went one to the left.) Then in Part 2 I accidentally converted something to an array, which blew up the run-time. Had I not done that I probably could have finished a minute or so sooner. Overall pretty minor mistakes, so I'm decently satisfied with how I did.
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/kj96iw/2020_day_24_solutions/ggvjjn1/
+  :body: |-
+    Ruby 241/1279
+
+    My original implementation used the 3d approach from https://www.redblobgames.com/grids/hexagons/. I implemented it quickly but it ran slowly on part 2 and cost me many minutes. Here's the cleaned up version:
+
+    https://gist.github.com/gurgeous/e78b9b06566821e9013df444c97a5c72
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kj96iw/2020_day_24_solutions/ggvv73y/
+  :body: |-
+    Ruby (1193/867):
+
+    https://gist.github.com/jablan/27bb4969af8ff736a35a070358b6e492
+  :replies: []
+- :author: DmitryShvetsov
+  :url: https://www.reddit.com/r/adventofcode/comments/kj96iw/2020_day_24_solutions/ggvvqyt/
+  :body: |-
+    # Ruby
+
+    part 1 [https://github.com/dmshvetsov/adventofcode/blob/master/2020/24/1.rb](https://github.com/dmshvetsov/adventofcode/blob/master/2020/24/1.rb)
+
+    thought I will speed up the instruction parsing process by expanding the initial directions [e, se, sw, w, ne, nw] from already calculated parts of instructions, but it worked fast even without dynamic programming technique.
+
+    part 2 [https://github.com/dmshvetsov/adventofcode/blob/master/2020/24/2.rb](https://github.com/dmshvetsov/adventofcode/blob/master/2020/24/2.rb)
+
+    One resource that helped with the idea of how to make [coordinates for hexoganal grid](https://www.redblobgames.com/grids/hexagons/)
+  :replies: []