advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,46 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/22
+  :solution: |-
+    # ITERATIONS = 7
+    # ITERATIONS = 70
+    ITERATIONS = 10_000
+
+    NODE_CLEAN = '.'
+    NODE_INFECTED = '#'
+
+    DIRECTION_DELTA = { NODE_CLEAN => -1,
+                        NODE_WEAKENED => 0,
+                        NODE_INFECTED => 1,
+                        NODE_FLAGGED => 2 }
+    STATE_TRANSITIONS = { NODE_CLEAN => NODE_WEAKENED,
+                          NODE_WEAKENED => NODE_INFECTED,
+                          NODE_INFECTED => NODE_FLAGGED,
+                          NODE_FLAGGED => NODE_CLEAN }
+    CORD_DELTA = { 0 => [-1, 0],
+                   1 => [0, 1],
+                   2 => [1, 0],
+                   3 => [0, -1] }
+
+    grid = Hash.new(NODE_CLEAN)
+    rows = 0
+    cols = 0
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |node, col|
+        grid[[row, col]] = node
+        cols = [cols, col].max
+      end
+      rows = [rows, row].max
+    end
+
+    direction = 0 # 0=up, 1=right, 2=down, 3=left
+    cords = [rows / 2, cols / 2]
+    infections = 0
+    ITERATIONS.times do
+      direction = (direction + DIRECTION_DELTA[grid[cords]]) % 4
+      grid[cords] = STATE_TRANSITIONS[grid[cords]]
+      infections += 1 if grid[cords] == NODE_INFECTED
+      cords = cords.zip(CORD_DELTA[direction]).map(&:sum)
+    end
+
+    puts infections

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

@@ -0,0 +1,47 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/22
+  :solution: |-
+    # ITERATIONS = 100
+    ITERATIONS = 10_000_000
+
+    NODE_CLEAN = '.'
+    NODE_INFECTED = '#'
+    NODE_WEAKENED = 'W'
+    NODE_FLAGGED = 'F'
+
+    DIRECTION_DELTA = { NODE_CLEAN => -1,
+                        NODE_WEAKENED => 0,
+                        NODE_INFECTED => 1,
+                        NODE_FLAGGED => 2 }
+    STATE_TRANSITIONS = { NODE_CLEAN => NODE_WEAKENED,
+                          NODE_WEAKENED => NODE_INFECTED,
+                          NODE_INFECTED => NODE_FLAGGED,
+                          NODE_FLAGGED => NODE_CLEAN }
+    CORD_DELTA = { 0 => [-1, 0],
+                   1 => [0, 1],
+                   2 => [1, 0],
+                   3 => [0, -1] }
+
+    grid = Hash.new(NODE_CLEAN)
+    rows = 0
+    cols = 0
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |node, col|
+        grid[[row, col]] = node
+        cols = [cols, col].max
+      end
+      rows = [rows, row].max
+    end
+
+    direction = 0 # 0=up, 1=right, 2=down, 3=left
+    cords = [rows / 2, cols / 2]
+    infections = 0
+    ITERATIONS.times do
+      direction = (direction + DIRECTION_DELTA[grid[cords]]) % 4
+      grid[cords] = STATE_TRANSITIONS[grid[cords]]
+      infections += 1 if grid[cords] == NODE_INFECTED
+      cords = cords.zip(CORD_DELTA[direction]).map(&:sum)
+    end
+
+    puts infections

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

@@ -0,0 +1,9 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/23
+  :solution: |-
+    require_relative 'computer'
+
+    instructions = ARGF.readlines.map { |l| l.chomp.split }
+    computer = Computer.new
+    puts computer.execute(instructions).registers['muls']

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

@@ -0,0 +1,26 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/23
+  :solution: |-
+    require_relative 'computer'
+
+    # instructions = ARGF.readlines.map { |l| l.chomp.split }
+    # computer = Computer.new('a' => 1)
+    # puts computer.execute(instructions).registers['h']
+
+    # Attempted translation in analysis.txt and translated.txt,
+    # however h/t https://www.reddit.com/r/adventofcode/comments/7lms6p/comment/drngit2/
+    # Checking how many numbers in steps of 17 in the range [B, C] are composite (non-prime)
+    B = 106_500
+    C = B + 17_000
+
+    h = 0
+    (B...(C + 1)).step(17) do |i|
+      (2...i).each do |j|
+        if i % j == 0
+          h += 1
+          break
+        end
+      end
+    end
+    puts h

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

@@ -0,0 +1,39 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/24
+  :solution: |-
+    require 'set'
+
+    require_relative 'lib'
+
+    def strongest_bridge(ports, last_port = 0)
+      strongest_bridge = []
+      unless ports[last_port].empty?
+        strongest_strengh = 0
+        ports[last_port].dup.each do |match_comp|
+          other_port = match_comp.port1 == last_port ? match_comp.port2 : match_comp.port1
+
+          ports[match_comp.port1].delete(match_comp)
+          ports[match_comp.port2].delete(match_comp)
+          bridge = strongest_bridge(ports, other_port).unshift(match_comp)
+          ports[match_comp.port1] << match_comp
+          ports[match_comp.port2] << match_comp
+
+          strength = bridge_strength(bridge)
+          if strength > strongest_strengh
+            strongest_bridge = bridge
+            strongest_strengh = strength
+          end
+        end
+      end
+      strongest_bridge
+    end
+
+    ports = Hash.new { |h, k| h[k] = Set.new }
+    ARGF.each_line.map do |line|
+      component = Component.new(*line.chomp.split('/').map(&:to_i))
+      ports[component.port1] << component
+      ports[component.port2] << component
+    end
+
+    puts bridge_strength(strongest_bridge(ports))

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

@@ -0,0 +1,40 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/24
+  :solution: |-
+    require 'set'
+
+    require_relative 'lib'
+
+    def longest_bridge(ports, last_port = 0)
+      longest_bridge = []
+      unless ports[last_port].empty?
+        longest_strengh = 0
+        ports[last_port].dup.each do |match_comp|
+          other_port = match_comp.port1 == last_port ? match_comp.port2 : match_comp.port1
+
+          ports[match_comp.port1].delete(match_comp)
+          ports[match_comp.port2].delete(match_comp)
+          bridge = longest_bridge(ports, other_port).unshift(match_comp)
+          ports[match_comp.port1] << match_comp
+          ports[match_comp.port2] << match_comp
+
+          strength = bridge_strength(bridge)
+          next unless bridge.length > longest_bridge.length ||
+                      bridge.length == longest_bridge.length && strength > longest_strengh
+
+          longest_bridge = bridge
+          longest_strengh = strength
+        end
+      end
+      longest_bridge
+    end
+
+    ports = Hash.new { |h, k| h[k] = Set.new }
+    ARGF.each_line.map do |line|
+      component = Component.new(*line.chomp.split('/').map(&:to_i))
+      ports[component.port1] << component
+      ports[component.port2] << component
+    end
+
+    puts bridge_strength(longest_bridge(ports))

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

@@ -0,0 +1,33 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2017/25
+  :solution: |-
+    state = ARGF.readline.chomp.split.last.delete('.')
+    check_steps = ARGF.readline.chomp.split[-2].to_i
+
+    fsm = {}
+    until ARGF.eof?
+      ARGF.readline
+      in_state = ARGF.readline.chomp.split.last.delete(':')
+      state_values = Array.new(2)
+      2.times.map do
+        cur_value = ARGF.readline.chomp.split.last.to_i
+        write = ARGF.readline.chomp.split.last.to_i
+        move = ARGF.readline.chomp.split.last.delete('.') == 'right' ? 1 : -1
+        next_state = ARGF.readline.chomp.split.last.delete('.')
+
+        state_values[cur_value] = [write, move, next_state]
+      end
+      fsm[in_state] = state_values
+    end
+
+    tape = Hash.new(0)
+    cursor = 0
+    check_steps.times do
+      write, move, next_state = fsm[state][tape[cursor]]
+      tape[cursor] = write
+      cursor += move
+      state = next_state
+    end
+
+    puts tape.values.sum

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

@@ -0,0 +1,4 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/01
+  :solution: puts ARGF.each_line.map(&:to_i).sum

data/data/solutions/github/erikw/2018/01_2.yml

@@ -0,0 +1,15 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/01
+  :solution: |-
+    require 'set'
+
+    seen = Set.new
+    ARGF.each_line.map(&:to_i).cycle.inject do |freq, df|
+      if seen.include?(freq)
+        puts freq
+        break
+      end
+      seen << freq
+      freq + df
+    end

data/data/solutions/github/erikw/2018/02_1.yml

@@ -0,0 +1,16 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/02
+  :solution: |-
+    checksum = ARGF.each_line.map do |line|
+      tally = line.chomp.chars.tally
+      twos = tally.values.include?(2) ? 1 : 0
+      threes = tally.values.include?(3) ? 1 : 0
+      [twos, threes]
+    end.inject do |sum, c|
+      sum[0] += c[0]
+      sum[1] += c[1]
+      sum
+    end.inject(&:*)
+
+    puts checksum

data/data/solutions/github/erikw/2018/02_2.yml

@@ -0,0 +1,8 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/02
+  :solution: |-
+    a, b = ARGF.each_line.map(&:chomp).map(&:chars).combination(2).select do |id1, id2|
+      id1.zip(id2).count { |c1, c2| c1 != c2 } == 1
+    end.first
+    puts a.zip(b).select { |c1, c2| c1 == c2 }.map(&:first).join

data/data/solutions/github/erikw/2018/03_1.yml

@@ -0,0 +1,20 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/03
+  :solution: |-
+    # SIDE = 11
+    SIDE = 1000
+    CLAIM_PATTERN = /#\d+ @ (\d+),(\d+): (\d+)x(\d+)/
+
+    fabric = Array.new(SIDE) { Array.new(SIDE, 0) }
+
+    ARGF.each_line do |line|
+      left, top, wide, tall = line.match(CLAIM_PATTERN)[1..].map(&:to_i)
+      (top...(top + tall)).each do |row|
+        (left...(left + wide)).each do |col|
+          fabric[row][col] += 1
+        end
+      end
+    end
+
+    puts fabric.sum { |row| row.count { |p| p > 1 } }

data/data/solutions/github/erikw/2018/03_2.yml

@@ -0,0 +1,29 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/03
+  :solution: |-
+    require 'set'
+
+    # SIDE = 11
+    SIDE = 1000
+    CLAIM_PATTERN = /#(\d+) @ (\d+),(\d+): (\d+)x(\d+)/
+
+    fabric = Array.new(SIDE) { Array.new(SIDE) }
+    nonoverlapping = Set.new
+
+    ARGF.each_line do |line|
+      id, left, top, wide, tall = line.match(CLAIM_PATTERN)[1..].map(&:to_i)
+      nonoverlapping << id
+      (top...(top + tall)).each do |row|
+        (left...(left + wide)).each do |col|
+          if fabric[row][col].nil?
+            fabric[row][col] = id
+          else
+            nonoverlapping.delete(id)
+            nonoverlapping.delete(fabric[row][col])
+          end
+        end
+      end
+    end
+
+    puts nonoverlapping.to_a.first

data/data/solutions/github/erikw/2018/04_1.yml

@@ -0,0 +1,34 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/04
+  :solution: |-
+    require 'time'
+
+    guard_id = nil
+    sleep_start = nil
+
+    guard_sleeps = Hash.new { |h, k| h[k] = Array.new(60, 0) }
+    ARGF.each_line.map do |line|
+      time, event = line.split(']')
+      time = Time.parse(time[1..])
+      event.strip!
+      [time, event]
+    end.sort_by(&:first).each do |time, event|
+      case event
+      when /Guard #(\d+) begins shift/
+        guard_id = Regexp.last_match(1).to_i
+      when 'falls asleep'
+        sleep_start = time.min
+      when 'wakes up'
+        (sleep_start...time.min).each do |min|
+          guard_sleeps[guard_id][min] += 1
+        end
+      end
+    end
+
+    ans = guard_sleeps.map do |guard_id, minutes|
+      total = minutes.sum
+      most_min = minutes.each_with_index.max_by(&:first).last
+      [total, most_min, guard_id]
+    end.max_by(&:first).drop(1).inject(&:*)
+    puts ans

data/data/solutions/github/erikw/2018/04_2.yml

@@ -0,0 +1,33 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/04
+  :solution: |-
+    require 'time'
+
+    guard_id = nil
+    sleep_start = nil
+
+    guard_sleeps = Hash.new { |h, k| h[k] = Array.new(60, 0) }
+    ARGF.each_line.map do |line|
+      time, event = line.split(']')
+      time = Time.parse(time[1..])
+      event.strip!
+      [time, event]
+    end.sort_by(&:first).each do |time, event|
+      case event
+      when /Guard #(\d+) begins shift/
+        guard_id = Regexp.last_match(1).to_i
+      when 'falls asleep'
+        sleep_start = time.min
+      when 'wakes up'
+        (sleep_start...time.min).each do |min|
+          guard_sleeps[guard_id][min] += 1
+        end
+      end
+    end
+
+    ans = guard_sleeps.map do |guard_id, minutes|
+      days, most_minute = minutes.each_with_index.max_by(&:first)
+      [days, most_minute, guard_id]
+    end.max_by(&:first).drop(1).inject(&:*)
+    puts ans

data/data/solutions/github/erikw/2018/05_1.yml

@@ -0,0 +1,8 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/05
+  :solution: |-
+    require_relative 'lib'
+
+    polymer = ARGF.readline.chomp.chars
+    puts react(polymer).length

data/data/solutions/github/erikw/2018/05_2.yml

@@ -0,0 +1,16 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/05
+  :solution: |-
+    require_relative 'lib'
+
+    polymer = ARGF.readline.chomp.chars
+    units = polymer.map(&:downcase).uniq
+
+    shortest = Float::INFINITY
+    units.each do |unit|
+      polymer_fixed = polymer.reject { |p| [unit, unit.upcase].include? p }
+      len = react(polymer_fixed).length
+      shortest = [shortest, len].min
+    end
+    puts shortest

data/data/solutions/github/erikw/2018/06_1.yml

@@ -0,0 +1,47 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/06
+  :solution: |-
+    def manhattan_distance(p1, p2)
+      p1.zip(p2).map { |a, b| (a - b).abs }.sum
+    end
+
+    def closest_point(points, x, y)
+      distances = points.map do |p|
+        [manhattan_distance(p, [x, y]), p]
+      end
+      min_dist_point = distances.min_by(&:first)
+      points = distances.select { |d, _p| d == min_dist_point[0] }
+
+      if points.length > 1
+        # '.'
+        nil
+      else
+        min_dist_point[1]
+      end
+    end
+
+    def is_infinite(grid, x_max, y_max, px, py)
+      [grid[0][px], grid[y_max][px], grid[py][0], grid[py][x_max]].include?([px, py])
+    end
+
+    def area(grid, _x_max, _y_max, point)
+      grid.flatten(1).count do |p|
+        p == point
+      end
+    end
+
+    points = ARGF.each_line.map { |l| l.split.map(&:to_i) }
+    x_max = points.map(&:first).max
+    y_max = points.map(&:last).max
+
+    grid = Array.new(y_max + 1)
+    (0...grid.length).each do |y|
+      grid[y] = Array.new(x_max + 1)
+      (0...grid[0].length).each do |x|
+        grid[y][x] = closest_point(points, x, y)
+      end
+    end
+
+    finite_points = points.reject { |x, y| is_infinite(grid, x_max, y_max, x, y) }
+    puts finite_points.map { |p| area(grid, x_max, y_max, p) }.max

data/data/solutions/github/erikw/2018/06_2.yml

@@ -0,0 +1,25 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/06
+  :solution: |-
+    # MAX_DIST = 32
+    MAX_DIST = 10_000
+
+    def manhattan_distance(p1, p2)
+      p1.zip(p2).map { |a, b| (a - b).abs }.sum
+    end
+
+    def dist_to_points(points, point)
+      points.map { |p| manhattan_distance(p, point) }.sum
+    end
+
+    points = ARGF.each_line.map { |l| l.split.map(&:to_i) }
+    x_max = points.map(&:first).max
+    y_max = points.map(&:last).max
+
+    region = (0..y_max).sum do |y|
+      (0..x_max).count do |x|
+        dist_to_points(points, [x, y]) < MAX_DIST
+      end
+    end
+    puts region

data/data/solutions/github/erikw/2018/07_1.yml

@@ -0,0 +1,28 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/07
+  :solution: |-
+    require 'set'
+
+    dependencies = Hash.new { |h, k| h[k] = Set.new }
+    dependencies_rev = Hash.new { |h, k| h[k] = Set.new }
+    steps = Set.new
+    ARGF.each_line do |line|
+      parts = line.split
+      dependencies[parts[7]] << parts[1]
+      dependencies_rev[parts[1]] << parts[7]
+      steps << parts[1] << parts[7]
+    end
+
+    available = steps - Set.new(dependencies.keys)
+
+    order = []
+    until available.empty?
+      order << available.to_a.sort.first
+      available.delete(order.last)
+      dependencies_rev[order.last].each do |step|
+        available << step if dependencies[step].subset?(order.to_set)
+      end
+    end
+
+    puts order.join

data/data/solutions/github/erikw/2018/07_2.yml

@@ -0,0 +1,50 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/07
+  :solution: |-
+    require 'set'
+
+    # WORKERS = 2
+    # STEP_TIME = 0
+    STEP_TIME = 60
+    WORKERS = 5
+
+    dependencies = Hash.new { |h, k| h[k] = Set.new }
+    dependencies_rev = Hash.new { |h, k| h[k] = Set.new }
+    steps = Set.new
+    ARGF.each_line do |line|
+      parts = line.split
+      dependencies[parts[7]] << parts[1]
+      dependencies_rev[parts[1]] << parts[7]
+      steps << parts[1] << parts[7]
+    end
+
+    available = steps - Set.new(dependencies.keys)
+
+    order = []
+    workers = Array.new(WORKERS)
+    second = -1
+    until available.empty? && workers.all? { |w| w.nil? }
+      second += 1
+
+      (0...WORKERS).reject { |w| workers[w].nil? }.each do |worker|
+        workers[worker][1] -= 1
+        next unless workers[worker][1].zero?
+
+        order << workers[worker][0]
+        workers[worker] = nil
+        dependencies_rev[order.last].each do |step|
+          available << step if dependencies[step].subset?(order.to_set)
+        end
+      end
+
+      free_workers = workers.each_with_index.select { |w, _i| w.nil? }.map(&:last)
+      while available.length > 0 && free_workers.length > 0
+        free_worker = free_workers.pop
+        next_step = available.to_a.sort.first
+        available.delete(next_step)
+        workers[free_worker] = [next_step, STEP_TIME + next_step.ord - 'A'.ord + 1]
+      end
+    end
+
+    puts second

data/data/solutions/github/erikw/2018/08_1.yml

@@ -0,0 +1,20 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/08
+  :solution: |-
+    def metadata_sum(numbers, pos = -1)
+      children = numbers[pos += 1]
+      metadata = numbers[pos += 1]
+      sum_total = 0
+      children.times do
+        pos, sum = metadata_sum(numbers, pos)
+        sum_total += sum
+      end
+      metadata.times do
+        sum_total += numbers[pos += 1]
+      end
+      [pos, sum_total]
+    end
+
+    numbers = ARGF.readline.split.map(&:to_i)
+    puts metadata_sum(numbers)[1]

data/data/solutions/github/erikw/2018/08_2.yml

@@ -0,0 +1,29 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/08
+  :solution: |-
+    def value(numbers, pos = -1)
+      children = numbers[pos += 1]
+      metadata = numbers[pos += 1]
+      child_values = Array.new(children)
+      children.times do |i|
+        pos, value = value(numbers, pos)
+        child_values[i] = value
+      end
+
+      value_total = 0
+      if children.zero?
+        metadata.times { value_total += numbers[pos += 1] }
+      else
+        metadata.times do
+          m = numbers[pos += 1] - 1
+          next unless m.between?(0, child_values.length - 1)
+
+          value_total += child_values[m]
+        end
+      end
+      [pos, value_total]
+    end
+
+    numbers = ARGF.readline.split.map(&:to_i)
+    puts value(numbers)[1]

data/data/solutions/github/erikw/2018/09_1.yml

@@ -0,0 +1,9 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/09
+  :solution: |-
+    require_relative 'lib'
+
+    players, marbles = ARGF.readline.scan(/\d+/).map(&:to_i)
+    scores = marble_game(players, marbles)
+    puts scores.max

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

@@ -0,0 +1,11 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/09
+  :solution: |-
+    require_relative 'lib'
+
+    FACTOR = 100
+
+    players, marbles = ARGF.readline.scan(/\d+/).map(&:to_i)
+    scores = marble_game(players, marbles * FACTOR)
+    puts scores.max