advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,249 @@
+---
+- :author: adjudicator
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gflr8bq/
+  :body: |-
+    OO Ruby:
+
+    https://pastebin.com/wR4j041i
+
+    Just using the 90 degree neg/swap vector rotation trick. Still took a while to figure out!
+  :replies: []
+- :author: odlp
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfkejes/
+  :body: |-
+    [Ruby](https://github.com/odlp/advent-of-code-2020/blob/main/day-12/solution.rb)
+
+    Enjoyed cracking out `Array#rotate!` ([ref](https://ruby-doc.org/core-2.7.2/Array.html#method-i-rotate-21)) to adjust the direction in part 1!
+  :replies: []
+- :author: willkill07
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfjy87o/
+  :body: |-
+    # Swift
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAKCAAAAAAAAAA0m0pnuFI8c4GDemuKS6NnNxbsUIBZ1PBVtHNiuwjq8Qk8GVq20+X09OWAuALN2UVWvl6h0A0MQ3N5G/M7yGoSR8eJo1GbatXfAWSxaYO1i6UlYkLCuNmE4B8KhFv2h3Z/5qJMqd6gt9Gk1XMUXUVUODpI6bv5mwuVa8dExIX8Ps7PUMg6qEPNMwa1KFAyimZZ/+5v/+C7xo+DAiRPQd60EmWhFNR3F3a55H80vhY+LtcCgL9MYWVizAaD7Iw1AxN+K7xAj97DsGUkVKF4a8fBMAn/G+AZL+h6BgFGKIvtKD8XaNC5CtAXV7xxD4JlL0qZi2xBUDGuZpGB+6g3TevngMFSL8hKSb3npuPWumMAmVktiRyYC4V54zX4ytBAT/tLzAY67toiK1xORpfz5hmmSeeaoJYdSMYXn5rWssaueme+5cjovlD0Mdm8pXzYIHEva4bHtamQQYTP1iRWmINJ/CzwBBYg6nVPQWVdEOirVnkHg+LANZra1n2819wX9+E4NMXkZnATp8NzkGlCdDXPekg53czlziYmInueicf9XBKw4Cm9R+2asGsJ6SYJHmk+z6dGd9/DFkitaRD5CTu+NYsG/SlQdAwaWu4CD414elfxdsdPmE8lhMKLKSeHuSsDjH/HwVk4DVfCMnHbxxs3to/yqqlh2Kaf04ipECnVLFLdFXDbybFMa/f/Fk4qz8BzmD+XnFi1L8Ege7qP93QP27ZPqkQALmfseOvmdNU6GoCtUM2wYVCwYAj1z2byuEtQWjzcPI1hsYin/JFKfHEisXF0S2AmWAS9M4+WVIVg4pzRyY1xo5w5OFBZKZ0gkvUy6qM3vpP4uf5C/IPI1g+RCoPfVqhbo2wlw4KMAcNDC8y+kUdulkoy/4qYMkg=)
+
+    My first swift program (ever) for Advent of Code! -- pivoting and going to try to do 25 different languages this year.
+
+    Done: C (2) , C++ (6) , Java (3), OCaml (1), Python (4), Bash (5), Swift (12) Todo (well, ones to choose from): F#, Haskell, Lisp, C#, Javascript, Typescript, Perl, Ruby, Scala, Rust, Assembly, Kotlin, FORTRAN, D, Go, Nim, Awk, Sed, Perl
+  :replies:
+  - :author: its_a_gibibyte
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfkblw5/
+    :body: This is an awesome idea, and a cool way to familiarize yourself with a bunch of different languages. What about Raku? If you're planning on doing Perl anyway, it'd be nice to do them one after another and compare the two.
+    :replies:
+    - :author: willkill07
+      :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfl7nx4/
+      :body: |-
+        Well /u/ **abigail** mentioned that I have Perl twice to choose from... so I’ll add Raku to the potential list
+
+        I have some familiarity with most of these, so it’s just a matter of **doing** it
+      :replies: []
+  - :author: __Abigail__
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfk9wvu/
+    :body: Perl twice? Good choice.
+    :replies: []
+  - :author: i_have_no_biscuits
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfk6bu5/
+    :body: |-
+      ... GWBASIC?
+
+      Come on in, the water's lovely!
+
+      (You can dip your toe in the water with QBASIC if you want...)
+    :replies: []
+- :author: parentheses-of-doom
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfi249v/
+  :body: |-
+    [Ruby](https://github.com/Prajjwal/advent-of-code/blob/master/2020/ruby/day_12.rb)
+
+    Had a bit of fun with this. Modeled ferries as objects aware of their location in a 2d space that you can issue commands to.
+
+    Runs lightning fast, too, since the cartesian transforms are just static lookups.
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfiw6qf/
+  :body: |-
+    # Ruby
+
+    Kept it [short and sweet](https://gist.github.com/peterc/ef27494a081c48334d1ef29ff67f9f4c) today. I don't do both solutions in one file so mushed them together here.
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfhsb4b/
+  :body: |-
+    Ruby, 50/305
+
+    Cleaned up version below. I misread part 2 and was diligently calculating the distance between the ship and the waypoint, sigh. I admire those who can do this quickly with complex numbers.
+
+    https://gist.github.com/gurgeous/925b29e43f1f0203985f40bb799fd752
+
+    Edit: here's how you do it with Ruby's Complex number support. I gotta learn this https://gist.github.com/gurgeous/a719b780fa5b117ec5a8f6ede5280985
+  :replies:
+  - :author: ald_loop
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfhsjry/
+    :body: |-
+      > sigh. I admire those who can do this quickly with complex numbers.
+      >
+      > 50/305
+
+      Does not compute
+    :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfhsbhf/
+  :body: |-
+    Ruby 744/1520. My brain absolutely shut down trying to figure out how to do the L/R rotations in part two.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQCpBgAAAAAAAAARiAqGkkN7pUjVWW5N06C9m0mxVKYwp83rTcRiKZucKy4ybNfbMp0Ut7lQYAGdIiY8Ss+49n+2YO5gh8nFh4IluugFFJd3MqZpehAvPqerIS/eDJJ2lyaUXh9xddAmGUA0ojALOLzyegeztuXdWijKBp8cEPi0NK7+91NXXH/EhX8o5hu7nYFFl4On5dMfZvkztMvb3fPtC6TGigR9H7AFB2A/pk8coLYV3mGmhrEPnZHPq5pP7zf/zYc+QoJz0xkPD/6QKN/Jrs6G1iDx49lR5RMaensNbQPWgMptlmx6kX6mTCM+ibVSDl9A8iR9E7iyTh0mopQ3Skv2luUBJCk0uDJVnfso2BGS4GuhOhGkC2Xe9G6tVRlGMn0SNsteteL4PjNn+vJJCVcRWZbKwvbGqrts/7x5zolt/H4SLZX48cW9Y1Vc5ONnIBk2ojQae/HDyU3vPX/RBaP5BM+672pBjqKRu+wfOPuudYBojizeRH5PGf/gUtHPJVHzfubM+ULS6VDU53wuH0Aggi5Ebrhn9i2/0zpt70KzKpvU4ycvVx9Nz7pBJv/2rpp4)
+  :replies:
+  - :author: sentry07
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfhtb5p/
+    :body: I misread the second part and thought it was still rotating the ship. Then I fixed it and screwed up an if statement and my 180 rotations weren’t happening. I shouldn’t do these when I’m tired.
+    :replies: []
+  - :author: nospamas
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfi5fdd/
+    :body: If you ever need a reference in future googling for "Coordinate rotation rules" or "Coordinate rotation table" will get you something like [this](https://useruploads.socratic.org/V4G3pprQT5evsH3JS5Zy_9D861043-9375-4DC6-85EE-5FDA751F5053.png). You could probably work it out with a piece of paper but way easier to google.
+    :replies:
+    - :author: frontpageminus
+      :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfkcc48/
+      :body: Yeah, that would’ve been much easier than drawing it out. Thanks!
+      :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfhxo8f/
+  :body: |-
+    # Ruby
+
+    5458/4751
+
+    [https://gist.github.com/Clashbuster/b66c950a6ad762a378d5c3c54d78c1a5](https://gist.github.com/Clashbuster/b66c950a6ad762a378d5c3c54d78c1a5)
+  :replies: []
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfi05h8/
+  :body: |-
+    # Ruby
+
+    Nice easy one for Friday. Got to bust out some complex numbers to help simplify the rotation calculation for part 2 ironically enough. :)
+
+    [pastebin](https://pastebin.com/RdhqEzCa)
+  :replies:
+  - :author: jtgorn
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfipktf/
+    :body: |-
+      I have the same approach, however I prefer another style of coding
+
+      ```ruby
+      a = ARGF.readlines.map{ |ins| [ins[0], ins.chomp[1..-1].to_i]}
+
+      i = Complex::I
+      angle = { 90=> i, 180=> -1, 270=> -i}
+
+      puts "Part 1:"
+      pos = Complex(0,0)
+      dir = Complex(1,0)
+
+      a.each { |ins,n|
+        case ins
+          when 'N' then pos += n*i
+          when 'S' then pos += -n*i
+          when 'E' then pos += n
+          when 'W' then pos += -n
+          when 'F' then pos += n*dir
+          when 'L' then dir = dir*angle[n]
+          when 'R' then dir = dir*angle[360-n]
+        end
+      }
+
+      puts pos.real.abs+pos.imaginary.abs
+      ```
+    :replies: []
+  - :author: Krakhan
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfi7jcv/
+    :body: |-
+      More compact version that uses complex numbers for both parts after realizing the generalisation noting that Part 1 is just a 'waypoint' at (1, 0) as well. Edit: Realized as I woke up that the only thing needed to change was whether you're moving the ship or waypoint. So, corrected function here below for that.
+
+      [pastebin](https://pastebin.com/SDzcS0mx)
+    :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfi084b/
+  :body: |-
+    **Ruby:** 7:16/14:30, 347/257
+
+    Here's a [recording](https://youtu.be/tQpDPgLesCU) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/63fa11dda94d4f5470e6a8e280d69efeedb1b467/2020/dec12.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Reasonably satisfied with this one. I imagine people who do more competition coding have rotation matrices down pat. Lost some time in Part 2 due to a bad find/replace.
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfizpvb/
+  :body: |-
+    # Ruby
+
+    Today was the first day I did't bother refactoring part 1 into something reusable for part 2. Instead I copied the loop and replaced the oneliners for each instructions in the `case` statement. Messed up and wasted a lot of time because I forgot to replace every necessary piece.
+
+    ```ruby
+    instructions = File
+      .readlines('input-12.txt")
+      .map { |line| [line[0], line[1..-1].to_i] }
+
+    DIRECTIONS = [
+      [1, 0], # east
+      [0, 1], # south
+      [-1, 0], # west
+      [0,-1], # north
+    ]
+
+    # Part 1
+    x,y = [0, 0]
+    dir = 0
+
+    instructions.each do |inst, arg|
+      case inst
+      when 'R'
+        dir += arg
+      when 'L'
+        dir -= arg
+      when 'F'
+        i, j = DIRECTIONS[dir / 90 % 4]
+        x, y = x + i*arg, y + j*arg
+      when 'E'
+        x += arg
+      when 'S'
+        y += arg
+      when 'W'
+        x -= arg
+      when 'N'
+        y -= arg
+      end
+    end
+
+    puts x.abs + y.abs
+
+    # Part 2
+    ship_x, ship_y = [0, 0]
+    waypoint_x, waypoint_y = [10, -1]
+
+    instructions.each do |inst, arg|
+      case inst
+      when 'R'
+        (arg / 90).times { waypoint_x, waypoint_y = -waypoint_y, waypoint_x }
+      when 'L'
+        (arg / 90).times { waypoint_x, waypoint_y = waypoint_y, -waypoint_x }
+      when 'F'
+        ship_x += waypoint_x * arg
+        ship_y += waypoint_y * arg
+      when 'E'
+        waypoint_x += arg
+      when 'S'
+        waypoint_y += arg
+      when 'W'
+        waypoint_x -= arg
+      when 'N'
+        waypoint_y -= arg
+      end
+    end
+
+    puts ship_x.abs + ship_y.abs
+    ```
+
+    Also, for part two at first I had `puts ship_x + ship_y` at the bottom (forgot the `.abs` part) and ended up with the same resulta as part1; Is there a pattern here, or just coincidence?
+  :replies:
+  - :author: el_daniero
+    :url: https://www.reddit.com/r/adventofcode/comments/kbj5me/2020_day_12_solutions/gfmwdd8/
+    :body: 'Also made an online visualization thing here: [https://daniero.netlify.app/aoc/2020/12/part2](https://daniero.netlify.app/aoc/2020/12/part2) (WIP)'
+    :replies: []

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

@@ -0,0 +1,184 @@
+---
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfrw3ms/
+  :body: |-
+    # Ruby
+
+    Knew that the second part was a number theory based one, didn't think it would be one right out of one inspired from the Chinese Remainder Theorem though. I got tired and lazy, since it was 5am by the time I thought of coding up an algorithm for it by hand, so found one from rosetta code that had it. I guess I could have done it the other sieving way that the wikipedia article mentions [in this section](https://en.wikipedia.org/wiki/Chinese_remainder_theorem#Search_by_sieving), but hey, at least this way solves it more or less instantly, though I'm sure the sieving way would have done it in under a minute too at least.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAYBwAAAAAAAAAnE8bNrcUaSC1RPLSslbg3C3mUhvgred777SJtxMUlLYkrtfCu151ao31yyyD8usLO9czk+cI2fDLKqVTt2oetB67KB0VGUVGo6zp2PZQn63Qyn/NGS3/c1hTo734IXYgBWXS6ZLltXzaHhfLEeahYanci5X8hcf4/vKW2FH6TTmJrIejunfUIoxOO3MPsQYVDI33EbFIHQXAzp/LEvPFDL+SIL9K0bmzYEtQwF7EL0SG3DBRvoR0qcdHG08yKABs/AS1ha78kfAKRWBUfDv6TywDCT3k8k6JlJBPionqsVfa/sng6hEwskfxiZeDo661eSzKxVU58vuwDOJsBaAYGApDh+cAzxnA9E0Dpn7ygvXX8XKVqsaLp6nyRRjCc0OQjoSM6hRCqnqdI4AtIE/q1oHNmdiih6WjRlE88mqp30hmn6TlTSv/WsShDHG7etbqxUuowg/wVljBERK65sWf0y8g/60Cd8RfpKifIaq4N8MHH2JC72lakOKPI0w4O3G8pZQ+NAt8xrlxu/XGUWXw3rH7dLd9LRjl/ilw1fru1Bf6Nhpx7s73HgAH6O9IJphxG0bag5HNd7BixjcMFnUHU+TcVfRdfmARir2t1DTR1YISUbey7tgT5vA79KX3BqvrC91xQiHANPyhU0IHSkVhqHk4mcYMmjncsOW0MccbMKnLSHXA4Xjae4cCM7DHXvkcH4IjJ9TO4dBJBn0O7ldLVBLz/wfvAgjR6ca6P7+aJOee4xca+NouqzYJrvhyX//IDh+jpycHf3TYPwdG+WcfaNgUUH4ADcXbU8C0uTyudP0oyzSOnNFgnISmyM2tMvM7P4Ms8nBVaLIhHl4LBRE/ztM6RiBT1mBr3FqStwlGJXkMNRaqbrv/BBfDYgG+CZtV6DbJMwifWy8q1DIfMGvuj0FZJHnUBvZl1aU8hFpZQprw2mHkBluyxTpMGS5DSWe7FBO03FSucOQMjS9JYqvsO3JKOfWwPzR6YQj4CIaOwgyhT6vsQf7oxBkCHhHnkDIEK37kyEKDNeipgNDlOmL7LLXI+vbvJIF6KZwpXLbXtMqdoqY+Yo/ROKjUn8A12WDi0ACaP00TitigSABRIVHF7Ketf/K6rOnIp1WJPCe7yxbBsUNpsYYK/kf66HeA=)
+  :replies: []
+- :author: adjudicator
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfra3pk/
+  :body: |-
+    OO Ruby part b, with both iterative and recursive implentations of the same solution.
+
+    The iterative is about 20x faster, coming in at around 43 microseconds, while the recursive takes almost a whole millisecond.
+
+    Interestingly, the whole thing is about twice as fast on WSL2 (Linux 4.19) as it is using Windows MinGW ruby.
+
+    https://nopaste.xyz/?9b0e91305941a03c#3o68g4zxLknXSoPY6XsRyZYak7JVz6cvQ6cMGV7dYaKf
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfr2njd/
+  :body: |-
+    # Ruby
+
+    I'm moderately happy with this.
+
+    ```ruby
+    # input = DATA.readlines
+    input = open('inputs/13.txt').readlines
+
+    $start = input[0].to_i
+    $busses = input[1].scan(/\d+/).map(&:to_i)
+    $positions = input[1].split(',').each_with_index.reject { |t, i| t == 'x' }.map(&:last)
+
+    def part_1
+      time = ($start..).find { |t| $busses.any? { |n| (t % n).zero? } }
+      bus = $busses.find { |n| (time % n).zero? }
+      (time - $start) * bus
+    end
+
+    def part_2
+      remainders = $busses.zip($positions).map { |bus, pos| bus - (pos % bus) }
+      product = $busses.reduce(:*)
+
+      multiples = $busses.map do |num|
+        base = product / num
+        multiplier = (1..).find { |n| (n * base) % num == 1 }
+        multiplier * base
+      end
+
+      multiples.each_with_index.map { |m, i| m * remainders[i] }.sum % product
+    end
+
+    p part_1
+    p part_2
+
+    __END__
+    939
+    7,13,x,x,59,x,31,19
+    ```
+  :replies: []
+- :author: Karl_Marxxx
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfqych1/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    input = ARGF
+    input = input.readlines(chomp: true)
+    target = input[0].to_i
+    busses = input[1].split(",").map.with_index {|e, idx|
+        next if e == "x"
+        e = e.to_i
+        [e, (e-idx) % e] # bus, wait time
+    }.compact
+
+    # part 1
+    wait, bus = busses.map {|b, _| b - (target % b)}.each_with_index.min
+    p wait * busses[bus][0]
+
+    # part 2
+    timestamp = busses[0][1]
+    offset = busses[0][0]
+    i = 0
+    while i < busses.size - 1
+        next_bus = busses[i+1][0]
+        next_bus_wait = busses[i+1][1]
+        until timestamp % next_bus == next_bus_wait
+            timestamp += offset
+        end
+        offset = offset * next_bus
+        i += 1
+    end
+    puts timestamp
+    ```
+  :replies: []
+- :author: parentheses-of-doom
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfnmkkd/
+  :body: |-
+    [Ruby](https://github.com/Prajjwal/advent-of-code/blob/master/2020/ruby/day_13.rb)
+
+    Not a huge fan of today's problem, because anyone that didn't know about the Chinese Remainder Theorem didn't really stand a chance of solving it. Pretty artificial in terms of difficulty.
+  :replies:
+  - :author: MimHufford
+    :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfoi0qx/
+    :body: |-
+      I solved it without knowing CRT.
+
+      The brute force solution is to check every t minutes (where t is your first bus) and then check each subsequent bus divides by t + bus offset. if it doesn't, jump to next t.
+
+      But, instead of jumping t every time you can potentially jump massive t values. I.e. if you know the first two buses matched you can jump bus1 \* bus2 minutes because you know that will be the next time they are synchronised. Then when you find 3 you can jump even larger steps.
+
+      [Here's mine](https://github.com/mimhufford/AdventOfCode/blob/master/2020/13.jai)
+    :replies: []
+  - :author: spookywooky_FE
+    :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfnr8gq/
+    :body: |-
+      I had, again, big problems to parse the problem statement, and to parse the problem input. For part2 I did read about [diophantine equations](https://cp-algorithms.com/algebra/linear-diophantine-equation.html) for like 20 minutes.
+
+      Then I realized that these do not really help, but that we can find a solution for two busses fairly simple, and combine this principle to all busses. [part2](https://gitlab.com/FrankEndriss/aoc2019/-/blob/master/src2020/13b.cc)
+
+      I heard of CRT before, but was never able to memoize how it works.
+    :replies:
+    - :author: Dementati
+      :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/ggu6foy/
+      :body: They did help me. I modelled the problem as a system of Diophantine equations and used a library to solve it.
+      :replies:
+      - :author: spookywooky_FE
+        :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/ggvj6pm/
+        :body: Well, a system of diophantine equations is more or less CRT. However, of course they can help ;) But they did not help me, because I did not get how to apply them.
+        :replies:
+        - :author: Dementati
+          :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/ggw9sgh/
+          :body: In what sense are they CRT? CRT seems completely different to me, not least because it requires the divisors to be coprime. And yeah, the way you phrased your comment made it sound like you were saying that Diophantine equations don't help in general.
+          :replies: []
+  - :author: Hydroxon1um
+    :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfq7uu2/
+    :body: |-
+      Actually some basic number theory (modular arithmetic and prime numbers) was sufficient to derive the sieving algorithm.
+
+      BusIDs were all prime, so one must simply add a multiple of the product of the previous BusIDs to maintain the same remainder mod all the previous BusIDs, such that the sum has a correct remainder mod the current BusID.
+
+      [https://en.wikipedia.org/wiki/Chinese\_remainder\_theorem#Search\_by\_sieving](https://en.wikipedia.org/wiki/Chinese_remainder_theorem#Search_by_sieving)
+    :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfnjtw8/
+  :body: |-
+    Ruby 911/1809. I've never heard of the Chinese Remainder Theorem, so I cheated and looked here after about an hour of struggling with the math. And then I cheated some more by copying a CRT solver from Rosetta Code.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDjAgAAAAAAAAARiAqGkkN7pUjVWW5O/8kAHtqieaDJW/x6fZAz4dPiQJToiDdFET3JIRXOC1zTFN8lrRTYtBiOuM94vK3SDrc+EyQY/mtgIi57X6SacUcFQ7OxrHgtHERfN996gXIXrNl7uMAjllAJGHaoC+er6HZC9pBmSAwW/Rub7ZdQPcvwPatBWiTNsY/S67wDftjTA5uzND80YFd6bMC5KwMXQBs68thKgzE9cITifEa28H48s/nU9To8v0iSas7T88Errs+8CzEuLDiwPh4mH9i+gTB16zvomGABL4gigPrxbZh0B0Ck/nbLp0R4rA2QXzaLbgtPVk5W3E+s8H+K5u/OH91C1aczTUs2d0GoMgQGdv8t0XIZdyJOxl1HEStcG9nJxDErhFzoPOqo5wsySgVAvxgNDOthpvcnBULYCFE50Fe2PB0Og7X6yqHoMsDhaiiVWopZoXJhdf7nhEKy7mnDOC0S/w2F35fGhCMROEaztYL/EEJVCkvbz8cakuu1Q7atprBmMgS6h96jaTukGd1j+hoYjvOLZuG6XJxi3RvWkxIbP2fSXCS/Jd5pggwIPlIJdayq/+g3cKz/6CH7nQ==)
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfnm3g1/
+  :body: |-
+    Ruby, 18/1577
+
+    The first part was easy, at least for me. The second part was virtually impossible since I have never heard of the CRT and had no clue how to solve it. As you can see in my code, I was able to get it eventually by noticing patterns in partial solutions. Took me quite a while to figure it out.
+
+    https://gist.github.com/gurgeous/045938641f5373a06b702faf3297eb1f
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfnpua3/
+  :body: |-
+    **Ruby:** 7:00/24:19, 737/289
+
+    Here's a [recording](https://youtu.be/jKOrFXbxfrI) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/00692f04b7319944762d227205386b22cafb8842/2020/dec13.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Problems are getting harder! Part 1 could have gone a little better, but I'm reasonably pleased with how Part 2 went, given how much my rank increased.
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/kc4njx/2020_day_13_solutions/gfpdmjs/
+  :body: |-
+    # Ruby
+
+    I was mostly a fan of my part 1 solution here because it had good golfing potential. Keen to know if it can be golfed further though:
+
+    ```ruby
+    $<.to_a.tap {|e,rs|p rs.split(',').map(&:to_i).reject(&:zero?).map{|r|[r,r-(e.to_i%r)]}.min_by(&:last).inject(:*)}
+    ```
+
+    For part two.. I didn't know or need any Chinese theory or whatever. Instead, I monitored intervals between successes as I increased the number of columns I was checking for and changed my counter increment to that value. Gets the eventual solution in about 0.6s: https://gist.github.com/peterc/4e6140461cd3c83b3cea03d514e5c8cc
+  :replies: []

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

@@ -0,0 +1,113 @@
+---
+- :author: MintyMiku
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gg08r3p/
+  :body: |-
+    # [Ruby](https://github.com/Ciremun/AOC-2020/blob/main/14%20-%20Ruby/14.rb)
+
+    it just works 4Head
+  :replies: []
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfvx57t/
+  :body: |-
+    # Ruby
+
+    Took me awhile due to just learning more of the stuff ruby has to offer for this. I did peak a bit before and did see the use of the repeated\_permutation being a very nice time saver though. :)
+
+    [paste](https://topaz.github.io/paste/#XQAAAQA2BgAAAAAAAAAkk4as5/1fmEdghelgYMg6VrsIK/UBR2vu5GgUjeztZFOMhdNgpLgx74sjP7cfZLLgPnfjH19j93zimPOcyRiaOsNyuGVl34T27q33yI7WUCYtyV2RlViqdyqRz5NtpdJ8M/ltXHnk8kEOLgarODukYeCLCPGbwu1QIgxrm9rYyE8ANN7y3Dv9Ui1ShiEJIpbPcE+XTbtznyfGhw3WUFT0w9gDEioL/moxPa/0CAkSj29eD1GFxihtgyjXco+KGOaJZHdFmBUxgk+XNssXjMFLyelsug4QkyV5iCCG4HhrdnJFfuMi7Ae68M2+b/FGtbZdmhw+Cz9BdQHDP78I5I8VTO+QBJSLrIeM5/DYVGXNbzUOn+7SRDSa+W+OUkqUUJGAEEsH2mYUEWNHLJuTY5B+DflNw+qywtMyuwrOr0iD2whD+W1ebeBfIlWK6tjcC4YXh0ELkA7qxSHAX6HuHG8cPjZhYjUrKZwHDRJjuqeNljg85p5iy5sGkz+PhU0XdQ4vtPR/vQ6Tj7+DAFKK52MLiI5p6de3AYwp+XqrLdsZ1kygso5P9PST6EHGFqFVZDtdxe83ci+b1yl3Glkb217rnh9FHuS2RLHVsRxYVPLYjSJtvHYUciIgid2wyua3UZ3JxSmfvXegE+2Gl9daPWO2dhjMbuYD8zVb6scZGkUOYzTe/xEqxEMu+5MFep8nu+XtIXXitdar2n48YGgzL54snH3gAqXqmk+6qDuKDiSVTrLooeE7PrE8FHbNW447wqLjrLkBEURd35JPHGTqsUaIlddtKB1UwG1lazTvfmNWXX2WTEBjvBa6sYMbVR7ZCjX5tsToqrH5HyUX74nb/mpajkXBGR4fXSJioWqlA53DfYjRwlU9g0U/Nxsv1BAeZfwY/fa7kpw=)
+  :replies: []
+- :author: willkill07
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfvakic/
+  :body: |-
+    # Ruby
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDdBQAAAAAAAAAxmwhIY/U9BVB8ketYcM8sE4hjXrFjIt9vIZU63PHjs/EBsxdoahabvHzgv+yWg5ttwac91QaHxPaH95XpPuREaqTx4tJjQxZq2wlMYIh5mBw2SxfNNxkBcGm2pVS5aa+ew6Dcf/De/60WPLCdBcxlz7U8PgTwkw2fUOHlSzgyfZ9yVWZdsXUeNCyqSK7jLbcGVeQTVubic3fmjG3OqzGKIB/zaMn4b++7Sbz61bjKmPC5NUHq9F4qjkHU7ySoJ0DfxvcTWRv9PH2QSifItl6B9/ich5uPAOxfyFmEwl+N4YESKynIAjktDXldQNNnGMnhXCrwCD+6dJrJKEK+FrMGTLajrTPKWKAPEsYhQ+gDmGiLerCoJeYpuf0GeURl2udeOsuV8dnnxpZIgm43R7DfWS+fW7SYOaWIHNj2+Zm7ak7ZtDFrFsDwMbj9HQjXtfk8+kD/v7Fs2um2rGZufRgwSrIrCdsfFzwQ+f2A9O7vS1nDEdfI0eUBdNgco3Gyhn+5c39CITy7cA+eMszt6ksXAW1H8FQAZfLLrPhj5lE7Lxm1MBTXGNOoXOjrBxAQSwuODVRNyd9Rl5a43dOnmEpfGlVPxXmU8dOItl3pHv9ouiSiht2J9DV0D5cDckSsdq4x5Vx6BFpEeJiAnQynlRoGyBVxG4/5cjldT/2UyIzlaGo3h3C2yPN+HzeUKMtvFqwkrQkP1JyvPsyP/utohQ==)
+
+    My only experience with ruby prior to today was working with an awesome [autograding platform](https://www.github.com/autolab/autolab) deployed at the university where I teach
+
+    I defined an abstract base class + two implementations for each part. Overall I'm pretty pleased!
+  :replies: []
+- :author: adjudicator
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfuh7xh/
+  :body: |-
+    Ruby Part 2.
+
+    Man... ruby is really not meant for bitwise operations.
+
+    `0` is truthy. `0b0` is not. Got sick of mixing them up and did this as strings without XORs. Big yikes.
+
+    https://pastebin.com/9S77hyCc
+
+    refactored a bit: https://pastebin.com/w4zyYfSJ
+  :replies: []
+- :author: billiamthesecond
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfsezb0/
+  :body: |-
+    [Ruby](https://www.billiam.org/advent-of-code/14.html)
+
+    Needs cleanup, but another successful use of repeated\_permutation
+  :replies:
+  - :author: adjudicator
+    :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfuzeql/
+    :body: |-
+      > repeated\_permutation
+
+      Cooooooool. Had no idea. I just did:
+
+      ```ruby
+        def bit_combinations(bits)
+          combinations = []
+          (2**bits).times do |number|
+            combinations.append(
+              number
+              .to_s(2)
+              .rjust(bits, '0')
+            )
+          end
+          combinations
+        end
+      ```
+    :replies: []
+- :author: justinpaulson
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfsa36z/
+  :body: |-
+    Ruby 325 / 310
+
+    First day I was actually under 500 for both! Hoping to hit the leaderboard sometime... I think my solutions are just more wordy than they need to be...
+
+    [Github](https://github.com/justinpaulson/advent-of-code-2020/blob/master/day_14.rb)
+  :replies: []
+- :author: odlp
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfszlek/
+  :body: |-
+    **Ruby**
+
+    - [Part 1](https://github.com/odlp/advent-of-code-2020/blob/main/day-14/part1.rb)
+    - [Part 2](https://github.com/odlp/advent-of-code-2020/blob/main/day-14/part2.rb)
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfsa879/
+  :body: |-
+    Ruby, 835/440
+
+    Big breakthrough was just treating things as strings since perf isn't an issue. As usual, many comprehension errors from typing way too quickly. In part 1 I initially assumed there was only one mask. In part 2 I kept operating on the value (not the address). Sigh. This has been cleaned up a bit, don't despair rubyists.
+
+    https://gist.github.com/gurgeous/eeeef7c3760ae2825d93313912ba83ab
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfsctyo/
+  :body: |-
+    Ruby 3481/2141. I wasted a lot of time before I realized the issue was that `x | y & z` != `(x | y) & z`.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBFBgAAAAAAAAARiAqGkkN7pUjVWW5QMRJorQl/iGDTuz7z9FE7Z0PROHdaroTicEU21UyHqu+JbrZn/hZVJVA0o7+hBbTdOUtULU7YRXF8ZeND/yP8nUt4GSQfvvOXxsFQUu/S5kfezPDFrh8UVeGBywu+Tsmdm7fBw/uebQWn/OUtkuYg7pHYif7HYE7mdq8/UAD4eq2xCKQyvq2NM0CBnu3tEjr3TVSA1kOA6B7qA5WjP0tZ97QjNG2BZjb7WLwYybRXPUvvIhvTcA+BYUb/rAwCQ1xaXVeNSug586eu8fuubIYzf0bet9YM7slUvq9poS7RtWlyWGwf5jeyqVRANHxDOP2Ld7Ff7ADXIQizNkgUWLumY0EpNhaEOgJ/AOKDKZa9+LjcBFNjwUHauibFBwvf+be2oiIlh+ZjmEmpg727tnfrQv6zqPeJJbDm62MMs9OzGEUqOuledDjU2nyYBErjYW6TVg2gFSLYml9xxC+4ogHkICymn/Yfm3q8LFxLNO7eI0TigZ96KfOlhD+C5UV14iJ0VBynrG4PRs+YM82sZVUKFp04tHy3wbhp1kidYRiM2MOI2rp05732v3+EsqeodL6KHPjc3hHCjLmaRJykTDaoWv3TwoGV1M2al3YHbAvIyd8BmeU5cBd41ZTMK8uFFRlUDpCiOHD+wpC1kQ3ZQSTq7QZE4iwj/b8VoA==)
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kcr1ct/2020_day_14_solutions/gfsdyft/
+  :body: |-
+    **Ruby:** 11:43/26:41, 489/470
+
+    Here's a [recording](https://youtu.be/5KUmnuaIq14) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/bbd16fef4f01e20467d4446ebf3e22f0a8122def/2020/dec14.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Wow, I am not good with bitmasks.
+
+    Looping from 0 to n, then using Ruby's combination method is definitely a much better way to loop through power sets. That approach crossed through my mind, but I ended up going a different, very convoluted route.
+  :replies: []

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

@@ -0,0 +1,91 @@
+---
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/ggir6ki/
+  :body: |-
+    **Ruby**
+
+    Computes part 2 in ~40 seconds
+
+    also has a logger and a timer.
+
+    [https://gist.github.com/Clashbuster/722338797dc16958652f7c3980accb4d](https://gist.github.com/Clashbuster/722338797dc16958652f7c3980accb4d)
+  :replies: []
+- :author: a_a-a_a-a_a-a_a-a_a
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gg01f77/
+  :body: |-
+    Ruby
+
+    part one: [https://github.com/ahoglund/adventofcode/commit/c6f95d81f985809d3d95c16a502c00379618a2b2](https://github.com/ahoglund/adventofcode/commit/c6f95d81f985809d3d95c16a502c00379618a2b2)
+
+    part two:
+
+    [https://github.com/ahoglund/adventofcode/commit/3afe5abf72c32ad5cf62f9f71b19767ac775a92f](https://github.com/ahoglund/adventofcode/commit/3afe5abf72c32ad5cf62f9f71b19767ac775a92f)
+
+    Should prob have extracted the logic into a single method and passed the constant number in, but didn't get around to it yet. Still working on day 12/13 part two so no time for clean up.
+  :replies: []
+- :author: billiamthesecond
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfymal1/
+  :body: |-
+    [Ruby](https://www.billiam.org/advent-of-code/15.html)
+
+    My first pass took some number of minutes to complete for part 2, but poked around with performance a bit afterward. Down to ~6 seconds, mostly by making the lookup hash and key local to the loop.
+  :replies: []
+- :author: skawid
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfyf8iw/
+  :body: "[Ruby!](https://github.com/simonbrahan/aoc2020/blob/master/day15/main.rb) Completes in eight seconds; it did this well first time, now I have to go back over it and figure out which bullet I accidentally dodged today..."
+  :replies: []
+- :author: odlp
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfwxfs9/
+  :body: |-
+    [Ruby solution](https://github.com/odlp/advent-of-code-2020/blob/main/day-15/solution.rb):
+
+    ```ruby
+    spoken = Hash.new { |hash, key| hash[key] = [] }
+
+    ARGV.first.split(",").each.with_index(1) do |value, round|
+      spoken[value.to_i] << round
+    end
+
+    max_rounds = ARGV.last.to_i
+    last_spoken = spoken.keys.last
+
+    (spoken.size + 1).upto(max_rounds) do |round|
+      first_time = spoken[last_spoken].size == 1
+      last_spoken = first_time ? 0 : (spoken[last_spoken][-1] - spoken[last_spoken][-2])
+      spoken[last_spoken] << round
+    end
+
+    puts last_spoken
+    ```
+  :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfw85v5/
+  :body: |-
+    Ruby, 528/291
+
+    As usual, understanding the problem was the hardest part. I accumulated all numbers since perf wasn't an issue. After cleanup -
+
+    https://gist.github.com/gurgeous/5636fd2e267bc7ae1ecf9224be20bbf2
+  :replies: []
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfwjtu5/
+  :body: |-
+    # Ruby
+
+    Just keeping track of all the last turns a number was spoken. I also had a way with doing a circular queue of only two items as a separate hash within this big has but it was about 3-4 times slower than just doing it this way.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQA5BAAAAAAAAAAnFUW8WzF1WEoJx9V0hOKfg4NcZ7Zk7SRGQT3OQ36ywk0b08L95+2OES2ZqZtizraLudliFIMNvbVWpu4eDd9rzrUL+J/wZrn7LhHMNeiNqmsLCdXKt8JUUG7FeOB187Wsq17adijbYQbNj5riEPzV9JGbyFJcEhr6pwsBVJDwCad8B+Ss9dpFLh+Y8Gbuu5f4M7Xn4ZA92rzErIdR9NEZhWeoeLetfmk2cw0stsCS7AK4JHuN2JFCczsmBTe6ca6JMngpGcRqoeoCCPxDmwniojEEiZqVSxNFYwmbg+GfP5Vht3Gx2qzALrJ/cjmOEyGiJ3KxgqohCY7OoFw6sNYS0E20dtjAJng5tyANJOFbIRN5uLeR2BJJ2WjrMFqpZLP+8o0gr7OttvxHUAJQpi+wwSg3T2uTrt+b4mdcI6Fr4wwhIlZC5pNIQMf0dYFVp/Odga++r9Qq5Jpb/Xh+rQBPvkHemisxG3Dgr16vrzwqRtwUzVZcxkt818hqW87j7UkKdYD6WZ94+6Y5XqW6lhhQQiGaqSD/BtV9AA==)
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfw80xr/
+  :body: 'Ruby: [http://ix.io/2I7f](http://ix.io/2I7f)'
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/kdf85p/2020_day_15_solutions/gfwcejk/
+  :body: |-
+    **Ruby:** 13:11/14:11, 927/351
+
+    Here's a [recording](https://youtu.be/Jnj1qdn2Bh4) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/7f52554f4bb9b2ce2f038b90b8e20505b2a53e35/2020/dec15.rb). (I'm streaming myself solving the problems right when they come out on [Twitch](https://twitch.tv/codeistheend)!)
+
+    Uh, did not do well on Part 1. Just confusing and arbitrary enough to really knock me off balance. Oh well, I was able to just plugin 29,999,999 for Part 2 and finish in a minute, so you win some, you lose some. The difference between the Part 1 and Part 2 cutoffs for the leaderboard was over three and a half minutes!
+  :replies: []