advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,49 @@
+---
+- :name: day-18-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-18
+  :solution: |-
+    DIRS = {
+      U: [0, -1],
+      D: [0, 1],
+      L: [-1, 0],
+      R: [1, 0]
+    }
+
+    pos = [0, 0]
+    points = [pos]
+    boundary = 0
+
+    input.each_line {
+      _, _, hex = _1.split
+      hex = hex[2, 6]
+      dis = hex[0..4].to_i(16)
+      dir = [?R, ?D, ?L, ?U][hex[-1].to_i]
+
+      boundary += dis
+
+      pos = DIRS[dir.to_sym]
+        .map { |mod| mod * dis }
+        .zip(pos)
+        .map(&:sum)
+
+      points << pos
+    }
+
+    # Shoe-lace formula to caclulate an area of a polygon
+    # https://en.wikipedia.org/wiki/Shoelace_formula#Trapezoid_formula_2
+    #
+    # Then add the perimeter area which is number of points / 2 + 1
+    # The plus one is to account for the net extra four quarter of area
+    # from each corner. Some corners represent only a quarter of area,
+    # while others represent three quarters. But the net amount will
+    # be 4 quarters (imagine a basic square with 4 corners).
+    #
+    points.count.times
+      .map { |i|
+        ni = (i + 1) % points.size
+        (points[i][1] + points[ni][1]) * (points[i][0] - points[ni][0])
+      }
+      .sum.abs
+      .then { _1 / 2 }
+      .then { _1 + boundary / 2 + 1 }
+      .tap { puts _1 }

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

@@ -0,0 +1,39 @@
+---
+- :name: day-19-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-19
+  :solution: |-
+    fns, parts = input.split("\n\n")
+
+    parts = parts.each_line.map { eval _1.strip.gsub(?=, ?:) }
+    fns = fns.each_line.map { _1.strip }
+
+    # Define the Ruby methods :D
+    # See part 2 for a less meta solution
+    #
+    # Example fn
+    # hjp{a>2545:nb,a>2381:qx,m>2463:nn,bt}
+
+    fns.each {
+      r = _1
+        .gsub(/\A/, "def ")                 # start of method
+        .gsub(?:, ";")                      # end of if boolean exp
+        .gsub(?{, "(o); if o[:")            # end of method def and start of body
+        .gsub(?<, "]<")                     # close array accesor
+        .gsub(?>, "]>")                     # close array accessor
+        .gsub(?}, "(o); end; end")          # end of if brand and end of method
+        .gsub(?,, "(o); elsif o[:")         # next if branch (elsif)
+        .gsub(":pp", ":ppp")                # avoid redefining `pp` method
+        .gsub("def pp(", "def ppp(")        # avoid redefining `pp` method
+        .gsub("R(o)", "")                   # ignore calls to R
+        .gsub("A(o)", "o.values.sum")       # the answer :)
+
+      r[r.rindex("elsif"), 9] = "else "     # last branch should just be 'else'
+
+      eval r
+    }
+
+    parts
+      .map { send(:in, _1) }
+      .compact
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,121 @@
+---
+- :name: day-19-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-19
+  :solution: |-
+    fns, parts = input.split("\n\n")
+
+    parts = parts.each_line.map { eval _1.strip.gsub(?=, ?:) }
+    ins = fns.each_line.map { _1.strip }
+
+    fns = {}
+
+    ins.each {
+      fn, method = _1.split(?{)
+
+      # [[cond, method], ... [method]]
+      fns[fn] = method
+        .gsub(?}, '')
+        .split(?,)
+        .map { |exp| exp.split(?:).compact }
+    }
+
+    # Part 1
+    #
+    sum = 0
+
+    parts.each do |part|
+      f = "in"
+
+      while f
+        if f == "R"
+          break
+        end
+
+        if f == "A"
+          sum += part.values.sum
+          break
+        end
+
+        fn = fns[f]
+
+        fn.each do |exp|
+          if exp.count == 2
+            iff = exp[0]
+            nf = exp[1]
+
+            sym = iff[0].to_sym
+            op = iff[1]
+            val = iff[2..-1].to_i
+
+            if part[sym].send(op, val)
+              f = nf
+              break
+            end
+          else
+            f = exp.first
+          end
+        end
+      end
+    end
+
+    pp sum
+
+
+    # Part 2
+    #
+    queue = [
+      ["in", {x: 1..4000, m: 1..4000, a: 1..4000, s: 1..4000 }]
+    ]
+
+    sum = 0
+
+    while queue.any?
+      f, part = queue.pop
+
+      next if f == "R"
+
+      if f == "A"
+        sum += part.values.map(&:size).inject(&:*)
+        next
+      end
+
+      fns[f].each do |exp|
+        if exp.count == 1
+          queue << [exp.first, part]
+          next
+        end
+
+        iff = exp[0]
+        nf = exp[1]
+
+        sym = iff[0].to_sym
+        op = iff[1]
+        val = iff[2..-1].to_i
+
+        r = part[sym]
+
+        if op == ?>
+          if r.end > val
+            ro = part.clone
+            ro[sym] = (val+1)..r.end
+            queue << [nf, ro]
+          end
+
+          if r.begin <= val
+            part[sym] = r.begin..val
+          end
+        else # <
+          if r.begin < val
+            lo = part.clone
+            lo[sym] = r.begin..(val - 1)
+            queue << [nf, lo]
+          end
+
+          if val <= r.end
+            part[sym] = val..r.end
+          end
+        end
+      end
+    end
+
+    pp sum

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

@@ -0,0 +1,82 @@
+---
+- :name: day-20-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-20
+  :solution: |-
+    modules = {}
+
+    input.each_line.each do
+      name, output = _1.split("->").map(&:strip)
+      output = output.split(",").map(&:strip)
+
+      if name != "broadcaster"
+        type = name[0]
+        name = name[1..]
+      end
+
+      case type
+      when ?%
+        memory = false
+      when ?&
+        memory = {}
+      end
+
+      modules[name] = [type, memory, output]
+    end
+
+    modules.each do |n, (_type, _memory, out)|
+      out.each do |n1|
+        type1, memory1, _ = modules[n1]
+
+        memory1[n] = :l if type1 == ?&
+      end
+    end
+
+    hc = 0
+    lc = 0
+    queue = []
+
+    1000.times do |i|
+      lc += 1
+
+      modules["broadcaster"].last.each do |to|
+        queue << ["broadcaster", to, :l]
+        lc += 1
+      end
+
+      while queue.any?
+        from, to, sig = queue.shift
+
+        type, memory, out = modules[to]
+
+        next if type.nil?
+
+        case type
+        when ?%
+          next if sig == :h
+
+          out_sig = memory ? :l : :h
+
+          modules[to][1] = !memory
+        when ?&
+          memory[from] = sig
+
+          if memory.values.all? { _1 == :h }
+            out_sig = :l
+          else
+            out_sig = :h
+          end
+        end
+
+        if out_sig == :l
+          lc += out.count
+        else
+          hc += out.count
+        end
+
+        out.each do
+          queue << [to, _1, out_sig]
+        end
+      end
+    end
+
+    pp hc * lc

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

@@ -0,0 +1,86 @@
+---
+- :name: day-20-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-20
+  :solution: |-
+    modules = {}
+
+    input.each_line.each do
+      name, output = _1.split("->").map(&:strip)
+      output = output.split(",").map(&:strip)
+
+      if name != "broadcaster"
+        type = name[0]
+        name = name[1..]
+      end
+
+      case type
+      when ?%
+        memory = false
+      when ?&
+        memory = {}
+      end
+
+      modules[name] = [type, memory, output]
+    end
+
+    modules.each do |n, (_type, _memory, out)|
+      out.each do |n1|
+        type1, memory1, _ = modules[n1]
+
+        memory1[n] = :l if type1 == ?&
+      end
+    end
+
+    queue = []
+    cycles = {}
+
+    100_000.times do |i|
+      modules["broadcaster"].last.each do |to|
+        queue << ["broadcaster", to, :l]
+      end
+
+      while queue.any?
+        from, to, sig = queue.shift
+
+        type, memory, out = modules[to]
+
+        # My input had these four modules connected to lx which was the
+        # conjunction module for rx.
+        #
+        # For lx to fire to a low pulse to rx, all 4 modules must
+        # send a low pulse to lx. Identify the cycle when each module
+        # sends a low pulse and find the lcm of these 4 numbers.
+        #
+        if %w(cl rp lb nj).include?(to) && sig == :l
+          cycles[to] = i + 1
+
+          if cycles.size == 4
+            pp cycles.values.inject(:lcm)
+            exit
+          end
+        end
+
+        next if type.nil?
+
+        case type
+        when ?%
+          next if sig == :h
+
+          out_sig = memory ? :l : :h
+
+          modules[to][1] = !memory
+        when ?&
+          memory[from] = sig
+
+          if memory.values.all? { _1 == :h }
+            out_sig = :l
+          else
+            out_sig = :h
+          end
+        end
+
+        out.each do
+          queue << [to, _1, out_sig]
+        end
+      end
+    end

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

@@ -0,0 +1,40 @@
+---
+- :name: day-21-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-21
+  :solution: |-
+    grid = input.each_line.map { _1.strip.chars }
+
+    w = grid.first.count
+    h = grid.count
+
+    idx = grid.flatten.index(?S)
+
+    y = idx / h
+    x = idx % h
+
+    queue = [[x, y, 0]]
+
+    visited = {}
+    visited[[x,y]] = 0
+
+    while queue.any?
+      x, y, step = queue.shift
+
+      [[0, 1], [0, -1], [1, 0], [-1, 0]].each do |dir|
+        x1, y1 = dir.zip([x,y]).map(&:sum)
+
+        next if x1 < 0 || y1 < 0 || x1 >= w || y1 >= h
+
+        c = grid[y1][x1]
+
+        next if c == ?#
+        next if visited[[x1, y1]]
+
+        visited[[x1,y1]] = step + 1
+        queue << [x1, y1, step + 1]
+      end
+    end
+
+    visited.values
+      .count { _1 <= 64 && _1.even? }
+      .tap { pp _1 }

data/data/solutions/github/gchan/2023/21_2.yml

@@ -0,0 +1,115 @@
+---
+- :name: day-21-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-21
+  :solution: |-
+    grid = input.each_line.map { _1.strip.chars }
+
+    w = grid.first.count
+    h = grid.count
+
+    idx = grid.flatten.index(?S)
+
+    y = idx / h
+    x = idx % h
+
+    # Observations
+    #
+    # * We start at the centre of the grid
+    # * The grid is square and has an odd width and length
+    # * e.g. 131 x 131 and we start in the middle at index 65, 65
+    # * There is no rocks in the starting row and column therefore it is possible
+    # to reach any edge in 65 steps
+    # * From the centre point of any edge (middle row or column), we can
+    # walk to the opposite edge in 131 steps
+    # * The border of the grid has no rocks
+    # * From the centre, we can reach the corner of any grid in 65 + 65 steps
+    # * From corner of any grid, we can reach the centre of a connecting edge
+    # in 65 steps.
+    # * From the centre, we can reach the furtherest edges of the four adjacent
+    # grids in 65 + 131 steps (by walking up, down, right, left to the edge in
+    # 65 steps, then walk from one edge to the opposite edge in 131 steps)
+    # * From the centre, we can reach furtherest edges of grids (2 grids away) in
+    # 65 + 131 * 2 steps. For the third furtherest grids, it is 65 + 131 * 3
+    # * We can draw a diamond in a universe where the grid is duplicated 3 times
+    # wide and high (3 x 3). From the centre, it takes 65 + 131 steps to reach
+    # the corner of the diamond, and the furtherest edge of a 3 x 3 universe
+    # * We can extend the universe by 131 * 2 and grow it into a 5 x 5 grid
+    # of grids. You can reap the process again and again for a 7x7, 9x9 and so
+    # on.
+    # * Observe the growth of our universe is quadratic!
+    # * The diamond (representing the reachable area) is also quadratic.
+    #
+    #        ------
+    #        | /\ |
+    #        |/  \|
+    #       /|    |\
+    #   ___/_|____|_\___
+    #   | /  |    |  \ |
+    #   |/   |    |   \|
+    #   |\   |    |   /|
+    #   |_\ _|____|_ /_|
+    #      \ |    | /
+    #       \|    |/
+    #        |\  /|
+    #        |_\/_|
+    #
+    # * The number of steps in our problem is 65 + 131 * 202300 = 26_501_365
+    # * We can solve the reachable area for the following:
+    #   - (65 + 131) + 131 * 0 = y0
+    #   - (65 + 131) + 131 * 1 = y1
+    #   - (65 + 131) + 131 * 2 = y2
+    # * And use these points to solve for a, b and c of the quadratic formula:
+    # y = ax^2 + bx + c where y is the number of reachable points and x is the
+    # size (as a multiple of 131 + (65 + 131)) of our universe
+    #
+    # * Apply a bit of algebra to solve a, b and c
+    # * y0 = c = a0^2 + b0 + c
+    # * y1 = a + b + c = a1^2 + 1b + c
+    # * y2 = a2^2 + 2b + c = 4a + 2b + c
+    # * a = (y2 + c - 2y1) / 2
+    # * b = y1 - a - c
+    #
+    # * Plug in 26_501_365 / 131 in the forumla to get the answer!
+
+    queue = [[x, y, 0]]
+
+    visited = {}
+    visited[[x,y]] = 0
+
+    while queue.any?
+      x, y, step = queue.shift
+
+      [[0, 1], [0, -1], [1, 0], [-1, 0]].each do |dir|
+        x1, y1 = dir.zip([x,y]).map(&:sum)
+
+        y2 = y1 % h
+        x2 = x1 % w
+        c = grid[y2][x2]
+
+        next if c == ?#
+        next if visited[[x1, y1]]
+        next if step > w * 3
+
+        visited[[x1,y1]] = step + 1
+        queue << [x1, y1, step + 1]
+      end
+    end
+
+    y0, y1, y2 = 3.times.map { |i|
+      # 65 + 131 * i
+      step = w / 2 + w * i
+
+      visited.values
+        .count { _1 <= step && _1 % 2 == step % 2 }
+    }
+
+    c = y0
+    a = (y2 + c - 2 * y1) / 2
+    b = y1 - a - c
+
+    steps = 26_501_365
+
+    x = steps / w
+    y = a * x**2 + b * x + c
+
+    pp y

data/data/solutions/github/gchan/2023/22_1.yml

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

data/data/solutions/github/gchan/2023/22_2.yml

@@ -0,0 +1,123 @@
+---
+- :name: day-22-part-1-and-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-22
+  :solution: |-
+    def overlap?(range1, range2)
+      range1.cover?(range2.begin) || range2.cover?(range1.begin)
+    end
+
+    def intersect?(brick, other)
+      bf = brick[0]
+      bt = brick[1]
+      of = other[0]
+      ot = other[1]
+
+      bx = bf[0]..bt[0]
+      by = bf[1]..bt[1]
+      bz = bf[2]..bt[2]
+
+      ox = of[0]..ot[0]
+      oy = of[1]..ot[1]
+      oz = of[2]..ot[2]
+
+      overlap?(bx, ox) && overlap?(by, oy) && overlap?(bz, oz)
+    end
+
+    bricks = input.each_line.map do
+      _1.strip.split(?~).map { |pos| pos.split(?,).map(&:to_i) }
+    end
+
+    bricks.sort_by! { |from, _| from.last }
+
+    # A poor (but adequate) look up Hash based on Z position
+    map = Hash.new { |h, k| h[k] = [] }
+    bricks.each do |brick|
+      (brick.first.last..brick.last.last).each do |z|
+        map[z] << brick
+      end
+    end
+
+    bricks.each do |from, to|
+      while from[2] != 1
+        spec_brick = [from.clone, to.clone]
+        spec_brick[0][2] -= 1
+        spec_brick[1][2] -= 1
+
+        z1 = from[2]
+        z2 = to[2]
+
+        # Detect for any blocking brick at z - 1
+        break if map[z1 - 1].any? { |other| intersect?(spec_brick, other) }
+
+        # Move it down
+        from[2] -= 1
+        to[2]   -= 1
+
+        # Update the Z position Hash
+        (z1..z2).each {
+          map[_1].delete([from, to])
+          map[_1 - 1] << [from, to]
+        }
+      end
+    end
+
+    bricks.sort_by! { |from, to| [from.last, to.last].min }
+
+    require 'set'
+    sole_supports = Set.new
+
+    above = Hash.new { |h, k| h[k] = [] }
+    below = {}
+
+    bricks.each.with_index { |(from, to), bidx|
+      spec_brick = [from.clone, to.clone]
+      spec_brick[0][2] -= 1
+      spec_brick[1][2] -= 1
+
+      # List of bricks supporting the current brick
+      supports = bricks.map.with_index
+        .select { |other, _| intersect?(spec_brick, other) }
+        .reject { |other, _| [from, to] == other }
+
+      supports.map(&:last).each {
+        above[_1] << bidx
+      }
+      below[bidx] = supports.map(&:last)
+
+      if supports.count == 1
+        sole_supports << supports.first.last
+      end
+    }
+
+    # Part 1
+    pp bricks.count - sole_supports.count
+
+    # Part 2
+    sole_supports.sum { |idx|
+      fell = Set.new
+      fell << idx
+
+      candidates = Set.new
+
+      above[idx].each { candidates << _1 }
+
+      falling = true
+      while falling
+        falling = false
+
+        # to_a to allow modification of candidates while iterating through it
+        candidates.to_a.each { |candidate|
+          # Check if this candidate has all their supports removed
+          if below[candidate].all? { fell.include?(_1) }
+            candidates.delete(candidate)
+            fell << candidate
+            above[candidate].each { candidates << _1 }
+            falling = true
+            break
+          end
+        }
+      end
+
+      # Less the brick that was removed
+      fell.count - 1
+    }.tap { puts _1 }

data/data/solutions/github/gchan/2023/23_1.yml

@@ -0,0 +1,54 @@
+---
+- :name: day-23-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-23
+  :solution: |-
+    require 'set'
+
+    $cache = {}
+
+    def distance(start, grid)
+      return $cache[start] if $cache[start]
+
+      curr = start
+
+      w = grid.first.size
+      h = grid.size
+
+      goal = [grid.last.index(?.), h - 1]
+
+      visited = [curr].to_set
+
+      while curr != goal
+        opts = [[0, 1], [1, 0], [-1, 0], [0, -1]]
+          .map { |mod| mod.zip(curr).map(&:sum) }
+          .reject { |x, y| x < 0 || y < 0 || x >= w || y >= h }
+          .reject { visited.include?(_1) }
+          .select { |x, y| grid[y][x] != ?# }
+          .reject { |x, y| grid[y][x] == ?> && x < curr[0] }
+          .reject { |x, y| grid[y][x] == ?v && y < curr[1] }
+          .reject { |x, y| grid[curr[1]][curr[0]] == ?v && y < curr[1] }
+          .reject { |x, y| grid[curr[1]][curr[0]] == ?> && x < curr[0] }
+
+        if opts.count == 1
+          curr = opts.first.clone
+          visited << curr
+        elsif opts.count > 1
+          count = visited.count + opts.map { distance(_1.clone, grid) }.max
+          $cache[start] = count
+
+          return count
+        end
+      end
+
+      $cache[start] = visited.count
+
+      visited.count
+    end
+
+    grid = input.each_line.map { _1.strip.chars }
+
+    x = grid.first.index(?.)
+    y = 0
+
+    # Exclude starting position
+    pp distance([x, y], grid) - 1