advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2019/08.yml

@@ -0,0 +1,103 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/faxrf8l/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_08
+  :replies: []
+- :author: MrMacintosh
+  :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/faba0sa/
+  :body: 'Quick solution in Ruby: [paste](https://topaz.github.io/paste/#XQAAAQBPAwAAAAAAAAA0m0hHVws1hFaETa6Q5kjKhoRGQhpEGP8Zi+ToEsZir/RFQ7IH8c5mUELULnsWbmAOpk5AZLKP+AK1gsu8ZUsSmbSTP1/SKf2a/sNFu5uy94x755AsIXEkqCUEyyknvTwKlj9h1YxXe/xx5uu3tAde+090KQowBEnZIXKvD6yH9U/uvL28qJ980Ln71J4R9SzKu3Kg0ruR07UvEZpOsKH3r0qvpjHkI8xqE2KKe6Gzy0p3aqlI86wcBykwjhKFMv/DoTV3pMyCh9/qiQW46TkSqMjgVAwUI4zmOexN0gFrmzFBPYPSjl0kmUBBKBtfXFYAxNZ/3A3oLZmxRaRENjpTGXm5nLCY4haOsrscJoer5eq8k9zu1wGKR0KWC59UIc4RtBmRe7KZFbl3L4D/cVLUqWq7NXmeFO64TmwzDmm/go/9AylJHZHbvSJJzCorltNi0mOxB9Yo2TMStbJf892WYHqOcwh4+3xgcfpdrR9cRNTGv5E8+UCPx8OJdVCGUPHrKzpU6FpEB/4NMjVcBFBMchchTMWa+0zJw3uk+HFaSGrOJ7i9KRNzC+HSzZejFUcQr2TdUrBi25xyDRomY4FXrdR0731+t0Ci02uGHv/xWC7e)'
+  :replies: []
+- :author: dpkcodes
+  :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/fa68fsl/
+  :body: |-
+    Here are my solutions in Ruby
+
+    [https://github.com/dpkeesling/adventOfCode/tree/master/2019/day8](https://github.com/dpkeesling/adventOfCode/tree/master/2019/day8)
+  :replies: []
+- :author: ryanbigg
+  :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/fa374pa/
+  :body: |-
+    Ruby, Part 1:
+
+    ```ruby
+    min_layer = File.read("input").strip.chars.map(&:to_i).each_slice(150).min_by { |slice| slice.count(0) }
+    min_layer.count(1) * min_layer.count(2)
+    ```
+  :replies:
+  - :author: petercooper
+    :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/fa3uas1/
+    :body: |-
+      Mine is very similar so I'm attaching it to your comment:
+
+      ```ruby
+      File.read('8.sif')
+        .chars
+        .each_slice(25 * 6)
+        .min_by { |vs| vs.count('0') }
+        .tap { |slice| puts slice.count('1') * slice.count('2') }
+      ```
+    :replies:
+    - :author: petercooper
+      :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/fa3yh7t/
+      :body: |-
+        And part 2:
+
+        ```ruby
+        puts File.read('8.sif')
+              .chars
+              .each_slice(25 * 6)
+              .inject { |a, b|
+                a.map.with_index { |pixel, idx|
+                  pixel == '2' ? b[idx] : pixel
+                }
+              }
+              .map { |c| c == '1' ? 'X' : ' ' }
+              .each_slice(25).map(&:join).join("\n")
+        ```
+      :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/fa4fdm1/
+  :body: |-
+    Ruby
+
+    ```ruby
+    WIDTH = 25
+    HEIGHT = 6
+
+    pixels = File.read('../input/input08.txt').chomp.chars.map(&:to_i)
+    layers = pixels.each_slice(WIDTH*HEIGHT)
+
+    # Part 1
+
+    p layers
+      .min_by { |layer| layer.count(0) }
+      .then { |layer| layer.count(1) * layer.count(2) }
+
+    # Part 2
+
+    BLACK = 0
+    WHITE = 1
+    TRANSPARENT = 2
+
+    def stack_pixels(a, b)
+      a == TRANSPARENT ? b : a
+    end
+
+    image = layers
+      .to_a
+      .transpose
+      .map { |pixel| pixel.reduce(&method(:stack_pixels)) }
+
+    puts image
+      .each_slice(WIDTH)
+      .map { |row| row.map(&{ BLACK => ' ', WHITE => '#'}) }
+      .map(&:join)
+    ```
+  :replies:
+  - :author: zxywx
+    :url: https://www.reddit.com/r/adventofcode/comments/e7pkmt/2019_day_8_solutions/fa8o6ne/
+    :body: Neat solution. Nice use of `min_by` and `transpose`
+    :replies: []

data/data/solutions/reddit/ruby/2019/09.yml

@@ -0,0 +1,50 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e85b6d/2019_day_9_solutions/faxrgkx/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_09
+  :replies: []
+- :author: Suitable_Flounder
+  :url: https://www.reddit.com/r/adventofcode/comments/e85b6d/2019_day_9_solutions/fa9zrhq/
+  :body: |-
+    **Ruby**
+
+    Like many people I didn't get relative mode on output parameters correct the first time. But let's appreciate the cleverness of /u/topaz2078 that the program tells you which code failed!
+
+    Anway, FWIW, [Ruby code](https://topaz.github.io/paste/#XQAAAQDYAwAAAAAAAAAoHInmjW7FQ21VepncIdt88EyjWtU63IQl6JqtLHB2nLT3hJaF+dOKgtxR8uSGS7VNeLB+m6bnxV3dumUheE5ZRkr1ullBW6L/9FK38Zyagat5B8/1oc+0wsi2wV9AwlMi+QDPT7n36Y6eq5Egux+YiPCRAGk2R66MEe9PpELpaA+J63XTIYGxh7tP2hKQXkl0zXPv/U+G6XveWaJYJZcXv08Gj0hEoCVrqvL6NlH+MlLmZQrYcv37YDxzy1gXagYMRUZsPPUYGOAGAJLrQjwzhbqg9yKBgtV3lv82MmA9Bn0Eb+z7loEdZC/TeNO6XwZ2LAdZCENBRVLKnZZ4S3elhXNnzu/Ad+fxaFgbAogWY5u1Z1o5JJKFLiIYqBn2+IhIzdXLLZyg30BJgy9ywOrSM/ULzDXsiGrHIpLol7nEgqovlnCQJmIxM6uz6+d79iErf4DGM3hqIFQ0tPKWd/tIoavd1wpIk0lebXHMEJni4NKMTW8N4qugzSh+KEhX3f98ZRmQ)
+  :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/e85b6d/2019_day_9_solutions/fa9qba7/
+  :body: |-
+    Hi.
+
+    Ruby got me #38/#37 on the leaderboard. [09_intcode_relative.rb](https://github.com/petertseng/adventofcode-rb-2019/blob/master/09_intcode_relative.rb) + [lib/intcode.rb](https://github.com/petertseng/adventofcode-rb-2019/blob/master/lib/intcode.rb). There's some stuff in there about "dynamic disassembly" and "static disassembly" and "execution stats" as well, which I'll get back to later.
+
+    Haskell is just for fun. [09_intcode_relative.hs](https://github.com/petertseng/adventofcode-hs-2019/blob/master/bin/09_intcode_relative.hs) and [lib/AdventOfCode/Intcode.hs](https://github.com/petertseng/adventofcode-hs-2019/blob/master/lib/AdventOfCode/Intcode.hs). Feel free to tear that one apart, I'm still learning Haskell. It doesn't have the three aforementioned tools because I didn't have the mental endurance to build them in two languages.
+
+    So about those disassemblers I was talking about. You can be sure this is coming. Here's what my part 2 was doing:
+
+    ```ruby
+    def f(x)
+      return a < 3 ? a : (f(a - 1) + f(a - 3))
+    end
+
+    output f(CONST_1) + CONST_2
+    ```
+
+    To preserve integrity, let's not elaborate on how to determine CONST_1 and CONST_2 by looking at your input file.
+
+    Part 2 was testing your interpreter's ability to call a recursive function. That would be why it took so much longer to run than part 1 (part 1 in \< 1 millisecond, part 2 in a whopping 1.3 seconds). You should look forward to disassembling one in a future day.
+
+    For those who thought "Oh, this relative base looks like a stack pointer" and who have some knowledge of how functions are called in many common assembly languages, this development should not be a surprise after seeing that a relative base was introduced today. I believe it was already possible to have functions without this relative base (you just need to designate a certain memory address that stores the relative base), but having a relative base makes it more convenient. Looking at the disassembled code you will see some clear `call` and `ret` patterns in there that take full advantage of the relative base.
+
+    As for how that function was determined, suffice it to say it took _me_ the use of all three tools I mentioned. I'm not very good at this, but I felt I had to prepare for the future day when this is coming. Maybe you can do it with fewer of the tools!
+
+    See you next time.
+  :replies:
+  - :author: goliatskipson
+    :url: https://www.reddit.com/r/adventofcode/comments/e85b6d/2019_day_9_solutions/fa9qnei/
+    :body: So ... Part 2 is testing a recursive function?
+    :replies: []

data/data/solutions/reddit/ruby/2019/10.yml

@@ -0,0 +1,93 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e8m1z3/2019_day_10_solutions/fbcvg9u/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_10
+  :replies: []
+- :author: Yardboy
+  :url: https://www.reddit.com/r/adventofcode/comments/e8m1z3/2019_day_10_solutions/fai82fg/
+  :body: |-
+    # Ruby
+
+    #notrig
+
+    [https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle10b/solution.rb](https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle10b/solution.rb)
+
+    Intcode source: [https://github.com/Yardboy/advent-of-code/tree/master/2019/intcode](https://github.com/Yardboy/advent-of-code/tree/master/2019/intcode)
+
+    # [Poem]
+
+    We moved when I was in eighth grade
+
+    And of trigonometry I learned none
+
+    My old school taught it semester 2
+
+    And my new school semester 1
+
+    So my Ruby solution has no trig
+
+    But that's okay, cause I'm no dope
+
+    Just fixed myself a whiskey and sour
+
+    After I solved it using only the slope
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/e8m1z3/2019_day_10_solutions/fafbqhm/
+  :body: |-
+    Ruby.
+
+    My answer to part 1 was greater than 200, so I didn't have to worry about the laser coming around 360 degrees.
+
+    ```ruby
+    asteroids = File
+      .open('../input/input10.txt')
+      .each_line
+      .with_index
+      .flat_map { |line, linenum|
+        line
+          .each_char
+          .with_index
+          .flat_map { |char, charnum|
+            char == '#' ? [[charnum, linenum]] : []
+          }
+      }
+
+    def angle_between(x1, y1, x2, y2)
+      Math.atan2(x2-x1, -(y2-y1)) % (2*Math::PI)
+    end
+
+    def distance_between(x1, y1, x2, y2)
+      Math.sqrt((x1-x2)**2 + (y1-y2)**2)
+    end
+
+    location, lines_of_sight = asteroids
+      .map { |asteroid|
+        others = asteroids - asteroid
+        lines = others.group_by { |other| angle_between(*asteroid, *other) }
+        [asteroid, lines]
+      }
+      .max_by { |_, lines| lines.size }
+
+    # Part 1
+    p lines_of_sight.size
+
+    # Part 2
+    p lines_of_sight
+      .sort[199].last
+      .min_by { |asteroid| distance_between(*location, *asteroid) }
+      .then { |x,y| x*100+y }
+    ```
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/e8m1z3/2019_day_10_solutions/fae1va2/
+  :body: |-
+    **Ruby**
+
+    I was determined not to use trigonometry at all for this, and for part 1 that was reasonably trivial to do: https://github.com/peterc/aoc2019solutions/blob/master/10a.rb
+
+    With stage two however, I was a bit facepalming it.. but then realized I could calculate a "pseudoangle" that _might_ just be accurate enough to sort the points. Thankfully... it was: https://github.com/peterc/aoc2019solutions/blob/master/10b.rb
+  :replies: []

data/data/solutions/reddit/ruby/2019/11.yml

@@ -0,0 +1,123 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/fbczcr4/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_11
+  :replies: []
+- :author: Kache
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/faj25ci/
+  :body: |-
+    **Ruby** shortened to 17 lines, not counting `Intcode`:
+
+    ```ruby
+    COLOR = { black: 0, white: 1 }
+    PAINT = { black: ' ', white: '█' }.transform_keys(&COLOR)
+
+    robot, coord = Intcode.new(File.read('input11')), Vector[0, 0]
+    facing = [Vector[0, -1], Vector[1, 0], Vector[0, 1], Vector[-1, 0]] # coordinate conversion
+
+    painted, hull_colorcode = Hash.new, COLOR[:white] # Part 1: COLOR[:black]
+    while (paintcode = robot.run([hull_colorcode]))
+      painted[coord.to_a] = paintcode
+      coord += facing.rotate!([-1, 1].at(robot.run)).first
+      hull_colorcode = painted.fetch(coord.to_a, COLOR[:black])
+    end
+
+    dim_x, dim_y = painted.keys.transpose.map(&:minmax).map { |lo, hi| (lo..hi) }
+    puts painted.size, dim_y.map { |y|
+      dim_x.map { |x| PAINT[painted.fetch([x, y], COLOR[:black])] }.join
+    }.join("\n")
+    ```
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/fai7sld/
+  :body: |-
+    Ruby again.
+
+    Built a basic Robot class that keeps track of the color of the panels and it's direction and position, with the methods _check\_color_, _paint_, and _turn_. Wanted to do some [more thread stuff](https://www.reddit.com/r/adventofcode/comments/e7a4nj/2019_day_7_solutions/f9z55xo?utm_source=share&utm_medium=web2x), so I set up a channel for the camera feed to the intcode program, and a command channel for the robot.
+
+    Then one thread does this:
+
+    ```ruby
+    loop do
+      camera_channel.push(robot.check_color)
+
+      robot.paint(command_channel.pop)
+      robot.turn(command_channel.pop)
+    end
+    ```
+
+    while another does this:
+
+    ```ruby
+    intcode = read_intcode('../input/input11.txt')
+
+    computer = IntcodeComputer
+      .new(intcode, input: camera_channel, output: command_channel)
+      .run
+
+    camera_channel.close
+    ```
+
+    I did a test run, expecting it to break or loop forever or someting bad, but to my suprise it simply worked and exited peacefylly. Turns out `Queue`'s [`close`](https://ruby-doc.org/core/Queue.html#method-i-close) method actually makes any subsequent calls to `push` raise an Exception that inherits from StopIteration, which simply make the robot thread break its loop without any fuzz. Neat!
+
+    The whole thing can be seen here: [aoc2019/ruby/11.rb](https://github.com/daniero/code-challenges/blob/master/aoc2019/ruby/11.rb)
+  :replies: []
+- :author: Yardboy
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/fai7p2m/
+  :body: |-
+    # Ruby
+
+    [https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle11b/solution.rb](https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle11b/solution.rb)
+
+    Intcode Computer source: [https://github.com/Yardboy/advent-of-code/tree/master/2019/intcode](https://github.com/Yardboy/advent-of-code/tree/master/2019/intcode)
+
+    # [Poem]
+
+    I just moved the robot around
+
+    Not realizing that in the ending
+
+    Negative coordinates would abound
+
+    And my map would need some mending
+
+    So I calculated max and min
+
+    And with them shifted down and right
+
+    Fixed myself a tonic and gin
+
+    Cause then I had the answer right
+  :replies: []
+- :author: MaterialFerret
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/fai5kx5/
+  :body: |-
+    # Ruby
+
+    Completely reused existing intcode parser. For robot movement I used sine and cosine functions, I felt like using some trigonometry just for the sake of using it after yesterday. And because of my unfulfilled robotics aspirations. :)
+
+    [https://github.com/LesnyRumcajs/advent-of-ruby-2019/blob/master/src/day11.rb](https://github.com/LesnyRumcajs/advent-of-ruby-2019/blob/master/src/day11.rb)
+  :replies: []
+- :author: hdf1986
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/fahd4f9/
+  :body: |-
+    I did wrote my solutions on Ruby, if there's another intcode problem i'll probably separate my intcodeVM to another module/file.
+
+    They also need a bit of clean up but here they are:
+
+    Part1: [https://github.com/hdf1986/advent-of-code/blob/master/day11/part1.rb](https://github.com/hdf1986/advent-of-code/blob/master/day11/part1.rb)
+
+    Part2: [https://github.com/hdf1986/advent-of-code/blob/master/day11/part2.rb](https://github.com/hdf1986/advent-of-code/blob/master/day11/part1.rb)
+  :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/e92jm2/2019_day_11_solutions/fagct5o/
+  :body: |-
+    Ruby [11_intcode_langtons\_ant.rb](https://github.com/petertseng/adventofcode-rb-2019/blob/master/11_intcode_langtons_ant.rb) and [lib/intcode.rb](https://github.com/petertseng/adventofcode-rb-2019/blob/master/lib/intcode.rb) for 96/56 today. Has been cleaned up but the idea is the same.
+
+    Haskell [11_intcode_langtons\_ant.hs](https://github.com/petertseng/adventofcode-hs-2019/blob/master/bin/11_intcode_langtons_ant.hs) and [lib/AdventOfCode/Intcode.hs](https://github.com/petertseng/adventofcode-hs-2019/blob/master/lib/AdventOfCode/Intcode.hs).
+
+    I examined the program. There are a few functions in there which is unsurprising. There is one particular function whose caller I couldn't find, until I saw there was a 106,0,X lying around, and that a previous function had stored the address of the otherwise-uncalled-so-far function into X after having been passed it by a caller. So today we got to see higher-order functions, or function pointers, or however you want to think of it. Interesting.
+  :replies: []

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

@@ -0,0 +1,157 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fbd2dmf/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_12
+  :replies:
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fefyp14/
+    :body: |-
+      > Swift
+
+      Hi. Please could you explain the logic of your hashing. I see it creates a hash for each axis. How does this get to an answer?
+    :replies:
+    - :author: J-Swift
+      :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/feirq84/
+      :body: |-
+        The general solution relies on the fact that X/Y/Z are actually independent. So you figure out how long X takes to repeat by itself, how long Y takes to repeat by itself, and how long Z takes to repeat by itself. Then you figure out the least common multiple of those for the solution.
+
+        For my approach, I hash the position and velocity of each moon by joining the position and velocity of each into a string. Here is an example of the moons and hash after 1 tick:
+
+        ```ruby
+        [#<Moon:0x00007f8fc9859840
+          @position=#<struct Coords x=6, y=-3, z=-3>,
+          @velocity=#<struct Coords x=-6, y=0, z=2>>,
+         #<Moon:0x00007f8fc9859638
+          @position=#<struct Coords x=4, y=-1, z=-2>,
+          @velocity=#<struct Coords x=6, y=2, z=6>>,
+         #<Moon:0x00007f8fc9859430
+          @position=#<struct Coords x=3, y=1, z=-3>,
+          @velocity=#<struct Coords x=2, y=4, z=-2>>,
+         #<Moon:0x00007f8fc9859228
+          @position=#<struct Coords x=2, y=0, z=-3>,
+          @velocity=#<struct Coords x=-2, y=-6, z=-6>>]
+        ```
+
+        Hashing this for "X" gives us
+
+        ```ruby
+        "6_-6x4_6x3_2x2_-2"
+        ```
+
+        I chose the '\_' and 'x' characters so that the components being joined were unambiguous.
+      :replies: []
+- :author: MaterialFerret
+  :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fauykys/
+  :body: |-
+    Ruby: [https://github.com/LesnyRumcajs/advent-of-ruby-2019/blob/master/src/day12.rb](https://github.com/LesnyRumcajs/advent-of-ruby-2019/blob/master/src/day12.rb)
+
+    I believe I came up with relatively clean and short solution - nothing innovative though, looking at the thread. LCMing the x,y and z for part 2. The day I started Advent of Code 2019 in Ruby I abandoned all hope of brute-forcing the solutions. :)
+  :replies: []
+- :author: Yardboy
+  :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fam8via/
+  :body: |-
+    # Ruby
+
+    Part 1: 30 minutes.
+
+    Part 2: The rest of the day.
+
+    I needed to read some hints, but I got there.
+
+    [https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle12b/solution.rb](https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle12b/solution.rb)
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/faknhog/
+  :body: |-
+    **Ruby**
+
+    Because there are so few Ruby solutions here. For the first time this AOC, I caved in and actually used classes and a little structure rather than golfing it as tiny as possible. It still ended up reasonably tight, however: https://github.com/peterc/aoc2019solutions/blob/master/12.rb
+  :replies: []
+- :author: hdf1986
+  :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fakngcd/
+  :body: |-
+    **Ruby**
+
+    The first part was pretty straightforward, but in the part 2 i tried to make some optimizations using sets and hashes but after a while i realized i needed a better solution, so i did separated the axis in 3 different flows and used the lowest common multiple between all the axis as the answer
+
+    Part 1: [https://github.com/hdf1986/advent-of-code/blob/master/day12/part1.rb](https://github.com/hdf1986/advent-of-code/blob/master/day12/part1.rb)
+
+    Part 2: [https://github.com/hdf1986/advent-of-code/blob/master/day12/part2.rb](https://github.com/hdf1986/advent-of-code/blob/master/day12/part2.rb)
+  :replies: []
+- :author: tckmn
+  :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/faja2gk/
+  :body: |-
+    ruby 28/14
+
+    posting because when i looked back at my part 2 code, i laughed out loud
+
+    ```ruby
+    def getpd i
+        a = read.lines.map{|x|x.ris[i]}
+        v = [0,0,0,0]
+        s = Set.new
+        10000000000000000000000.times do |n|
+            v = v.zip(a).map{|vel,pos| vel+a.map{|x| x <=> pos }.sum}
+            a = a.zip(v).map{|x,y|x+y}
+            asdfasdf = a[0]*932849+v[0]*928+a[1]*8327+v[1]*8172+a[2]*29734+v[2]*298379+a[3]*832329+v[3]*9432859832898
+            return n if s.include? asdfasdf
+            s.add asdfasdf
+        end
+    end
+    p [*0..2].map{|x|getpd x}.reduce :lcm
+    ```
+
+    (that line that assigns to the optimally-named `asdfasdf` is a hacked-together """hash function""")
+
+    the strategy, which i assume was the intended one, was to find the period for each coordinate and then lcm them together
+  :replies:
+  - :author: sophiebits
+    :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fajbk9u/
+    :body: Um. Tell us more about how you landed on using this hash function.
+    :replies:
+    - :author: tckmn
+      :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fajc1o1/
+      :body: that is where my fingers landed on my keyboard
+      :replies:
+      - :author: sophiebits
+        :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fajd1bh/
+        :body: Not worried about collisions?
+        :replies:
+        - :author: tckmn
+          :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fal3bkl/
+          :body: the original code had fewer digits at the end, i tacked on a few and compared the answers to make sure that didn't happen :P
+          :replies: []
+  - :author: Kache
+    :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fajfkbc/
+    :body: |-
+      What's the `#ris` method?
+
+      Every ruby object has a `#hash` method, by the way, (although I learned from [another comment](https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/faja0lj?utm_source=share&utm_medium=web2x) that it wasn't necessary).
+    :replies:
+    - :author: tckmn
+      :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fal361d/
+      :body: |-
+        oh, that's "[r]egex [i]nt[s]", which is a short helper function in my template file that's basically `self.scan(/-?\d+/).map(&:to_i)`
+
+        also, that's good to know, thanks!
+      :replies: []
+  - :author: petercooper
+    :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/faknabz/
+    :body: |-
+      While this is paraphrasing somewhat, my solution replaces the `asdfasdf` line with something like:
+
+      `asdfasdf = a.pack("s*")`
+
+      .. which nets you something both small and unique to the data, although your solution is different enough that I might be missing something obvious :)
+    :replies:
+    - :author: tckmn
+      :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fal2y3e/
+      :body: ah nice - you are definitely not missing anything obvious, this was just the first thing that came to mind when trying to go fast :P
+      :replies:
+      - :author: petercooper
+        :url: https://www.reddit.com/r/adventofcode/comments/e9j0ve/2019_day_12_solutions/fal7ub5/
+        :body: To be honest, the pack thing was part of my refactor. My initial "off the cuff" looked more like yours, but was like `a[0] << 48 + a[1] << 32 + a[2] << 16 + a[3]` or something like that, but I've spent a lot of time living in C(!) :-)
+        :replies: []

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

@@ -0,0 +1,68 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/e9zgse/2019_day_13_solutions/fbdyaia/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_13
+  :replies: []
+- :author: Yardboy
+  :url: https://www.reddit.com/r/adventofcode/comments/e9zgse/2019_day_13_solutions/fb5loqa/
+  :body: |-
+    # Ruby
+
+    It just plays the game, not trying (or able) to break any speed records. :)
+
+    [https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle13b/solution.rb](https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle13b/solution.rb)
+  :replies: []
+- :author: hdf1986
+  :url: https://www.reddit.com/r/adventofcode/comments/e9zgse/2019_day_13_solutions/fapgw34/
+  :body: |-
+    **Ruby**
+
+    I thought about making a small AI to play or cheating, but i didn't have enought concentration today, so i prefered to make a simple savegame system and restore the game every time i lose to a good checkopoint and just play
+
+    I wanted to upload it to asciinema but my savegame play was bigger than their file size limit . :(
+
+    Anyways, you can run part2 and it will autoload the savegame as a replay (it's a savegame really near to the win point!), you play with:
+
+    - a: left
+    - s: stay in place
+    - d: right
+    - g: save game (it's stored on savegame.txt, you can clean it if you want to start from scratch)
+
+    Also, i didn't test this too much and it's the first time i work with stdin in ruby, so maybe there are a lot of things wrong there
+
+    [https://github.com/hdf1986/advent-of-code/tree/master/day13](https://github.com/hdf1986/advent-of-code/tree/master/day13)
+  :replies: []
+- :author: vinc686
+  :url: https://www.reddit.com/r/adventofcode/comments/e9zgse/2019_day_13_solutions/fan7f6r/
+  :body: |-
+    [Ruby](https://github.com/vinc/adventofcode/blob/master/ruby/2019/13/)[Screenshot](https://github.com/vinc/adventofcode/blob/master/ruby/2019/13/screenshot.png)
+
+    My favorite day so far, very fun! I naively tried to win the game by hand for about a minute before giving up. I also had to hack my `Computer#run` method to get the input from a block and I lost some time there because the last screen after winning the game in autoplay was not printed.
+  :replies:
+  - :author: ColonelMcColonel
+    :url: https://www.reddit.com/r/adventofcode/comments/e9zgse/2019_day_13_solutions/fan82qb/
+    :body: |-
+      Hahaha I did the same too!
+
+      I also watched it auto play, I knew I could run it much faster if I just executed the auto-player without rendering at 60FPS, but hey - it was so satisfying!
+    :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/e9zgse/2019_day_13_solutions/fan6cjr/
+  :body: |-
+    Just for fun... of course I solved the problem the regular way at first, but that takes my poor Ruby code _an entire second_ to run, and that's just too slow.
+
+    If you've disassembled the code, you know that there is a function that I'll name block\_broken(x, y) that is called when a block is broken, and given the coordinates of the block. It updates the score and displays it. It calls another function to index into an array to determine the correct score increment to be used for the specific block broken. It might take a bit too much time to figure out how the function maps from (x, y) to index.
+
+    So let's just call block\_broken directly and let the computer do all the work. Here we go.
+
+    [13\_breakout.rb#L33-L59](https://github.com/petertseng/adventofcode-rb-2019/blob/master/13_breakout.rb#L33-L59)
+
+    Hooray, much faster now!!! (About 33ms, but Ruby startup also adds about another 100ms to that)
+
+    Erm, the author of the above comment does not endorse cheating in any games...?
+
+    The interesting part about these Intcode problems compared to previous years is that they allow some level of interactivity. Since we have the entire computer available to us, this opens up the way to creativity as well. I've seen a lot of great ways to solve the problem in this thread already (make your paddle cover the entire screen width, add walls to the bottom of the screen, override "ball fell off the screen" detection to instead allow the ball to bounce back...) so here is mine.
+  :replies: []

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

@@ -0,0 +1,17 @@
+---
+- :author: Yardboy
+  :url: https://www.reddit.com/r/adventofcode/comments/eafj32/2019_day_14_solutions/fbbicfv/
+  :body: |-
+    # Ruby
+
+    TIL how to use Ruby's #bsearch.
+
+    [https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle14b/solution.rb](https://github.com/Yardboy/advent-of-code/blob/master/2019/puzzle14b/solution.rb)
+  :replies: []
+- :author: vinc686
+  :url: https://www.reddit.com/r/adventofcode/comments/eafj32/2019_day_14_solutions/faurisj/
+  :body: |-
+    [Ruby](https://github.com/vinc/adventofcode/blob/master/ruby/2019/14/lib.rb)
+
+    Part 1 took me forever, it was frustrating! My brain was fried, I ended up printing my `needed` and `wasted` hash tables everywhere and modifying the code at semi random until all the tests passed... At least in ruby parsing the input was easy and the second part was just one line of code.
+  :replies: []

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

@@ -0,0 +1,26 @@
+---
+- :author: J-Swift
+  :url: https://www.reddit.com/r/adventofcode/comments/eaurfo/2019_day_15_solutions/fbtloxq/
+  :body: |-
+    Ruby
+
+    https://github.com/J-Swift/advent-of-code-2019/tree/master/day\_15
+  :replies: []
+- :author: petercooper
+  :url: https://www.reddit.com/r/adventofcode/comments/eaurfo/2019_day_15_solutions/fb2lefx/
+  :body: |-
+    [**Ruby**](https://github.com/peterc/aoc2019solutions/blob/master/15.rb)
+
+    I was out all day so only had pen and paper so I planned my solution on paper. Luckily it worked right away when I got back to my computer! For part 1, I took what seems to be a novel approach based on my reading here. I added snapshotting and rollback to my IntCode VM. I have a "to visit" list, I pull a location from this, snapshot the VM, try all of the directions, and any that are clear, I pass on the current VM state and add the location to the "to visit" list. Rinse and repeat until I find the oxygen. So "unsuccessful" VMs keep getting killed and one is lucky enough to get straight to the goal! :-) The power of clones.. but it is parallelizable.
+
+    Sadly this approach doesn't help with part 2 whatsoever, alas, so now I'm working on that and sadly it seems I'll have to go with a more bog standard algorithm.. which I've been trying to avoid.
+
+    _Update: So for part 2 I managed to avoid implementing anything. I just took my maximum distance on the entire map, took away the distance from the origin at the closest intersection to the oxygen tank, then added the length of the passage to to the oxygen tank. No path searching needed as I had the distance values already stored for every single block :-)_
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/eaurfo/2019_day_15_solutions/faxs1m7/
+  :body: |-
+    [Ruby 54/52](https://github.com/acornellier/adventofcode/blob/master/2019/15.rb)
+
+    I made my bot wander randomly for a while, then printed the map to the screen, and copy pasted the map into my code. Once that was done it was easy to apply my dijkstra and "grid" libraries to solve it!
+  :replies: []