advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,92 @@
+---
+- :name: day-21-part-2.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)
+
+    human_str = "humn"
+
+    ancestry = []
+
+    search = human_str
+    target_str = nil
+
+    while search
+      key, expression = unsolved.find { _2.include?(search) }
+
+      if key == "root"
+        target_str = expression.split
+          .select { _1.match?(/\w/) }
+          .find { _1 != ancestry.last[0] }
+
+        search = nil
+      else
+        ancestry << [key, expression]
+        search = key
+      end
+    end
+
+    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
+
+    target = solved[target_str]
+
+    ancestry.reverse!.each.with_index do |(key, expression), idx|
+      a, op, b = expression.split
+
+      next_str = ancestry[idx + 1]&.first || human_str
+
+      # Debugging
+      #if b == next_str
+      #  expression.sub!(a, solved[a].to_s)
+      #else
+      #  expression.sub!(b, solved[b].to_s)
+      #end
+
+      #puts "#{target} = #{expression}"
+
+      case op
+      when ?-
+        if b == next_str
+          target = -target + solved[a]
+        else
+          target = target + solved[b]
+        end
+      when ?+
+        if b == next_str
+          target = target - solved[a]
+        else
+          target = target - solved[b]
+        end
+      when ?/
+        if b == next_str
+          target = 1/target * solved[a]
+        else
+          target = target * solved[b]
+        end
+      when ?*
+        if b == next_str
+          target = target / solved[a]
+        else
+          target = target / solved[b]
+        end
+      end
+    end
+
+    puts target

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

@@ -0,0 +1,50 @@
+---
+- :name: day-22-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-22
+  :solution: |-
+    map, instructions = input.split("\n\n")
+
+    instructions = instructions.scan(/\d+|[A-z]+/)
+
+    rows = map.split("\n")
+    width = rows.map(&:size).max
+    height = rows.size
+
+    grid = rows
+      .map { _1.ljust(width, " ") }
+      .map(&:chars)
+
+    y = 0
+    x = grid.first.index(".")
+    dir = [1, 0]
+
+    instructions.each do
+      case _1
+      when "L"
+        dir = [dir[1], -dir[0]]
+      when "R"
+        dir = [-dir[1], dir[0]]
+      else # number
+        _1.to_i.times {
+          x1, y1 = [x, y].zip(dir).map(&:sum)
+
+          x1 %= width
+          y1 %= height
+
+          while grid[y1][x1] == " "
+            x1, y1 = [x1, y1].zip(dir).map(&:sum)
+
+            x1 %= width
+            y1 %= height
+          end
+
+          break if grid[y1][x1] == "#"
+
+          x, y = x1, y1
+        }
+      end
+    end
+
+    puts (y + 1) * 1000 +
+      (x + 1) * 4 +
+      [[1, 0], [0, 1], [-1, 0], [0, -1]].index(dir)

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

@@ -0,0 +1,260 @@
+---
+- :name: day-22-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2022/day-22
+  :solution: |-
+    map, instructions = input.split("\n\n")
+
+    instructions = instructions.scan(/\d+|[A-z]+/)
+
+    rows = map.split("\n")
+    width = rows.map(&:size).max
+    height = rows.size
+
+    grid = rows
+      .map { _1.ljust(width, " ") }
+      .map(&:chars)
+
+    # Dice map with relative rotations
+    #
+    # Face 1 has the same orientation as its neighbours, no rotation required
+    # Face 5 relative to face 4 requires a quarter anti-clockwise turn rotation
+    # Face 4 relative to face 5 requires a quarter clockwise turn
+    #
+    # So when heading north of face 5, it 'portals' to the right edge of face 4
+    # and is facing west (turn left)
+    #
+    #    4^         4>         4<
+    # 2^ 1^ 5^   1^ 5^ 6v   6v 2^ 1^
+    #    3^         3<         3>
+    #
+    #    6^         1^         3^
+    # 2> 4^ 5<   2< 3^ 5>   2v 6^ 5v
+    #    1^         6^         4^
+
+    FACE_MAP = {
+      [1, ?N] => [4, ?N], [5, ?N] => [4, ?E], [2, ?N] => [4, ?W],
+      [1, ?E] => [5, ?N], [5, ?E] => [6, ?S], [2, ?E] => [1, ?N],
+      [1, ?W] => [2, ?N], [5, ?W] => [1, ?N], [2, ?W] => [6, ?S],
+      [1, ?S] => [3, ?N], [5, ?S] => [3, ?W], [2, ?S] => [3, ?E],
+
+      [4, ?N] => [6, ?N], [3, ?N] => [1, ?N], [6, ?N] => [3, ?N],
+      [4, ?E] => [5, ?W], [3, ?E] => [5, ?E], [6, ?E] => [5, ?S],
+      [4, ?W] => [2, ?E], [3, ?W] => [2, ?W], [6, ?W] => [2, ?S],
+      [4, ?S] => [1, ?N], [3, ?S] => [6, ?N], [6, ?S] => [4, ?N],
+    }
+
+    DIRS = [?N, ?E, ?S, ?W]
+
+    # Assign face numbers to the input and orient them so they are 'facing upwards'
+    # with a BFS starting with the top left-most face as number 1
+
+    face_size = Math.sqrt(grid.flatten.join.gsub(" ", "").size / 6).to_i
+
+    fw = width / face_size
+    fh = height / face_size
+
+    y = 0
+    x = grid.first.index(".")
+
+    faces = {}
+    face_locs = {}
+
+    faces[1] = face_size.times.map { |yd| grid[y + yd][x, face_size] }
+    face_locs[1] = [x, y, ?N]
+
+    queue = [[x, y, 1, ?N]]
+    visited = Set.new([[x, y]])
+
+    while queue.any?
+      x, y, face, f_dir = queue.shift
+
+      [
+        [x + face_size, y, ?E],
+        [x - face_size, y, ?W],
+        [x, y + face_size, ?S],
+        [x, y - face_size, ?N]
+      ]
+        .select { _1 >= 0 && _2 >= 0 && _1 < width && _2 < height }
+        .reject { grid[_2][_1] == " " }
+        .reject { visited.include?([_1, _2])}
+        .each { |x1, y1, move_dir|
+          adj_dir =
+            case f_dir
+            when ?N
+              move_dir
+            when ?S
+              # U-Turn
+              DIRS[(DIRS.index(move_dir) + 2) % 4]
+            when ?E
+              # Left
+              DIRS[(DIRS.index(move_dir) - 1) % 4]
+            when ?W
+              # Right
+              DIRS[(DIRS.index(move_dir) + 1) % 4]
+            end
+
+          next_face, next_f_dir = FACE_MAP[[face, adj_dir]]
+
+          face_grid = face_size.times.map { |yd| grid[y1 + yd][x1, face_size] }
+
+          # Rotate the face so it's 'facing up'
+          # Rotation respects current f_dir
+          rotation =
+            case f_dir
+            when ?N
+              next_f_dir
+            when ?S
+              # U-Turn
+              DIRS[(DIRS.index(next_f_dir) + 2) % 4]
+            when ?E
+              # Right
+              DIRS[(DIRS.index(next_f_dir) + 1) % 4]
+            when ?W
+              # Left
+              DIRS[(DIRS.index(next_f_dir) - 1) % 4]
+            end
+
+          case rotation
+          when ?N
+          when ?E
+            face_grid = face_grid.transpose.reverse
+          when ?W
+            face_grid = face_grid.transpose.map(&:reverse)
+          when ?S
+            2.times {
+              face_grid = face_grid.transpose.map(&:reverse)
+            }
+          end
+
+          faces[next_face] = face_grid
+          face_locs[next_face] = [x1, y1, rotation]
+
+          visited.add([x1, y1])
+          queue << [x1, y1, next_face, next_f_dir]
+        }
+    end
+
+    face = 1
+    x, y = [0, 0]
+    dir = [1, 0]
+
+    instructions.each do
+      case _1
+      when "L"
+        dir = [dir[1], -dir[0]]
+      when "R"
+        dir = [-dir[1], dir[0]]
+      else # number
+        _1.to_i.times {
+          x1, y1 = [x, y].zip(dir).map(&:sum)
+
+          next_face, next_rotation = if x1 < 0
+            FACE_MAP[[face, ?W]]
+          elsif y1 < 0
+            FACE_MAP[[face, ?N]]
+          elsif x1 >= face_size
+            FACE_MAP[[face, ?E]]
+          elsif y1 >= face_size
+            FACE_MAP[[face, ?S]]
+          else
+            face
+          end
+
+          # Teleport
+          if face != next_face
+            # N - no change
+            # S - 180 (mirror both)
+            # E - right  (swap and mirror y)
+            # W - left (swap and mirror x)
+            case next_rotation
+            when ?N
+            when ?S
+              x1 = (face_size - 1) - x1
+              y1 = (face_size - 1) - y1
+            when ?E
+              x1, y1 = y1, (face_size - 1) - x1
+            when ?W
+              x1, y1 = (face_size - 1) - y1, x1
+            end
+          end
+
+          x1 = x1 % face_size
+          y1 = y1 % face_size
+
+          break if faces[next_face][y1][x1] == "#"
+          #p [x1, y1, next_face]
+
+          # Rotate Direction
+          if face != next_face
+            # E - Left
+            # W - Right
+            # S - 180
+            # N - no change
+            dir = case next_rotation
+            when ?N
+              dir
+            when ?E
+              dir = [dir[1], -dir[0]]
+            when ?W
+              dir = [-dir[1], dir[0]]
+            when ?S
+              dir = [-dir[0], -dir[1]]
+            end
+
+            #p dir
+          end
+
+
+          x, y = x1, y1
+          face = next_face
+        }
+      end
+    end
+
+
+    # Calculate the cube net's X and Y
+    # A rotation may be required
+
+    x1, y1, rotation = face_locs[face]
+
+    # Similar code as the 'teleport' code above
+    # Except in reverse (E and W are reversed)
+    # N - no change
+    # S - 180 (mirror both)
+    # E - left (swap and mirror x)
+    # W - right  (swap and mirror y)
+    case rotation
+    when ?N
+    when ?S
+      x = (face_size - 1) - x
+      y = (face_size - 1) - y
+    when ?E
+      x, y = (face_size - 1) - y, x
+    when ?W
+      x, y = y, (face_size - 1) - x
+    end
+
+    x = x % face_size
+    y = y % face_size
+
+    # Adjust for the face's position on the cube net
+    x += x1
+    y += y1
+
+    dir = case rotation
+      when ?N
+        dir
+      when ?E
+        # Right
+        dir = [-dir[1], dir[0]]
+      when ?W
+        # Left
+        dir = [dir[1], -dir[0]]
+      when ?S
+        # U-Turn
+        dir = [-dir[0], -dir[1]]
+      end
+
+    puts (y + 1) * 1000 +
+      (x + 1) * 4 +
+      [[1, 0], [0, 1], [-1, 0], [0, -1]].index(dir)

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+---
+- :name: day-01-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-01
+  :solution: |-
+    input
+      .split("\n")
+      .sum { _1.scan(/\d/).values_at(0, -1).join.to_i }
+      .tap { puts _1 }

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

@@ -0,0 +1,24 @@
+---
+- :name: day-01-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-01
+  :solution: |-
+    # We don't need a fany Hash here for the given input. We could
+    # make do with an Array and call `DIGITS.index(match)&.+(1)`
+    # instead of `DIGITS[match]`
+    DIGITS = %w(one two three four five six seven eight nine)
+      .map.with_index
+      .to_a.to_h
+      .transform_values { _1 + 1 }
+
+    # Postive lookahead assertion regex
+    input
+      .split("\n")
+      .sum {
+        _1.scan(/(?=(#{DIGITS.keys.join("|")}|\d))/)
+          .flatten
+          .values_at(0, -1)
+          .map { |match| DIGITS[match] || match }
+          .join
+          .to_i
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,22 @@
+---
+- :name: day-02-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-02
+  :solution: |-
+    RED = 12
+    GREEN = 13
+    BLUE = 14
+
+    input
+      .each_line
+      .sum {
+        blue  = _1.scan(/(\d+) b/).flatten.map(&:to_i).max
+        red   = _1.scan(/(\d+) r/).flatten.map(&:to_i).max
+        green = _1.scan(/(\d+) g/).flatten.map(&:to_i).max
+
+        if blue > BLUE || red > RED || green > GREEN
+          0
+        else
+          _1.scan(/Game (\d*)/).flatten.first.to_i
+        end
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,14 @@
+---
+- :name: day-02-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-02
+  :solution: |-
+    input
+      .each_line
+      .sum {
+        blue  = _1.scan(/(\d+) b/).flatten.map(&:to_i).max
+        red   = _1.scan(/(\d+) r/).flatten.map(&:to_i).max
+        green = _1.scan(/(\d+) g/).flatten.map(&:to_i).max
+
+        blue * red * green
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,28 @@
+---
+- :name: day-03-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-03
+  :solution: |-
+    numbers = {}
+
+    lines = input.each_line.to_a.map(&:strip)
+
+    lines.each_with_index do |line, y|
+      line.scan(/\d+/) do
+        numbers[[Regexp.last_match.begin(0), y]] = _1
+      end
+    end
+
+    numbers.sum { |(x, y), num|
+      min_x = [x - 1, 0].max
+      min_y = [y - 1, 0].max
+
+      max_x = x + num.length
+      max_y = y + 1
+
+      lines[min_y..max_y]
+        .map { _1[min_x..max_x] }
+        .join
+        .match?(/[^\d\.]/)
+        .then { _1 ? num.to_i : 0 }
+    }
+    .tap { puts _1 }

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

@@ -0,0 +1,34 @@
+---
+- :name: day-03-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-03
+  :solution: |-
+    gears = {}
+    numbers = {}
+
+    input.each_line.with_index do |line, y|
+      line.scan(/\*/) do
+        gears[[Regexp.last_match.begin(0), y]] = []
+      end
+
+      line.scan(/\d+/) do
+        numbers[[Regexp.last_match.begin(0), y]] = _1
+      end
+    end
+
+    numbers.each { |(x, y), num|
+      min_x = x - 1
+      min_y = y - 1
+
+      max_x = x + num.length
+      max_y = y + 1
+
+      (min_x..max_x).to_a.product((min_y..max_y).to_a)
+        .select { gears[_1] }
+        .each { gears[_1] << num.to_i }
+    }
+
+    gears
+      .values
+      .select { _1.count == 2 }
+      .sum { _1.reduce(:*) }
+      .tap { puts _1 }

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

@@ -0,0 +1,19 @@
+---
+- :name: day-04-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-04
+  :solution: |-
+    input.each_line.sum {
+      _, winners, numbers = _1.split(/[:|]/)
+
+      winners = winners.scan(/\d+/)
+      numbers = numbers.scan(/\d+/)
+
+      matches = (winners & numbers).count
+
+      if matches > 0
+        2**(matches - 1)
+      else
+        0
+      end
+    }
+    .tap { puts _1 }

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

@@ -0,0 +1,25 @@
+---
+- :name: day-04-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-04
+  :solution: |-
+    input
+      .each_line
+      .with_object(Hash.new(0)) { |line, counts|
+        id, winners, numbers = line.split(/[:|]/)
+
+        id = id.scan(/\d+/).first.to_i
+        winners = winners.scan(/\d+/)
+        numbers = numbers.scan(/\d+/)
+
+        matches = (winners & numbers).count
+
+        counts[id] += 1
+
+        matches.times do |i|
+          card_id = id + i + 1
+          counts[card_id] += counts[id]
+        end
+      }
+      .values
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,36 @@
+---
+- :name: day-05-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-05
+  :solution: |-
+    seeds, *maps = input.split("\n\n")
+
+    seeds = seeds.scan(/\d+/).map(&:to_i)
+
+    maps.map! {
+      map = {}
+
+      _1.split("\n")[1..-1].each do |line|
+        dest, source, length = line.split.map(&:to_i)
+
+        range = source..(source + length)
+        offset = dest - source
+
+        map[range] = offset
+      end
+
+      map
+    }
+
+    seeds
+      .map { |source|
+        maps.reduce(source) do |source, map|
+          range, offset = map.find do |range, offset|
+            range.include?(source)
+          end
+
+          source += offset if range
+          source
+        end
+      }
+      .min
+      .tap { puts _1 }