advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/eregon/2017/17_2.yml

@@ -0,0 +1,37 @@
+---
+- :name: 17b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    n = Integer(ARGV[0] || 50_000_000)
+    steps = 314
+
+    # idx is the node value, ary[idx] is next node
+    nodes = Array.new(n, 0)
+    nodes[0] = 0
+    pos = 0
+
+    n.times do |i|
+      p i if i % 1_000_000 == 0
+      steps.times { pos = nodes[pos] }
+      nodes[i+1] = nodes[pos]
+      nodes[pos] = i+1
+      pos = i+1
+    end
+
+    p nodes[0]
+- :name: 17b_no_buffer.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    n = Integer(ARGV[0] || 50_000_000)
+    steps = 314
+    pos = 0
+    after_zero = 0
+
+    n.times do |i|
+      n = i+1
+      pos = (pos + steps) % n
+      after_zero = n if pos == 0
+      pos += 1
+    end
+
+    p after_zero

data/data/solutions/github/eregon/2017/18_1.yml

@@ -0,0 +1,67 @@
+---
+- :name: 18a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("18.txt")
+
+    REGISTERS = registers = Hash.new(0)
+    last_sound = nil
+
+    REG = /[a-z]/
+    OP = /(?:#{REG}|-?\d+)/
+
+    # Needs to be a method, otherwise $~ is shared with below
+    def val(str)
+      if REG =~ str
+        r = str
+        -> { REGISTERS[r] }
+      else
+        v = Integer(str)
+        -> { v }
+      end
+    end
+
+    code = input.strip.lines.map { |line|
+      case line
+      when /^set (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] = v.call }
+      when /^add (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] += v.call }
+      when /^mul (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] *= v.call }
+      when /^mod (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] %= v.call }
+      when /^snd (#{OP})$/
+        v = val($1)
+        -> { last_sound = v.call }
+      when /^rcv (#{OP})$/
+        v = val($1)
+        -> {
+          if v.call != 0
+            p last_sound
+            exit
+          end
+        }
+      when /^jgz (#{OP}) (#{OP})$/
+        v, off = val($1), val($2)
+        -> pc { pc + (v.call > 0 ? off.call : 1) }
+      else
+        raise line
+      end
+    }
+
+    loop {
+      pc = 0
+      while instr = code[pc]
+        if instr.arity == 0
+          instr.call
+          pc += 1
+        else
+          pc = instr.call(pc)
+        end
+      end
+    }

data/data/solutions/github/eregon/2017/18_2.yml

@@ -0,0 +1,97 @@
+---
+- :name: 18b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("18.txt")
+
+    class Program
+      REG = /[a-z]/
+      OP = /(?:#{REG}|-?\d+)/
+
+      attr_writer :other
+      attr_reader :queue, :sends
+
+      def initialize(input, pid)
+        @pid = pid
+        @registers = Hash.new(0)
+        @registers['p'] = pid
+        @queue = Queue.new
+        @sends = 0
+        parse(input)
+      end
+
+      def val(str)
+        if REG =~ str
+          r = str
+          -> { @registers[r] }
+        else
+          v = Integer(str)
+          -> { v }
+        end
+      end
+
+      def parse(input)
+        @code = input.strip.lines.map { |line|
+          case line
+          when /^set (#{REG}) (#{OP})$/
+            r, v = $1, val($2)
+            -> { @registers[r] = v.call }
+          when /^add (#{REG}) (#{OP})$/
+            r, v = $1, val($2)
+            -> { @registers[r] += v.call }
+          when /^mul (#{REG}) (#{OP})$/
+            r, v = $1, val($2)
+            -> { @registers[r] *= v.call }
+          when /^mod (#{REG}) (#{OP})$/
+            r, v = $1, val($2)
+            -> { @registers[r] %= v.call }
+          when /^snd (#{OP})$/
+            v = val($1)
+            -> {
+              @sends += 1
+              @other.queue << v.call
+              Fiber.yield :send
+            }
+          when /^rcv (#{REG})$/
+            r = $1
+            -> {
+              Fiber.yield :waiting while @queue.empty?
+              @registers[r] = @queue.pop
+            }
+          when /^jgz (#{OP}) (#{OP})$/
+            v, off = val($1), val($2)
+            -> pc { pc + (v.call > 0 ? off.call : 1) }
+          else
+            raise line
+          end
+        }
+      end
+
+      def run
+        loop {
+          pc = 0
+          while instr = @code[pc]
+            if instr.arity == 0
+              instr.call
+              pc += 1
+            else
+              pc = instr.call(pc)
+            end
+          end
+        }
+      end
+    end
+
+    a, b = Program.new(input, 0), Program.new(input, 1)
+    a.other, b.other = b, a
+    progs = [a, b].map { |prog| Fiber.new { prog.run } }.cycle
+
+    last = :send
+    loop do
+      result = progs.next.resume
+      if result == :waiting and last == :waiting
+        p b.sends
+        break
+      end
+      last = result
+    end

data/data/solutions/github/eregon/2017/19_1.yml

@@ -0,0 +1,4 @@
+---
+- :name: 19.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: "input = File.read(\"19.txt\")\ninput2 = <<AOC\n     |          \n     |  +--+    \n     A  |  C    \n F---|----E|--+ \n     |  |  |  D \n     +B-+  +--+ \n\nAOC\n\ngrid = input.chomp.lines.map { |line| line.chars.map { |c| c == ' ' ? nil : c } }\nheight = grid.size\nwidth = grid.map(&:size).max\n\nin_bounds = -> pos {\n  pos.real.between?(0, width-1) and\n  pos.imag.between?(0, height-1)\n}\nat = -> pos {\n  if in_bounds.(pos)\n    grid[pos.imag][pos.real]\n  end\n}\n\nstart = grid[0].index('|') + 0.i\npos = start\ndir = 1i\nsteps = 1\npath = []\n\nNEIGHBORS = [-1i, 1, 1i, -1]\n\nloop {\n  cur = at.(pos)\n  path << cur if ('A'..'Z').include?(cur)\n\n  if cur == '|' or cur == '-' or ('A'..'Z').include?(cur)\n    front = pos + dir\n    if at.(front)\n      pos = front\n    else\n      break\n    end\n  elsif cur == '+'\n    turns = NEIGHBORS - [dir, -dir]\n    possible = turns.select { |turn| at.(pos+turn) }\n    raise unless possible.size == 1\n    dir = possible.first\n    pos += dir\n  else\n    raise cur\n  end\n  steps += 1\n}\n\np path.join\np steps"

data/data/solutions/github/eregon/2017/19_2.yml

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

data/data/solutions/github/eregon/2017/20_1.yml

@@ -0,0 +1,31 @@
+---
+- :name: 20a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    require 'matrix'
+
+    input = File.read("20.txt")
+
+    Particle = Struct.new(:position, :velocity, :acceleration)
+
+    particles = input.strip.lines.map { |line|
+      Particle.new *line.split(', ').map { |part|
+        part =~ /<(-?\d+),(-?\d+),(-?\d+)>/
+        Vector[*$~.captures.map(&:to_i)]
+      }
+    }
+
+    def distance(particle)
+      particle.position.to_a.map(&:abs).reduce(:+)
+    end
+
+    closest = Hash.new(0)
+    begin
+      particles.each { |particle|
+        particle.position += particle.velocity += particle.acceleration
+      }
+      closer = particles.min_by { |particle| distance(particle) }
+      idx = particles.index(closer)
+    end until (closest[idx] += 1) == 1000
+
+    p idx

data/data/solutions/github/eregon/2017/20_2.yml

@@ -0,0 +1,34 @@
+---
+- :name: 20b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    require 'matrix'
+
+    input = File.read("20.txt")
+
+    Particle = Struct.new(:position, :velocity, :acceleration)
+
+    particles = input.strip.lines.map { |line|
+      Particle.new *line.split(', ').map { |part|
+        part =~ /<(-?\d+),(-?\d+),(-?\d+)>/
+        Vector[*$~.captures.map(&:to_i)]
+      }
+    }
+
+    left = Hash.new(0)
+    until (left[particles.size] += 1) == 1000
+      collisions = {}
+      destroyed = []
+
+      particles.each { |particle|
+        particle.position += particle.velocity += particle.acceleration
+        if with = collisions[particle.position]
+          destroyed << with << particle
+        else
+          collisions[particle.position] = particle
+        end
+      }
+      destroyed.each { |particle| particles.delete(particle) }
+    end
+
+    p particles.size

data/data/solutions/github/eregon/2017/21_1.yml

@@ -0,0 +1,53 @@
+---
+- :name: 21.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    require 'matrix'
+
+    input = File.read("21.txt")
+
+    class Matrix
+      def self.from(str)
+        Matrix[*str.split('/').map { |row| row.chars.map { |c| c == '#' } }]
+      end
+
+      def to_s
+        "\n" + to_a.map { |row| row.map { |c| c ? '#' : '.' }.join }.join("\n")
+      end
+    end
+
+    board = Matrix.from(".#./..#/###")
+
+    rules = {}
+    input.lines.each { |line|
+      line =~ /^([.#\/]+) => ([.#\/]+)$/
+      pattern, replacement = [$1, $2].map(&Matrix.method(:from))
+      [pattern, pattern.transpose].each { |m|
+        m = m.to_a
+        [
+          Matrix[*m],
+          Matrix[*m.reverse],
+          Matrix[*m.map(&:reverse)],
+          Matrix[*m.map(&:reverse).reverse]
+        ].each { |pattern|
+          rules[pattern] = Matrix[*replacement]
+        }
+      }
+    }
+
+    (1..18).each do |i|
+      size = board.row_count
+      n = size.even? ? 2 : 3
+      raise unless size % n == 0
+      board = Matrix.vstack *size.times.each_slice(n).map { |i,|
+        Matrix.hstack *size.times.each_slice(n).map { |j,|
+          rules.fetch board.minor(i, n, j, n)
+        }
+      }
+      # p i
+      # puts board
+
+      if i == 5 or i == 18
+        p board.to_a.flat_map(&:itself).count(&:itself)
+      end
+    end

data/data/solutions/github/eregon/2017/21_2.yml

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

data/data/solutions/github/eregon/2017/22_1.yml

@@ -0,0 +1,34 @@
+---
+- :name: 22a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("22.txt")
+
+    init_board = input.lines.map { |line| line.chomp.chars }
+
+    board = Hash.new('.')
+    init_board.each_with_index { |row, i|
+      row.each_with_index { |v, j| board[j+i.i] = v }
+    }
+
+    pos = (init_board[0].size/2) + (init_board.size/2).i
+    dir = -1i
+    infections = 0
+
+    dirs = [-1i, 1, 1i, -1] * 2
+
+    10000.times {
+      state = board[pos]
+      board[pos] = case board[pos]
+      when '#'
+        dir = dirs[dirs.index(dir)+1]
+        '.'
+      when '.'
+        dir = dirs[dirs.index(dir)-1]
+        infections += 1
+        '#'
+      end
+      pos += dir
+    }
+
+    p infections

data/data/solutions/github/eregon/2017/22_2.yml

@@ -0,0 +1,38 @@
+---
+- :name: 22b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("22.txt")
+
+    init_board = input.lines.map { |line| line.chomp.chars }
+
+    board = Hash.new('.')
+    init_board.each_with_index { |row, i|
+      row.each_with_index { |v, j| board[j+i.i] = v }
+    }
+
+    pos = (init_board[0].size/2) + (init_board.size/2).i
+    dir = -1i
+    infections = 0
+
+    dirs = [-1i, 1, 1i, -1] * 2
+
+    10_000_000.times {
+      board[pos] = case board[pos]
+      when '.'
+        dir = dirs[dirs.index(dir)-1]
+        'W'
+      when 'W'
+        infections += 1
+        '#'
+      when '#'
+        dir = dirs[dirs.index(dir)+1]
+        'F'
+      when 'F'
+        dir = dirs[dirs.index(dir)+2]
+        '.'
+      end
+      pos += dir
+    }
+
+    p infections

data/data/solutions/github/eregon/2017/23_1.yml

@@ -0,0 +1,51 @@
+---
+- :name: 23a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("23.txt")
+
+    REGISTERS = registers = Hash.new(0)
+
+    REG = /[a-z]/
+    OP = /(?:#{REG}|-?\d+)/
+
+    def val(str)
+      if REG =~ str
+        r = str
+        -> { REGISTERS[r] }
+      else
+        v = Integer(str)
+        -> { v }
+      end
+    end
+
+    muls = 0
+    code = input.strip.lines.map { |line|
+      case line
+      when /^set (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] = v.call }
+      when /^sub (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] -= v.call }
+      when /^mul (#{REG}) (#{OP})$/
+        r, v = $1, val($2)
+        -> { registers[r] *= v.call; muls += 1 }
+      when /^jnz (#{OP}) (#{OP})$/
+        v, off = val($1), val($2)
+        -> pc { pc + (v.call != 0 ? off.call : 1) }
+      else
+        raise line
+      end
+    }
+
+    pc = 0
+    while instr = code[pc]
+      if instr.arity == 0
+        instr.call
+        pc += 1
+      else
+        pc = instr.call(pc)
+      end
+    end
+    p muls

data/data/solutions/github/eregon/2017/23_2.yml

@@ -0,0 +1,126 @@
+---
+- :name: 23b.decoded.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    b = 65
+    c = b
+    if a == 0 # jump + 2 if a != 0
+      jump + 5; end
+    b *= 100
+    b += 100_000
+    c = b
+    c += 17_000
+    loop do;f = 1
+    d = 2
+    begin; e = 2
+    begin; g = d
+    g *= e
+    g -= b
+    if g == 0; # jump + 2 if g != 0
+      f = 0; end
+    e += 1
+    g = e
+    g -= b
+    end while g != 0 # jump -8 if g != 0
+    d += 1
+    g = d
+    g -= b
+    end while g != 0 # jump - 13 if g != 0
+    if f == 0 # jump + 2 if f != 0
+      h += 1; end
+    g = b
+    g -= c
+    if g == 0 # jump + 2 if g != 0
+      exit; end # jump + 3
+    b += 17
+    end # jump -23
+- :name: 23b.indented.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    # Init
+    m = 0
+    a = 0
+    h = 0
+
+    b = 65
+    c = b
+    if a != 0
+      b *= 100; m += 1
+      b += 100_000
+      c = b
+      c += 17_000
+    end
+    loop do
+      f = 1
+      d = 2
+      begin
+        e = 2
+        begin
+          g = d
+          g *= e; m += 1
+          g -= b
+          if g == 0
+            f = 0
+          end
+          e += 1
+          g = e
+          g -= b
+        end while g != 0
+        d += 1
+        g = d
+        g -= b
+      end while g != 0
+      if f == 0
+        h += 1
+      end
+      g = b
+      g -= c
+      if g == 0 # jump + 2 if g != 0
+        p m
+        exit
+      end # jump + 3
+      b += 17
+    end # jump -23
+- :name: 23b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    # Solved by disassembling the input to Ruby code and manually optimizing
+
+    # The program actually counts the non-prime numbers amongst
+    # 106_500, +17, +34, ..., 123_500
+    require 'prime'
+    p (106_500..123_500).step(17).count { |e| !Prime.prime?(e) }
+
+    a = 1
+    h = 0
+
+    A = 1
+    b = 106_500
+    C = 123_500
+
+    loop do
+      f = 1
+      d = 2
+      begin
+
+        # e = 2
+        # begin
+        #   f = 0 if d * e == b
+        #   e += 1
+        # end while e != b
+
+        # Optimized to:
+        e = b
+        # Check if b is the product of 2 integers, both >= 2,
+        # i.e., if it is not a prime number
+        f = 0 if b % d == 0 and div = b / d and div.between?(2, e-1)
+
+        d += 1
+      end while d != b
+
+      h += 1 if f == 0
+      break if b == C
+      b += 17
+    end
+
+    p h

data/data/solutions/github/eregon/2017/24_1.yml

@@ -0,0 +1,61 @@
+---
+- :name: 24.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("24.txt")
+
+    components = input.lines.map { |line| line.chomp.split('/').map(&:to_i).sort }.sort
+
+    Node = Struct.new(:prev, :component, :last, :remaining, :score, :length)
+    root = Node.new(nil, nil, 0, components.dup.freeze, 0, 0)
+
+    def path(node)
+      if prev = node.prev
+        path(prev) << node
+      else
+        []
+      end
+    end
+
+    def show(node)
+      path = path(node)
+
+      path.map { |n|
+        c = n.component
+        if n.prev.last == c[0]
+          c
+        else
+          c.reverse
+        end
+      }
+    end
+
+    stack = [root]
+    all = []
+
+    while node = stack.pop
+      all << node
+      node.remaining.select { |c| c.include?(node.last) }.each { |c|
+        remaining = node.remaining.dup
+        remaining.delete_at remaining.index(c)
+        neighbor = Node.new(
+          node,
+          c,
+          c[0] == node.last ? c[1] : c[0],
+          remaining.freeze,
+          node.score + c.reduce(:+),
+          node.length + 1)
+        stack << neighbor
+      }
+    end
+
+    puts "Part 1"
+    strongest = all.max_by(&:score)
+    p strongest.score
+    p show(strongest)
+
+    puts "\nPart 2"
+    max_length = all.max_by(&:length).length
+    longest = all.select { |n| n.length == max_length }.max_by(&:score)
+    p longest.score
+    p show(longest)

data/data/solutions/github/eregon/2017/24_2.yml

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

data/data/solutions/github/eregon/2017/25_1.yml

@@ -0,0 +1,40 @@
+---
+- :name: 25.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("25.txt")
+
+    header, *rules = input.split("\n\n")
+    start, steps = header.lines
+
+    start = start[/Begin in state (\w+)\./, 1]
+    steps = steps[/Perform a diagnostic checksum after (\d+) steps\./, 1].to_i
+
+    tape = Hash.new(0)
+    cursor = 0
+
+    rules = rules.map { |rule|
+      lines = rule.lines
+      state = lines.shift[/In state (\w+):/, 1]
+      clauses = {}
+      lines.each_slice(4).map { |cond|
+        old_value = cond[0][/If the current value is (\d+):/, 1].to_i
+        new_value = cond[1][/- Write the value (\d+)\./, 1].to_i
+        move     = (cond[2][/- Move one slot to the (left|right)\./, 1].ord - ?o.ord) / 3
+        new_state = cond[3][/- Continue with state (\w+)\./, 1]
+        clauses[old_value] = -> {
+          tape[cursor] = new_value
+          cursor += move
+          new_state
+        }
+      }
+      [state, clauses]
+    }.to_h
+
+    state = start
+    steps.times do
+      value = tape[cursor]
+      state = rules[state][value].call
+    end
+
+    p tape.values.reduce(:+)

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

@@ -0,0 +1,4 @@
+---
+- :name: 1a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2018
+  :solution: 'p File.readlines("1.txt", chomp: true).map(&:to_i).sum'