advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,111 @@
+---
+- :name: 22b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2016
+  :solution: |-
+    # lines = ARGF.readlines
+    lines = File.readlines("22.txt")
+
+    lines = lines.drop(2)
+
+    h = 28
+    w = 38
+
+    board = Array.new(h) { Array.new(w) }
+
+    nodes = lines.map { |line|
+      x, y, size, used, avail, use = line.scan(/\d+/).map(&:to_i)
+      board[y][x] = {x: x, y: y, size: size, used: used, avail: avail, use: use}
+      {x: x, y: y, size: size, used: used, avail: avail, use: use}
+    }
+
+    viable = 0
+    nodes.combination(2) { |a,b|
+      if a[:used] > 0 and a[:used] <= b[:avail]
+        # p [a[:used], b[:avail]]
+        p a => b if b[:x] != 34 || b[:y] != 26
+        viable += 1
+      end
+      if b[:used] > 0 and b[:used] <= a[:avail]
+        viable += 1
+        p b => a if a[:x] != 34 || a[:y] != 26
+      end
+    }
+    # p viable
+
+    used = nodes.map { |n| n[:used] }
+    avail = nodes.map { |n| n[:avail] }
+    size = nodes.map { |n| n[:size] }
+    p used.min(2)
+    # p used.max(30)
+    p avail.max(2)
+    p size.min(2)
+
+    can_move = avail.max
+    can_move = size.min
+
+    goal = board[0][w-1]
+    goal = [w-1, 0]
+
+    pos = [board[-2].index { |n| n[:used] == 0 }, h-2]
+
+    print = -> {
+      board.each { |row|
+        puts row.map { |node|
+          if node[:used] == 0
+            "S"
+          elsif node[:x] == pos[0] and node[:y] == pos[1]
+            "_"
+          elsif node[:x] == goal[0] and node[:y] == goal[1]
+            "G"
+          elsif node[:used] <= can_move
+            "."
+          else
+            "#"
+          end
+        }.join
+      }
+      puts
+    }
+
+    moves = 0
+
+    i = board[-4].index { |n| n[:used] > can_move }
+    (w-i-3).times {
+      pos[0] -= 1
+      moves += 1
+    }
+
+    print[]
+
+    until pos[1] == 0
+      pos[1] -= 1
+      moves += 1
+    end
+
+    print[]
+
+    until pos[0] == w-2
+      pos[0] += 1
+      moves += 1
+    end
+
+    print[]
+
+    until pos[0] == 0
+      pos[0] += 1
+      goal[0] -= 1
+      moves += 1
+      pos[1] += 1
+      pos[0] -= 2
+      pos[1] -= 1
+      moves += 4
+      # break
+    end
+
+    goal[0] -= 1
+    pos[0] += 1
+    moves += 1
+
+    print[]
+
+    p moves

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

@@ -0,0 +1,112 @@
+---
+- :name: 23a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2016
+  :solution: |-
+    input = <<EOS.lines
+    cpy 2 a
+    tgl a
+    tgl a
+    tgl a
+    cpy 1 a
+    dec a
+    dec a
+    EOS
+
+    input = ARGF.readlines
+
+    REGS = regs = {a: 0, b: 0, c: 0, d: 0}
+    # regs[:a] = 7
+    regs[:a] = 12
+
+
+    def val(expr)
+      if Symbol === expr
+        REGS[expr]
+      else
+        expr
+      end
+    end
+
+    def operand(op)
+      if ('a'..'d').include?(op)
+        op.to_sym
+      else
+        Integer(op)
+      end
+    end
+
+
+    instrs = input.map { |instr|
+      cmd, arg1, arg2 = instr.chomp.split
+      arg1 = operand(arg1) if arg1
+      arg2 = operand(arg2) if arg2
+      [cmd.to_sym, arg1, *arg2]
+    }
+
+    stats = instrs.map { 0 }
+
+    begin
+      pc = 0
+      while pc < instrs.size
+        stats[pc] += 1
+        cmd, arg1, arg2 = instrs[pc]
+        case cmd
+        when :add
+          regs[arg1] += regs[arg2]
+          regs[arg2] = 0
+          pc += 3
+        when :mul
+          regs[:a] = regs[arg1] * regs[arg2]
+          regs[:c] = 0
+          regs[:d] = 0
+          pc += 6
+        when :inc
+          regs[arg1] += 1
+          pc += 1
+        when :dec
+          regs[arg1] -= 1
+          pc += 1
+        when :cpy
+          regs[arg2] = val(arg1)
+          pc += 1
+        when :jnz
+          if val(arg1) != 0
+            pc += val(arg2)
+          else
+            pc += 1
+          end
+        when :tgl
+          i = pc + regs[arg1]
+          p [:tgl, i, instrs[i]]
+          if instr = instrs[i]
+            instrs[i] = if instr.size == 2
+              cmd, arg1 = instr
+              case cmd
+              when :inc
+                [:dec, arg1]
+              else
+                [:inc, arg1]
+              end
+            elsif instr.size == 3
+              cmd, arg1, arg2 = instr
+              case cmd
+              when :add, :mul
+                raise instr.to_s
+              when :jnz
+                [:cpy, arg1, arg2]
+              else
+                [:jnz, arg1, arg2]
+              end
+            else
+              raise instr.to_s
+            end
+          end
+          pc += 1
+        else
+          raise cmd.to_s
+        end
+      end
+    ensure
+      p stats
+      p regs
+    end

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

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

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

@@ -0,0 +1,77 @@
+---
+- :name: 24a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2016
+  :solution: |-
+    require 'set'
+
+    goals = []
+
+    board = ARGF.readlines.map.with_index { |line, y|
+      line.chomp.chars.map.with_index { |cell, x|
+        case cell
+        when "#"
+          "#"
+        when "."
+          "."
+        when "0".."9"
+          goals[Integer(cell)] = [x,y]
+          cell #{ }"."
+        else
+          raise cell
+        end
+      }
+    }
+
+    puts board.map { |row| row.join }
+
+    p goals
+
+    # dist = Array.new(goals.size) { Array.new(goals.size, 0) }
+
+    # goals.
+
+    def bfs(start, board)
+      dist = Hash.new(Float::INFINITY)
+      prev = {}
+      dist[start] = 0
+      q = [start]
+      visited = Set.new
+      while n = q.shift
+        next if visited.include? n
+        visited << n
+        pr = prev[n]
+        x, y = n
+        d = dist[n]
+        # p [x,y,d]
+        [[x-1,y], [x+1,y], [x,y+1], [x,y-1]].each { |x,y|
+          alt = [x,y]
+          if y >= 0 and y >= 0 and board.dig(y, x) != '#' and alt != pr
+            prev[alt] = n
+            dist[alt] = d+1
+            q << alt
+          end
+        }
+      end
+      dist
+    end
+
+    dist = goals.map { |g|
+      d = bfs(g, board)
+      goals.map { |g| d[g] }
+    }
+
+    puts dist.map { |row| row.join(' ') }
+
+    p (1...goals.size).to_a.permutation.size
+
+    def total(perm, dist)
+      perm.each_cons(2).inject(dist[0][perm[0]]) { |d,(a,b)| d + dist[a][b] }
+    end
+
+    best = (1...goals.size).to_a.permutation.min_by { |perm|
+      total(perm, dist)
+    }
+
+    p best
+
+    p total(best, dist)

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

@@ -0,0 +1,77 @@
+---
+- :name: 24b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2016
+  :solution: |-
+    require 'set'
+
+    goals = []
+
+    board = ARGF.readlines.map.with_index { |line, y|
+      line.chomp.chars.map.with_index { |cell, x|
+        case cell
+        when "#"
+          "#"
+        when "."
+          "."
+        when "0".."9"
+          goals[Integer(cell)] = [x,y]
+          cell #{ }"."
+        else
+          raise cell
+        end
+      }
+    }
+
+    puts board.map { |row| row.join }
+
+    p goals
+
+    # dist = Array.new(goals.size) { Array.new(goals.size, 0) }
+
+    # goals.
+
+    def bfs(start, board)
+      dist = Hash.new(Float::INFINITY)
+      prev = {}
+      dist[start] = 0
+      q = [start]
+      visited = Set.new
+      while n = q.shift
+        next if visited.include? n
+        visited << n
+        pr = prev[n]
+        x, y = n
+        d = dist[n]
+        # p [x,y,d]
+        [[x-1,y], [x+1,y], [x,y+1], [x,y-1]].each { |x,y|
+          alt = [x,y]
+          if y >= 0 and y >= 0 and board.dig(y, x) != '#' and alt != pr
+            prev[alt] = n
+            dist[alt] = d+1
+            q << alt
+          end
+        }
+      end
+      dist
+    end
+
+    dist = goals.map { |g|
+      d = bfs(g, board)
+      goals.map { |g| d[g] }
+    }
+
+    puts dist.map { |row| row.join(' ') }
+
+    p (1...goals.size).to_a.permutation.size
+
+    def total(perm, dist)
+      perm.each_cons(2).inject(dist[0][perm[0]]) { |d,(a,b)| d + dist[a][b] } + dist[perm.last][0]
+    end
+
+    best = (1...goals.size).to_a.permutation.min_by { |perm|
+      total(perm, dist)
+    }
+
+    p best
+
+    p total(best, dist)

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

@@ -0,0 +1,85 @@
+---
+- :name: 25a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2016
+  :solution: |-
+    input = ARGF.readlines
+
+    REGS = regs = {a: 0, b: 0, c: 0, d: 0}
+
+    def val(expr)
+      if Symbol === expr
+        REGS[expr]
+      else
+        expr
+      end
+    end
+
+    def operand(op)
+      if ('a'..'d').include?(op)
+        op.to_sym
+      else
+        Integer(op)
+      end
+    end
+
+
+    instrs = input.map { |instr|
+      cmd, arg1, arg2 = instr.chomp.split
+      arg1 = operand(arg1) if arg1
+      arg2 = operand(arg2) if arg2
+      [cmd.to_sym, arg1, *arg2]
+    }
+
+    0.step do |n|
+      regs.replace({a: n, b: 0, c: 0, d: 0})
+      stats = instrs.map { 0 }
+      p n
+      begin
+        pc = 0
+        out_i = 0
+        out = []
+        twenty27 = 0
+        while pc < instrs.size
+          cmd, arg1, arg2 = instrs[pc]
+          case cmd
+          when :add
+            regs[arg1] += regs[arg2]
+            regs[arg2] = 0
+            pc += 3
+            next
+          when :mul
+            regs[:a] = regs[arg1] * regs[arg2]
+            regs[:c] = 0
+            regs[:d] = 0
+            pc += 6
+            next
+          when :inc
+            regs[arg1] += 1
+          when :dec
+            regs[arg1] -= 1
+          when :cpy
+            regs[arg2] = val(arg1)
+          when :jnz
+            if val(arg1) != 0
+              pc += val(arg2)
+              next
+            end
+          when :out
+            v = regs[arg1]
+            out << v
+            break unless v == out_i % 2
+            out_i += 1
+            break if out_i > 30
+          else
+            raise cmd.to_s
+          end
+          pc += 1
+        end
+      ensure
+        if out.size >= 30
+          p regs
+          p out
+          puts
+        end
+      end
+    end

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

@@ -0,0 +1,17 @@
+---
+- :name: 1a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("1.txt")
+    digits = input.strip.chars.map { |e| Integer(e) }
+
+    p (digits + [digits.first]).each_cons(2).select { |a,b| a == b }.sum(&:first)
+
+    sum = 0
+    cycle = digits.cycle
+    digits.size.times do
+      a = cycle.next
+      b = cycle.peek
+      sum += a if a == b
+    end
+    p sum

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

@@ -0,0 +1,8 @@
+---
+- :name: 1b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("1.txt")
+    digits = input.strip.chars.map { |e| Integer(e) }
+
+    p digits.zip(digits.rotate(digits.size/2)).select { |a, b| a == b }.sum(&:first)

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

@@ -0,0 +1,8 @@
+---
+- :name: 2a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("2.txt")
+    rows = input.strip.lines.map { |line| line.split.map(&:to_i) }
+
+    p rows.map { |row| row.minmax.reduce(:-).abs }.sum

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

@@ -0,0 +1,10 @@
+---
+- :name: 2b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("2.txt")
+    rows = input.strip.lines.map { |line| line.split.map(&:to_i) }
+
+    p rows.map { |row|
+      row.sort.reverse.combination(2).select { |a,b| a % b == 0 }.first.reduce(:/)
+    }.sum

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

@@ -0,0 +1,16 @@
+---
+- :name: 3a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = 368078
+
+    max = 1
+    side = 0
+    while input > max
+      max += (side += 2) * 4
+    end
+
+    prev_max = (side-2+1)**2
+    east_value = (prev_max + side/2)
+    dist_from_east = (east_value - input).abs % side
+    p side/2 + [ dist_from_east, side - dist_from_east ].min

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

@@ -0,0 +1,52 @@
+---
+- :name: 3b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = 368078
+
+    NEIGHBORS = [
+      -1-1i, -1i, 1-1i,
+      -1,         1,
+      -1+1i,  1i, 1+1i,
+    ]
+
+    spiral = [[1]]
+    side = 0
+    max = 1
+    off = 0
+
+    compute_value = -> pos {
+      spiral[pos.imag+off][pos.real+off] = NEIGHBORS.map { |delta|
+        neighbor = pos + delta
+        x, y = neighbor.real+off, neighbor.imag+off
+        spiral[y][x] if y >= 0 and x >= 0 and spiral[y]
+      }.sum(&:to_i)
+    }
+
+    show = -> {
+      puts
+      spiral.each { |row| puts row.map(&:inspect).join("\t") }
+    }
+
+    while input > max
+      side += 2
+      r = side/2
+      off = side/2
+      spiral = [[nil]*(side+1)] + spiral.map { |row| [nil, *row, nil] } + [[nil]*(side+1)]
+
+      (side-1).times do |dy|
+        compute_value[(r) + (r-1-dy).i]
+      end
+      side.times do |dx|
+        compute_value[(r-dx) + (-r).i]
+      end
+      side.times do |dy|
+        compute_value[(-r) + (-r+dy).i]
+      end
+      side.times do |dx|
+        compute_value[(-r+dx) + (r).i]
+      end
+      max = compute_value[r + r.i]
+
+      show[]
+    end

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

@@ -0,0 +1,10 @@
+---
+- :name: 4a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("4.txt")
+
+    p input.strip.lines.count { |line|
+      words = line.split
+      words.uniq == words
+    }

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

@@ -0,0 +1,10 @@
+---
+- :name: 4b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("4.txt")
+
+    p input.strip.lines.count { |line|
+      words = line.split.map { |word| word.chars.sort.join }
+      words.uniq == words
+    }

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

@@ -0,0 +1,16 @@
+---
+- :name: 5a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("5.txt")
+    code = input.strip.lines.map(&:to_i)
+
+    pc = 0
+    steps = 0
+    while pc.between?(0, code.size-1)
+      jump = code[pc]
+      code[pc] += 1
+      pc += jump
+      steps += 1
+    end
+    p steps

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

@@ -0,0 +1,20 @@
+---
+- :name: 5b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("5.txt")
+    code = input.strip.lines.map(&:to_i)
+
+    pc = 0
+    steps = 0
+    while pc.between?(0, code.size-1)
+      jump = code[pc]
+      if jump >= 3
+        code[pc] -= 1
+      else
+        code[pc] += 1
+      end
+      pc += jump
+      steps += 1
+    end
+    p steps

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

@@ -0,0 +1,24 @@
+---
+- :name: 6.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("6.txt")
+    banks = input.split.map(&:to_i)
+
+    count = 0
+    seen = Hash.new { |h,k| h[k.dup] = count; nil }
+    seen[banks]
+
+    p loop {
+      max_blocks = banks.max
+      i_max = banks.index(max_blocks)
+      banks[i_max] = 0
+      max_blocks.times { |i|
+        banks[(i_max + 1 + i) % banks.size] += 1
+      }
+      count += 1
+      if v = seen[banks]
+        break count - v
+      end
+    }
+    p count

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

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

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

@@ -0,0 +1,27 @@
+---
+- :name: 7a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2017
+  :solution: |-
+    input = File.read("7.txt")
+
+    data = input.strip.lines.map { |line|
+      case line
+      when /^(\w+) \(\d+\)$/
+        [$1, []]
+      when /^(\w+) \(\d+\) -> (.+)$/
+        [$1, $2.split(", ")]
+      else
+        raise line
+      end
+    }
+
+    below = {}
+    data.each { |prog, holds|
+      holds.each { |e| below[e] = prog }
+    }
+
+    bottom = data.first[0]
+    while b = below[bottom]
+      bottom = b
+    end
+    p bottom