advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/eregon/2018/11_2.yml

@@ -0,0 +1,46 @@
+---
+- :name: 11b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    GRID_SERIAL_NUMBER = 9995
+
+    def power_level(x, y)
+      rack_id = x + 10
+      power = ((rack_id * y) + GRID_SERIAL_NUMBER) * rack_id
+      raise if power < 0
+      power = (power % 1000) / 100
+      power - 5
+    end
+
+    RANGE = (1..300)
+    POWER = [0, *RANGE].map { |y|
+      [0, *RANGE].map { |x|
+        power_level(x, y)
+      }
+    }
+
+    def best_square(size)
+      best = nil
+      best_score = -10 * size * size
+
+      RANGE.each_cons(size) { |yy|
+        RANGE.each_cons(size) { |xx|
+          score = yy.sum { |y| xx.sum { |x| POWER[y][x] } }
+          if score > best_score
+            best = [xx[0], yy[0]]
+            best_score = score
+          end
+        }
+      }
+
+      [best, best_score]
+    end
+
+    best, best_score = (1..20).map { |size|
+      p size
+      best, best_score = best_square(size)
+      p [(best + [size]).join(','), best_score]
+    }.max_by(&:last)
+
+    p best_score
+    puts best

data/data/solutions/github/eregon/2018/12_1.yml

@@ -0,0 +1,30 @@
+---
+- :name: 12a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    class String
+      def pad
+        raise if start_with?("....")
+        until start_with?("...")
+          prepend "."
+          $offset -= 1
+        end
+        self << "." until end_with?("...")
+        self
+      end
+    end
+
+    $offset = 0
+    state, _, *rules = File.readlines("12.txt", chomp: true)
+    state = state[/initial state: (.+)/, 1].pad
+    rules = rules.map { |rule| rule.split(" => ") }.to_h
+
+    (1..20).each do |step|
+      $offset += 2
+      state = state.chars.each_cons(5).map { |s|
+        rules[s.join] || "."
+      }.join.pad
+      puts ("%2d: " % step) + state
+    end
+
+    p state.each_char.with_index($offset).sum { |e,i| e == "." ? 0 : i }

data/data/solutions/github/eregon/2018/12_2.yml

@@ -0,0 +1,38 @@
+---
+- :name: 12b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    class String
+      def pad
+        raise if start_with?("....")
+        until start_with?("...")
+          prepend "."
+          $offset -= 1
+        end
+        self << "." until end_with?("...")
+        self
+      end
+    end
+
+    $offset = 0
+    state, _, *rules = File.readlines("12.txt", chomp: true)
+    state = state[/initial state: (.+)/, 1].pad
+    rules = rules.map { |rule| rule.split(" => ") }.to_h
+    cache = {}
+
+    (1..50_000_000_000).each do |step|
+      break if cache.key?(state) and cache[state][0] == state
+
+      old_offset = $offset
+      $offset += 2
+      new_state = state.chars.each_cons(5).map { |s|
+        rules[s.join] || "."
+      }.join.pad
+
+      cache[state] = [new_state, $offset-old_offset, step]
+      state = new_state
+    end
+
+    repeating_state, doffset, step = cache[state]
+    $offset += (50_000_000_000 - step) * doffset
+    p state.each_char.with_index($offset).sum { |e,i| e == "." ? 0 : i }

data/data/solutions/github/eregon/2018/13_1.yml

@@ -0,0 +1,81 @@
+---
+- :name: 13a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    lines = File.readlines("13.txt", chomp: true)
+
+    DIRS = [1, 1.i, -1, -1.i]
+
+    CHOICE = [
+      -> dir { DIRS[DIRS.index(dir)-1] }, # left
+      -> dir { dir }, # straight
+      -> dir { DIRS[DIRS.index(dir)-3] }, # right
+    ]
+
+    Cart = Struct.new(:pos, :dir, :choice) do
+      def x
+        pos.real
+      end
+      def y
+        pos.imag
+      end
+    end
+
+    carts = []
+
+    board = lines.map.with_index { |line, y|
+      line.chars.map.with_index { |c, x|
+        case c
+        when "v", "^"
+          dy = c == "v" ? 1.i : -1.i
+          carts << Cart.new(x + y.i, dy, CHOICE.cycle)
+          c = "|"
+        when "<", ">"
+          dx = c == ">" ? 1 : -1
+          carts << Cart.new(x + y.i, dx, CHOICE.cycle)
+          c = "-"
+        end
+
+        case c
+        when "|"
+          {-1.i => -1.i, 1.i => 1.i}
+        when "-"
+          {-1 => -1, 1 => 1}
+        when "/"
+          {-1.i => 1, -1 => 1.i, 1 => -1.i, 1.i => -1}
+        when "\\"
+          {-1.i => -1, 1 => 1.i, 1.i => 1, -1 => -1.i}
+        when " "
+          " "
+        when "+"
+          "+"
+        else
+          raise c
+        end
+      }
+    }
+
+    width = board.map(&:size).max
+
+    loop do
+      carts.sort_by! { |cart| cart.y * width + cart.x }
+
+      carts.each { |cart|
+        track = board[cart.y][cart.x]
+        case track
+        when Hash
+          cart.dir = track.fetch(cart.dir)
+          cart.pos += cart.dir
+        when "+"
+          cart.dir = cart.choice.next.call(cart.dir)
+          cart.pos += cart.dir
+        else
+          raise track
+        end
+
+        if carts.map(&:pos).uniq.size != carts.size
+          puts "#{cart.x},#{cart.y}"
+          exit
+        end
+      }
+    end

data/data/solutions/github/eregon/2018/13_2.yml

@@ -0,0 +1,93 @@
+---
+- :name: 13b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    lines = File.readlines("13.txt", chomp: true)
+
+    DIRS = [1, 1.i, -1, -1.i]
+
+    CHOICE = [
+      -> dir { DIRS[DIRS.index(dir)-1] }, # left
+      -> dir { dir }, # straight
+      -> dir { DIRS[DIRS.index(dir)-3] }, # right
+    ]
+
+    Cart = Struct.new(:pos, :dir, :choice, :crashed) do
+      def x
+        pos.real
+      end
+      def y
+        pos.imag
+      end
+    end
+
+    carts = []
+
+    board = lines.map.with_index { |line, y|
+      line.chars.map.with_index { |c, x|
+        case c
+        when "v", "^"
+          dy = c == "v" ? 1.i : -1.i
+          carts << Cart.new(x + y.i, dy, CHOICE.cycle, false)
+          c = "|"
+        when "<", ">"
+          dx = c == ">" ? 1 : -1
+          carts << Cart.new(x + y.i, dx, CHOICE.cycle, false)
+          c = "-"
+        end
+
+        case c
+        when "|"
+          {-1.i => -1.i, 1.i => 1.i}
+        when "-"
+          {-1 => -1, 1 => 1}
+        when "/"
+          {-1.i => 1, -1 => 1.i, 1 => -1.i, 1.i => -1}
+        when "\\"
+          {-1.i => -1, 1 => 1.i, 1.i => 1, -1 => -1.i}
+        when " "
+          " "
+        when "+"
+          "+"
+        else
+          raise c
+        end
+      }
+    }
+
+    width = board.map(&:size).max
+
+    while carts.size > 1
+      carts.sort_by! { |cart| cart.y * width + cart.x }
+
+      carts.each { |cart|
+        next if cart.crashed
+
+        track = board[cart.y][cart.x]
+        case track
+        when Hash
+          cart.dir = track.fetch(cart.dir)
+          cart.pos += cart.dir
+        when "+"
+          cart.dir = cart.choice.next.call(cart.dir)
+          cart.pos += cart.dir
+        else
+          raise track
+        end
+
+        if carts.map(&:pos).uniq.size != carts.size
+          freq = Hash.new(0)
+          carts.each { |cart| freq[cart.pos] += 1 }
+          to_remove = []
+          freq.each_pair { |pos, count| to_remove << pos if count > 1 }
+          carts = carts.reject { |cart|
+            if to_remove.include?(cart.pos)
+              cart.crashed = true
+            end
+          }
+        end
+      }
+    end
+
+    cart = carts.first
+    puts "#{cart.x},#{cart.y}"

data/data/solutions/github/eregon/2018/14_1.yml

@@ -0,0 +1,19 @@
+---
+- :name: 14a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    n = 77201
+
+    elves = [0, 1]
+    recipes = [3, 7]
+    limit = n + 10
+
+    until recipes.size >= limit
+      recipes.concat elves.sum { |elf| recipes[elf] }.to_s.chars.map(&:to_i)
+
+      elves.map! { |elf|
+        (elf + 1 + recipes[elf]) % recipes.size
+      }
+    end
+
+    puts recipes[n, 10].join

data/data/solutions/github/eregon/2018/14_2.yml

@@ -0,0 +1,69 @@
+---
+- :name: 14b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    ENDING = '077201'.chars.map(&:to_i)
+    elves = [0, 1]
+    recipes = [3, 7]
+
+    # recipes[-ENDING.size..-1] == ENDING is too slow
+    eval <<-AOC
+    def check(recipes)
+      #{ENDING.map.with_index { |d,i| "recipes[#{-ENDING.size+i}] == #{d}" }.join(' && ')}
+    end
+    AOC
+
+    def check(recipes)
+      ENDING.each_with_index.all? { |d,i| recipes[-ENDING.size+i] == d }
+    end
+
+    def check(recipes)
+      ENDING.each_with_index { |d,i| return false unless recipes[-ENDING.size+i] == d }
+      true
+    end
+
+    loop do
+      new_recipes = elves.sum { |elf| recipes[elf] }
+
+      if new_recipes >= 10
+        recipes << (new_recipes / 10)
+        break if check(recipes)
+        recipes << (new_recipes % 10)
+        break if check(recipes)
+      else
+        recipes << new_recipes
+        break if check(recipes)
+      end
+
+      elves.map! { |elf|
+        (elf + 1 + recipes[elf]) % recipes.size
+      }
+
+      p recipes.size if (recipes.size & 0xFFFF) == 0xFFFF
+    end
+
+    p recipes.size - ENDING.size
+- :name: 14b_string.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    ending = '077201'
+    elf1 = 0
+    elf2 = 1
+    recipes = "37"
+
+    loop do
+      a = recipes[elf1].to_i
+      b = recipes[elf2].to_i
+
+      recipes << (a + b).to_s
+
+      elf1 = (elf1 + 1 + a) % recipes.size
+      elf2 = (elf2 + 1 + b) % recipes.size
+
+      break if recipes.end_with?(ending)
+      break if recipes[-ending.size-1, ending.size] == ending
+
+      p recipes.size if (recipes.size & 0xFFFF) == 0xFFFF
+    end
+
+    p recipes.index(ending)

data/data/solutions/github/eregon/2018/15_1.yml

@@ -0,0 +1,171 @@
+---
+- :name: 15.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    Cell = Struct.new(:pos, :neighbors) do
+      def free?
+        BOARD[pos.imag][pos.real].equal?(self)
+      end
+
+      def hash
+        pos.hash
+      end
+
+      def eql?(cell)
+        equal?(cell)
+      end
+
+      def inspect
+        "#{pos}"
+      end
+
+      def to_s
+        "."
+      end
+    end
+
+    Unit = Struct.new(:type, :hp, :atk, :cell) do
+      def pos
+        cell.pos
+      end
+
+      def move_to(new_cell)
+        leave
+        self.cell = new_cell
+        raise unless new_cell.free?
+        BOARD[new_cell.pos.imag][new_cell.pos.real] = self
+      end
+
+      def dead?
+        hp <= 0
+      end
+
+      def find_enemy(targets)
+        in_range = cell.neighbors.map { |n| targets.find { |t| t.pos == n.pos } }.compact
+        in_range.sort_by(&READING_ORDER).min_by(&:hp)
+      end
+
+      def attack(enemy)
+        enemy.hp -= atk
+        if enemy.dead?
+          enemy.leave
+          UNITS.delete(enemy)
+        end
+      end
+
+      def leave
+        BOARD[pos.imag][pos.real] = cell
+      end
+
+      def inspect
+        "<#{type} #{hp} #{cell.pos}>"
+      end
+
+      def to_s
+        type
+      end
+    end
+
+    UNITS = []
+    CELLS = {}
+
+    ELF_ATK = Integer(ARGV[1] || 3)
+
+    BOARD = File.readlines(ARGV.first || "15.txt", chomp: true).map.with_index { |row, y|
+      row.chomp.chars.map.with_index { |c, x|
+        case c
+        when 'G', 'E'
+          cell = Cell.new(x + y.i)
+          CELLS[cell.pos] = cell
+
+          unit = Unit.new(c, 200, c == 'G' ? 3 : ELF_ATK, cell)
+          UNITS << unit
+          unit
+        when '.'
+          cell = Cell.new(x + y.i)
+          CELLS[cell.pos] = cell
+          cell
+        when '#'
+          c
+        else
+          raise c
+        end
+      }
+    }
+
+    WIDTH = BOARD.map(&:size).max
+
+    READING_ORDER = -> cell {
+      cell.pos.imag * WIDTH + cell.pos.real
+    }
+
+    MOVES = [1, 1.i, -1, -1.i]
+
+    CELLS.each_value { |cell|
+      cell.neighbors = MOVES.map { |move| CELLS[cell.pos + move] }.compact.sort_by(&READING_ORDER)
+    }
+
+    def bfs(from)
+      dist = Hash.new(Float::INFINITY)
+      dist[from] = 0
+      q = [from]
+
+      while cell = q.shift
+        d = dist[cell]
+
+        cell.neighbors.each { |neighbor|
+          if neighbor.free?
+            prev = dist[neighbor]
+            if d + 1 < prev
+              dist[neighbor] = d + 1
+              q << neighbor
+            end
+          end
+        }
+      end
+
+      dist
+    end
+
+    puts BOARD.map(&:join)
+    p UNITS.group_by(&:type).transform_values(&:size)
+
+    (0...Float::INFINITY).each do |round|
+      UNITS.sort_by!(&READING_ORDER)
+      UNITS.dup.each do |unit|
+        next if unit.dead?
+
+        targets = UNITS.select { |u| u.type != unit.type }
+        if targets.empty?
+          puts "#{unit.type} win"
+          p round * UNITS.sum(&:hp)
+          p UNITS.group_by(&:type).transform_values(&:size)
+          exit
+        end
+
+        if enemy = unit.find_enemy(targets)
+          unit.attack(enemy)
+        else
+          attack_squares = targets.flat_map { |t| t.cell.neighbors }.select(&:free?).sort_by(&READING_ORDER)
+
+          bfs = bfs(unit.cell)
+          closest = attack_squares.min_by { |as| bfs[as] }
+
+          if closest and bfs[closest].finite?
+            rbfs = bfs(closest)
+            step = unit.cell.neighbors.select(&:free?).min_by { |n|
+              rbfs[n]
+            }
+            unit.move_to(step)
+
+            if enemy = unit.find_enemy(targets)
+              unit.attack(enemy)
+            end
+          end
+        end
+      end
+
+      puts
+      p round + 1
+      puts BOARD.map(&:join)
+    end

data/data/solutions/github/eregon/2018/15_2.yml

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

data/data/solutions/github/eregon/2018/16_1.yml

@@ -0,0 +1,46 @@
+---
+- :name: 16a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    instructions = {}
+    addressing = -> mode, arg { mode == :r ? "regs[#{arg}]" : arg }
+    def_instr = -> name, mode_a, mode_b, &block do
+      instructions[name] = eval "-> regs, a, b, c {
+        #{block.(addressing[mode_a, "a"], addressing[mode_b, "b"], addressing[:r, "c"])}
+      }"
+    end
+
+    [:r, :i].each do |mode|
+      { add: :+, mul: :*, ban: :&, bor: :| }.each_pair { |name, op|
+        def_instr.(:"#{name}#{mode}", :r, mode) { |a, b, c|
+          "#{c} = #{a} #{op} #{b}"
+        }
+      }
+
+      def_instr.(:"set#{mode}", mode, :i) { |a, b, c|
+        "#{c} = #{a}"
+      }
+    end
+
+    [ [:i, :r], [:r, :i], [:r, :r] ].each do |mode_a, mode_b|
+      { gt: :>, eq: :== }.each_pair { |name, cmp|
+        def_instr.(:"#{name}#{mode_a}#{mode_b}", mode_a, mode_b) { |a, b, c|
+          "#{c} = #{a} #{cmp} #{b} ? 1 : 0"
+        }
+      }
+    end
+
+    regs = /\[(\d+), (\d+), (\d+), (\d+)\]/
+    numbers = /(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/
+    regexp = /^Before:\s*#{regs}\n#{numbers}\nAfter:\s*#{regs}/
+    samples = File.read("16.txt").scan(regexp).map { |matches| matches.map(&:to_i) }
+
+    p samples.count { |data|
+      before, inputs, after = data[0...4], data[5...8], data[8...12]
+      before.freeze
+      instructions.each_pair.count { |instr, action|
+        regs = before.dup
+        action[regs, *inputs]
+        regs == after
+      } >= 3
+    }

data/data/solutions/github/eregon/2018/16_2.yml

@@ -0,0 +1,68 @@
+---
+- :name: 16b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: |-
+    instructions = {}
+    addressing = -> mode, arg { mode == :r ? "regs[#{arg}]" : arg }
+    def_instr = -> name, mode_a, mode_b, &block do
+      instructions[name] = eval "-> regs, a, b, c {
+        #{block.(addressing[mode_a, "a"], addressing[mode_b, "b"], addressing[:r, "c"])}
+      }"
+    end
+
+    [:r, :i].each do |mode|
+      { add: :+, mul: :*, ban: :&, bor: :| }.each_pair { |name, op|
+        def_instr.(:"#{name}#{mode}", :r, mode) { |a, b, c|
+          "#{c} = #{a} #{op} #{b}"
+        }
+      }
+
+      def_instr.(:"set#{mode}", mode, :i) { |a, b, c|
+        "#{c} = #{a}"
+      }
+    end
+
+    [ [:i, :r], [:r, :i], [:r, :r] ].each do |mode_a, mode_b|
+      { gt: :>, eq: :== }.each_pair { |name, cmp|
+        def_instr.(:"#{name}#{mode_a}#{mode_b}", mode_a, mode_b) { |a, b, c|
+          "#{c} = #{a} #{cmp} #{b} ? 1 : 0"
+        }
+      }
+    end
+
+    regs = /\[(\d+), (\d+), (\d+), (\d+)\]/
+    numbers = /(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/
+    regexp = /^Before:\s*#{regs}\n#{numbers}\nAfter:\s*#{regs}/
+    samples = File.read("16.txt").scan(regexp).map { |matches| matches.map(&:to_i) }
+
+    mapping = instructions.size.times.map { instructions.keys }
+
+    samples.each { |data|
+      before, opcode, inputs, after = data[0...4], data[4], data[5...8], data[8...12]
+      before.freeze
+
+      mapping[opcode] &= instructions.each_pair.select { |instr, action|
+        regs = before.dup
+        action[regs, *inputs]
+        regs == after
+      }.map(&:first)
+    }
+
+    while mapping.any? { |instrs| instrs.size > 1 }
+      mapping.each_with_index { |instrs, i|
+        if instrs.size == 1
+          mapping.each_index { |j|
+            mapping[j] -= instrs if i != j
+          }
+        end
+      }
+    end
+
+    mapping.map!(&:first)
+
+    program = File.read("16.txt")[/\n{4}(\d.+)\z/m, 1].lines.map { |line| line.split.map(&:to_i) }
+    regs = [0] * 4
+    program.each { |opcode, a, b, c|
+      instructions[mapping[opcode]][regs, a, b, c]
+    }
+    p regs