advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/eregon/2020/08_2.yml

@@ -0,0 +1,46 @@
+---
+- :name: 8b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    instructions = File.readlines('8.txt', chomp: true).map { |line|
+      line.split.then { [_1.to_sym, Integer(_2)] }
+    }.freeze
+
+    def try(instructions)
+      cpu = Enumerator.produce([0, 0]) { |pc, accumulator|
+        case instructions.fetch(pc)
+        in [:nop, _]
+          [pc + 1, accumulator]
+        in [:acc, n]
+          [pc + 1, accumulator + n]
+        in [:jmp, offset]
+          [pc + offset, accumulator]
+        end
+      }
+
+      visited = [false] * instructions.size
+      cpu.each { |pc, acc|
+        if pc == instructions.size
+          return acc
+        else
+          if visited[pc]
+            return nil
+          else
+            visited[pc] = true
+          end
+        end
+      }
+    end
+
+    instructions.each_with_index { |instruction, i|
+      case instruction
+      in [:nop, arg] if arg != 0
+        variant = [:jmp, arg]
+      in [:jmp, offset]
+        variant = [:nop, offset]
+      in _
+        next
+      end
+
+      try(instructions.dup.tap { |insns| insns[i] = variant })&.then { p(_1) }
+    }

data/data/solutions/github/eregon/2020/09_1.yml

@@ -0,0 +1,7 @@
+---
+- :name: 9a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    File.readlines('9.txt').map { Integer(_1) }.each_cons(25+1) { |*prev, n|
+      p n if prev.combination(2).none? { |a,b| a + b == n }
+    }

data/data/solutions/github/eregon/2020/09_2.yml

@@ -0,0 +1,14 @@
+---
+- :name: 9b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    numbers = File.readlines('9.txt').map { Integer(_1) }
+
+    N = numbers.each_cons(25+1).find { |*prev, n|
+      break n if prev.combination(2).none? { |a,b| a + b == n }
+    }
+
+    numbers.each_with_index do |sum, from, to = from|
+      sum += numbers[to += 1] while sum < N
+      break p numbers[from..to].minmax.sum if sum == N
+    end

data/data/solutions/github/eregon/2020/10_1.yml

@@ -0,0 +1,8 @@
+---
+- :name: 10a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    adapters = File.readlines('10.txt').map { Integer(_1) }
+    adapters << 0 << adapters.max + 3
+    increments = adapters.sort.each_cons(2).map { |a,b| b - a }.tally
+    p increments[1] * increments[3]

data/data/solutions/github/eregon/2020/10_2.yml

@@ -0,0 +1,16 @@
+---
+- :name: 10b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    adapters = File.readlines('10.txt').map { Integer(_1) }
+    adapters << 0 << adapters.max + 3
+
+    p adapters.sort.slice_when { |a, b| b - a == 3 }.map { |seq|
+      dfs = -> pos {
+        cur = seq[pos]
+        cur == seq.last ? 1 : seq.each_with_index.sum { |e, i|
+          (e - cur).between?(1, 3) ? dfs[i] : 0
+        }
+      }
+      dfs[0]
+    }.reduce(:*)

data/data/solutions/github/eregon/2020/11_1.yml

@@ -0,0 +1,30 @@
+---
+- :name: 11a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+
+    layout = Matrix2D.new File.readlines('11.txt', chomp: true).map { |line| line.chars.map(&:-@) }
+
+    neighbors = layout.map { |cell, pos|
+      [-1i-1, -1i, -1i+1, -1, +1, 1i-1, 1i, 1i+1].filter_map { |delta|
+        n = pos + delta
+        n if at = layout[n] and at != '.'
+      } if cell != '.'
+    }
+
+    after = layout.dup
+    begin
+      before = after
+      after = before.map { |cell, pos|
+        if cell == 'L' and neighbors[pos].none? { |n| before[n] == '#' }
+          '#'
+        elsif cell == '#' and neighbors[pos].count { |n| before[n] == '#' } >= 4
+          'L'
+        else
+          cell
+        end
+      }
+    end until before == after
+
+    puts after.count('#')

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

@@ -0,0 +1,31 @@
+---
+- :name: 11b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+
+    layout = Matrix2D.new File.readlines('11.txt', chomp: true).map { |line| line.chars.map(&:-@) }
+
+    neighbors = layout.map { |cell, pos|
+      [-1i-1, -1i, -1i+1, -1, +1, 1i-1, 1i, 1i+1].filter_map { |delta|
+        n = pos + delta
+        n += delta while at = layout[n] and at == '.'
+        n if at
+      } if cell != '.'
+    }
+
+    after = layout.dup
+    begin
+      before = after
+      after = before.map { |cell, pos|
+        if cell == 'L' and neighbors[pos].none? { |n| before[n] == '#' }
+          '#'
+        elsif cell == '#' and neighbors[pos].count { |n| before[n] == '#' } >= 5
+          'L'
+        else
+          cell
+        end
+      }
+    end until before == after
+
+    puts after.count('#')

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

@@ -0,0 +1,29 @@
+---
+- :name: 12a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+
+    steps = File.readlines('12.txt', chomp: true).map { |line| line[/^(\w)(\d+)$/] and [$1.to_sym, $2.to_i] }
+    MOVES = { N: 1i, E: 0i+1, S: -1i, W: 0i-1 }
+    DIRS = RepeatingArray.new MOVES.values
+
+    pos = 0 + 0i
+    dir = MOVES[:E]
+
+    steps.each { |instr, n|
+      if MOVES.key?(instr)
+        pos += MOVES[instr] * n
+      else
+        case instr
+        in :F
+          pos += dir * n
+        in :L
+          dir = DIRS[DIRS.index(dir) - n/90]
+        in :R
+          dir = DIRS[DIRS.index(dir) + n/90]
+        end
+      end
+    }
+
+    p pos.rect.sum(&:abs)

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

@@ -0,0 +1,28 @@
+---
+- :name: 12b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    steps = File.readlines('12.txt', chomp: true).map { |line| line[/^(\w)(\d+)$/] and [$1.to_sym, $2.to_i] }
+    MOVES = { N: 1i, E: 0i+1, S: -1i, W: 0i-1 }
+
+    pos = 0 + 0i
+    waypoint = 10 + 1i
+
+    steps.each { |instr, n|
+      if MOVES.key?(instr)
+        waypoint += MOVES[instr] * n
+      else
+        case instr
+        in :F
+          pos += waypoint * n
+        in :L | :R
+          n = -n if instr == :R
+          waypoint = Complex.polar(waypoint.abs, waypoint.angle + n/180.0*Math::PI).round
+        end
+      end
+    }
+
+    p pos.rect.sum(&:abs)

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

@@ -0,0 +1,12 @@
+---
+- :name: 13a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    now, buses = File.readlines('13.txt', chomp: true).then {
+      [_1.to_i, (_2.split(',') - ['x']).map(&:to_i)]
+    }
+
+    p buses.map { |bus| [bus, bus - now % bus] }.min_by { _2 }.reduce(:*)

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

@@ -0,0 +1,116 @@
+---
+- :name: 13b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    buses_with_offsets = File.readlines('13.txt', chomp: true).last.split(',').map {
+      _1 == 'x' ? nil : _1.to_i
+    }.each_with_index.filter_map { |bus, i| [bus, i] if bus }.freeze
+
+    t = 0
+    inc = 1
+    buses_with_offsets.each { |bus, offset|
+      t += inc until (t + offset) % bus == 0
+      inc *= bus # Chinese remainder theorem
+    }
+    p t
+- :name: 13b_5min.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    buses_with_offsets = File.readlines('13.txt', chomp: true).last.split(',').map {
+      _1 == 'x' ? nil : _1.to_i
+    }.each_with_index.filter_map { |bus, i| [bus, i] if bus }.freeze
+
+    slowest_bus = buses_with_offsets.max
+
+    t0 = slowest_bus.reduce(:-)
+    until t0 % buses_with_offsets[0][0] == 0
+      t0 += slowest_bus[0]
+    end
+
+    t1 = t0 + slowest_bus[0]
+    until t1 % buses_with_offsets[0][0] == 0
+      t1 += slowest_bus[0]
+    end
+
+    t2 = t1 + slowest_bus[0]
+    until t2 % buses_with_offsets[0][0] == 0
+      t2 += slowest_bus[0]
+    end
+
+    raise unless t2-t1 == t1-t0
+
+    inc = t1 - t0
+
+    code = <<RUBY
+    t = #{t0}
+    while true
+      if #{(buses_with_offsets[1..-1] - [slowest_bus]).map { |bus, offset| "(t + #{offset}) % #{bus} == 0" }.join(' and ')}
+        break p t
+      end
+      t += #{inc}
+    end
+    RUBY
+    puts code
+    eval code
+- :name: 13b_inc.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    buses_with_offsets = File.readlines('13.txt', chomp: true).last.split(',').map {
+      _1 == 'x' ? nil : _1.to_i
+    }.each_with_index.filter_map { |bus, i| [bus, i] if bus }.freeze
+
+    start = 0
+    inc = 1
+    buses_with_offsets.each { |bus, offset|
+      t0 = start
+      until (t0 + offset) % bus == 0
+        t0 += inc
+      end
+      start = t0
+
+      t1 = t0 + inc
+      until (t1 + offset) % bus == 0
+        t1 += inc
+      end
+
+      t2 = t1 + inc
+      until (t2 + offset) % bus == 0
+        t2 += inc
+      end
+
+      raise unless t2-t1 == t1-t0
+      inc = t1 - t0
+    }
+    p start
+- :name: 13b_naive.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require_relative 'lib'
+    using Refinements
+
+    buses_with_offsets = File.readlines('13sample2.txt', chomp: true).last.split(',').map {
+      _1 == 'x' ? nil : _1.to_i
+    }.each_with_index.filter_map { |bus, i| [bus, i] if bus }.freeze
+
+    slowest_bus = buses_with_offsets.max
+
+    p Enumerator.produce(slowest_bus.reduce(:-)) { |t| t + slowest_bus[0] }.find { |t|
+      buses_with_offsets.all? { |bus, offset|
+        (t + offset) % bus == 0
+      }
+    }
+
+    # p Enumerator.produce(0, &:succ).find { |t|
+    #   buses_with_offsets.all? { |bus, offset|
+    #     (t + offset) % bus == 0
+    #   }
+    # }

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

@@ -0,0 +1,20 @@
+---
+- :name: 14a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    mem = Hash.new(0)
+
+    File.readlines('14.txt', chomp: true).slice_before(/^mask =/).each { |program|
+      mask, *operations = program
+      mask = mask.split('=', 2).last.strip
+      remove = mask.tr('01X', '100').to_i(2)
+      add = mask.tr('01X', '010').to_i(2)
+
+      operations.each { |op|
+        /^mem\[(\d+)\] = (\d+)$/ =~ op or raise op
+        address, value = $1.to_i, $2.to_i
+        mem[address] = (value & ~remove) | add
+      }
+    }
+
+    p mem.values.sum

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

@@ -0,0 +1,36 @@
+---
+- :name: 14b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require 'set'
+
+    def expand(array, i = 0, val = 0, set = Set.new)
+      e = array.fetch(i)
+      set << val << val + e
+      if i+1 < array.size
+        expand(array, i+1, val, set)
+        expand(array, i+1, val + e, set)
+      end
+      set.to_a.sort
+    end
+
+    mem = Hash.new(0)
+
+    File.readlines('14.txt', chomp: true).slice_before(/^mask =/).each { |program|
+      mask, *operations = program
+      mask = mask.split('=', 2).last.strip
+      add = mask.tr('01X', '010').to_i(2)
+      floating_mask = mask.tr('01X', '001').to_i(2)
+      floating = expand floating_mask.digits(2).map.with_index.filter_map { |b,i| 1 << i if b == 1 }
+
+      operations.each { |op|
+        /^mem\[(\d+)\] = (\d+)$/ =~ op or raise op
+        address, value = $1.to_i, $2.to_i
+        address = (address | add) & ~floating_mask
+        floating.each { |inc|
+          mem[address + inc] = value
+        }
+      }
+    }
+
+    p mem.values.sum

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

@@ -0,0 +1,21 @@
+---
+- :name: 15a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    initial = '9,6,0,10,18,2,1'.split(',').map(&:to_i).freeze
+
+    last_seen_at = {}
+    p Enumerator.produce([initial.first, 0]) { |prev, i|
+      n = if i < initial.size-1
+        initial[i+1]
+      else
+        if prev_idx = last_seen_at[prev]
+          i - prev_idx
+        else
+          0
+        end
+      end
+
+      last_seen_at[prev] = i
+      [n, i+1]
+    }.take(2020).map(&:first).last

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

@@ -0,0 +1,45 @@
+---
+- :name: 15b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    initial = '9,6,0,10,18,2,1'.split(',').map(&:to_i).freeze
+
+    last_seen_at = {}
+    p Enumerator.produce([initial.first, 0]) { |prev, i|
+      n = if i < initial.size-1
+        initial[i+1]
+      else
+        if prev_idx = last_seen_at[prev]
+          i - prev_idx
+        else
+          0
+        end
+      end
+
+      last_seen_at[prev] = i
+      [n, i+1]
+    }.take(30_000_000).map(&:first).last
+- :name: 15b_loop.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    initial = '9,6,0,10,18,2,1'.split(',').map(&:to_i).freeze
+
+    last_seen_at = {}
+    i = 0
+    n = initial.first
+    while i < 30_000_000
+      prev = n
+      n = if i < initial.size-1
+        initial[i+1]
+      else
+        if prev_idx = last_seen_at[prev]
+          i - prev_idx
+        else
+          0
+        end
+      end
+
+      last_seen_at[prev] = i
+      i += 1
+    end
+    p prev

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

@@ -0,0 +1,21 @@
+---
+- :name: 16a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    fields, mine, others = File.read('16.txt').split("\n\n")
+    valid = fields.scan(/(\d+)-(\d+)/).map { |from, to| (from.to_i..to.to_i) }
+    p others.scan(/\d+/).map(&:to_i).select { |n| valid.none? { |range| range === n } }.sum
+- :name: 16a_parse.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    fields, mine, others = File.read('16.txt').split("\n\n")
+
+    valid = fields.lines.flat_map { |line|
+      line[/^[\w ]+: ((\d+-\d+)( or \d+-\d+)*)$/, 1].split(' or ').map { |range|
+        range =~ /(\d+)-(\d+)/ and ($1.to_i..$2.to_i)
+      }
+    }
+
+    p others.lines.drop(1).flat_map { |line|
+      line.chomp.split(',').map(&:to_i)
+    }.select { |n| valid.none? { |range| range === n } }.sum

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

@@ -0,0 +1,40 @@
+---
+- :name: 16b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    fields, mine, others = File.read('16.txt').split("\n\n")
+
+    fields = fields.lines.map { |line|
+      name = line[/^([\w ]+):/, 1]
+      [name, line[/^[\w ]+: ((\d+-\d+)( or \d+-\d+)*)$/, 1].split(' or ').map { |range|
+        range =~ /(\d+)-(\d+)/ and ($1.to_i..$2.to_i)
+      }]
+    }
+    valid = fields.flat_map(&:last)
+
+    mine = mine.lines.drop(1)[0].chomp.split(',').map(&:to_i)
+
+    tickets = others.lines.drop(1).map { |line|
+      line.chomp.split(',').map(&:to_i)
+    }.reject { |ticket|
+      ticket.any? { |n| valid.none? { |range| range === n } }
+    }
+
+    to_assign = fields.dup
+    assignment = [nil] * fields.size
+    until to_assign.empty?
+      assignment.each_with_index { |assigned,i|
+        next if assigned
+        data = tickets.map { |ticket| ticket[i] }
+        matching_fields = to_assign.select { |name, ranges|
+          data.all? { |n| ranges.any? { |range| range === n } }
+        }
+
+        if matching_fields.size == 1
+          assignment[i] = to_assign.delete(matching_fields.first)
+        end
+      }
+    end
+
+    indices = assignment.map(&:first).map.with_index.to_a.select { |name,_| /^departure/ =~ name }.map(&:last)
+    p mine.values_at(*indices).reduce(:*)

data/data/solutions/github/eregon/2020/17_1.yml

@@ -0,0 +1,74 @@
+---
+- :name: 17a.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require 'matrix'
+    require_relative 'lib'
+    using Refinements
+
+    class Cell
+      attr_reader :pos, :state
+      def initialize(pos, state)
+        @pos = pos
+        @state = state
+      end
+
+      def prepare
+        @next_state = (@state ? (2..3) : (3..3)).cover?(neighbors.count(&:state))
+      end
+
+      def advance
+        @state = @next_state
+        @next_state = nil
+      end
+
+      def neighbors
+        @neighbors ||= (-1..1).flat_map { |z|
+          (-1..1).flat_map { |y|
+            (-1..1).filter_map { |x|
+              pos = @pos + Vector[x, y, z]
+              BOARD[pos] unless pos == @pos
+            }
+          }
+        }
+      end
+
+      def to_s
+        @state ? '#' : '.'
+      end
+      alias_method :inspect, :to_s
+    end
+
+    BOARD = Hash.new { |h,pos| h[pos] = Cell.new(pos, false) }
+    def BOARD.show
+      all_pos = keys
+      puts
+      all_pos.map { _1[2] }.minmax_range.each { |z|
+        puts
+        puts "z=#{z}"
+        all_pos.map { _1[1] }.minmax_range.each { |y|
+          puts all_pos.map { _1[0] }.minmax_range.map { |x|
+            self[Vector[x,y,z]]
+          }.join
+        }
+      }
+    end
+
+    initial = File.readlines('17.txt', chomp: true).map(&:chars)
+    initial.each_with_index { |row,y|
+      row.each_with_index { |state,x|
+        pos = Vector[x-row.size/2, y-initial.size/2, 0]
+        BOARD[pos] = Cell.new(pos, state == '#')
+      }
+    }
+    BOARD.values.each(&:neighbors)
+
+    6.times do
+      cells = BOARD.values
+      cells.each(&:prepare)
+      cells.each(&:advance)
+    end
+
+    # BOARD.show
+
+    p BOARD.values.count(&:state)

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

@@ -0,0 +1,78 @@
+---
+- :name: 17b.rb
+  :url: https://github.com/eregon/adventofcode/blob/master/2020
+  :solution: |-
+    require 'matrix'
+    require_relative 'lib'
+    using Refinements
+
+    class Cell
+      attr_reader :pos, :state
+      def initialize(pos, state)
+        @pos = pos
+        @state = state
+      end
+
+      def prepare
+        @next_state = (@state ? (2..3) : (3..3)).cover?(neighbors.count(&:state))
+      end
+
+      def advance
+        @state = @next_state
+        @next_state = nil
+      end
+
+      def neighbors
+        @neighbors ||= (-1..1).flat_map { |w|
+          (-1..1).flat_map { |z|
+            (-1..1).flat_map { |y|
+              (-1..1).filter_map { |x|
+                pos = @pos + Vector[x, y, z, w]
+                BOARD[pos] unless pos == @pos
+              }
+            }
+          }
+        }
+      end
+
+      def to_s
+        @state ? '#' : '.'
+      end
+      alias_method :inspect, :to_s
+    end
+
+    BOARD = Hash.new { |h,pos| h[pos] = Cell.new(pos, false) }
+    def BOARD.show
+      all_pos = keys
+      puts
+      all_pos.map { _1[3] }.minmax_range.each { |w|
+        all_pos.map { _1[2] }.minmax_range.each { |z|
+          puts
+          puts "z=#{z}, w=#{w}"
+          all_pos.map { _1[1] }.minmax_range.each { |y|
+            puts all_pos.map { _1[0] }.minmax_range.map { |x|
+              self[Vector[x,y,z,w]]
+            }.join
+          }
+        }
+      }
+    end
+
+    initial = File.readlines('17.txt', chomp: true).map(&:chars)
+    initial.each_with_index { |row,y|
+      row.each_with_index { |state,x|
+        pos = Vector[x-row.size/2, y-initial.size/2, 0, 0]
+        BOARD[pos] = Cell.new(pos, state == '#')
+      }
+    }
+    BOARD.values.each(&:neighbors)
+
+    6.times do
+      cells = BOARD.values
+      cells.each(&:prepare)
+      cells.each(&:advance)
+    end
+
+    # BOARD.show
+
+    p BOARD.values.count(&:state)