advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,230 @@
+---
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/5hijk5/2016_day_10_solutions/db0v9jb/
+  :body: |-
+    Ruby.
+
+    I first set up a `Bot` class with some simple methods `receives(value)`, `gives_low(bot)`, `gives_high(bot)`. Each method checks if all the necessary info is given, and then calls `receives` on the appropriate receivers, so that the values cascades nicely through the graph.
+
+    Then the main thing goes like this:
+
+    ```ruby
+    VALUES = [17, 61]
+
+    bots = Hash.new { |hash, key| hash[key] = Bot.new(key) }
+    input = File.open('10_input.txt')
+
+    input.each_line do |line|
+      case line
+      when /(bot \d+) gives low to ((?:bot|output) \d+) and high to ((?:bot|output) \d+)/
+        gives, to_low, to_high = bots.values_at($1, $2, $3)
+
+        gives.gives_low(to_low)
+        gives.gives_high(to_high)
+      when /value (\d+) goes to (bot \d+)/
+        value, bot = $1.to_i, bots[$2]
+
+        bot.receives(value)
+      else
+        puts "huh?"
+      end
+    end
+
+    # Part 1
+    puts bots.values.find { |bot| bot.input.sort == VALUES }.name
+
+    # Part 2
+    outputs = bots.values.select { |bot| bot.name =~ /output [012]$/ }
+    puts outputs.flat_map(&:input).reduce(:*)
+    ```
+
+    The whole thing can be found [here](https://github.com/daniero/code-challenges/blob/master/aoc2016/10.rb)
+  :replies: []
+- :author: blanketandtea
+  :url: https://www.reddit.com/r/adventofcode/comments/5hijk5/2016_day_10_solutions/db0p8im/
+  :body: |-
+    **Ruby** for both steps
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    ##
+    # Base class for entities in the factory
+    class InputProcessor
+      def initialize(id)
+        @id = id
+        @chips = []
+      end
+      attr_accessor :id, :chips
+
+      def add_chip(chip)
+        @chips << chip
+        act_on_new_chip
+      end
+
+      def act_on_new_chip
+        raise "#{self.class}: Method not implemented"
+      end
+    end
+
+    ##
+    # Outputs take do nothing special with chips, they just store them.
+    class Output < InputProcessor
+      def act_on_new_chip
+        # Outputs just store the new values
+      end
+    end
+
+    ##
+    # Bots wait till they have two chips and then hand them
+    # over to the next bot based on the set behaviour.
+    class Bot < InputProcessor
+      def initialize(id, specials, notify_on_specials)
+        super(id)
+        @specials = specials
+        @notify_on_specials = notify_on_specials
+      end
+
+      def set_behaviour(low_to: nil, high_to: nil)
+        @low_to = low_to
+        @high_to = high_to
+      end
+
+      def act_on_new_chip
+        return unless @chips.size > 1
+        @low_to.add_chip(@chips.min) if @low_to
+        @high_to.add_chip(@chips.max) if @high_to
+        check_for_special_vals
+        @chips.clear
+      end
+
+      def check_for_special_vals
+        @notify_on_specials.got_specials(bot: self) if @chips.sort == @specials
+      end
+    end
+
+    ##
+    # A Factory represents a collection of bots and outputs that are connected
+    # to each other and can process input.
+    class Factory
+      INPUT_INSTR = /^value (?<val>\d+) goes to bot (?<bot>\d+)$/
+      BEHAV_INSTR = /^^bot (?<id>\d+) gives low to (?<low_type>bot|output) (?<low_id>\d+) and high to (?<high_type>bot|output) (?<high_id>\d+)$$/
+
+      def initialize(setup)
+        @bots = []
+        @outputs = []
+        @specials = [17, 61]
+        create_entities(setup)
+        create_connections(setup)
+      end
+      attr_accessor :bots, :outputs
+
+      def create_entities(setup)
+        setup.each do |instr|
+          instr.match(BEHAV_INSTR) do |m|
+            add_entity('bot', m[:id].to_i)
+            add_entity(m[:low_type], m[:low_id].to_i)
+            add_entity(m[:high_type], m[:high_id].to_i)
+          end
+        end
+      end
+
+      def create_connections(setup)
+        setup.each do |instr|
+          instr.match(BEHAV_INSTR) do |m|
+            low_to = get_entity(m[:low_type], m[:low_id].to_i)
+            high_to = get_entity(m[:high_type], m[:high_id].to_i)
+            @bots[m[:id].to_i].set_behaviour(low_to: low_to, high_to: high_to)
+          end
+        end
+      end
+
+      def process(inputs)
+        inputs.each do |input|
+          input.match(INPUT_INSTR) do |m|
+            @bots[m[:bot].to_i].add_chip(m[:val].to_i)
+          end
+        end
+      end
+
+      def add_entity(type, id)
+        if type == 'bot' && @bots[id].nil?
+          @bots[id] = Bot.new(id, @specials, self)
+        elsif @outputs[id].nil?
+          @outputs[id] = Output.new(id)
+        end
+      end
+
+      def got_specials(bot:)
+        @special_bots ||= []
+        @special_bots << bot
+      end
+      attr_accessor :special_bots
+
+      private def get_entity(type, id)
+        type == 'bot' ? @bots[id] : @outputs[id]
+      end
+    end
+
+    input = open(ARGV[0]).readlines.map(&:strip)
+    factory = Factory.new(input)
+    factory.process(input)
+
+    puts "Step1: #{factory.special_bots[0].id}"
+    puts "Step2: #{factory.outputs[0].chips[0] \
+                   * factory.outputs[1].chips[0] \
+                   * factory.outputs[2].chips[0]}"
+    ```
+  :replies: []
+- :author: eregontp
+  :url: https://www.reddit.com/r/adventofcode/comments/5hijk5/2016_day_10_solutions/db122wz/
+  :body: |-
+    Ruby, with a coroutine (Fiber) per bot:
+
+    ```ruby
+    lines = File.readlines("10.txt").map(&:chomp)
+    inputs, moves = lines.partition { |line| line.start_with? 'value ' }
+
+    class Fiber
+      alias call resume
+      alias :[] :instance_variable_get
+      alias :[]= :instance_variable_set
+    end
+
+    outputs = Hash.new { |h,k| h[k] = [] }
+    actions = {}
+    bots = Hash.new { |h,k|
+      h[k] = f = Fiber.new { |in1|
+        in2 = Fiber.yield
+        min, max = [in1, in2].minmax
+        if min == 17 and max == 61
+          p [:bot, k]
+        end
+        min_to, max_to = f[:@action]
+        min_to.call(min)
+        max_to.call(max)
+      }
+    }
+
+    moves.each { |move|
+      move =~ /bot (\d+) gives low to (bot|output) (\d+) and high to (bot|output) (\d+)$/
+      raise move unless $~
+      bot, low, high = Integer($1), Integer($3), Integer($5)
+      bot = bots[bot]
+      raise if bot[:@action]
+      bot[:@action] = [
+        $2 == "output" ? outputs[low].method(:<<) : bots[low],
+        $4 == "output" ? outputs[high].method(:<<) : bots[high]
+      ]
+    }
+
+    inputs.each { |input|
+      raise input unless input =~ /^value (\d+) goes to bot (\d+)$/
+      value, bot = Integer($1), Integer($2)
+      bots[bot].call(value)
+    }
+
+    p outputs
+    p (0..2).map { |i| outputs[i].first }.reduce(:*)
+    ```
+  :replies: []

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

@@ -0,0 +1,5 @@
+---
+- :author: eregontp
+  :url: https://www.reddit.com/r/adventofcode/comments/5hoia9/2016_day_11_solutions/db21n90/
+  :body: Ruby, BFS with pruning same states by sorting chips/gens per floor. Runs for 43ms for the first star, 20 min for the second (phew, wondered if it'd ever come back :) https://gist.github.com/eregon/28ee8504d4bb5b225fcafdb9872b884a
+  :replies: []

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

@@ -0,0 +1,115 @@
+---
+- :author: yjerem
+  :url: https://www.reddit.com/r/adventofcode/comments/5hus40/2016_day_12_solutions/db36vjr/
+  :body: |-
+    This was really fun! Here's a compiler in Ruby that outputs C.
+
+    ```ruby
+    C_VALUE = 1
+
+    puts "#include <stdio.h>"
+    puts
+    puts "int a = 0, b = 0, c = #{C_VALUE}, d = 0;"
+    puts
+    puts "int main() {"
+
+    DATA.each.with_index do |line, n|
+      puts "line#{n}:"
+      if line =~ /^cpy ([abcd]|-?\d+) ([abcd])$/
+        puts " #$2 = #$1;"
+      elsif line =~ /^cpy (-?\d+) ([abcd])$/
+        puts " #$2 = #$1;"
+      elsif line =~ /^inc ([abcd])$/
+        puts " #$1++;"
+      elsif line =~ /^dec ([abcd])$/
+        puts " #$1--;"
+      elsif line =~ /^jnz ([abcd]|-?\d+) (-?\d+)$/
+        puts " if (#$1) goto line#{n + $2.to_i};"
+      else
+        puts "!!! PARSE ERROR: #{line}"
+        exit
+      end
+    end
+
+    puts
+    puts " printf(\"%d\\n\", a);"
+    puts " return 0;"
+    puts "}"
+    puts
+
+    __END__...insert asm input here...
+    ```
+  :replies:
+  - :author: willkill07
+    :url: https://www.reddit.com/r/adventofcode/comments/5hus40/2016_day_12_solutions/db36zjn/
+    :body: heh, I [did mine in awk](https://www.reddit.com/r/adventofcode/comments/5hus40/2016_day_12_solutions/db36od6/). Almost identical
+    :replies: []
+- :author: brantyr
+  :url: https://www.reddit.com/r/adventofcode/comments/5hus40/2016_day_12_solutions/db37axs/
+  :body: |-
+    Ruby assembunny parser. Scraped into the top 100, but have done some heavy refactoring since that
+
+    ```ruby
+    file = File.new("ainput12.txt","r")
+    lines = []
+    while (line=file.gets)
+        lines << line.split(' ')
+    end
+
+    i=0
+    @a = @b = @d = 0
+    @c = 1 # Part 1/2
+
+    def get(var)
+        out = 0
+        case var
+        when "a"
+            out = @a
+        when "b"
+            out = @b
+        when "c"
+            out = @c
+        when "d"
+            out = @d
+        else
+            out = var.to_i
+        end
+        return out
+    end
+
+    def set(var,val)
+        case var
+        when "a"
+            @a = val
+        when "b"
+            @b = val
+        when "c"
+            @c = val
+        when "d"
+            @d = val
+        end
+    end
+
+    while (i<lines.length and i>-1)
+        jumped=false
+        case lines[i][0]
+        when "cpy"
+            set(lines[i][2],get(lines[i][1]))
+        when "inc"
+            set(lines[i][1],get(lines[i][1])+1)
+        when "dec"
+            set(lines[i][1],get(lines[i][1])-1)
+        when "jnz"
+            val = get(lines[i][1])
+            if val!=0 then
+                jumped=true
+                i+=lines[i][2].to_i
+            end
+        end
+        if !jumped then
+            i+=1
+        end
+    end
+    puts @a
+    ```
+  :replies: []

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

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

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

@@ -0,0 +1,102 @@
+---
+- :author: yjerem
+  :url: https://www.reddit.com/r/adventofcode/comments/5i8pzz/2016_day_14_solutions/db6bfrw/
+  :body: |-
+    Ruby, took 90 seconds to run for part II:
+
+    ```ruby
+    require 'digest'
+
+    SALT = 'yjdafjpo'
+
+    def md5_stretched(index)
+      hash = Digest::MD5.hexdigest("#{SALT}#{index}")
+      2016.times { hash = Digest::MD5.hexdigest(hash) }
+      hash
+    end
+
+    hashes = 0.upto(999).map { |i| md5_stretched(i) }
+
+    count = 0
+    i = 0
+    loop do
+      cur = hashes[i % 1000]
+      hashes[i % 1000] = md5_stretched(i + 1000)
+
+      if cur =~ /(.)\1\1/ && hashes.any? { |hex| hex[$1 * 5] }
+        count += 1
+        if count == 64
+          puts i
+          exit
+        end
+      end
+      i += 1
+    end
+    ```
+  :replies:
+  - :author: 3urny
+    :url: https://www.reddit.com/r/adventofcode/comments/5i8pzz/2016_day_14_solutions/db6p8s0/
+    :body: |-
+      I did a Ruby solution too. It took about 80s just like yours. One thing that makes the ruby code fast is only checking for hashes with 5 repeated characters at first, and then going back when one is found.
+
+      But I wasn't satisfied, so I added some parallelism using `fork`. I got it to run in about 40s. (I only have a dual core :/).
+
+      Well then I tried coding the stretched md5 function in C. This is when I had 13s.
+
+      And since I had the forking anyways, I used that too and got it to run in 5s with both C extension and forking.
+    :replies: []
+  - :author: jtbandes
+    :url: https://www.reddit.com/r/adventofcode/comments/5i8pzz/2016_day_14_solutions/db6cm0z/
+    :body: "Very neat. TIL that `String#[]` can accept a substring to search for.\n\nI got #3 for part 1 with a much less clean Ruby solution, but it was too slow for part 2...then I made the fatal choice of deciding to rewrite it in C... \U0001F635 let's just say you won't find me on the part 2 leaderboard."
+    :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/5i8pzz/2016_day_14_solutions/db758en/
+  :body: |-
+    Ruby.
+
+    I strive to create some generic, reusable stuff for part 1 so that part 2 can be solved with as little extra code as possible. Today I made a function that takes a salt and a code block for the hashing and creates a generator for the valid keys. Solving part 2 was then just calling that method with a slightly different code block.
+
+    ```ruby
+    require 'digest'
+
+    SALT = 'ahsbgdzn'
+
+    class String
+      def triplet
+        self =~ /(.)\1\1/ && $1
+      end
+
+      def quintuplets
+        self.scan(/(.)\1{4}/).flat_map(&:first).uniq
+      end
+    end
+
+    def keys(salt)
+      triplets = Hash.new { |h,k| h[k] = [] }
+
+      Enumerator.new do |yielder|
+        0.step do |i|
+          hash = yield("#{salt}#{i}")
+
+          triplet = hash.triplet
+          next unless triplet
+
+          hash.quintuplets
+            .flat_map { |char| triplets[char].select { |found_at| found_at > i - 1000 } }
+            .sort
+            .each { |key| yielder << key }
+
+          triplets[triplet] << i
+        end
+      end
+    end
+
+    # Part 1:
+    puts keys(SALT) { |s| Digest::MD5.hexdigest(s) }.take(64).last
+
+    # Part 2:
+    puts keys(SALT) { |s| (0..2016).reduce(s) { |h,_| Digest::MD5.hexdigest(h) } }.take(64).last
+    ```
+
+    Also found here: https://github.com/daniero/code-challenges/blob/master/aoc2016/14.rb
+  :replies: []

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

@@ -0,0 +1,146 @@
+---
+- :author: jtbandes
+  :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db7uj0t/
+  :body: |-
+    Today's a great day for [another](https://www.reddit.com/r/adventofcode/comments/3xjpp2/day_20_solutions/cy59qye/) [Mathematica one-liner](http://reference.wolfram.com/language/ref/ChineseRemainder.html):
+
+    ```ruby
+    ChineseRemainder[-initialValues - Range[7], discSizes]
+    ```
+
+     
+
+    The inputs would be `initialValues = {5, 8, 1, 7, 1, 0, 0}` and `discSizes = {17, 19, 7, 13, 5, 3, 11}`, given my puzzle input:
+
+    > Disc #1 has 17 positions; at time=0, it is at position 5.
+    >
+    > Disc #2 has 19 positions; at time=0, it is at position 8.
+    >
+    > Disc #3 has 7 positions; at time=0, it is at position 1.
+    >
+    > Disc #4 has 13 positions; at time=0, it is at position 7.
+    >
+    > Disc #5 has 5 positions; at time=0, it is at position 1.
+    >
+    > Disc #6 has 3 positions; at time=0, it is at position 0.
+    >
+    > **_(part 2)_** Disc #7 has 11 positions; at time=0, it is at position 0.
+
+    And the sentence I seem to be repeating every day: "my actual leaderboard solution was written much less elegantly in Ruby" :-)
+
+    In the interest of getting higher on the leaderboard in the future, maybe it'd actually be interesting to consider what I think I _wasted_ time on today:
+
+    - actually parsing the input instead of putting the numbers in an array manually
+    - initially trying to increment the "current" state at each timestep (and reset it between tries) instead of explicitly computing each disc's position at the time the capsule reaches it
+    - off-by-one errors :(
+  :replies:
+  - :author: Wee2mo
+    :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db7vciq/
+    :body: I had a hunch Mathematica would have an abrupt solution if you happened to know about it.
+    :replies: []
+  - :author: nononopotato
+    :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/dbalad9/
+    :body: |-
+      I tried this with my input: ChineseRemainder[{10, 15, 17, 1, 0, 1}-Range[6], {13, 17, 19, 7, 5, 3}]
+
+      And it gave me 388735, which wasn't the correct answer..? Anything I did wrong?
+    :replies:
+    - :author: jtbandes
+      :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/dbatom5/
+      :body: |-
+        You missed a `-`; it should be `ChineseRemainder[-{10, 15, 17, 1, 0, 1}-Range[6], {13, 17, 19, 7, 5, 3}]`.
+
+        That's because, for instance, for your first disc we want `10+t+1 = 0 (mod 13)`, or `t = -10-1 (mod 13)`.
+      :replies: []
+- :author: andars_
+  :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db7u0fg/
+  :body: |-
+    Ruby!
+
+    Feels good to be back on the leaderboard for the first time in a while.
+
+    ```ruby
+    disks = []
+
+    File.read(ARGV[0]).each_line do |line|
+      if line =~ /Disc #(\d+) has (\d+) positions; at time=(\d+), it is at position (\d+)./
+        disks << [$1.to_i, $2.to_i, $4.to_i]
+      end
+    end
+
+    def solve(disks)
+      t = 0
+      while true
+        s = disks.inject(0) { |n, d|
+          pos = (d[2] + d[0] + t) % d[1]
+          n + pos
+        }
+        return t if s == 0
+        t += 1
+      end
+    end
+
+    puts "Part 1: #{solve(disks)}"
+    disks << [disks.length+1, 11, 0]
+    puts "Part 2: #{solve(disks)}"
+    ```
+  :replies:
+  - :author: jtbandes
+    :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db7uy6u/
+    :body: |-
+      Quick tip that I've been using for some of these: you can use the `DATA`/` __END__ ` feature to cram everything in one file:
+
+      ```ruby
+      DATA.read.each_line { |line| ... }
+      ...more code...
+      __END__
+      your puzzle input here!
+      ```
+    :replies:
+    - :author: andars_
+      :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db7v4ik/
+      :body: That's neat, I haven't seen that before. I'll give it a try.
+      :replies: []
+  - :author: mperham
+    :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db7vnz8/
+    :body: |-
+      I created the input manually rather than regexp'ing it. Enumerable#all? came in super-handy:
+
+      ```ruby
+      discs = [
+        [0, 5, 2],
+        [1, 13, 7],
+        [2, 17, 10],
+        [3, 3, 2],
+        [4, 19, 9],
+        [5, 7, 0],
+        [6, 11, 0],
+      ]
+
+      count = 0
+      loop do
+        (puts count; break) if discs.all? do |disc|
+          (disc[2] + count + (disc[0] + 1)) % disc[1] == 0
+        end
+        count += 1
+      end
+      ```
+    :replies:
+    - :author: "[deleted]"
+      :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db805j4/
+      :body: "[deleted]"
+      :replies:
+      - :author: mperham
+        :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db8c8jb/
+        :body: |-
+          Whoa, that first line is amazing. Kudos.
+
+          Side note, I always use #detect because #find clashes with ActiveRecord::Base#find.
+        :replies: []
+      - :author: eregontp
+        :url: https://www.reddit.com/r/adventofcode/comments/5ifn4v/2016_day_15_solutions/db8qn8e/
+        :body: |-
+          Mine is p (0..Float::INFINITY).find { |t| disks.all? { |dt, n, pos| (t + pos + dt) % n == 0 } }
+
+          Nice trick with 0.step
+        :replies: []

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

@@ -0,0 +1,27 @@
+---
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/5imh3d/2016_day_16_solutions/db9m64a/
+  :body: |-
+    This is one lucky program that runs both in Ruby and Crystal :-)
+
+    ```ruby
+    input = "10001001100000001"
+    length = 35651584
+
+    a = input.each_char.map { |c| c == '1' }.to_a
+    while a.size < length
+      b = a.reverse.map { |x| !x }
+      a = a + [false] + b
+    end
+    a = a.first(length)
+
+    checksum = a
+    loop do
+      checksum = checksum.each_slice(2).map { |(x, y)| x == y }.to_a
+      break if checksum.size.odd?
+    end
+    puts checksum.map { |x| x ? '1' : '0' }.join
+    ```
+
+    The second part runs in 14.5s in Ruby, and in 1.2s in Crystal if compiled with `--release`.
+  :replies: []