advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/gchan/2022/15_2.yml

@@ -0,0 +1,65 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-15
+  :solution: |-
+    sensors = {}
+
+    input.strip.each_line do |sensor|
+      sensor, beacon = sensor.split(":")
+
+      x, y = sensor.scan(/\d+/).map(&:to_i)
+      bx, by = beacon.scan(/-?\d+/).map(&:to_i)
+
+      dist = (x - bx).abs + (y - by).abs
+
+      sensors[[x,y]] = dist
+    end
+
+    # Enumerate through each sensor and build ranges for each row.
+    #
+    # However it rould be more efficient to enumerate through
+    # each row, build the ranges and check as we go. That way we
+    # can discard row ranges and avoid build ranges that we may
+    # not need.
+    #
+    rows = Hash.new { |h, k| h[k] = [] }
+
+    max = 4_000_000
+
+    sensors.each do |(x, y), dist|
+      print ?.
+
+      x1 = x - dist
+      x2 = x + dist
+
+      (dist + 1).times do |i|
+        range = [x1 + i, x2 - i]
+
+        # Not cloning here cost me a lot of debugging time!
+        rows[y + i] << range.clone
+        rows[y - i] << range.clone
+      end
+    end
+
+    puts
+
+    (max + 1).times.each do |y|
+      print ?. if y % 100_000 == 0
+
+      ranges = rows[y].sort
+
+      range = ranges.shift
+
+      ranges.each do |(from, to)|
+        if from <= range[1]
+          range[1] = [range[1], to].max
+        else
+          x = from - 1
+
+          puts
+          puts [x, y].inspect
+          puts x * 4000000 + y
+          exit
+        end
+      end
+    end

data/data/solutions/github/gchan/2022/16_1.yml

@@ -0,0 +1,92 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-16
+  :solution: |-
+    valves = {}
+    flows = {}
+
+    input.each_line do |line|
+      valve = line.scan(/(\w+) has/).first.first
+      leads = line.scan(/to valves? (.*)/).first.first.split(",").map(&:strip)
+      flow = line.scan(/\d+/).first.to_i
+
+      flows[valve] = flow
+      valves[valve] = leads
+    end
+
+    start = "AA"
+
+    # Simplify the graph by removing rooms with zero-flow valves.
+    #
+    # Do this by finding the distances between each non-zero flow valves
+    #
+    # You can also use the Floyd–Warshall algorithm (see part 2)
+    #
+
+    distances = {}
+
+    nodes = flows.select { |valve, flow| flow > 0 }.keys
+    nodes << start
+
+    nodes.combination(2).each do |from, to|
+      visited = { from: 0 }
+
+      queue = [[from, 0]]
+
+      while queue.any?
+        curr, dist = queue.shift
+
+        valves[curr].each do |dest|
+          next if visited[dest]
+
+          queue << [dest, dist + 1]
+          visited[dest] = dist + 1
+        end
+
+        break if visited[to]
+      end
+
+      distances[[from, to].sort] = visited[to]
+    end
+
+
+    # Breath-first search of the graph
+    #
+    # Keep track of the maximum pressure for each position and opened
+    # valves state
+    #
+
+    queue = [
+      [
+        position = start, # current position
+        opened = [],      # valves opened
+        pressure = 0,     # total pressure if no more valves are opened
+        time = 30         # time remaining
+      ]
+    ]
+
+    valves_to_open = flows.select { |_valve, flow| flow > 0 }.keys
+
+    visited = {}
+
+    while queue.any?
+      curr, opened, pressure, time = queue.shift
+
+      (valves_to_open - opened).each do |dest|
+        dist = distances[[curr, dest].sort]
+
+        n_time = time - dist - 1
+        next if n_time < 0
+
+        n_pressure = pressure + flows[dest] * n_time
+        n_opened = (opened.clone << dest).sort
+
+        next if visited[[dest, n_opened]] &&
+          visited[[dest, n_opened]] > n_pressure
+
+        visited[[dest, n_opened]] = n_pressure
+        queue << [dest, n_opened, n_pressure, n_time]
+      end
+    end
+
+    pp visited.values.max

data/data/solutions/github/gchan/2022/16_2.yml

@@ -0,0 +1,119 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-16
+  :solution: |-
+    valves = {}
+    flows = {}
+
+    input.each_line do |line|
+      valve = line.scan(/(\w+) has/).first.first
+      leads = line.scan(/to valves? (.*)/).first.first.split(",").map(&:strip)
+      flow = line.scan(/\d+/).first.to_i
+
+      flows[valve] = flow
+      valves[valve] = leads
+    end
+
+    # Simplify the graph by removing rooms with zero-flow valves.
+    #
+    # Do this by finding the distances between each non-zero flow valves
+    #
+    # Using the Floyd–Warshall algorithm (although it doesn't seem
+    # to be more efficient than a basic shortest path algorithm).
+    #
+
+    distances = Hash.new { |h, k| h[k] = Hash.new(9999) }
+
+    valves.each do |valve, leads|
+      leads.each do |lead|
+        distances[valve][lead] = 1
+        distances[lead][valve] = 1
+      end
+    end
+
+    valves.each do |inter, _|
+      valves.each do |from, _|
+        valves.each do |to, _|
+          dist = distances[from][inter] + distances[inter][to]
+
+          if dist < distances[from][to]
+            distances[from][to] = dist
+          end
+        end
+      end
+    end
+
+
+    # Breath-first search of the graph
+    #
+    # Keep track of the maximum pressure for each position and opened
+    # valves state
+    #
+
+    queue = [
+      [
+        position = "AA",  # current position
+        opened = [],      # valves opened
+        pressure = 0,     # total pressure if no more valves are opened
+        time = 26         # time remaining
+      ]
+    ]
+
+    valves_to_open = flows.select { |_valve, flow| flow > 0 }.keys
+
+    visited = {}
+
+    while queue.any?
+      curr, opened, pressure, time = queue.shift
+
+      (valves_to_open - opened).each do |dest|
+        dist = distances[curr][dest]
+
+        n_time = time - dist - 1
+        next if n_time < 0
+
+        n_pressure = pressure + flows[dest] * n_time
+        n_opened = (opened.clone << dest).sort
+
+        next if visited[[dest, n_opened]] &&
+          visited[[dest, n_opened]] > n_pressure
+
+        visited[[dest, n_opened]] = n_pressure
+        queue << [dest, n_opened, n_pressure, n_time]
+      end
+    end
+
+    # Simplify to sets of opened valves and the maximum pressure
+    # released for each set of open valves.
+    #
+    # Each set represents the valves one human/elephant opened
+    #
+    opened_valves = {}
+
+    visited.each do |(_position, opened), pressure|
+      next if opened_valves[opened] && pressure < opened_valves[opened]
+
+      opened_valves[opened] = pressure
+    end
+
+    # Find all disjoint set pairs (where the valves opened are distinct
+    # amongst both sets)
+    #
+    # Return the maximum sum of each pair of disjoint sets
+    #
+    max = 0
+
+    opened_valves.each do |opened, pressure|
+      opened_valves.each do |o2, p2|
+        # It would be more efficient to represent the opened valves
+        # as a bit set so the AND/& operation would be very cheap
+        #
+        if opened & o2  == []
+          total = p2 + pressure
+
+          max = [max, total].max
+        end
+      end
+    end
+
+    puts max

data/data/solutions/github/gchan/2022/17_1.yml

@@ -0,0 +1,105 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-17
+  :solution: |-
+    jets = input.strip.chars
+
+    rocks = "####
+
+    .#.
+    ###
+    .#.
+
+    ..#
+    ..#
+    ###
+
+    #
+    #
+    #
+    #
+
+    ##
+    ##
+    "
+
+    rocks = rocks.split("\n\n").map do |rock|
+      rock.split("\n").map(&:chars)
+    end
+
+    CHAMBER_WIDTH = 7
+    MAX_ROCK_HEIGHT = rocks.map(&:length).max
+    X_OFFSET = 2
+    Y_OFFSET = 4
+
+    grid = Array.new(5) { Array.new(CHAMBER_WIDTH, " ") }
+
+    def can_move?(rock, grid, x, y)
+      h = rock.length
+      w = rock.first.length
+
+      return false if y >= grid.length
+      return false if x < 0 || x + w > grid[0].length
+
+      rock.each_with_index do |row, y1|
+        row.each_with_index do |cell, x1|
+          if cell == "#" && grid[y - h + 1 + y1][x + x1] == "#"
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
+    tower_height = 0
+    jet_idx = 0
+
+    2022.times do |i|
+      rock = rocks[i % rocks.length]
+
+      rock_height = rock.length
+
+      x = X_OFFSET
+      y = grid.length - tower_height - Y_OFFSET
+
+      while true
+        move = jets[jet_idx]
+        jet_idx = (jet_idx + 1) % jets.length
+
+        case move
+        when ?<
+          x -= 1 if can_move?(rock, grid, x - 1, y)
+        when ?>
+          x += 1 if can_move?(rock, grid, x + 1, y)
+        end
+
+        if can_move?(rock, grid, x, y + 1)
+          y += 1
+        else
+          rock.each_with_index do |row, y1|
+            row.each_with_index do |cell, x1|
+              next if cell == ?.
+
+              y2 = y - (rock_height - 1) + y1
+              grid[y2][x + x1] = cell
+            end
+          end
+
+          tower_height = [
+            grid.length - y + (rock_height - 1),
+            tower_height
+          ].max
+
+          break
+        end
+      end
+
+      (Y_OFFSET + MAX_ROCK_HEIGHT - 1 - (grid.length - tower_height)).times do
+        grid.unshift(Array.new(CHAMBER_WIDTH, " "))
+      end
+    end
+
+    puts tower_height
+
+    # puts grid.first(20).map(&:join).join("\n")

data/data/solutions/github/gchan/2022/17_2.yml

@@ -0,0 +1,136 @@
+---
+- :name: day-17-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-17
+  :solution: |-
+    jets = input.strip.chars
+
+    rocks = "####
+
+    .#.
+    ###
+    .#.
+
+    ..#
+    ..#
+    ###
+
+    #
+    #
+    #
+    #
+
+    ##
+    ##
+    "
+
+    rocks = rocks.split("\n\n").map do |rock|
+      rock.split("\n").map(&:chars)
+    end
+
+    CHAMBER_WIDTH = 7
+    MAX_ROCK_HEIGHT = rocks.map(&:length).max
+    X_OFFSET = 2
+    Y_OFFSET = 4
+
+    grid = Array.new(5) { Array.new(CHAMBER_WIDTH, " ") }
+
+    def can_move?(rock, grid, x, y)
+      h = rock.length
+      w = rock.first.length
+
+      return false if y >= grid.length
+      return false if x < 0 || x + w > grid[0].length
+
+      rock.each_with_index do |row, y1|
+        row.each_with_index do |cell, x1|
+          if cell == "#" && grid[y - h + 1 + y1][x + x1] == "#"
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
+    tower_height = 0
+    jet_idx = 0
+    idx = 0
+
+    states = {}
+    target = 1_000_000_000_000
+    loop_height = nil
+
+    while idx < target
+      rock = rocks[idx % rocks.length]
+
+      rock_height = rock.length
+
+      x = X_OFFSET
+      y = grid.length - tower_height - Y_OFFSET
+
+      while true
+        move = jets[jet_idx]
+        jet_idx = (jet_idx + 1) % jets.length
+
+        case move
+        when ?<
+          x -= 1 if can_move?(rock, grid, x - 1, y)
+        when ?>
+          x += 1 if can_move?(rock, grid, x + 1, y)
+        end
+
+        if can_move?(rock, grid, x, y + 1)
+          y += 1
+        else
+          rock.each_with_index do |row, y1|
+            row.each_with_index do |cell, x1|
+              next if cell == ?.
+
+              y2 = y - (rock_height - 1) + y1
+              grid[y2][x + x1] = cell
+            end
+          end
+
+          tower_height = [
+            grid.length - y + (rock_height - 1),
+            tower_height
+          ].max
+
+          break
+        end
+      end
+
+      (Y_OFFSET + MAX_ROCK_HEIGHT - 1 - (grid.length - tower_height)).times do
+        grid.unshift(Array.new(CHAMBER_WIDTH, " "))
+      end
+
+      idx += 1
+
+      #
+      # Find a cycle/loop by looking for two states with the same:
+      #   * Next rock
+      #   * Next jet movement index
+      #   * Tower statesern (top 30 lines)
+      #
+      grid_top = grid[grid.length - tower_height, 30].map(&:join).join("\n")
+
+      state = [idx % 5, jet_idx, grid_top]
+
+      if states[state] && !loop_height
+        prev_rock_idx, prev_tower_height = states[state]
+
+        cycle_length = idx - prev_rock_idx
+        cycle_height = tower_height - prev_tower_height
+
+        cycles = (target - idx) / cycle_length
+
+        loop_height = cycle_height * cycles
+        idx += cycle_length * cycles
+      else
+        states[state] = [idx, tower_height]
+      end
+    end
+
+    puts tower_height + loop_height
+
+    # puts grid.first(20).map(&:join).join("\n")

data/data/solutions/github/gchan/2022/18_1.yml

@@ -0,0 +1,24 @@
+---
+- :name: day-18-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-18
+  :solution: |-
+    input     = File.read(file_path)
+
+    cubes = Set.new
+
+    input.strip.split("\n").map do |cube|
+      cubes << cube.split(",").map(&:to_i)
+    end
+
+    count = 0
+
+    cubes.each do |pos|
+      neighbours = [-1, 1].product([0, 1, 2]).map do |v, i|
+        neighbour = pos.clone
+        neighbour[i] += v
+
+        count += 1 if cubes.include?(neighbour)
+      end
+    end
+
+    puts cubes.count * 6 - count

data/data/solutions/github/gchan/2022/18_2.yml

@@ -0,0 +1,44 @@
+---
+- :name: day-18-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-18
+  :solution: |-
+    input     = File.read(file_path)
+
+    cubes = Set.new
+
+    input.strip.split("\n").map do |cube|
+      cubes << cube.split(",").map(&:to_i)
+    end
+
+    x_max = cubes.map { |cube| cube[0] }.max + 1
+    y_max = cubes.map { |cube| cube[1] }.max + 1
+    z_max = cubes.map { |cube| cube[2] }.max + 1
+
+    visited = Set.new
+    queue = [[0, 0, 0]]
+
+    count = 0
+
+    while queue.any?
+      pos = queue.shift
+
+      neighbours = [-1, 1].product([0, 1, 2]).map do |move, d|
+        neighbour = pos.clone
+        neighbour[d] += move
+
+        x, y, z = neighbour
+
+        next if visited.include?(neighbour)
+        next if x < -1 || y < -1 || z < -1 ||
+          x > x_max || y > y_max || z > z_max
+
+        if cubes.include?(neighbour)
+          count += 1
+        else
+          queue << neighbour
+          visited << neighbour
+        end
+      end
+    end
+
+    puts count

data/data/solutions/github/gchan/2022/19_1.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/gchan/2022/19_2.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/github/gchan/2022/20_1.yml

@@ -0,0 +1,20 @@
+---
+- :name: day-20-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-20
+  :solution: |-
+    nums = input.split.map(&:to_i)
+      .each_with_index.map { [_1, _2] }
+
+    nums.length.times { |n|
+      idx = nums.index { _2 == n }
+
+      val = nums.delete_at(idx)
+
+      nums.insert((idx + val[0]) % nums.size, val)
+    }
+
+    idx = nums.index { _1[0] == 0 }
+
+    puts nums[(idx + 1000) % nums.length][0] +
+      nums[(idx + 2000) % nums.length][0] +
+      nums[(idx + 3000) % nums.length][0]

data/data/solutions/github/gchan/2022/20_2.yml

@@ -0,0 +1,23 @@
+---
+- :name: day-20-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-20
+  :solution: |-
+    nums = input.split.map(&:to_i)
+
+    nums = nums.each_with_index.map { [_1 * 811589153, _2] }
+
+    10.times {
+      nums.length.times { |n|
+        idx = nums.find_index { _2 == n }
+
+        val = nums.delete_at(idx)
+
+        nums.insert((idx + val[0]) % nums.size, val)
+      }
+    }
+
+    idx = nums.index { _1[0] == 0 }
+
+    puts nums[(idx + 1000) % nums.length][0] +
+      nums[(idx + 2000) % nums.length][0] +
+      nums[(idx + 3000) % nums.length][0]

data/data/solutions/github/gchan/2022/21_1.yml

@@ -0,0 +1,26 @@
+---
+- :name: day-21-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-21
+  :solution: |-
+    monkeys = input.split(?\n).map {
+      out, ins = _1.split(": ")
+      ins = ins.to_i if ins.match?(/\d+/)
+
+      [out, ins]
+    }
+
+    solved, unsolved = monkeys
+      .partition { _2.is_a?(Numeric) }
+      .map(&:to_h)
+
+    while unsolved.any?
+      unsolved.each do |out, expression|
+        a, op, b = expression.split
+        next unless solved[a] && solved[b]
+
+        solved[out] = solved[a].send(op, solved[b])
+        unsolved.delete(out)
+      end
+    end
+
+    puts solved["root"]