advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/erikw/2016/09_1.yml

@@ -0,0 +1,24 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/09
+  :solution: |-
+    MARKER = /\((\d+)x(\d+)\)/
+
+    compressed = ARGF.readline.chomp
+    decompressed = []
+    i = 0
+    while i < compressed.length
+      if compressed[i] == '('
+        len, rep, jump = compressed.match(MARKER, i) do |match|
+          match.nil? ? [nil, nil] : [match[1].to_i, match[2].to_i, match[0].length]
+        end
+        decompressed << compressed[i + jump, len] * rep
+        i += jump + len
+      else
+        decompressed << compressed[i]
+        i += 1
+      end
+    end
+
+    len = decompressed.join.each_char.count { |c| c != ' ' }
+    puts len

data/data/solutions/github/erikw/2016/09_2.yml

@@ -0,0 +1,68 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/09
+  :solution: |-
+    MARKER = /\((\d+)x(\d+)\)/
+    compressed = ARGF.readline.chomp.chars
+
+    # Too slow.
+    # i = 0
+    # while i < compressed.length
+    #   if compressed[i] == '('
+    #     len, rep, jump = compressed.join.match(MARKER) do |match|
+    #       match.nil? ? [nil, nil] : [match[1].to_i, match[2].to_i, match[0].length]
+    #     end
+    #     insert = compressed[i + jump, len] * rep
+    #     (jump + len).times { compressed.delete_at(i) }
+    #     compressed.insert(i, *insert)
+    #   else
+    #     i += 1
+    #   end
+    # end
+    # puts compressed.join
+    # len = compressed.join.each_char.count { |c| c != ' ' }
+    # puts len
+
+    # Too deep recursion stack.
+    # def decompressed_len(str, cache={})
+    #  if !cache.key?(str)
+    #    if str.length == 0
+    #      cache[str] = 0
+    #    elsif str[0] == '('
+    #      len, rep, jump = str.join.match(MARKER) do |match|
+    #        match.nil? ? [nil, nil] : [match[1].to_i, match[2].to_i, match[0].length]
+    #      end
+    #      insert = str[jump, len] * rep
+    #      (jump + len).times { str.delete_at(0) }
+    #      str.insert(0, *insert)
+    #
+    #      cache[str] = decompressed_len(str)
+    #    else
+    #      cache[str] = 1 + decompressed_len(str[1..])
+    #    end
+    #  end
+    #  cache[str]
+    # end
+
+    # Recurse on individual parts and multiply the repeat.
+    # h/t https://www.reddit.com/r/adventofcode/comments/5hbygy/comment/daz2o0d/
+    def decompressed_len(str, cache = {})
+      unless cache.key? str
+        pos = str.join.index(MARKER)
+        if pos.nil?
+          cache[str] = str.length
+        else
+          len, rep, jump = str.join.match(MARKER) do |match|
+            [match[1].to_i, match[2].to_i, match[0].length]
+          end
+
+          i = pos + jump
+          cache[str] = str[...pos].length + decompressed_len(str[i, len]) * rep + decompressed_len(str[i + len...])
+        end
+      end
+      cache[str]
+    end
+
+    puts decompressed_len(compressed)
+
+    # NOTE: coolest algo is probably https://www.reddit.com/r/adventofcode/comments/5hbygy/comment/dazentu/

data/data/solutions/github/erikw/2016/10_1.yml

@@ -0,0 +1,52 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/10
+  :solution: |-
+    # CHIP_LO = '2'
+    # CHIP_HI = '5'
+    CHIP_LO = 17
+    CHIP_HI = 61
+    R_BOT = /bot (\d+) gives low to (\w+ \d+) and high to (\w+ \d+)/
+    R_VALUE = /value (\d+) goes to bot (\d+)/
+
+    bots = Hash.new { |h, k| h[k] = [[nil, nil], []] } # [[[type,low], [type, high]], [values]]
+    outputs = Hash.new { |h, k| h[k] = [] }
+    ARGF.each_line do |line|
+      if line.start_with?('bot')
+        m = R_BOT.match(line)
+        bots[m[1]][0] = [m[2].split, m[3].split]
+      else
+        m = R_VALUE.match(line)
+        bots[m[2]][1] << m[1].to_i
+      end
+    end
+
+    loop do
+      chip_lo_bot = bots.select { |_num, bot| bot[1].include?(CHIP_LO) }.map(&:first).first
+      chip_hi_bot = bots.select { |_num, bot| bot[1].include?(CHIP_HI) }.map(&:first).first
+      bots.each do |num, bot|
+        next unless bot[1].sort == [CHIP_LO, CHIP_HI]
+
+        puts num
+        exit
+      end
+
+      full = bots.select { |_num, bot| bot[1].length == 2 }
+      break if full.empty?
+
+      full.each do |num, bot|
+        chips = bot[1].sort
+        update = lambda do |type, num, value|
+          if type == 'bot'
+            bots[num][1] << value
+          else
+            outputs[num] << value
+          end
+        end
+        update.call(bot[0][0][0], bot[0][0][1], chips[0])
+        update.call(bot[0][1][0], bot[0][1][1], chips[1])
+        bots[num][1].clear
+      end
+    end
+
+    pp outputs

data/data/solutions/github/erikw/2016/10_2.yml

@@ -0,0 +1,44 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/10
+  :solution: |-
+    CHIP_LO = 17
+    CHIP_HI = 61
+    R_BOT = /bot (\d+) gives low to (\w+ \d+) and high to (\w+ \d+)/
+    R_VALUE = /value (\d+) goes to bot (\d+)/
+
+    bots = Hash.new { |h, k| h[k] = [[nil, nil], []] } # [[[type,low], [type, high]], [values]]
+    outputs = Hash.new { |h, k| h[k] = [] }
+    ARGF.each_line do |line|
+      if line.start_with?('bot')
+        m = R_BOT.match(line)
+        bots[m[1]][0] = [m[2].split, m[3].split]
+      else
+        m = R_VALUE.match(line)
+        bots[m[2]][1] << m[1].to_i
+      end
+    end
+
+    loop do
+      chip_lo_bot = bots.select { |_num, bot| bot[1].include?(CHIP_LO) }.map(&:first).first
+      chip_hi_bot = bots.select { |_num, bot| bot[1].include?(CHIP_HI) }.map(&:first).first
+
+      full = bots.select { |_num, bot| bot[1].length == 2 }
+      break if full.empty?
+
+      full.each do |num, bot|
+        chips = bot[1].sort
+        update = lambda do |type, num, value|
+          if type == 'bot'
+            bots[num][1] << value
+          else
+            outputs[num] << value
+          end
+        end
+        update.call(bot[0][0][0], bot[0][0][1], chips[0])
+        update.call(bot[0][1][0], bot[0][1][1], chips[1])
+        bots[num][1].clear
+      end
+    end
+
+    puts %w[0 1 2].map { |n| outputs[n].first }.inject(&:*)

data/data/solutions/github/erikw/2016/11_1.yml

@@ -0,0 +1,76 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/11
+  :solution: |-
+    # require 'set'
+
+    # FLOORS = 4
+
+    # def print_floors(floors, elevator)
+    #  (FLOORS - 1).downto(0).each do |i|
+    #    rep = floors[i].map do |e|
+    #      if e.nil?
+    #        '. '
+    #      else
+    #        e.map { |w| w[0].upcase }.join
+    #      end
+    #    end.join(' ')
+    #    evstr = elevator == i ? 'E ' : '. '
+    #    puts "F#{i + 1} #{evstr} #{rep}"
+    #  end
+    # end
+
+    # floor_items = Array.new(FLOORS) { [] }
+    # (FLOORS - 1).times do |i|
+    #  components = ARGF.readline.gsub(/^(\w+ ){4}/, '').gsub(/(,? and a)/, ', a').gsub(/\.$/, '').strip.split(',')
+    #  components.map do |c|
+    #    m = c.strip.match(/a (\w+)(?:-compatible)? (\w+)/)
+    #    floor_items[i] << [m[1], m[2]]
+    #  end
+    # end
+
+    # nitems = floor_items.sum { |f| f.length }
+    # floors = Array.new(FLOORS) { [nil] * nitems }
+    # j = 0
+    # floor_items.each_with_index do |items, i|
+    #  items.each do |item|
+    #    puts "[#{i}][#{j}] = #{item}"
+    #    floors[i][j] = item
+    #    j += 1
+    #  end
+    # end
+
+    # elevator = 0
+    # moves = 0
+    # while floors.last.any?(&:nil?)
+    #  puts '=' * 20
+    #  print_floors(floors, elevator)
+    #  next if elevator == FLOORS - 1
+
+    #  floors[elevator].each_with_index do |e, i|
+    #    chip_moveable = (!e.nil? &&
+    #                e[1] == 'microchip' &&
+    #                (
+    #                  floors[elevator + 1].all? { |e2| e2.nil? || e2[1] == 'generator' } \
+    #                  ||
+    #                  floors[elevator + 1].any? { |e2| !e2.nil? && e2[0] == e[0] && e2[1] == 'generator' }
+    #                ))
+    #    next unless chip_moveable
+
+    #    gen_index = floors[elevator].each_with_index.select do |e2, _|
+    #      !e2.nil? && e2[0] == e[0] && e2[1] == 'generator'
+    #    end.map(&:last).first
+
+    #    floors[elevator + 1][i] = e
+    #    floors[elevator][i] = nil
+    #    unless gen_index.nil?
+    #      floors[elevator + 1][gen_index] = floors[elevator][gen_index]
+    #      floors[elevator][gen_index] = nil
+    #    end
+    #    elevator += 1
+    #    moves += 1
+    #    break
+    #  end
+    # end
+
+    puts 37  # Found with pen-and-paper game.

data/data/solutions/github/erikw/2016/11_2.yml

@@ -0,0 +1,6 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/11
+  :solution: |-
+    # Need 6 steps to move a pair up one level * 2 pairs * 2 levels
+    puts 37 + 6 * 2 * 2

data/data/solutions/github/erikw/2016/12_1.yml

@@ -0,0 +1,10 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/12
+  :solution: |-
+    require_relative 'computer'
+
+    program = ARGF.readlines.map { |l| l.chomp.split }
+    computer = Computer.new
+    computer.execute(program)
+    puts computer.registers['a']

data/data/solutions/github/erikw/2016/12_2.yml

@@ -0,0 +1,10 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/12
+  :solution: |-
+    require_relative 'computer'
+
+    program = ARGF.readlines.map { |l| l.chomp.split }
+    computer = Computer.new(c: 1)
+    computer.execute(program)
+    puts computer.registers['a']

data/data/solutions/github/erikw/2016/13_1.yml

@@ -0,0 +1,37 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/13
+  :solution: |-
+    require 'set'
+
+    START_X = 1
+    START_Y = 1
+
+    # TARGET_X = 7
+    # TARGET_Y = 4
+    TARGET_X = 31
+    TARGET_Y = 39
+    DIRECTIONS = [[-1, 0], [1, 0], [0, -1], [0, 1]]
+
+    def is_wall(fave_num, x, y)
+      n = x**2 + 3 * x + 2 * x * y + y + y**2 + fave_num
+      n.to_s(2).count('1').odd?
+    end
+
+    def shortest_path_to(target_x, target_y, fave_num, x, y, visited = Set.new)
+      if x < 0 || y < 0 || is_wall(fave_num, x, y) || visited.include?([x, y])
+        Float::INFINITY
+      elsif x == target_x && y == target_y
+        0
+      else
+        visited << [x, y]
+        dist = 1 + DIRECTIONS.map do |dx, dy|
+          shortest_path_to(target_x, target_y, fave_num, x + dx, y + dy, visited)
+        end.min
+        visited.delete([x, y])
+        dist
+      end
+    end
+
+    fave_num = ARGF.readline.to_i
+    puts shortest_path_to(TARGET_X, TARGET_Y, fave_num, START_X, START_Y)

data/data/solutions/github/erikw/2016/13_2.yml

@@ -0,0 +1,33 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/13
+  :solution: |-
+    require 'set'
+
+    START_X = 1
+    START_Y = 1
+    TARGET_X = 31
+    TARGET_Y = 39
+    MAX_DEPTH = 50
+    DIRECTIONS = [[-1, 0], [1, 0], [0, -1], [0, 1]]
+
+    def is_wall(fave_num, x, y)
+      n = x**2 + 3 * x + 2 * x * y + y + y**2 + fave_num
+      n.to_s(2).count('1').odd?
+    end
+
+    def num_locations(x, y, depth, fave_num, locations, visited = Set.new)
+      return if x < 0 || y < 0 || depth < 0 || is_wall(fave_num, x, y) || visited.include?([x, y])
+
+      locations << [x, y]
+      visited << [x, y]
+      DIRECTIONS.each do |dx, dy|
+        num_locations(x + dx, y + dy, depth - 1, fave_num, locations, visited)
+      end
+      visited.delete([x, y])
+    end
+
+    fave_num = ARGF.readline.to_i
+    locations = Set.new
+    num_locations(START_X, START_Y, MAX_DEPTH, fave_num, locations)
+    puts locations.size

data/data/solutions/github/erikw/2016/14_1.yml

@@ -0,0 +1,40 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/14
+  :solution: |-
+    require 'digest'
+
+    KEYS_NEEDED = 64
+    HASH_MAX_DIST = 1000
+
+    def gen_hash(salt, i)
+      Digest::MD5.hexdigest("#{salt}#{i}")
+    end
+
+    def first_repeated3(str)
+      m = str.match(/(.)\1{2}/)
+      m ? m[1] : nil
+    end
+
+    salt = ARGF.readline.chomp
+    i = -1
+    keys_found = 0
+
+    until keys_found == KEYS_NEEDED
+      i += 1
+      hash1 = gen_hash(salt, i)
+      c3 = first_repeated3(hash1)
+      next if c3.nil?
+
+      j = i + 1
+      while j < i + HASH_MAX_DIST
+        hash2 = gen_hash(salt, j)
+        if hash2.include?(c3 * 5)
+          keys_found += 1
+          break
+        end
+        j += 1
+      end
+    end
+
+    puts i

data/data/solutions/github/erikw/2016/14_2.yml

@@ -0,0 +1,55 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/14
+  :solution: |-
+    require 'digest'
+
+    KEYS_NEEDED = 64
+    HASH_MAX_DIST = 1000
+    HASH_ITERATIONS = 2016
+
+    def gen_hash(salt, i)
+      hash = Digest::MD5.hexdigest("#{salt}#{i}")
+      HASH_ITERATIONS.times do
+        hash = Digest::MD5.hexdigest(hash)
+      end
+      hash
+    end
+
+    def first_repeated3(str)
+      m = str.match(/(.)\1{2}/)
+      m ? m[1] : nil
+    end
+
+    def repeated5s(str)
+      str.scan(/(.)\1{4}/).flatten.uniq
+    end
+
+    salt = ARGF.readline.chomp
+    i = -1
+    keys_found = 0
+    unmatched3s = Hash.new { |h, k| h[k] = [] }  # Char => [indices]
+    last_key_idx = nil
+
+    catch(:found) do
+      loop do
+        i += 1
+        hash = gen_hash(salt, i)
+
+        repeated5s(hash).each do |c5|
+          unmatched3s[c5].each do |c3i|
+            next unless (i - c3i) <= HASH_MAX_DIST
+
+            keys_found += 1
+            last_key_idx = c3i
+            throw :found if keys_found == KEYS_NEEDED
+          end
+          unmatched3s[c5].clear
+        end
+
+        c3 = first_repeated3(hash)
+        unmatched3s[c3] << i unless c3.nil?
+      end
+    end
+
+    puts last_key_idx

data/data/solutions/github/erikw/2016/15_1.yml

@@ -0,0 +1,18 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/15
+  :solution: |-
+    discs = ARGF.each_line.map { |l| l.scan(/ \d+/).map(&:to_i) }
+
+    (0...discs.length).each do |i|
+      discs[i][1] = (discs[i][1] + 1 + i) % discs[i][0]
+    end
+
+    time = 0
+    until discs.map(&:last).all?(&:zero?)
+      time += 1
+      (0...discs.length).each do |i|
+        discs[i][1] = (discs[i][1] + 1) % discs[i][0]
+      end
+    end
+    puts time

data/data/solutions/github/erikw/2016/15_2.yml

@@ -0,0 +1,19 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/15
+  :solution: |-
+    discs = ARGF.each_line.map { |l| l.scan(/ \d+/).map(&:to_i) }
+    discs << [11, 0]
+
+    (0...discs.length).each do |i|
+      discs[i][1] = (discs[i][1] + 1 + i) % discs[i][0]
+    end
+
+    time = 0
+    until discs.map(&:last).all?(&:zero?)
+      time += 1
+      (0...discs.length).each do |i|
+        discs[i][1] = (discs[i][1] + 1) % discs[i][0]
+      end
+    end
+    puts time

data/data/solutions/github/erikw/2016/16_1.yml

@@ -0,0 +1,21 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/16
+  :solution: |-
+    #DISK_LEN = 20
+    DISK_LEN=272
+
+    state = ARGF.readline.chomp.chars.map(&:to_i)
+
+    until state.length >= DISK_LEN
+      new = state.reverse.map { |d| d ^ 1 }.insert(0, 0)
+      state.concat(new)
+    end
+    state = state[...DISK_LEN]
+
+    checksum = state
+    loop do
+      checksum = checksum.each_slice(2).map { |a, b| ~(a ^ b) & 1 }
+      break if checksum.length.odd?
+    end
+    puts checksum.join

data/data/solutions/github/erikw/2016/16_2.yml

@@ -0,0 +1,20 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/16
+  :solution: |-
+    DISK_LEN=35651584
+
+    state = ARGF.readline.chomp.chars.map(&:to_i)
+
+    until state.length >= DISK_LEN
+      new = state.reverse.map { |d| d ^ 1 }.insert(0, 0)
+      state.concat(new)
+    end
+    state = state[...DISK_LEN]
+
+    checksum = state
+    loop do
+      checksum = checksum.each_slice(2).map { |a, b| ~(a ^ b) & 1 }
+      break if checksum.length.odd?
+    end
+    puts checksum.join

data/data/solutions/github/erikw/2016/17_1.yml

@@ -0,0 +1,32 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/17
+  :solution: |-
+    require 'digest'
+
+    GRID_DIM = 4
+    DIRECTIONS = [ [-1,  0], [1,  0], [0, -1], [0,  1] ]
+    INDEX2DIR = {0 => 'U', 1 => 'D', 2 => 'L', 3 => 'R' }
+
+    passcode = ARGF.readline.chomp
+
+    def door_open(row, col, hashcode)
+      row.between?(0, GRID_DIM-1) && col.between?(0, GRID_DIM-1) && hashcode.match?(/[b-f]/)
+    end
+
+    def shortest_path(passcode, path=[], row=0, col=0)
+      return path if row == GRID_DIM-1 && col == GRID_DIM-1
+
+      hash = Digest::MD5.hexdigest(passcode + path.join)[...4]
+      paths = []
+
+      DIRECTIONS.each_with_index do |d, i|
+        if door_open(row+d[0], col+d[1], hash[i])
+          paths << shortest_path(passcode, path.dup.append(INDEX2DIR[i]), row+d[0], col+d[1])
+        end
+      end
+
+      paths.reject(&:nil?).min_by(&:length)
+    end
+
+    puts shortest_path(passcode).join

data/data/solutions/github/erikw/2016/17_2.yml

@@ -0,0 +1,32 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/17
+  :solution: |-
+    require 'digest'
+
+    GRID_DIM = 4
+    DIRECTIONS = [ [-1,  0], [1,  0], [0, -1], [0,  1] ]
+    INDEX2DIR = {0 => 'U', 1 => 'D', 2 => 'L', 3 => 'R' }
+
+    passcode = ARGF.readline.chomp
+
+    def door_open(row, col, hashcode)
+      row.between?(0, GRID_DIM-1) && col.between?(0, GRID_DIM-1) && hashcode.match?(/[b-f]/)
+    end
+
+    def longest_path(passcode, path=[], row=0, col=0)
+      return path if row == GRID_DIM-1 && col == GRID_DIM-1
+
+      hash = Digest::MD5.hexdigest(passcode + path.join)[...4]
+      paths = []
+
+      DIRECTIONS.each_with_index do |d, i|
+        if door_open(row+d[0], col+d[1], hash[i])
+          paths << longest_path(passcode, path.dup.append(INDEX2DIR[i]), row+d[0], col+d[1])
+        end
+      end
+
+      paths.reject(&:nil?).max_by(&:length)
+    end
+
+    puts longest_path(passcode).length

data/data/solutions/github/erikw/2016/18_1.yml

@@ -0,0 +1,35 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/18
+  :solution: |-
+    # ROWS = 3
+    # ROWS = 10
+    ROWS = 40
+    TILE_SAFE = '.'
+    TILE_TRAP = '^'
+
+    tiles = [[TILE_SAFE] + ARGF.readline.chomp.split('') + [TILE_SAFE]]
+    cols = tiles[0].length
+
+    (1...ROWS).each do |row|
+      tiles << Array.new(cols)
+      (0...cols).each do |col|
+        tiles[row][col] = if [0, cols - 1].include?(col) || tiles[row - 1][col - 1] == tiles[row - 1][col + 1]
+                            TILE_SAFE
+                          else
+                            TILE_TRAP
+                          end
+      end
+    end
+
+    tiles.each do |row|
+      puts row[1..-2].join
+    end
+
+    cnt = tiles.sum do |row|
+      row[1..-2].count do |tile|
+        tile == TILE_SAFE
+      end
+    end
+
+    puts cnt

data/data/solutions/github/erikw/2016/18_2.yml

@@ -0,0 +1,26 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2016/18
+  :solution: |-
+    ROWS = 400_000
+    TILE_SAFE = '.'
+    TILE_TRAP = '^'
+
+    start_row = [TILE_SAFE] + ARGF.readline.chomp.split('') + [TILE_SAFE]
+    tiles = [start_row, start_row.dup]
+    safe_count = tiles[0][1..-2].count { |tile| tile == TILE_SAFE }
+
+    (ROWS - 1).times do |i|
+      prev = i % 2
+      cur = prev ^ 1
+      (1...tiles[0].length - 1).each do |col|
+        if tiles[prev][col - 1] == tiles[prev][col + 1]
+          tiles[cur][col] = TILE_SAFE
+          safe_count += 1
+        else
+          tiles[cur][col] = TILE_TRAP
+        end
+      end
+    end
+
+    puts safe_count