advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,12 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/10
+  :solution: |-
+    require_relative 'lib'
+
+    points = ARGF.each_line.map do |line|
+      x, y, vx, vy = line.scan(/-?\d+/).map(&:to_i)
+      [[x, y], [vx, vy]]
+    end
+
+    print_message(search_message(points)[0])

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

@@ -0,0 +1,12 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/10
+  :solution: |-
+    require_relative 'lib'
+
+    points = ARGF.each_line.map do |line|
+      x, y, vx, vy = line.scan(/-?\d+/).map(&:to_i)
+      [[x, y], [vx, vy]]
+    end
+
+    puts search_message(points)[1]

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

@@ -0,0 +1,55 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/11
+  :solution: |-
+    GRID_DIM = 300
+    SQUARE_DIM = 3
+
+    def power_level(serial, x, y)
+      rack_id = x + 10
+      power = rack_id * y
+      power += serial
+      power *= rack_id
+      power = (power / 100) % 10
+      power -= 5
+    end
+
+    def power_grid(grid_dim, serial)
+      grid = Array.new(grid_dim + 1) { Array.new(grid_dim + 1) }
+      (1..grid_dim).each do |y|
+        (1..grid_dim).each do |x|
+          grid[y][x] = power_level(serial, x, y)
+        end
+      end
+      grid
+    end
+
+    def square_power(grid, dim, x, y)
+      power = 0
+      (0...dim).each do |dy|
+        (0...dim).each do |dx|
+          power += grid[y + dy][x + dx]
+        end
+      end
+      power
+    end
+
+    def largest_square(grid_dim, square_dim, grid)
+      largest_power = -Float::INFINITY
+      largest_cord = nil
+      (1...(grid_dim - square_dim)).each do |y|
+        (1...(grid_dim - square_dim)).each do |x|
+          power = square_power(grid, square_dim, x, y)
+          if power > largest_power
+            largest_power = power
+            largest_cord = [x, y]
+          end
+        end
+      end
+      [largest_cord, largest_power]
+    end
+
+    serial = ARGF.readline.to_i
+    grid = power_grid(GRID_DIM, serial)
+    cord, _power = largest_square(GRID_DIM, SQUARE_DIM, grid)
+    puts cord.join(',')

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

@@ -0,0 +1,53 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/11
+  :solution: |-
+    GRID_DIM = 300
+
+    def power_level(serial, x, y)
+      rack_id = x + 10
+      power = rack_id * y
+      power += serial
+      power *= rack_id
+      power = (power / 100) % 10
+      power -= 5
+    end
+
+    # Summed-area table: https://en.wikipedia.org/wiki/Summed-area_table
+    def power_grid_sat(grid_dim, serial)
+      grid = Array.new(grid_dim + 1) { Array.new(grid_dim + 1, 0) }
+      (1..grid_dim).each do |y|
+        (1..grid_dim).each do |x|
+          grid[y][x] = power_level(serial, x, y) +
+                       grid[y][x - 1] +
+                       grid[y - 1][x] -
+                       grid[y - 1][x - 1]
+        end
+      end
+      grid
+    end
+
+    def square_power_sat(grid, dim, x, y)
+      grid[y][x] + grid[y - dim][x - dim] - grid[y][x - dim] - grid[y - dim][x]
+    end
+
+    serial = ARGF.readline.to_i
+    grid = power_grid_sat(GRID_DIM, serial)
+
+    largest_power = -Float::INFINITY
+    largest_cord = nil
+    largest_sqdim = nil
+    (1..GRID_DIM).each do |square_dim|
+      (square_dim..GRID_DIM).each do |y|
+        (square_dim..GRID_DIM).each do |x|
+          power = square_power_sat(grid, square_dim, x, y)
+          next unless power > largest_power
+
+          largest_power = power
+          largest_cord = [x - square_dim + 1, y - square_dim + 1]
+          largest_sqdim = square_dim
+        end
+      end
+    end
+
+    puts largest_cord.concat([largest_sqdim]).join(',')

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

@@ -0,0 +1,11 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/12
+  :solution: |-
+    require_relative 'lib'
+
+    GENERATIONS = 20
+
+    pots, states = read_input
+    GENERATIONS.times { pots = next_generation(states, pots) }
+    puts pots_sum(pots)

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

@@ -0,0 +1,21 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/12
+  :solution: |-
+    require_relative 'lib'
+
+    GENERATIONS = 50_000_000_000
+
+    pots, states = read_input
+    sums = [0, 0, 0]
+    gen = 0
+    loop do
+      (sums << pots_sum(pots)).shift
+      break if sums.each_cons(2).map { |a, b| b - a }.uniq.length == 1
+
+      pots = next_generation(states, pots)
+      gen += 1
+    end
+
+    final_sum = sums.last + (GENERATIONS - gen) * (sums[1] - sums[0])
+    puts final_sum

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

@@ -0,0 +1,103 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/13
+  :solution: |-
+    DIRECTION_DELTA = {
+      '^' => [0, -1],
+      'v' => [0, 1],
+      '<' => [-1, 0],
+      '>' => [1, 0]
+    }
+
+    # [dir, curve] => dir_new
+    CURVES = {
+      ['^', '/'] => '>',
+      ['<', '/'] => 'v',
+      ['>', '/'] => '^',
+      ['v', '/'] => '<',
+      ['>', '\\'] => 'v',
+      ['^', '\\'] => '<',
+      ['v', '\\'] => '>',
+      ['<', '\\'] => '^'
+    }
+
+    # [dir, rot_mod] => dir_new
+    TURNS = {
+      ['^', 0] => '<',
+      ['^', 1] => '^',
+      ['^', 2] => '>',
+      ['>', 0] => '^',
+      ['>', 1] => '>',
+      ['>', 2] => 'v',
+      ['v', 0] => '>',
+      ['v', 1] => 'v',
+      ['v', 2] => '<',
+      ['<', 0] => 'v',
+      ['<', 1] => '<',
+      ['<', 2] => '^'
+    }
+
+    def move_cart(map, carts, cart_coord)
+      x_new, y_new = cart_coord.zip(DIRECTION_DELTA[carts[cart_coord][0]]).map { |a, b| a + b }
+      coord_new = [x_new, y_new]
+
+      cart_old, turns_old = carts.delete(cart_coord)
+      crashed = false
+
+      if carts.key?(coord_new)
+        crashed = true
+      elsif ['-', '|'].include?(map[y_new][x_new])
+        carts[coord_new] = [cart_old, turns_old]
+      elsif ['/', '\\'].include?(map[y_new][x_new])
+        dir_new = CURVES[[cart_old, map[y_new][x_new]]]
+        carts[coord_new] = [dir_new, turns_old]
+      else # '+'
+        turns = (turns_old + 1) % 3
+        dir_new = TURNS[[cart_old, turns]]
+        carts[coord_new] = [dir_new, turns]
+      end
+
+      [crashed, coord_new]
+    end
+
+    def print_map(map, carts)
+      map.each.with_index do |row, y|
+        row.each_char.with_index do |char, x|
+          if carts.key?([x, y])
+            print carts[[x, y]][0]
+          else
+            print char
+          end
+        end
+        print "\n"
+      end
+    end
+
+    map = ARGF.each_line.map(&:chomp)
+    carts = {}  # [cart_sym, rotation_mod]
+    (0...map.length).each do |y|
+      (0...map[0].length).each do |x|
+        next unless ['^', 'v', '<', '>'].include?(map[y][x])
+
+        cart = map[y][x]
+        carts[[x, y]] = [cart, -1]
+        map[y][x] = case cart
+                    when '^' then '|'
+                    when 'v' then '|'
+                    when '<' then '-'
+                    when '>' then '-'
+                    end
+      end
+    end
+
+    coord_last = nil
+    catch(:crashed) do
+      loop do
+        carts.keys.sort_by { |coord| coord.reverse }.each do |coord|
+          crashed, coord_last = move_cart(map, carts, coord)
+          throw :crashed if crashed
+        end
+      end
+    end
+
+    puts coord_last.join(',')

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

@@ -0,0 +1,101 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/13
+  :solution: |-
+    require 'set'
+
+    DIRECTION_DELTA = {
+      '^' => [0, -1],
+      'v' => [0, 1],
+      '<' => [-1, 0],
+      '>' => [1, 0]
+    }
+
+    CURVES = {
+      ['^', '/'] => '>',
+      ['<', '/'] => 'v',
+      ['>', '/'] => '^',
+      ['v', '/'] => '<',
+      ['>', '\\'] => 'v',
+      ['^', '\\'] => '<',
+      ['v', '\\'] => '>',
+      ['<', '\\'] => '^'
+    }
+
+    TURNS = {
+      ['^', 0] => '<',
+      ['^', 1] => '^',
+      ['^', 2] => '>',
+      ['>', 0] => '^',
+      ['>', 1] => '>',
+      ['>', 2] => 'v',
+      ['v', 0] => '>',
+      ['v', 1] => 'v',
+      ['v', 2] => '<',
+      ['<', 0] => 'v',
+      ['<', 1] => '<',
+      ['<', 2] => '^'
+    }
+
+    def move_cart(map, carts, cart_coord)
+      x_new, y_new = cart_coord.zip(DIRECTION_DELTA[carts[cart_coord][0]]).map { |a, b| a + b }
+      coord_new = [x_new, y_new]
+
+      dir_old, turns_old = carts.delete(cart_coord)
+      crashed_coord = nil
+
+      if carts.key?(coord_new)
+        carts.delete(coord_new)
+        crashed_coord = coord_new
+      elsif ['-', '|'].include?(map[y_new][x_new])
+        carts[coord_new] = [dir_old, turns_old]
+      elsif ['/', '\\'].include?(map[y_new][x_new])
+        dir_new = CURVES[[dir_old, map[y_new][x_new]]]
+        carts[coord_new] = [dir_new, turns_old]
+      else # '+'
+        turns = (turns_old + 1) % 3
+        dir_new = TURNS[[dir_old, turns]]
+        carts[coord_new] = [dir_new, turns]
+      end
+
+      crashed_coord
+    end
+
+    def print_map(map, carts)
+      map.each.with_index do |row, y|
+        row.each_char.with_index do |char, x|
+          if carts.key?([x, y])
+            print carts[[x, y]][0]
+          else
+            print char
+          end
+        end
+        print "\n"
+      end
+    end
+
+    map = ARGF.each_line.map(&:chomp)
+    carts = {}
+    (0...map.length).each do |y|
+      (0...map[0].length).each do |x|
+        next unless ['^', 'v', '<', '>'].include?(map[y][x])
+
+        cart = map[y][x]
+        carts[[x, y]] = [cart, -1]
+        map[y][x] = case cart
+                    when '^' then '|'
+                    when 'v' then '|'
+                    when '<' then '-'
+                    when '>' then '-'
+                    end
+      end
+    end
+
+    until carts.length == 1
+      crashed_coords = Set.new
+      carts.keys.sort_by { |coord| coord.reverse }.each do |coord|
+        crashed_coords << move_cart(map, carts, coord) unless crashed_coords.include?(coord)
+      end
+    end
+
+    puts carts.to_a.first.first.join(',')

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

@@ -0,0 +1,20 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/14
+  :solution: |-
+    RECEPIES_NEEDED = 10
+
+    nbr_recipies = ARGF.gets.to_i
+    recepies = [3, 7]
+    elf_pos = [0, 1]
+
+    until recepies.length >= nbr_recipies + RECEPIES_NEEDED
+      sum = recepies[elf_pos[0]] + recepies[elf_pos[1]]
+      recepies << sum / 10 if sum > 9
+      recepies << sum % 10
+      2.times do |i|
+        elf_pos[i] = (elf_pos[i] + 1 + recepies[elf_pos[i]]) % recepies.length
+      end
+    end
+
+    puts recepies[nbr_recipies, RECEPIES_NEEDED].join

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

@@ -0,0 +1,26 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/14
+  :solution: |-
+    FAST_FORWARD_ITERS = 20_000_000
+
+    input = ARGF.gets.to_i
+    input_len = input.to_s.length
+    input_digits = input.to_s.chars.map(&:to_i)
+    recepies = [3, 7]
+    elf_pos = [0, 1]
+
+    # Looping on condition like:
+    # until recepies.length >= input_len && (recepies[-input_len..] == input_digits || recepies[-input_len - 1..] == input_digits)
+    # takes forever. Instead: do enough iterations then look for the answer.
+    # Also lesson learned: goes a lot faster working on int array than string in Ruby, see part2_str.rb
+    FAST_FORWARD_ITERS.times do
+      sum = recepies[elf_pos[0]] + recepies[elf_pos[1]]
+      recepies << sum / 10 if sum > 9
+      recepies << sum % 10
+      2.times do |i|
+        elf_pos[i] = (elf_pos[i] + 1 + recepies[elf_pos[i]]) % recepies.length
+      end
+    end
+
+    puts recepies.map(&:to_s).join.index(input.to_s)

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

@@ -0,0 +1,9 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/15
+  :solution: |-
+    require_relative 'game'
+
+    map = read_input
+    units = create_units(map)
+    puts play_game(map, units)

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

@@ -0,0 +1,25 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/15
+  :solution: |-
+    require_relative 'game'
+
+    def nbr_elfs(units)
+      units.count { |unit| unit.instance_of?(Elf) }
+    end
+
+    map_orig = read_input
+
+    attack = 4
+    loop do
+      map = Marshal.load(Marshal.dump(map_orig))
+      units = create_units(map, attack)
+      elfs_before = nbr_elfs(units)
+      begin
+        puts play_game(map, units, elf_quit: true)
+        break
+      rescue ElfDied
+      end
+
+      attack += 1
+    end

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

@@ -0,0 +1,22 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/16
+  :solution: |-
+    require_relative 'computer'
+
+    total_behaving = 0
+    while !ARGF.eof? && (before = ARGF.readline.chomp.split(': '))[0] == 'Before'
+      before = before[1].scan(/\d+/).map(&:to_i)
+      instruction = ARGF.readline.scan(/\d+/).map(&:to_i)
+      after = ARGF.readline.scan(/\d+/).map(&:to_i)
+      ARGF.readline
+
+      computer = Computer.new
+      behaving = Computer::OPCODES.times.count do |opcode|
+        program = [[opcode] + instruction[1..]]
+        computer.registers.replace(before)
+        computer.execute(program).registers == after
+      end
+      total_behaving += 1 if behaving >= 3
+    end
+    puts total_behaving

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

@@ -0,0 +1,41 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/16
+  :solution: |-
+    require_relative 'computer'
+    require 'set'
+
+    behaving = Hash.new { |h, k| h[k] = Set.new }
+    while !ARGF.eof? && (before = ARGF.readline.chomp.split(': '))[0] == 'Before'
+      before = before[1].scan(/\d+/).map(&:to_i)
+      instruction = ARGF.readline.scan(/\d+/).map(&:to_i)
+      after = ARGF.readline.scan(/\d+/).map(&:to_i)
+      ARGF.readline
+
+      computer = Computer.new
+      Computer::OPCODES.times.count do |opcode|
+        program = [[opcode] + instruction[1..]]
+        computer.registers.replace(before)
+        behaving[instruction[0]] << opcode if computer.execute(program).registers == after
+      end
+    end
+
+    mapping = {}
+    until mapping.length == Computer::OPCODES
+      newly_mapped = Set.new
+      behaving.each do |opcode, matching_ops|
+        if matching_ops.length == 1
+          mapping[opcode] = matching_ops.first
+          newly_mapped << mapping[opcode]
+        end
+      end
+      (behaving.keys - mapping.keys).each do |opcode|
+        behaving[opcode] -= newly_mapped
+      end
+    end
+
+    ARGF.readline
+    ARGF.readline
+
+    instructions = ARGF.each_line.map { |l| l.split.map(&:to_i) }
+    puts Computer.new(mapping:).execute(instructions).registers[0]

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

@@ -0,0 +1,18 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/17
+  :solution: |-
+    require_relative 'lib'
+
+    # Adding | above water source to kick-start the recursion, water source itself should also not count
+    SRC_OFFSET = 2
+    # Too tired to debug; Error in map generation;
+    # I'm adding 4 lines below the water source that should not be there
+    ERROR_OFFSET = 4
+
+    map = read_map
+    ymax = map.keys.map(&:last).max
+    flow = nil
+    flow = drop_water(map, *WATER_SRC_CORD, ymax) until flow == :flow_inf
+
+    puts map.values.count { |s| [SYM_WATER_FLOW, SYM_WATER_REST].include?(s) } - SRC_OFFSET - ERROR_OFFSET

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

@@ -0,0 +1,12 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/17
+  :solution: |-
+    require_relative 'lib'
+
+    map = read_map
+    ymax = map.keys.map(&:last).max
+    flow = nil
+    flow = drop_water(map, *WATER_SRC_CORD, ymax) until flow == :flow_inf
+
+    puts map.values.count { |s| [SYM_WATER_REST].include?(s) }

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

@@ -0,0 +1,17 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/18
+  :solution: |-
+    require_relative 'lib'
+
+    MINUTES = 10
+
+    acres = ARGF.each_line.map(&:chomp)
+
+    MINUTES.times do
+      acres = iterate_acres(acres)
+    end
+
+    wood = acres.join.chars.count(SYM_TREES)
+    lumber = acres.join.chars.count(SYM_LUMBER)
+    puts wood * lumber

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

@@ -0,0 +1,27 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/18
+  :solution: |-
+    require_relative 'lib'
+    require 'set'
+
+    MINUTES = 1_000_000_000
+
+    acres = ARGF.each_line.map(&:chomp)
+
+    acres_seen = Set.new
+    min = 0
+    until acres_seen.include?(acres)
+      acres_seen << acres
+      acres = iterate_acres(acres)
+      min += 1
+    end
+
+    min *= MINUTES / min
+    (min...MINUTES).each do
+      acres = iterate_acres(acres)
+    end
+
+    wood = acres.join.chars.count(SYM_TREES)
+    lumber = acres.join.chars.count(SYM_LUMBER)
+    puts wood * lumber

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

@@ -0,0 +1,19 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/19
+  :solution: |-
+    require_relative 'computer'
+
+    instructions = ARGF.each_line.map { |l| l.chomp.split }
+    # puts Computer.new.execute(instructions).registers[0]
+
+    # h/t https://www.reddit.com/r/adventofcode/comments/a7j9zc/comment/ec45g4d/
+    a = instructions[22][2].to_i
+    b = instructions[24][2].to_i
+    n = 836 + 22 * a + b
+    sqn = (n**0.5).to_i
+    ans = (1...(sqn + 1)).map do |d|
+      n % d == 0 ? d + n / d : 0
+    end.sum
+    ans = sqn**2 == n ? ans - sqn : ans
+    puts ans

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

@@ -0,0 +1,19 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/19
+  :solution: |-
+    require_relative 'computer'
+
+    instructions = ARGF.each_line.map { |l| l.chomp.split }
+    # puts Computer.new.execute(instructions).registers[0]
+
+    # h/t https://www.reddit.com/r/adventofcode/comments/a7j9zc/comment/ec45g4d/
+    a = instructions[22][2].to_i
+    b = instructions[24][2].to_i
+    n = 836 + 22 * a + b + 10_550_400
+    sqn = (n**0.5).to_i
+    ans = (1...(sqn + 1)).map do |d|
+      n % d == 0 ? d + n / d : 0
+    end.sum
+    ans = sqn**2 == n ? ans - sqn : ans
+    puts ans

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

@@ -0,0 +1,12 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/20
+  :solution: |-
+    require_relative 'lib'
+
+    regex = ARGF.readline.chomp[1...-1]
+    parser = RegexMapParser.new(regex)
+    parser.parse
+    # print_map(parser.map)
+    dist, prev = dijkstra(parser.map)
+    puts dist.values.max

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

@@ -0,0 +1,13 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2018/20
+  :solution: |-
+    require_relative 'lib'
+
+    MIN_DOORS = 1000
+
+    regex = ARGF.readline.chomp[1...-1]
+    parser = RegexMapParser.new(regex)
+    parser.parse
+    dist, prev = dijkstra(parser.map)
+    puts dist.values.count { |d| d >= MIN_DOORS }