advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/gchan/2024/14_2.yml

@@ -0,0 +1,41 @@
+---
+- :name: day-14-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-14
+  :solution: |-
+    width = 101
+    height = 103
+
+    robots = input.split(?\n)
+      .map { _1.scan(/-*\d+/).map(&:to_i) }
+
+    seconds = 0
+
+    while true
+      seconds += 1
+
+      robots.each.with_index { |(x, y, vx, vy), idx|
+        x = (x + vx) % width
+        y = (y + vy) % height
+
+        robots[idx][0] = x
+        robots[idx][1] = y
+      }
+
+      grid = []
+
+      height.times {
+        grid << ?. * width
+      }
+
+      robots.each {
+        grid[_2][_1] = ?#
+      }
+
+      grid = grid.join(?\n)
+
+      if grid.include?("########")
+        puts grid
+        puts seconds
+        exit
+      end
+    end

data/data/solutions/github/gchan/2024/15_1.yml

@@ -0,0 +1,81 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-15
+  :solution: |-
+    grid, movements = input.split("\n\n")
+
+    pos = grid.split.join.index(?@)
+    grid = grid.split.map(&:chars)
+
+    height = grid.size
+    width = grid[0].size
+
+    y = pos / width
+    x = pos % width
+
+    movements.split.join.strip.chars.each do |dir|
+      case dir
+      when ?>
+        x1, y1 = [x + 1, y]
+      when ?<
+        x1, y1 = [x - 1, y]
+      when ?^
+        x1, y1 = [x, y - 1]
+      when ?v
+        x1, y1 = [x, y + 1]
+      end
+
+      ## Debugging
+      # puts grid.map(&:join).join("\n")
+      # gets
+      # puts dir
+
+      # We see a block, go to next instruction
+      next if grid[y1][x1] == ?#
+
+      # Move if there is an open space
+      if grid[y1][x1] == ?.
+        grid[y1][x1] = ?@
+        grid[y][x]   = ?.
+        x, y = x1, y1
+
+        next
+      end
+
+      # Identify whether there is space for the box(es)
+      x2, y2 = x1, y1
+
+      while grid[y2][x2] == ?O
+        case dir
+        when ?>
+          x2, y2 = [x2 + 1, y2]
+        when ?<
+          x2, y2 = [x2 - 1, y2]
+        when ?^
+          x2, y2 = [x2, y2 - 1]
+        when ?v
+          x2, y2 = [x2, y2 + 1]
+        end
+      end
+
+      # If there is a space for the boxes, move
+      if grid[y2][x2] == ?.
+        grid[y2][x2] = ?O
+
+        grid[y1][x1] = ?@
+        grid[y][x] = ?.
+        x, y = x1, y1
+      end
+    end
+
+    # puts grid.map(&:join).join("\n")
+
+    sum = 0
+
+    grid.each.with_index do |row, y|
+      row.each.with_index do |cell, x|
+        sum += (y * 100 + x) if cell == ?O
+      end
+    end
+
+    puts sum

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

@@ -0,0 +1,153 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-15
+  :solution: |-
+    grid, movements = input.split("\n\n")
+
+    grid = grid
+      .gsub(?#, "##")
+      .gsub(?O, "[]")
+      .gsub(?., "..")
+      .gsub(?@, "@.")
+
+    pos = grid.split.join.index(?@)
+    grid = grid.split.map(&:chars)
+
+    # puts grid.map(&:join).join("\n")
+
+    height = grid.size
+    width = grid[0].size
+
+    y = pos / width
+    x = pos % width
+
+    movements.split.join.strip.chars.each do |dir|
+      case dir
+      when ?>
+        x1, y1 = [x + 1, y]
+      when ?<
+        x1, y1 = [x - 1, y]
+      when ?^
+        x1, y1 = [x, y - 1]
+      when ?v
+        x1, y1 = [x, y + 1]
+      end
+
+      ## Debugging
+      # puts grid.map(&:join).join("\n")
+      # gets
+      # puts dir
+
+      # We see a block, go to next instruction
+      next if grid[y1][x1] == ?#
+
+      # Move if there is an open space
+      if grid[y1][x1] == ?.
+        grid[y1][x1] = ?@
+        grid[y][x]   = ?.
+
+        x, y = x1, y1
+
+        next
+      end
+
+      # We see a box, see if we can push them
+      #
+      # Moving boxes left and right is easy
+      if dir == ?> || dir == ?<
+        x2, y2 = x1, y1
+
+        while grid[y2][x2] == ?[ || grid[y2][x2] == ?]
+          case dir
+          when ?>
+            x2, y2 = [x2 + 1, y2]
+          when ?<
+            x2, y2 = [x2 - 1, y2]
+          end
+        end
+
+        # If there is a space to the left/right for the box(es), move them
+        if grid[y2][x2] == ?.
+          from, to = x1 + 1, x2
+          from, to = to, from if from > to
+
+          (from..to).each.with_index {
+            grid[y][_1] = _2.even? ? ?[ : ?]
+          }
+
+          grid[y1][x1] = ?@
+          grid[y][x] = ?.
+
+          x, y = x1, y1
+        end
+      else # Moving boxes up or down is more difficult
+        # Track connected boxes by their left-side position
+        boxes = []
+
+        if grid[y1][x1] == ?]
+          boxes << [x1 - 1, y1]
+        else
+          boxes << [x1, y1]
+        end
+
+        # Assume we can push boxes until we see a block
+        movable = true
+
+        # Find all connected boxes
+        queue = boxes.dup
+        queue << boxes[0].dup.tap { _1[0] += 1 }
+
+        while queue.any?
+          bx, by = queue.pop
+          by += (dir == ?^ ? -1 : 1 )
+
+          if grid[by][bx] == ?[ || grid[by][bx] == ?]
+            if grid[by][bx] == ?]
+              boxes << [bx - 1, by]
+            else
+              boxes << [bx, by]
+            end
+
+            queue << boxes.last
+            queue << boxes.last.dup.tap { _1[0] += 1 }
+
+          elsif grid[by][bx] == ?#
+            movable = false
+            queue.clear
+          end
+        end
+
+        if movable
+          # Clear the grid cells
+          boxes.each { |bx, by|
+            grid[by][bx] = ?.
+            grid[by][bx + 1] = ?.
+          }
+
+          # Paint the new box locations
+          boxes.each { |bx, by|
+            by += (dir == ?^ ? -1 : 1 )
+
+            grid[by][bx] = ?[
+            grid[by][bx + 1] = ?]
+          }
+
+          grid[y1][x1] = ?@
+          grid[y][x] = ?.
+
+          x, y = x1, y1
+        end
+      end
+    end
+
+    # puts grid.map(&:join).join("\n")
+
+    sum = 0
+
+    grid.each.with_index do |row, y|
+      row.each.with_index do |cell, x|
+        sum += (y * 100 + x) if cell == ?[
+      end
+    end
+
+    puts sum

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

@@ -0,0 +1,50 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-16
+  :solution: |-
+    grid = input.split.map(&:chars)
+
+    width = grid[0].size
+    height = grid.size
+
+    start = input.split.join.index(?S)
+    start = [start % width, start / height]
+
+    # East
+    dir = [1, 0]
+
+    visited = {}
+    visited.default = 100_000_000
+
+    queue = []
+    queue << [0, start, dir]
+
+    enqueue = -> (score, loc, dir) {
+      next if visited[[loc, dir]] <= score
+
+      queue.unshift([score, loc, dir])
+      visited[[loc, dir]] = score
+    }
+
+    while queue.any?
+      queue.sort_by!(&:first)
+      score, loc, dir = queue.shift
+
+      # Move forward
+      loc2 = loc.zip(dir).map { _1.inject(:+) }
+      x, y = loc2
+
+      case grid[y][x]
+      when ?E
+        puts score + 1
+        exit
+      when ?.
+        enqueue.call(score + 1, loc2, dir)
+      end
+
+      # Left turn
+      enqueue.call(score + 1000, loc, [dir[1], -dir[0]])
+
+      # Right turn
+      enqueue.call(score + 1000, loc, [-dir[1], dir[0]])
+    end

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

@@ -0,0 +1,99 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-16
+  :solution: |-
+    grid = input.split.map(&:chars)
+
+    width = grid[0].size
+    height = grid.size
+
+    start = input.split.join.index(?S)
+    start = [start % width, start / height]
+
+    # East
+    dir = [1, 0]
+
+    visited = {}
+    visited.default = 100_000_000
+
+    queue = []
+    queue << [0, start, dir, [[start, dir]]]
+
+    from = Hash.new { |h, k| h[k] = [] }
+    good_path = Set.new
+
+    enqueue = -> (score, loc, dir, p_loc, p_dir, path) {
+      if visited[[loc, dir]] > score
+        visited[[loc, dir]] = score
+
+        # We found a better path to this node, remove any previous children
+        from[[loc, dir]] = [[p_loc, p_dir]]
+
+        queue.unshift([score, loc, dir, path.clone << [loc, dir]])
+      elsif visited[[loc, dir]] == score
+        from[[loc, dir]] << [p_loc, p_dir]
+      end
+    }
+
+    goal = []
+    while queue.any?
+      score, loc, dir, path = queue.shift
+
+      # Move forward
+      loc2 = loc.zip(dir).map { _1.inject(:+) }
+      x1, y1 = loc2
+
+      case grid[y1][x1]
+      when ?E
+        puts score + 1
+
+        goal = [loc2, dir]
+        path << [loc2, dir]
+
+        path.each { good_path.add(_1) }
+        next
+      when ?.
+        enqueue.call(score + 1, loc2, dir, loc, dir, path)
+      end
+
+      # Left turn
+      enqueue.call(
+        score + 1000,
+        loc, [dir[1], -dir[0]],
+        loc, dir,
+        path
+      )
+
+      # Right turn
+      dir2 = [-dir[1], dir[0]]
+      enqueue.call(
+        score + 1000,
+        loc, dir2,
+        loc, dir,
+        path
+      )
+
+      queue.sort_by!(&:first)
+    end
+
+    queue = good_path.to_a
+
+    while queue.any?
+      loc, dir = queue.pop
+
+      from[[loc, dir]].each do |l2, d2|
+        next if good_path.include?([l2,d2])
+
+        queue << [l2, d2]
+        good_path << [l2, d2]
+      end
+    end
+
+    p good_path.map(&:first).uniq.count
+
+    ## Debugging
+    # good_path.map(&:first).uniq.each {
+    #   grid[_2][_1] = ?O
+    # }
+    #
+    # puts grid.map(&:join).join("\n")

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

@@ -0,0 +1,49 @@
+---
+- :name: day-17-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-17
+  :solution: |-
+    registers, commands = input.split("\n\n")
+
+    reg = registers.scan(/\d+/).map(&:to_i)
+    cmds = commands.scan(/\d+/).map(&:to_i)
+
+    out = []
+
+    ptr = 0
+
+    while ptr < cmds.length
+      cmd, op = cmds[ptr], cmds[ptr + 1]
+
+      lit = op
+      co = op
+      if op >= 4 && op<= 6
+        co = reg[op - 4]
+      end
+
+      case cmd
+      when 0
+        reg[0] = reg[0] / (2**co)
+      when 1
+        reg[1] = reg[1] ^ lit
+      when 2
+        # keep last 3 bits
+        reg[1] = co % 8
+      when 3
+        if reg[0] != 0 && lit != ptr
+          ptr = lit
+          next
+        end
+      when 4
+        reg[1] = reg[1] ^ reg[2]
+      when 5
+        out << co % 8
+      when 6
+        reg[1] = reg[0] / (2**co)
+      when 7
+        reg[2] = reg[0] / (2**co)
+      end
+
+      ptr += 2
+    end
+
+    puts out.join(?,)

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

@@ -0,0 +1,89 @@
+---
+- :name: day-17-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-17
+  :solution: |-
+    registers, commands = input.split("\n\n")
+
+    reg = registers.scan(/\d+/).map(&:to_i)
+    cmds = commands.scan(/\d+/).map(&:to_i)
+
+    def run(cmds, a_reg)
+      reg = [a_reg, 0, 0]
+
+      out = []
+
+      ptr = 0
+
+      while ptr < cmds.length
+        cmd, op = cmds[ptr], cmds[ptr + 1]
+
+        lit = op
+        co = op
+        if op >= 4 && op<= 6
+          co = reg[op - 4]
+        end
+
+        case cmd
+        when 0
+          reg[0] = reg[0] / (2**co)
+        when 1
+          reg[1] = reg[1] ^ lit
+        when 2
+          reg[1] = co % 8
+        when 3
+          if reg[0] != 0 && lit != ptr
+            ptr = lit
+            next
+          end
+        when 4
+          reg[1] = reg[1] ^ reg[2]
+        when 5
+          out << co % 8
+        when 6
+          reg[1] = reg[0] / (2**co)
+        when 7
+          reg[2] = reg[0] / (2**co)
+        end
+
+        ptr += 2
+      end
+
+      return out
+    end
+
+    # The device runs in a loop and prints an output once per loop.
+    # At the end of the one loop, the least significant 3 bits are discarded.
+    # Registers B and C are derived by the A register at the start of each
+    # iteration of the loop
+    #
+    # So we can build up the desired output from building up the value of A
+    # by shifting the value by 3 bits in each iteration (i.e. multiplying A
+    # by 8). The search space is 3 bits (8 values) each time so it's feasible
+    # to 'brute force'.
+
+    goal = cmds.clone
+
+    target = []
+    solutions = [0] # to initialise the search space, zero not a valid solution!
+
+    while goal.any?
+      target.unshift(goal.pop)
+
+      new_solutions = []
+
+      solutions.each {
+        solution = _1 * 8
+
+        from = solution
+        to = solution + 8
+
+        (from..to).each { |input|
+          out = run(cmds, input)
+          new_solutions << input if out == target
+        }
+      }
+
+      solutions = new_solutions
+    end
+
+    puts solutions.min

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

@@ -0,0 +1,39 @@
+---
+- :name: day-18-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-18
+  :solution: |-
+    size = 71
+    grid = ("." * size * size).chars.each_slice(size).to_a
+    bytes = input.split.map { _1.split(?,).map(&:to_i) }
+
+    bytes[0..1023].each { |x, y|
+      grid[y][x] = ?#
+    }
+
+    start = [0, 0]
+
+    queue = []
+    queue << [start, 0]
+
+    visited = Set.new
+
+    while queue.any?
+      loc, steps = queue.pop
+      x, y = loc
+
+      candidates = [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+
+      candidates
+        .reject { _1 < 0 || _2 < 0 || _1 >= size || _2 >= size }
+        .reject { grid[_2][_1] == ?# }
+        .reject { visited.include?([_1, _2]) }
+        .each {
+          if _1 == size - 1 && _2 == size - 1
+            puts steps + 1
+            exit
+          end
+
+          visited.add([_1, _2])
+          queue.unshift [[_1, _2], steps + 1]
+        }
+    end

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

@@ -0,0 +1,92 @@
+---
+- :name: day-18-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-18
+  :solution: |-
+    $cache = {}
+
+    def path?(input, simulate, size)
+      return $cache[simulate] if $cache.has_key?(simulate)
+
+      grid = ("." * size * size).chars.each_slice(size).to_a
+
+      input.split
+        .map { _1.split(?,).map(&:to_i) }
+        .slice(0, simulate)
+        .each { |x, y| grid[y][x] = ?# }
+
+      start = [0, 0]
+
+      queue = []
+      queue << [start, 0]
+
+      visited = Set.new
+
+      while queue.any?
+        loc, steps = queue.pop
+        x, y = loc
+
+        candidates = [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+
+        candidates
+          .reject { _1 < 0 || _2 < 0 || _1 >= size || _2 >= size }
+          .reject { grid[_2][_1] == ?# }
+          .reject { visited.include?([_1, _2]) }
+          .each {
+            if _1 == size - 1 && _2 == size - 1
+              $cache[simulate] = true
+              return true
+            end
+
+            visited.add([_1, _2])
+            queue.unshift [[_1, _2], steps + 1]
+          }
+      end
+
+      $cache[simulate] = false
+      false
+    end
+
+    size = 71
+    simulate = 1024
+
+    bytes = input.split.map { _1.split(?,).map(&:to_i) }
+
+    byte = (simulate..bytes.size-1).bsearch {
+      left = path?(input, _1, size)
+      right = path?(input, _1 + 1, size)
+
+      if left && right
+        1
+      elsif left && !right
+        0
+      else # !left
+        -1
+      end
+    }
+
+    puts bytes[byte].join(?,)
+
+
+    ## Handrolled binary search
+
+    low = simulate
+    high = bytes.size - 1
+
+    while low <= high
+      mid = low + (high - low) / 2
+
+      # possible outcomes:
+      # [true, true], [true, false], [false, false]
+      left = path?(input, mid, size)
+      right = path?(input, mid + 1, size)
+
+      break if left && !right
+
+      if left
+        low = mid + 1
+      else
+        high = mid - 1
+      end
+    end
+
+    puts bytes[mid].join(?,)