advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,127 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/18
+  :solution: |-
+    # About 60% faster than the part1_naive.rb, because we don't have to duplicate the map for each recursion.
+    # Algorithm:
+    # 1. Shortest-path to every ey we can discover, entering doors that we have keeys though (replace door with open space when enter first time)
+    # 2. On each path to key available
+    #    * Backtrack each path. On each path, remove collected keys and doors entered
+    #    * recurse down and get steps to end, or notall found
+    # 3. Select shortest of these and move these number of steps and move to this key
+
+    require 'lazy_priority_queue'
+    require 'set'
+
+    SYM_ENTRANCE = '@'
+    SYM_OPEN = '.'
+    SYM_WALL = '#'
+    SYM_KEY = /[a-z]/
+    SYM_DOOR = /[A-Z]/
+
+    NEIGHBOUR_DELTAS = [-1 + 0i, 1 + 0i, 0 - 1i, 0 + 1i]
+
+    class LazyPriorityQueue
+      def upsert(element, key)
+        change_priority(element, key)
+      rescue StandardError
+        enqueue(element, key)
+      end
+    end
+
+    def print_map(map, pos_me, keys_collected = Set.new)
+      xmin, xmax = map.keys.map(&:real).minmax
+      ymin, ymax = map.keys.map(&:imag).minmax
+      (xmin..xmax).each do |x|
+        (ymin..ymax).each do |y|
+          pos = Complex(x, y)
+          if pos == pos_me
+            print SYM_ENTRANCE
+          elsif SYM_KEY.match(map[pos]) && keys_collected.include?(map[pos])
+            print SYM_OPEN
+          else
+            print map[pos]
+          end
+        end
+        puts
+      end
+      puts
+    end
+
+    # Modified Dijkstra's algorithm:
+    # - Only adds neighbour positions to queue as they are discovered, to avoid having to BFS all currently available positions before the algoritm.
+    # - Logic for enterying doors that we have a collected key for.
+    # - Return all positions of keys encountred.
+    def dijkstra(map, doors, keys_collected, source)
+      dist = Hash.new(Float::INFINITY)
+      dist[source] = 0
+      keypos_found = Set.new
+
+      q = MinPriorityQueue.new
+      q.push(source, dist[source])
+      until q.empty?
+        pos = q.pop
+        if SYM_KEY.match(map[pos]) && !keys_collected.include?(map[pos])
+          keypos_found << pos
+          next # Don't go beyond this key to keep it simple. Avoid multi-key collection paths.
+        end
+
+        NEIGHBOUR_DELTAS.map do |delta|
+          npos = pos + delta
+          next if map[npos] == SYM_WALL || doors.keys.include?(map[npos]) && !keys_collected.include?(map[npos].downcase)
+
+          alt = dist[pos] + 1
+          next unless alt <= dist[npos]
+
+          dist[npos] = alt
+          q.upsert(npos, alt)
+        end
+      end
+      [dist, keypos_found]
+    end
+
+    def collect_keys(map, doors, keys, pos_me, keys_collected = Set.new, cache = {})
+      return 0 if keys.length == keys_collected.length
+
+      # print_map(map, pos_me, keys_collected)
+      cache_key = pos_me.to_s + keys_collected.to_a.sort.to_s
+      unless cache.include?(cache_key)
+
+        dist, keypos_found = dijkstra(map, doors, keys_collected, pos_me)
+        steps_min = Float::INFINITY
+        keypos_found.each do |pos_key|
+          steps_to_key = dist[pos_key]
+          nkeys_collected = keys_collected + Set[map[pos_key]]
+
+          steps_rest = collect_keys(map, doors, keys, pos_key, nkeys_collected, cache)
+
+          steps_min = [steps_min, steps_to_key + steps_rest].min
+        end
+        cache[cache_key] = steps_min
+      end
+      cache[cache_key]
+    end
+
+    map = Hash.new(SYM_WALL)
+    pos_entrance = nil
+    doors = {}
+    keys = {}
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |char, col|
+        pos = Complex(row, col)
+        map[pos] = char
+        case char
+        when SYM_ENTRANCE
+          pos_entrance = pos
+          map[pos] = SYM_OPEN
+        when SYM_DOOR
+          doors[char] = pos
+        when SYM_KEY
+          keys[char] = pos
+        end
+      end
+    end
+
+    # print_map(map, pos_entrance)
+
+    puts collect_keys(map, doors, keys, pos_entrance)

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

@@ -0,0 +1,141 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/18
+  :solution: |-
+    # Algorithm:
+    # * Same as part1.rb, with addition of for each iteration consider all the keys that can be reach from each robot.
+
+    require 'lazy_priority_queue'
+    require 'set'
+
+    SYM_ENTRANCE = '@'
+    SYM_OPEN = '.'
+    SYM_WALL = '#'
+    SYM_KEY = /[a-z]/
+    SYM_DOOR = /[A-Z]/
+
+    NEIGHBOUR_DELTAS = [-1 + 0i, 1 + 0i, 0 - 1i, 0 + 1i]
+
+    class LazyPriorityQueue
+      def upsert(element, key)
+        change_priority(element, key)
+      rescue StandardError
+        enqueue(element, key)
+      end
+    end
+
+    def print_map(map, pos_robots, keys_collected = Set.new)
+      xmin, xmax = map.keys.map(&:real).minmax
+      ymin, ymax = map.keys.map(&:imag).minmax
+      (xmin..xmax).each do |x|
+        (ymin..ymax).each do |y|
+          pos = Complex(x, y)
+          if pos_robots.include?(pos)
+            print SYM_ENTRANCE
+          elsif SYM_KEY.match(map[pos]) && keys_collected.include?(map[pos])
+            print SYM_OPEN
+          else
+            print map[pos]
+          end
+        end
+        puts
+      end
+      puts
+    end
+
+    # Modified Dijkstra's algorithm:
+    # - Only adds neighbour positions to queue as they are discovered, to avoid having to BFS all currently available positions before the algoritm.
+    # - Logic for enterying doors that we have a collected key for.
+    # - Return all positions of keys encountred.
+    def dijkstra(map, doors, keys_collected, source)
+      dist = Hash.new(Float::INFINITY)
+      dist[source] = 0
+      keypos_found = Set.new
+
+      q = MinPriorityQueue.new
+      q.push(source, dist[source])
+      until q.empty?
+        pos = q.pop
+        if SYM_KEY.match(map[pos]) && !keys_collected.include?(map[pos])
+          keypos_found << pos
+          next # Don't go beyond this key to keep it simple. Avoid multi-key collection paths.
+        end
+
+        NEIGHBOUR_DELTAS.map do |delta|
+          npos = pos + delta
+          next if map[npos] == SYM_WALL || doors.keys.include?(map[npos]) && !keys_collected.include?(map[npos].downcase)
+
+          alt = dist[pos] + 1
+          next unless alt <= dist[npos]
+
+          dist[npos] = alt
+          q.upsert(npos, alt)
+        end
+      end
+      [dist, keypos_found]
+    end
+
+    # Find all keys we can reach from any robot.
+    def keys_reachable(map, doors, keys_collected, pos_robots)
+      pos_robots.each_with_index.map do |pos_robot, robot_idx|
+        dist, keypos_found = dijkstra(map, doors, keys_collected, pos_robot)
+        keypos_found.map do |pos_key|
+          [pos_key, dist[pos_key], robot_idx]
+        end
+      end.flatten(1)
+    end
+
+    def collect_keys(map, doors, keys, pos_robots, keys_collected = Set.new, cache = {})
+      return 0 if keys.length == keys_collected.length
+
+      # print_map(map, pos_robots, keys_collected)
+      cache_key = pos_robots.map(&:rectangular).sort.to_s + keys_collected.to_a.sort.to_s
+      unless cache.include?(cache_key)
+        steps_min = Float::INFINITY
+        keys_reachable(map, doors, keys_collected, pos_robots).each do |pos_key, steps_to_key, robot_idx|
+          npos_robots = pos_robots.dup
+          npos_robots[robot_idx] = pos_key
+          nkeys_collected = keys_collected + Set[map[pos_key]]
+
+          steps_rest = collect_keys(map, doors, keys, npos_robots, nkeys_collected, cache)
+
+          steps_min = [steps_min, steps_to_key + steps_rest].min
+        end
+        cache[cache_key] = steps_min
+      end
+      cache[cache_key]
+    end
+
+    map = Hash.new(SYM_WALL)
+    pos_entrance = nil
+    doors = {}
+    keys = {}
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |char, col|
+        pos = Complex(row, col)
+        map[pos] = char
+        case char
+        when SYM_ENTRANCE
+          pos_entrance = pos
+          map[pos] = SYM_OPEN
+        when SYM_DOOR
+          doors[char] = pos
+        when SYM_KEY
+          keys[char] = pos
+        end
+      end
+    end
+
+    map[pos_entrance] = SYM_WALL
+    (NEIGHBOUR_DELTAS + [-1 - 1i, -1 + 1i, 1 - 1i, 1 + 1i]).each do |delta|
+      map[pos_entrance + delta] = SYM_WALL
+    end
+    pos_entrances = [-1 - 1i, -1 + 1i, 1 - 1i, 1 + 1i].map do |delta|
+      epos = pos_entrance + delta
+      map[epos] = SYM_OPEN
+      epos
+    end
+
+    # print_map(map, pos_entrances)
+
+    puts collect_keys(map, doors, keys, pos_entrances)

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

@@ -0,0 +1,41 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/19
+  :solution: |-
+    require '../09/computer_iter'
+
+    AREA_DIM = 50
+
+    DRONE_STATIONARY = 0
+    DRONE_PULLED = 1
+
+    SYM_STATIONARY = '.'
+    SYM_PULLED = '#'
+
+    def scan(intcode, x, y)
+      computer = Computer.new(intcode)
+      computer.stdin << x << y
+      computer.execute
+      computer.stdout.pop
+    end
+
+    def print_area(area)
+      area.each do |row|
+        puts row.map { |c| c == DRONE_STATIONARY ? SYM_STATIONARY : SYM_PULLED }.join
+      end
+    end
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+
+    area = Array.new(AREA_DIM) { Array.new(AREA_DIM) }
+    (0...AREA_DIM).each do |y|
+      (0...AREA_DIM).each do |x|
+        area[y][x] = scan(intcode, x, y)
+      end
+    end
+    # print_area(area)
+
+    total_pulled = area.sum do |row|
+      row.count { |c| c == DRONE_PULLED }
+    end
+    puts total_pulled

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

@@ -0,0 +1,45 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/19
+  :solution: |-
+    # h/t https://www.reddit.com/r/adventofcode/comments/ecogl3/comment/fbdmn5n/?utm_source=share&utm_medium=web2x&context=3
+    # Algorithm:
+    # * Fit the SHIP_DIM * SHIP_DIM square by moving it diagonally down.
+    # x
+    # x
+    #  x
+    #   x
+    #   x
+    #   x
+    #    x
+    #     x
+    #     x
+
+    require '../09/computer_iter'
+
+    SHIP_DIM = 100
+
+    DRONE_STATIONARY = 0
+    DRONE_PULLED = 1
+
+    def scan(intcode, x, y)
+      computer = Computer.new(intcode)
+      computer.stdin << x << y
+      computer.execute
+      computer.stdout.pop
+    end
+
+    def is_pulled?(intcode, x, y)
+      scan(intcode, x, y) == DRONE_PULLED
+    end
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    x = 0
+    y = 0
+
+    until is_pulled?(intcode, x + SHIP_DIM - 1, y)
+      y += 1
+      x += 1 until is_pulled?(intcode, x, y + SHIP_DIM - 1)
+    end
+
+    puts x * 10_000 + y

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

@@ -0,0 +1,108 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/20
+  :solution: |-
+    require 'set'
+
+    SYM_WALL = '#'
+    SYM_OPEN = '.'
+    SYM_UNDEF = ' '
+    SYM_PORTAL = /[A-Z]/
+    SYM_POS_CUR = '@'
+
+    PORTAL_START = 'AA'
+    PORTAL_END = 'ZZ'
+
+    NEIGHBOUR_DELTAS = [-1 + 0i, 1 + 0i, 0 - 1i, 0 + 1i]
+
+    def print_map(map, pos_cur = nil)
+      xmin, xmax = map.keys.map(&:real).minmax
+      ymin, ymax = map.keys.map(&:imag).minmax
+      (xmin..xmax).each do |x|
+        (ymin..ymax).each do |y|
+          pos = Complex(x, y)
+          print pos_cur == pos ? SYM_POS_CUR : map[pos]
+        end
+        puts
+      end
+    end
+
+    def find_portals(map)
+      portals_by_name = Hash.new { |h, k| h[k] = [] } # "xx" -> [Complex, Complex]
+
+      xmin, xmax = map.keys.map(&:real).minmax
+      ymin, ymax = map.keys.map(&:imag).minmax
+      (xmin..xmax).each do |x|
+        (ymin..ymax).each do |y|
+          pos = Complex(x, y)
+          next unless map[pos].match(SYM_PORTAL)
+
+          ndelta = NEIGHBOUR_DELTAS.select { |d| map[pos + d].match(SYM_PORTAL) }.first
+          next unless map[pos + ndelta * 2] == SYM_OPEN
+
+          # Portal names are apparently read from left-to-right like reading.
+          name = [pos, pos + ndelta].sort_by(&:rectangular).map { |p| map[p] }.join
+          portals_by_name[name] << pos + ndelta * 2
+        end
+      end
+
+      portals = {} # Complex -> Complex
+      portals_by_name.each do |_name, positions|
+        portals[positions[0]] = positions[1]
+        portals[positions[1]] = positions[0]
+      end
+
+      pos_start = portals_by_name[PORTAL_START].first
+      pos_end = portals_by_name[PORTAL_END].first
+
+      portals.delete(pos_start)
+      portals.delete(pos_end)
+      portals.delete(nil)
+
+      [portals, pos_start, pos_end]
+    end
+
+    def visitable_neighbours(map, portals, visited, pos)
+      pos_neighbours = NEIGHBOUR_DELTAS.map { |d| pos + d }.select { |p| map[p] == SYM_OPEN }
+      pos_neighbours << portals[pos] if portals.include?(pos)
+      pos_neighbours.reject { |posn| visited.include?(posn) }
+    end
+
+    def min_steps(map, portals, pos_end, pos, visited = Set.new)
+      # puts "min_steps(#{pos}, #{visited})"
+      steps_ff = 0
+      # Fast-forward simple paths without direction choices to save on recursion depth.
+      loop do
+        pos_neighbours = visitable_neighbours(map, portals, visited, pos)
+        break unless pos_neighbours.length == 1
+
+        pos = pos_neighbours.first
+        visited << pos
+        steps_ff += 1
+      end
+      return steps_ff if pos == pos_end
+
+      steps_rest_min = Float::INFINITY
+      visitable_neighbours(map, portals, visited, pos).each do |npos|
+        steps_rest = 1 + min_steps(map, portals, pos_end, npos, visited + [npos])
+        steps_rest_min = [steps_rest_min, steps_rest].min
+      end
+
+      steps_ff + steps_rest_min
+    end
+
+    map = Hash.new(SYM_UNDEF) # Complex -> Char
+    ARGF.each_line.with_index do |line, x|
+      line.chomp.each_char.with_index do |char, y|
+        next if char == SYM_UNDEF
+
+        pos = Complex(x, y)
+        map[pos] = char
+      end
+    end
+
+    # print_map(map)
+
+    portals, pos_start, pos_end = find_portals(map)
+    # pp portals, pos_start, pos_end
+    puts min_steps(map, portals, pos_end, pos_start)

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

@@ -0,0 +1,123 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/20
+  :solution: |-
+    require 'set'
+
+    SYM_WALL = '#'
+    SYM_OPEN = '.'
+    SYM_UNDEF = ' '
+    SYM_PORTAL = /[A-Z]/
+    SYM_POS_CUR = '@'
+
+    PORTAL_START = 'AA'
+    PORTAL_END = 'ZZ'
+
+    PTYPE_INNER = :inner
+    PTYPE_OUTER = :outer
+
+    # Notes from input2.2: not only can you enter the same portal twice, but also coming from the same portal. Thus saving visited portals is not a way to detect infinite recursion.
+    MAX_LEVELS = 25 # Empirically found and not by chance coinciding with christmas. Set to 15 for input2.2.
+
+    NEIGHBOUR_DELTAS = [-1 + 0i, 1 + 0i, 0 - 1i, 0 + 1i]
+
+    def print_map(map, pos_cur = nil)
+      xmin, xmax = map.keys.map(&:real).minmax
+      ymin, ymax = map.keys.map(&:imag).minmax
+      (xmin..xmax).each do |x|
+        (ymin..ymax).each do |y|
+          pos = Complex(x, y)
+          print pos_cur == pos ? SYM_POS_CUR : map[pos]
+        end
+        puts
+      end
+    end
+
+    def find_portals(map)
+      portals_by_name = Hash.new { |h, k| h[k] = [] } # "xx" -> [Complex, Complex]
+
+      xmin, xmax = map.keys.map(&:real).minmax
+      ymin, ymax = map.keys.map(&:imag).minmax
+      (xmin..xmax).each do |x|
+        (ymin..ymax).each do |y|
+          pos = Complex(x, y)
+          next unless map[pos].match(SYM_PORTAL)
+
+          ndelta = NEIGHBOUR_DELTAS.select { |d| map[pos + d].match(SYM_PORTAL) }.first
+          next unless map[pos + ndelta * 2] == SYM_OPEN
+
+          # Portal names are apparently read from left-to-right like reading.
+          name = [pos, pos + ndelta].sort_by(&:rectangular).map { |p| map[p] }.join
+          ptype = [xmin, xmax].include?(pos.real) || [ymin, ymax].include?(pos.imag) ? PTYPE_OUTER : PTYPE_INNER
+          portals_by_name[name] << [pos + ndelta * 2, ptype]
+        end
+      end
+
+      portals = {} # Complex -> [Complex, PTYPE]
+      portals_by_name.each do |_name, positions|
+        next unless positions.length > 1
+
+        portals[positions[0][0]] = [positions[1][0], positions[0][1]]
+        portals[positions[1][0]] = [positions[0][0], positions[1][1]]
+      end
+
+      pos_start = portals_by_name[PORTAL_START].first[0]
+      pos_end = portals_by_name[PORTAL_END].first[0]
+
+      [portals, pos_start, pos_end]
+    end
+
+    # All visitable neighbours and what level, as neighbours via portals are considerd a neighbour as well.
+    def visitable_neighbours(map, portals, visited, pos, level)
+      pos_neighbours = NEIGHBOUR_DELTAS.map { |d| [pos + d, level] }.select { |p, _l, _pn| map[p] == SYM_OPEN }
+
+      if portals.include?(pos)
+        port_pos, ptype = portals[pos]
+        unless level == 0 && ptype == PTYPE_OUTER
+          port_level = level + (ptype == PTYPE_INNER ? 1 : -1)
+          pos_neighbours << [port_pos, port_level]
+        end
+      end
+
+      pos_neighbours.reject { |npos, nlevel| visited.include?([npos, nlevel]) }
+    end
+
+    def min_steps(map, portals, pos_end, pos, visited = Set.new, level = 0)
+      return Float::INFINITY unless level.between?(0, MAX_LEVELS)
+
+      steps_ff = 0
+      # Fast-forward simple paths without direction choices to save on recursion depth.
+      loop do
+        pos_neighbours = visitable_neighbours(map, portals, visited, pos, level)
+        break unless pos_neighbours.length == 1
+
+        npos, nlevel = pos_neighbours.first
+        pos = npos
+        level = nlevel
+
+        visited << [pos, level]
+        steps_ff += 1
+      end
+      return steps_ff if pos == pos_end && level == 0
+
+      steps_rest_min = Float::INFINITY
+      visitable_neighbours(map, portals, visited, pos, level).each do |npos, nlevel|
+        steps_rest = 1 + min_steps(map, portals, pos_end, npos, visited + [[npos, nlevel]], nlevel)
+        steps_rest_min = [steps_rest_min, steps_rest].min
+      end
+
+      steps_ff + steps_rest_min
+    end
+
+    map = Hash.new(SYM_UNDEF) # Complex -> Char
+    ARGF.each_line.with_index do |line, x|
+      line.chomp.each_char.with_index do |char, y|
+        next if char == SYM_UNDEF
+
+        pos = Complex(x, y)
+        map[pos] = char
+      end
+    end
+
+    portals, pos_start, pos_end = find_portals(map)
+    puts min_steps(map, portals, pos_end, pos_start, Set[[pos_start, 0]])

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

@@ -0,0 +1,31 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/21
+  :solution: |-
+    require_relative 'lib'
+    require '../09/computer_iter'
+
+    VERBOSE = false
+
+    PROGRAM = <<~SPRINGSCRIPT
+      NOT A J
+      NOT B T
+      OR T J
+      NOT C T
+      OR T J
+      AND D J
+    SPRINGSCRIPT
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new(intcode)
+
+    run(computer)
+    read_print(computer, VERBOSE)
+
+    PROGRAM.each_line do |instruction|
+      input(computer, instruction, VERBOSE)
+    end
+    input(computer, "WALK\n", VERBOSE)
+    run(computer)
+
+    read_print(computer, VERBOSE)

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

@@ -0,0 +1,44 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/21
+  :solution: |-
+    require_relative 'lib'
+    require '../09/computer_iter'
+
+    VERBOSE = false
+
+    # Logical expression is (developed with logic.rb)
+    # (-A v -B v -C) ^ D ^ (H v E ^ I v E ^ F)
+    # which can be refactored to save on logical operators to
+    # -(A ^ B ^ C) ^ D ^ (H v E ^ (I v F))
+    # The expression is implemented from inside-to-out below:
+    PROGRAM = <<~SPRINGSCRIPT
+      OR F T
+      OR I T
+      AND E T
+      OR H J
+      OR T J
+      AND D J
+      AND A T#{!'Reset T:=false by our current assumption to ABC=false' ? '' : ''}
+      AND B T
+      AND C T
+      OR C T#{!'Now we can save C to T' ? '' : ''}
+      AND B T
+      AND A T
+      NOT T T
+      AND T J
+    SPRINGSCRIPT
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new(intcode)
+
+    run(computer)
+    read_print(computer, VERBOSE)
+
+    PROGRAM.each_line do |instruction|
+      input(computer, instruction, VERBOSE)
+    end
+    input(computer, "RUN\n", VERBOSE)
+    run(computer)
+
+    read_print(computer, VERBOSE)