advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,72 @@
+---
+- :author: andars_
+  :url: https://www.reddit.com/r/adventofcode/comments/5gdvve/2016_day_4_solutions/darhz11/
+  :body: |-
+    Ruby, parts 1 and 2. [link](https://raw.githubusercontent.com/andars/advent-of-code/master/2016/day4/task.rb)
+
+    Solutions for part 2 found via a quick search of the output for `north` in vim.
+  :replies: []
+- :author: anadhdguy
+  :url: https://www.reddit.com/r/adventofcode/comments/5gdvve/2016_day_4_solutions/darj14n/
+  :body: |-
+    ```ruby
+    #!/usr/bin/env ruby
+    input = File.read('input')
+    sum = 0
+    room = 0
+    input.each_line{|line|
+      m=line.chomp.split(/[-\[\]]/); cs=m.pop; sid=m.pop.to_i
+      sum += sid if cs == m.join.chars.group_by{|x|x}.sort_by{|k,v|[-v.size,k]}.map{|k,v|k}.take(5).join
+      room = sid if m.join(' ').gsub(/[a-z]/){|c| (((c.ord-0x61+sid)%26)+0x61).chr }[/north/]
+    }
+    puts ">> PART1: #{sum}"
+    puts ">> PART2: #{room}"
+    ```
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/5gdvve/2016_day_4_solutions/darm5t9/
+  :body: |-
+    I can do both parts in 3 lines of Ruby, and even construct additional pylons:
+
+    ```ruby
+    l=File.open('input4.txt','r').readlines.map{|l|/^([a-z\-]+)-(\d+)\[([a-z]{5})\]/.match(l).to_a}.select{|pylon|pylon && pylon[1].chars.reject{|c|c=='-'}.each_with_object(Hash.new(0)){|c,o|o[c]+=1}.sort_by{|k,v|-v*256 + k.ord % 256}.map(&:first).first(5).join('') == pylon[3]}
+    l.inject(0){|sum,e|sum+=e[2].to_i}
+    l.map{|s|[s[1].chars.map{|c|((c.ord-'a'.ord+s[2].to_i) % 26+ 'a'.ord).chr}.join(''), s[2].to_i]}.select{|e|e[0] =~ /northpole/}[0][1]
+    ```
+
+    more readable:
+
+    ```ruby
+    l=File.open('input4.txt','r').readlines\
+    .map{|l|/^([a-z\-]+)-(\d+)\[([a-z]{5})\]/\
+    .match(l).to_a}\
+    .select{|pylon|pylon &&
+        pylon[1].chars.reject{|c|c=='-'}\
+    .each_with_object(Hash.new(0)){|c,o|o[c]+=1}\
+    .sort_by{|k,v|-v*256 + k.ord % 256}\
+    .map(&:first)\
+    .first(5)\
+    .join('') == pylon[3]}
+    l.inject(0){|sum,e|sum+=e[2].to_i}
+    l.map{|s|
+      [s[1].chars\
+    .map{|c|((c.ord-'a'.ord+s[2].to_i) % 26+ 'a'.ord).chr}.join(''),
+       s[2].to_i]
+    }.select{|e|e[0] =~ /northpole/}[0][1]
+    ```
+  :replies: []
+- :author: socialmeatloaf
+  :url: https://www.reddit.com/r/adventofcode/comments/5gdvve/2016_day_4_solutions/dasoy5y/
+  :body: |-
+    One disgustingly ugly line of Ruby for Part 1:
+
+    ```ruby
+    puts File.foreach('day4.input').map{ |line| if line.tr('-', '').tr("\n","").gsub(%r{\[\S+\]},"").gsub(/\d/,'').split("").inject(Hash.new(0)) { |h,v| h[v] += 1; h }.sort_by{|k, v| [-v, k]}.first(5).map {|row| row[0]}.join("").eql?line.tr('-', '').match(%r{\[\S+\]})[0].tr('[]',"") then line.match(%r{\d+})[0].to_i end }.compact.inject(0){|sum,x| sum + x }
+    ```
+
+    One disgustingly ugly line of Ruby for Part 2:
+
+    ```ruby
+    File.foreach('day4.input').map{ |line| if line.tr("\n","").split('-').slice(0..line.tr("\n","").split('-').size-2).join("").each_char.inject("") { |newtext, char| newtext + Hash[('a'..'z').to_a.zip(('a'..'z').to_a.rotate(line.tr("\n","").split('-')[-1].gsub(%r{\[\D+\]},"").to_i ))][char]}.include? "north" then puts line.tr("\n","").split('-')[-1].gsub(%r{\[\D+\]},"").to_i end}
+    ```
+  :replies: []

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

@@ -0,0 +1,67 @@
+---
+- :author: broadwall
+  :url: https://www.reddit.com/r/adventofcode/comments/5gk2yv/2016_day_5_solutions/dasy3lw/
+  :body: |-
+    Solution: [GitHub](https://github.com/broad-well/aoc2016/blob/master/day5.rb)
+
+    A bunch of mistakes postponed my 2nd part. They include accidentally calling part 1's code (I should split the files next time) and overwriting certain positions of the password.
+
+    **This program should display a nice hacking effect on ANSI terminals. For part 2, call this using `ruby day5.rb part2`**
+  :replies: []
+- :author: eregontp
+  :url: https://www.reddit.com/r/adventofcode/comments/5gk2yv/2016_day_5_solutions/dat3ff8/
+  :body: |-
+    A clean and simple Ruby solution:
+
+    ```ruby
+    require 'digest/md5'
+    door_id = "reyedfim"
+    start = "00000"
+    code = " "*8
+    (0..Float::INFINITY).each { |i|
+      md5 = Digest::MD5.hexdigest "#{door_id}#{i}"
+      if md5.start_with?(start)
+        p md5
+        pos = Integer(md5[5], 16)
+        digit = md5[6]
+        if 0 <= pos and pos < 8
+          if code[pos] == " "
+            code[pos] = digit
+          end
+          break if code.count(" ") == 0
+        end
+      end
+    }
+    p code
+    ```
+  :replies: []
+- :author: fixed_carbon
+  :url: https://www.reddit.com/r/adventofcode/comments/5gk2yv/2016_day_5_solutions/datwn7c/
+  :body: |-
+    Ruby solution (part two) using an Enumerator to generate [digit, position] pairs. This one is interesting because it generalizes to passwords of any length between 1 and 16 simply by changing the number in the last line of the `take_while` block.
+
+    ```ruby
+    require 'digest'
+
+    # Yields *all* digit, position pairs
+    coderator = Enumerator.new do |y|
+      md5 = Digest::MD5.new
+      (0..Float::INFINITY).each do |n|
+        digest = md5.hexdigest("#{INPUT}#{n}")
+        if digest.start_with?("00000")
+          y.yield [digest[6], digest[5].hex]
+        end
+      end
+    end
+
+    # Applies positional and stateful constraints to digit, position pairs
+    code = Array.new(16, nil)
+    coderator.take_while do |digit, pos|
+      code[pos] = digit if code[pos].nil?
+      puts code.map{|c| c.nil? ? '_' : c}.join
+      code.take(8).include?(nil)
+    end
+
+    puts code.take(8).join
+    ```
+  :replies: []

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

@@ -0,0 +1,89 @@
+---
+- :author: fixed_carbon
+  :url: https://www.reddit.com/r/adventofcode/comments/5gr0xf/2016_day_6_solutions/dauhuao/
+  :body: |-
+    Ruby. `chunk` seems to be getting a lot of exercise in these problems.
+
+    ```ruby
+    INPUTFILE = 'input.txt'
+
+    inp = File.readlines(INPUTFILE).map{|s| s.strip.chars}.transpose
+
+    # Part One
+    puts inp.map{|line| line.sort.chunk{|b| b}.sort_by{|el| el.last.size}.last.first}.join
+
+    # Part Two
+    puts inp.map{|line| line.sort.chunk{|b| b}.sort_by{|el| el.last.size}.first.first}.join
+    ```
+  :replies: []
+- :author: andars_
+  :url: https://www.reddit.com/r/adventofcode/comments/5gr0xf/2016_day_6_solutions/daufndh/
+  :body: |-
+    Ruby.
+
+    ```ruby
+    positions = []
+    10.times do |i|
+      positions << Hash.new(0)
+    end
+
+    File.open(filename).each_line do |line|
+      chars = line.split('')
+      chars.each_with_index do |c, i|
+        positions[i][c] += 1
+      end
+    end
+
+    puts "Part 1:"
+    puts positions.map { |pos|
+      k,_ = pos.max_by{|k,v| v}
+      k
+    }.join
+
+    puts "Part 2:"
+    puts positions.map { |pos|
+      k,_ = pos.min_by{|k,v| v}
+      k
+    }.join
+    ```
+  :replies: []
+- :author: doublehyphen
+  :url: https://www.reddit.com/r/adventofcode/comments/5gr0xf/2016_day_6_solutions/daufx8l/
+  :body: |-
+    Ruby solution. I think it is pretty short and clean.
+
+    ```ruby
+    count = Hash.new { |h, k| h[k] = Hash.new(0) }
+    $stdin.each do |line|
+      line.scan(/./).each_with_index { |c, i| count[i][c] += 1 }
+    end
+    puts count.values.map { |x| x.max_by { |_, n| n }[0] }.join
+    ```
+  :replies: []
+- :author: brantyr
+  :url: https://www.reddit.com/r/adventofcode/comments/5gr0xf/2016_day_6_solutions/dauh5yy/
+  :body: |-
+    Trying to learn ruby... apparently there are no do - while loops...
+
+    ```ruby
+    file = File.new("input06.txt","r")
+    frequencies = Array.new
+    line = file.gets
+    line.each_char do
+        frequencies << Hash.new(0)
+    end
+
+    loop do
+        for i in 0..(line.length-1) do
+            frequencies[i][line[i]] += 1
+        end
+        break if !(line=file.gets)
+    end
+
+    frequencies.each do | current |
+        freqArr = current.sort { |a,b| b[1]<=>a[1]}
+        #print freqArr[0][0] # Part 1
+        print freqArr.last[0] # Part 2
+    end
+    ```
+  :replies: []

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

@@ -0,0 +1,121 @@
+---
+- :author: fixed_carbon
+  :url: https://www.reddit.com/r/adventofcode/comments/5gy1f2/2016_day_7_solutions/daw1gcv/
+  :body: |-
+    Ruby, showing part 2 only. I wasted a bunch of time trying to understand why the sample input for part 1 passed my original regexp-based code, but the real input gave me the wrong answer. Took me forever to realize the real input could contain multiple hypernet sequences on each line. Ditched my nice stateless regexp solution for this stateful mess. I feel all dirty.
+
+    ```ruby
+    def hasababab(code)
+      idx = 0
+      isbracket = false
+      abas = []
+      babs = []
+      code.chars.each_cons(2) do |a, b|
+        isbracket = true if a == '['
+        isbracket = false if a == ']'
+        if a != b
+          if code.chars[idx+2] == a
+            babs << [b,a,b] if isbracket
+            abas << [a,b,a] if !isbracket
+          end
+        end
+        idx += 1
+      end
+      return false if abas.empty? || babs.empty?
+      abas.each do |aba|
+        return true if babs.include?(aba)
+      end
+      return false
+    end
+
+    inp = File.readlines(INPUTFILE).map{|s| s.strip}
+    puts inp.map{|code| hasababab(code)}.count(true)
+    ```
+  :replies:
+  - :author: fixed_carbon
+    :url: https://www.reddit.com/r/adventofcode/comments/5gy1f2/2016_day_7_solutions/daw3542/
+    :body: |-
+      Couldn't resist polishing that stateful turd into a stateless one:
+
+      ```ruby
+      def group(addr)
+        addr.split(/\[|\]/).
+          zip([0, 1].cycle).
+          sort_by{|a, i| i}.
+          chunk{|a, i| i}.to_a.
+          map{|ck, ary| ary.map{|str, num| str} }
+      end
+
+      def checkgroups2(groups)
+        out, hyp = groups.map{|g| g.map{|el| getabas(el)}.flatten}
+        out.each do |o|
+          a, b, c = o.chars
+          return true if hyp.include?(b + a + b)
+        end
+        false
+      end
+
+      def getabas(str)
+        str.chars.each_cons(3).map{|a, b, c| (a == c && a != b) ? [a,b,c].join : nil}.compact
+      end
+
+      inp = File.readlines(INPUTFILE).map{|s| s.strip}
+      inp.map{|addr| checkgroups2(group(addr))}.count(true)
+      ```
+    :replies: []
+- :author: johneffort
+  :url: https://www.reddit.com/r/adventofcode/comments/5gy1f2/2016_day_7_solutions/dawq1go/
+  :body: |-
+    Day 7 part 2 in Ruby:
+
+    ```ruby
+    def abas(input)
+      results = []
+      (0..(input.length - 3)).each do |i|
+        current = input[i..(i+2)]
+        results << current if (current[0] == current[2] && current[0] != current[1])
+      end
+      return results
+    end
+
+    def match(abas, babs)
+      inverted = babs.map{|b|[b[1],b[0],b[1]].join}
+      return (abas & inverted).length > 0
+    end
+
+    def valid(full_input)
+
+      brackets = full_input.scan(/\[(\w+)/).flatten.compact
+      non_brackets = full_input.scan(/(^|\])(\w+)/).map{|l|l[1]}.flatten.compact
+
+    # puts full_input
+    # puts "brackets:#{brackets.join(',')}"
+    # puts "non_brackets:#{non_brackets.join(',')}"
+
+      abas = non_brackets.map{|l|abas(l)}.flatten
+      babs = brackets.map{|l|abas(l)}.flatten
+      return (match(abas, babs))
+    end
+
+    def process(lines)
+      valid_count = 0
+      lines.each do |l|
+        valid = valid(l.strip)
+        valid_count += 1 if valid
+        puts "#{l.strip}: #{valid}"
+      end
+      puts "Total valid: #{valid_count}"
+    end
+
+    test1 = "aba[bab]xyz"
+    test2 = "xyx[xyx]xyx"
+    test3 = "aaa[kek]eke"
+    test4 = "zazbz[bzb]cdb"
+
+    process([test1,test2,test3,test4])
+
+    puts
+
+     process(File.new("day7_input.txt").readlines.map{|l|l.strip})
+    ```
+  :replies: []

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

@@ -0,0 +1,250 @@
+---
+- :author: becojo
+  :url: https://www.reddit.com/r/adventofcode/comments/5h52ro/2016_day_8_solutions/daxi9cd/
+  :body: |-
+    Ayy 20th/13th with Ruby. https://github.com/Becojo/adventofcode/blob/master/2016/day08.rb
+
+    It was indeed a very nice challenge today!
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/5h52ro/2016_day_8_solutions/daxif2o/
+    :body: "[deleted]"
+    :replies:
+    - :author: becojo
+      :url: https://www.reddit.com/r/adventofcode/comments/5h52ro/2016_day_8_solutions/daxilo2/
+      :body: Nice, I did no know that, thank you! I'm so used to this cycle/lazy/drop/take pattern lol.
+      :replies: []
+- :author: blanketandtea
+  :url: https://www.reddit.com/r/adventofcode/comments/5h52ro/2016_day_8_solutions/day4pag/
+  :body: |-
+    **Ruby**
+
+    Reminders to myself
+
+    - do not forget to match all digits of a number
+    - Array#rotate rotates left for positive numbers
+
+    Display data is an array of arrays which allows for using Array#rotate.
+
+    This is straight forward for rows. For columns I map the column pixels to an Array which is then rotated and written back.
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    class Display
+      CMD_MAP = {
+        /^rect (?<p1>\d+)x(?<p2>\d+)$/ => :draw_rect,
+        /^rotate row [xy]=(?<p1>\d+) by (?<p2>\d+)$/ => :rotate_row,
+        /^rotate column [xy]=(?<p1>\d+) by (?<p2>\d+)$/ => :rotate_column
+      }.freeze
+
+      def initialize(width:, height:)
+        @data = Array.new(height) { Array.new(width, 0) }
+      end
+
+      def process_commands(commands)
+        commands.each { |cmd| process_command(cmd) }
+      end
+
+      def process_command(command)
+        CMD_MAP.each do |pattern, method|
+          command.match(pattern) do |m|
+            send(method, m[:p1].to_i, m[:p2].to_i)
+            return true
+          end
+        end
+        raise "Unknown command '#{command}'"
+      end
+
+      def draw_rect(width, height)
+        width.times { |x| height.times { |y| @data[y][x] = 1 } }
+      end
+
+      def rotate_column(index, dist)
+        @data.map { |row| row[index] }
+             .rotate(-dist)
+             .each_with_index { |c, i| @data[i][index] = c }
+      end
+
+      def rotate_row(index, dist)
+        @data[index].rotate!(-dist)
+      end
+
+      def pixels_lit
+        @data.flatten.inject(0, &:+)
+      end
+
+      def print
+        puts '=' * (@data[0].size * 2 + 4)
+        @data.each { |ln| puts "==#{ln.map { |px| px == 1 ? '##' : ' ' }.join}==" }
+        puts '=' * (@data[0].size * 2 + 4)
+      end
+    end
+
+    display = Display.new(width: 50, height: 6)
+    commands = open(ARGV[0]).readlines.map(&:strip)
+    display.process_commands(commands)
+
+    display.print
+    puts "Puzzle08 Step1: Pixels lit: #{display.pixels_lit}"
+    puts 'Puzzle08 Step2: Read the displayprint above'
+    ```
+  :replies: []
+- :author: johneffort
+  :url: https://www.reddit.com/r/adventofcode/comments/5h52ro/2016_day_8_solutions/day5zot/
+  :body: |-
+    Ruby Day 8. I really liked the way you can use .transpose and .rotate, it makes the actual work code quite clean.
+
+    ```ruby
+    class Screen
+
+      def initialize(width, height)
+        @array = []
+        height.times do |l|
+          line = [false] * width
+          @array << line
+        end
+      end
+
+      def rect(width, height)
+        (0...height).each do |h|
+          (0...width).each do |w|
+            @array[h][w] = true
+          end
+        end
+      end
+
+      def rotate_column(x, by)
+        transposed = @array.transpose
+        transposed[x].rotate!(-by)
+        @array = transposed.transpose
+      end
+
+      def rotate_row(y, by)
+        @array[y].rotate!(-by)
+      end
+
+      def values
+        @array.flatten
+      end
+
+      def to_s
+        @array.length.times do |y|
+          puts @array[y].map{|v|v ? "#" : "."}.join
+        end
+      end
+    end
+
+    class Processor
+
+      attr_reader :screen
+
+      def initialize(width, height)
+        @screen = Screen.new(width,height)
+      end
+
+      def process_command(command)
+        m = command.match(/rect (\d+)x(\d+)/)
+        if (m)
+          @screen.rect(m[1].to_i, m[2].to_i)
+          return
+        end
+        m = command.match(/rotate column x=(\d+) by (\d+)/)
+        if (m)
+          @screen.rotate_column(m[1].to_i, m[2].to_i)
+          return
+        end
+        m = command.match(/rotate row y=(\d+) by (\d+)/)
+        if (m)
+          @screen.rotate_row(m[1].to_i, m[2].to_i)
+          return
+        end
+
+      end
+
+      def lit
+        @screen.values.count{|v|v}
+      end
+
+      def to_s
+        @screen.to_s
+      end
+
+    end
+
+    p = Processor.new(7,3)
+    p.process_command("rect 3x2")
+    puts p
+    p.process_command("rotate column x=1 by 1")
+    puts p
+    p.process_command("rotate row y=0 by 4")
+    puts p
+    p.process_command("rotate column x=1 by 1")
+    puts p
+    puts
+
+    p = Processor.new(50,6)
+    File.new("day8_input.txt").readlines.map{|l|l.strip}.each do |l|
+      p.process_command(l)
+    end
+    puts p.lit
+    ```
+  :replies: []
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/5h52ro/2016_day_8_solutions/dazgoas/
+  :body: |-
+    ok i feel pretty good about this one, i actually implemented a basic dsl in ruby and execute each line of input as if it was an invokation. things i liked - \* dsl approach \* realising rotating a row is the same as rotating a transposed column \* writing a visualisation before completing part one, meaning i got part 2 for free :D
+
+    ```ruby
+    input = File.open("input.txt").readlines.map {|l| l.chomp }
+
+    @grid = Array.new(50){ Array.new(6) { 0 }}
+
+    def rect pos
+      x,y = pos.match(/(\d+)x(\d+)/).captures.map{|s| s.to_i}
+
+      0.upto(x-1) do |row|
+        0.upto(y-1) do |column|
+          @grid[row][column] = 1
+        end
+      end
+    end
+
+    def rotate input
+      type, dim,loc, amount = input.match(/\s*(row|column)\s(x|y)=(\d+)\sby\s(\d+)/).captures
+      case type
+      when "column"
+        rotate_column loc.to_i, amount.to_i
+      when "row"
+        rotate_row loc.to_i, amount.to_i
+      end
+    end
+
+    def rotate_column column, val
+      d = @grid[column].pop val
+      @grid[column].unshift(d).flatten!
+      nil
+    end
+
+    def rotate_row row, val
+      @grid = @grid.transpose
+      rotate_column row, val
+      @grid = @grid.transpose
+      nil
+    end
+
+    def pg
+      @grid.transpose.each {|l| puts l.join.gsub("1","#").gsub("0","-") }
+      nil
+    end
+
+    input.each do |line|
+      cmd, input = line.match(/(\w+)\s(.*)/).captures
+      eval "#{cmd} '#{input}'"
+    end
+
+    pg
+
+    puts @grid.flatten.reduce(:+)
+    ```
+  :replies: []

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

@@ -0,0 +1,5 @@
+---
+- :author: andars_
+  :url: https://www.reddit.com/r/adventofcode/comments/5hbygy/2016_day_9_solutions/daz2oxg/
+  :body: "[Ruby](https://github.com/andars/advent-of-code/blob/14db4fca586360e6301d89d76245c733a5fbd28b/2016/day9/task.rb). 118/138"
+  :replies: []