advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,8 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/09
+  :solution: |-
+    require_relative 'computer'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    puts Computer.new(stdin: Thread::Queue.new([2])).execute(intcode).stdout.pop

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

@@ -0,0 +1,9 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/10
+  :solution: |-
+    require_relative 'lib'
+
+    asteroids = read_input
+    _mon_asteroid, detectable = best_monitoring_asteroid(asteroids)
+    puts detectable

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

@@ -0,0 +1,44 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/10
+  :solution: |-
+    # 1. Find the asteroid to put the monitoring station with laser gun on.
+    # 2. Group the other asteroid by it's polar coordniate's angle
+    #    * Transform to be in the range [-3PI/2, PI/2]
+    # 3. Sort each grouping by the polar coordinate's length
+    # 4. Until we've vaporized 200 asteroids, go angle by angle in clock-wise order and wipe the closest one (by polar coordinate length) on that angle.
+
+    require_relative 'lib'
+
+    NTH = 200
+
+    asteroids = read_input
+    mon_asteroid, _detectable = best_monitoring_asteroid(asteroids)
+
+    asteroids_by_angle = Hash.new { |h, k| h[k] = [] }
+    asteroids.reject { |c| c == mon_asteroid }.each do |asteroid|
+      dr = asteroid.imag - mon_asteroid.imag
+      dc = asteroid.real - mon_asteroid.real
+      angle = Math.atan2(-dr, dc) # Transform Y axis to go from bottom to up.
+      angle -= 2 * Math::PI if angle > Math::PI / 2 # Angles now in [-3Pi/2, Pi/2]
+      asteroids_by_angle[angle] << asteroid
+    end
+
+    asteroids_by_angle.keys.each do |angle|
+      asteroids_by_angle[angle].sort_by! do |asteroid|
+        asteroid.real**2 + asteroid.imag**2
+      end.reverse!
+    end
+
+    i = 0
+    until asteroids_by_angle.empty?
+      asteroids_by_angle.keys.sort.reverse.each do |angle|
+        asteroid = asteroids_by_angle[angle].pop
+        asteroids_by_angle.delete(angle) if asteroids_by_angle[angle].empty?
+        i += 1
+        next unless i == NTH
+
+        puts asteroid.real * 100 + asteroid.imag
+        exit
+      end
+    end

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

@@ -0,0 +1,28 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/11
+  :solution: |-
+    require_relative '../09/computer'
+
+    COLOR_BLACK = 0
+    COLOR_WHITE = 1
+    PANEL_BLACK = '.'
+    PANEL_WHITE = '#'
+    DIRECTION = { 0 => 1i, 1 => -1i }
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    panels = Hash.new(COLOR_BLACK) # Coordinate => color
+    dir = -1 # [-1, i, 1, -i] == [north, east, south, west]
+    pos = 0 + 0i
+
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+
+    while comp_thr.alive?
+      computer.stdin << panels[pos]
+      panels[pos] = computer.stdout.pop
+      pos += dir *= DIRECTION[computer.stdout.pop]
+    end
+
+    puts panels.size

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

@@ -0,0 +1,38 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/11
+  :solution: |-
+    require_relative '../09/computer'
+
+    COLOR_BLACK = 0
+    COLOR_WHITE = 1
+    DIRECTION = { 0 => 1i, 1 => -1i }
+    COLOR = {
+      COLOR_BLACK => '.',
+      COLOR_WHITE => '#'
+    }
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    panels = Hash.new(COLOR_BLACK) # Coordinate => color
+    dir = -1 # [-1, i, 1, -i] == [north, east, south, west]
+    pos = 0 + 0i
+    panels[pos] = COLOR_WHITE
+
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+
+    while comp_thr.alive?
+      computer.stdin << panels[pos]
+      panels[pos] = computer.stdout.pop
+      pos += dir *= DIRECTION[computer.stdout.pop]
+    end
+
+    xmin, xmax = panels.keys.map(&:real).minmax
+    ymin, ymax = panels.keys.map(&:imag).minmax
+    (xmin..xmax).each do |x|
+      (ymin..ymax).each do |y|
+        print COLOR[panels[Complex(x, y)]]
+      end
+      puts
+    end

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

@@ -0,0 +1,48 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/12
+  :solution: |-
+    # STEPS = 10
+    # STEPS = 100
+    STEPS = 1000
+
+    def apply_gravity(positions, velocities)
+      (0...positions.length).to_a.combination(2).each do |a, b|
+        (0...3).each do |i|
+          if positions[a][i] < positions[b][i]
+            velocities[a][i] += 1
+            velocities[b][i] -= 1
+          elsif positions[a][i] > positions[b][i]
+            velocities[a][i] -= 1
+            velocities[b][i] += 1
+          end
+        end
+      end
+    end
+
+    def apply_velocity(positions, velocities)
+      positions.length.times do |i|
+        positions[i] = positions[i].zip(velocities[i]).map { |a, b| a + b }
+      end
+    end
+
+    def potential_energy(position)
+      position.map(&:abs).sum
+    end
+    alias kinetic_energy potential_energy
+
+    def total_energy(positions, velocities)
+      positions.zip(velocities).sum do |position, velocity|
+        potential_energy(position) * kinetic_energy(velocity)
+      end
+    end
+
+    positions = ARGF.each_line.map { |l| l.scan(/-?\d+/).map(&:to_i) }
+    velocities = Array.new(positions.length) { [0, 0, 0] }
+
+    STEPS.times do
+      apply_gravity(positions, velocities)
+      apply_velocity(positions, velocities)
+    end
+
+    puts total_energy(positions, velocities)

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

@@ -0,0 +1,43 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/12
+  :solution: |-
+    def apply_gravity(positions, velocities)
+      (0...positions.length).to_a.combination(2).each do |a, b|
+        if positions[a] < positions[b]
+          velocities[a] += 1
+          velocities[b] -= 1
+        elsif positions[a] > positions[b]
+          velocities[a] -= 1
+          velocities[b] += 1
+        end
+      end
+    end
+
+    def apply_velocity(positions, velocities)
+      positions.length.times do |i|
+        positions[i] += velocities[i]
+      end
+    end
+
+    def cycle_length(positions)
+      velocities = Array.new(positions.length, 0)
+      i = 0
+      hash_init = [positions, velocities].hash
+      loop do
+        i += 1
+        apply_gravity(positions, velocities)
+        apply_velocity(positions, velocities)
+        break if hash_init == [positions, velocities].hash
+      end
+      i
+    end
+
+    positions = ARGF.each_line.map { |l| l.scan(/-?\d+/).map(&:to_i) }
+
+    # The axes operate independently.
+    # Our answer is the LCM of the 3 different axis cyles.
+    cyclen_x = cycle_length(positions.transpose[0])
+    cyclen_y = cycle_length(positions.transpose[1])
+    cyclen_z = cycle_length(positions.transpose[2])
+    puts [cyclen_x, cyclen_y, cyclen_z].inject(&:lcm)

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

@@ -0,0 +1,26 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/13
+  :solution: |-
+    require_relative '../09/computer'
+
+    TILE_EMPTY = 0
+    TILE_WALL = 1
+    TILE_BLOCK = 2
+    TILE_HPADDLE = 3
+    TILE_BALL = 4
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    tiles = Hash.new(TILE_EMPTY) # Coordinate => tile
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+
+    while comp_thr.alive? || !computer.stdout.empty?
+      x = computer.stdout.pop
+      y = computer.stdout.pop
+      tile = computer.stdout.pop
+      tiles[Complex(x, y)] = tile
+    end
+
+    puts tiles.values.count { |t| t == TILE_BLOCK }

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

@@ -0,0 +1,76 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/13
+  :solution: |-
+    require_relative '../09/computer_iter'
+
+    TILE_EMPTY = 0
+    TILE_WALL = 1
+    TILE_BLOCK = 2
+    TILE_HPADDLE = 3
+    TILE_BALL = 4
+
+    SCORE_POS = -1 + 0i
+    ANSI_CLEAR_SCREEN = "\033c"
+
+    SYM = {
+      TILE_EMPTY => ' ',
+      TILE_WALL => '#',
+      TILE_BLOCK => 'B',
+      TILE_HPADDLE => '=',
+      TILE_BALL => '*'
+    }
+
+    def display(tiles, score)
+      return if tiles.length == 0
+
+      puts ANSI_CLEAR_SCREEN
+      xmin, xmax = tiles.keys.map(&:imag).minmax
+      ymin, ymax = tiles.keys.map(&:real).minmax
+      puts "===== Score: #{score}"
+      (ymin..ymax).each do |y|
+        (xmin..xmax).each do |x|
+          print SYM[tiles[Complex(x, y)]]
+        end
+        puts
+      end
+    end
+
+    def joystick_pos_ai(x_ball, x_hpaddle)
+      return 0 if x_ball == x_hpaddle
+
+      x_ball < x_hpaddle ? -1 : 1
+    end
+
+    intcode = File.open(ARGV[0]).readline.split(',').map(&:to_i)
+    intcode[0] = 2
+
+    tiles = Hash.new(TILE_EMPTY) # Coordinate => tile
+    score = 0
+    computer = Computer.new(intcode)
+
+    x_ball = 0
+    x_hpaddle = 0
+    status = nil
+    until status == Computer::STATUS_DONE
+      status = computer.execute
+      case status
+      when Computer::STATUS_INPUT_NEEDED
+        computer.stdin << joystick_pos_ai(x_ball, x_hpaddle)
+      when Computer::STATUS_OUTPUT
+        if computer.stdout.length >= 3
+          pos = Complex(computer.stdout.pop, computer.stdout.pop)
+          val = computer.stdout.pop
+          if pos == SCORE_POS
+            score = val
+            # display(tiles, score)
+          else
+            x_ball = pos.real if val == TILE_BALL
+            x_hpaddle = pos.real if val == TILE_HPADDLE
+            tiles[pos] = val
+          end
+        end
+      end
+    end
+    # display(tiles, score)
+    puts score

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

@@ -0,0 +1,8 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/14
+  :solution: |-
+    require_relative 'lib'
+
+    inv_reactions = inv_reactions_from_input
+    puts fuel_cost(inv_reactions, 1)

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

@@ -0,0 +1,34 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/14
+  :solution: |-
+    require_relative 'lib'
+
+    ORES = 1_000_000_000_000
+
+    inv_reactions = inv_reactions_from_input
+
+    # The solution is simply not (ORES / fuel_cost(inv_reactions, 1).to_f).floor
+    # because there might be reactions that pays off more in the long run when we need
+    # more than 1 fuel.
+    # Instead: binary search the solution!
+
+    lower = (ORES / fuel_cost(inv_reactions, 1).to_f).floor.to_f
+    upper = lower * 2 # Heuristic
+
+    mid = nil
+    cost = nil
+    while lower <= upper
+      mid = ((upper - lower) / 2.0).floor + lower
+      cost = fuel_cost(inv_reactions, mid)
+      if cost < ORES
+        lower = mid + 1
+      elsif cost > ORES
+        upper = mid - 1
+      else
+        break
+      end
+    end
+
+    mid -= 1 if cost > ORES
+    puts mid.to_i

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

@@ -0,0 +1,24 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/15
+  :solution: |-
+    # Algorithm
+    # 1. Recursively discover the whole reachable map
+    #   * Backtrack when recursion returns to step the robot back to the original position.
+    # 2. Run Dijkstra on the map from origin to the found oxysys in previous system
+    #   * No need for the intcomputer anymore in this step.
+
+    require_relative 'lib'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+
+    map = Hash.new(SYM_UNKNOWN) # Complex coord => symbol
+    map[POS_START] = SYM_OPEN
+
+    explore(map, computer, POS_START)
+    # print_map(map, POS_START)
+    pos_oxysys = map.select { |_k, v| v == SYM_OXYSYS }.keys.first
+    dist, _prev = dijkstra(map, POS_START, pos_oxysys)
+    puts dist[pos_oxysys]

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

@@ -0,0 +1,43 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/15
+  :solution: |-
+    # * Find the map
+    # * Flood oxygen with a modifed BFS that goes ring by ring to count the depth/level (= minutes).
+
+    require_relative 'lib'
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+
+    map = Hash.new(SYM_UNKNOWN) # Complex coord => symbol
+    map[POS_START] = SYM_OPEN
+
+    explore(map, computer, POS_START)
+    pos_oxysys = map.select { |_k, v| v == SYM_OXYSYS }.keys.first
+    num_open = map.count { |_k, v| v == SYM_OPEN }
+
+    que = Thread::Queue.new
+    que << pos_oxysys
+    minutes = 0
+    flooded = 0
+
+    until flooded == num_open
+      layer_count = que.length
+      layer_count.times do
+        pos = que.pop
+        DIR2DELTA.values.each do |delta|
+          npos = pos + delta
+          next unless map.keys.include?(npos) && map[npos] == SYM_OPEN
+
+          map[npos] = SYM_OXYGEN
+          flooded += 1
+          que << npos
+        end
+      end
+      # print_map(map)
+      minutes += 1
+    end
+
+    puts minutes

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

@@ -0,0 +1,32 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/16
+  :solution: |-
+    # PHASES = 4
+    PHASES = 100
+
+    KEEP_DIGITS = 8
+
+    BASE_PATTERN = [0, 1, 0, -1]
+
+    def fft(input, phases = 1)
+      output = Array.new(input.length)
+      patterns = Array.new(input.length)
+      (0...input.length).each do |i|
+        patterns[i] = BASE_PATTERN.map do |p|
+          [p] * (i + 1)
+        end.flatten.rotate.cycle.take(input.length)
+      end
+
+      phases.times do
+        (0...input.length).each do |i|
+          v = input.zip(patterns[i]).map { |a, b| a * b }.sum
+          output[i] = v.abs % 10
+        end
+        input = output
+      end
+      output
+    end
+
+    signal = ARGF.readline.chomp.each_char.map(&:to_i)
+    puts fft(signal, PHASES)[0, KEEP_DIGITS].join

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

@@ -0,0 +1,32 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/16
+  :solution: |-
+    PHASES = 100
+
+    KEEP_DIGITS = 8
+    INPUT_REPEAT = 10_000
+    BASE_PATTERN = [0, 1, 0, -1]
+    OFFSET_LEN = 7
+
+    # h/t https://www.reddit.com/r/adventofcode/comments/ebf5cy/comment/fb4awi4/?utm_source=share&utm_medium=web2x&context=3
+    # The key insights are
+    # * we can skip computing values before the offset
+    # * The offset is so large, that to calculate each digit in a phase is just the sum in that unitriangular matrix.
+    def fft(input, phases = 1)
+      output = input.dup
+      phases.times do
+        partial_sum = output.sum
+        (0...input.length).each do |i|
+          s = partial_sum
+          partial_sum -= output[i]
+          output[i] = s.abs % 10
+        end
+      end
+      output
+    end
+
+    signal = ARGF.readline.chomp.each_char.map(&:to_i) * INPUT_REPEAT
+    offset = signal[0, OFFSET_LEN].join.to_i
+    signal = signal[offset..]
+    puts fft(signal, PHASES)[0, KEEP_DIGITS].join

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

@@ -0,0 +1,53 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/17
+  :solution: |-
+    require '../09/computer'
+
+    SYM_SCAFFOLD = '#'
+    SYM_OPEN = '.'
+    SYM_TUMBLING = 'X'
+
+    SYM_UP = '^'
+    SYM_DOWN = 'v'
+    SYM_LEFT = '<'
+    SYM_RIGHT = '>'
+
+    SYM_SCAFFOLD_ALL = [SYM_SCAFFOLD, SYM_UP, SYM_DOWN, SYM_LEFT, SYM_RIGHT]
+
+    def print_image(image)
+      image.each do |row|
+        puts row
+      end
+    end
+
+    def intersection?(image, row, col)
+      return false unless SYM_SCAFFOLD_ALL.include?(image[row][col])
+
+      [[-1, 0], [1, 0], [0, -1], [0, 1]].all? do |dr, dc|
+        rown = row + dr
+        coln = col + dc
+        rown.between?(0, image.length - 1) &&
+          coln.between?(0, image[0].length - 1) &&
+          SYM_SCAFFOLD_ALL.include?(image[rown][coln])
+      end
+    end
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+    comp_thr.join
+
+    image = []
+    image << computer.stdout.pop.chr until computer.stdout.empty?
+    image = image.join.split("\n")
+    # print_image(image)
+
+    alignparam_sum = 0
+    (0...image.length).each do |row|
+      (0...image[0].length).each do |col|
+        alignparam_sum += row * col if intersection?(image, row, col)
+      end
+    end
+
+    puts alignparam_sum

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

@@ -0,0 +1,45 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/17
+  :solution: |-
+    require '../09/computer'
+
+    VERBOSE = false
+    ANSI_CLEAR_SCREEN = "\033c"
+
+    def answer(computer, answer)
+      (answer + "\n").each_char.map(&:ord).each do |char|
+        computer.stdin << char
+      end
+    end
+
+    def read(computer, verbose = false)
+      line = []
+      until computer.stdout.empty?
+        line << computer.stdout.pop
+        next unless line.last == "\n".ord
+
+        puts line.map(&:chr).join if verbose
+        if line.length == 1 && verbose
+          sleep 0.03
+          puts ANSI_CLEAR_SCREEN
+        end
+        line.clear
+      end
+      puts line.join unless line.empty?
+    end
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    intcode[0] = 2
+    computer = Computer.new
+    comp_thr = Thread.new { computer.execute(intcode) }
+
+    # Solved with paper and pen.
+    answer(computer, 'A,A,B,C,C,A,C,B,C,B')
+    answer(computer, 'L,4,L,4,L,6,R,10,L,6')
+    answer(computer, 'L,12,L,6,R,10,L,6')
+    answer(computer, 'R,8,R,10,L,6')
+    answer(computer, VERBOSE ? 'y' : 'n')
+
+    comp_thr.join
+    read(computer, VERBOSE)