advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,84 @@
+---
+- :name: day-23-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-23
+  :solution: |-
+    require 'set'
+
+    grid = input.each_line.map { _1.strip.chars }
+
+    x = grid.first.index(?.)
+    y = 0
+
+    w = grid.first.size
+    h = grid.size
+
+    goal = [grid.last.index(?.), h - 1]
+
+    graph = Hash.new { |h, k| h[k] = {} }
+
+    queue = [[[x,y], [x,y]]]
+
+    while queue.any?
+      pos, origin = queue.shift
+
+      visited = [pos].to_set
+
+      until graph[origin][pos]
+        opts = [[0, 1], [1, 0], [-1, 0], [0, -1]]
+          .map { |mod| mod.zip(pos).map(&:sum) }
+          .reject { |x, y| x < 0 || y < 0 || x >= w || y >= h }
+          .select { |x, y| grid[y][x] != ?# }
+          .reject { visited.include?(_1) }
+          .reject { _1 == origin }
+
+        # Only one direction - keep moving
+        if opts.count == 1
+          pos = opts.first.clone
+
+          visited << pos
+        # Found an intersection or reached the goal (no where left to go)
+        elsif opts.count > 1 || opts.empty?
+          opts.each { |opt| queue << [opt, pos] }
+
+          graph[origin][pos] = visited.count
+          graph[pos][origin] = visited.count
+        end
+      end
+    end
+
+
+    $max = 0
+
+    def dfs(pos, graph, goal, seen = Set.new)
+      return 0 if pos == goal
+
+      # Return a negative number if we can't find a solution where
+      # we end on the goal square
+      max = -100_000
+
+      # Prevent revisiting existing nodes
+      seen << pos
+
+      graph[pos].each do |node, dist|
+        next if seen.include?(node)
+
+        max = [
+          max,
+          dfs(node, graph, goal, seen) + dist
+        ].max
+
+        if max > $max
+          puts max
+          $max = max
+        end
+      end
+
+      # So other DFS calls can visit this node
+      seen.delete(pos)
+
+      max
+    end
+
+    # This takes ~ 1 min to run
+    # We subtract one to remove the starting square
+    pp dfs([x,y], graph, goal) - 1

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

@@ -0,0 +1,36 @@
+---
+- :name: day-24-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-24
+  :solution: |-
+    stones = input.each_line.map {
+      pos, vel = _1.split(?@)
+
+      pos = pos.strip.split(?,).map(&:to_i)
+      vel = vel.strip.split(?,).map(&:to_i)
+
+      # Solve for a and b in y = ax + b
+      a = vel[1] / vel[0].to_f
+      b = pos[1] - (a * pos[0])
+      [pos, vel, a, b]
+    }
+
+    from = 200000000000000
+    to = 400000000000000
+
+    stones.combination(2).count { |s1, s2|
+      p1, v1, a1, b1 = s1
+      p2, v2, a2, b2 = s2
+
+      next if (a1 - a2) == 0
+
+      # Use y = ax + b and a bit of algebra to solve for x and y
+      x = (b2 - b1).to_f / (a1 - a2)
+      y = a1 * x + b1
+
+      next if x > p1[0] && v1[0] < 0
+      next if x < p1[0] && v1[0] > 0
+      next if x > p2[0] && v2[0] < 0
+      next if x < p2[0] && v2[0] > 0
+
+      x >= from && x <= to && y >= from && y <= to
+    }.tap { puts _1 }

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

@@ -0,0 +1,110 @@
+---
+- :name: day-24-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-24
+  :solution: |-
+    stones = input.each_line.map {
+      pos, vel = _1.split(?@)
+
+      pos = pos.strip.split(?,).map(&:to_i)
+      vel = vel.strip.split(?,).map(&:to_i)
+
+      [pos, vel]
+    }
+
+    # gem install 'prime'
+    require 'prime'
+
+    def factors_of(number)
+      primes, powers = number.prime_division.transpose
+      exponents = powers.map { (0.._1).to_a }
+
+      exponents.shift.product(*exponents).map do |powers|
+        primes
+          .zip(powers)
+          .map { |prime, power| prime ** power }
+          .inject(:*)
+      end
+    end
+
+    # Infer rock velocities by identifying hailstones with the same velocities
+    # across one dimension, and identifying the factors in the difference in
+    # that dimension.
+    #
+    # The rock's velocity, vx, must move as factor of the difference of two
+    # hailstones (with respect to relative velocities of the hailstones):
+    #
+    # vx = hailstone velocity +/- factor of the difference between two hailstones
+    #
+    # https://www.reddit.com/r/adventofcode/comments/18qcfsp
+    #
+    # idx - x, y, z
+    #
+    # 0 - x
+    # 1 - y
+    # 2 - z
+    #
+    def rock_v(idx, stones)
+      stones
+        .group_by { |pos, vel| vel[idx] }
+        .select { |vel, stones| stones.size == 2 }
+        .transform_values { _1.map { |pos, _vel| pos[idx] } }
+        .map { |v, p|
+          [
+            v,
+            p.inject(&:-).abs
+          ]
+        }
+        .select { |_v, d| d != 0 }
+        .map { |v, d|
+          factors_of(d).flat_map { |f| [v - f, v + f] }
+        }
+        .inject(&:&)
+        .first
+    end
+
+    # Find the common intersection point for a series of hail stones.
+    #
+    # A moving rock is the same as the keeping the rock stationary and
+    # adjusting the hailstone velocities relative to the rock's velocity
+    #
+    # Components (comp) is an array composed of two dimensions:
+    #
+    # 0 - x
+    # 1 - y
+    # 2 - z
+    #
+    def intersection(stones, comp, rock_v0, rock_v1)
+      stones.combination(2).map { |s1, s2|
+        p1, v1 = s1
+        p2, v2 = s2
+
+        a1 = (v1[comp[1]] - rock_v1) / (v1[comp[0]] - rock_v0).to_f
+        b1 = p1[comp[1]] - (a1 * p1[comp[0]])
+
+        a2 = (v2[comp[1]] - rock_v1) / (v2[comp[0]] - rock_v0).to_f
+        b2 = p2[comp[1]] - (a2 * p2[comp[0]])
+
+        # Use y = ax + b and a bit of algebra to solve for x and y
+        #
+        # x - component 1
+        # y - component 2
+        x = (b2 - b1).to_f / (a1 - a2)
+        y = a1 * x + b1
+
+        [x, y].map(&:round).map(&:to_i)
+      }
+        .tally.sort_by(&:last).last.first
+    end
+
+    rvx = rock_v(0, stones)
+    rvy = rock_v(1, stones)
+    rvz = rock_v(2, stones)
+
+    pp rvx
+    pp rvy
+    pp rvz
+
+    x, y = intersection(stones.sample(3), [0, 1], rvx, rvy)
+    _, z = intersection(stones.sample(3), [0, 2], rvx, rvz)
+
+    pp x + y + z

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

@@ -0,0 +1,83 @@
+---
+- :name: day-25-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-25
+  :solution: |-
+    require 'set'
+
+    graph = Hash.new { |h, k| h[k] = [] }
+
+    input.each_line.each {
+      from, to = _1.strip.split(?:)
+
+      to.split.each { |other|
+        graph[from] << other
+        graph[other] << from
+      }
+    }
+
+    def dfs(from, goal, graph)
+      queue = graph[from].map { |to| [from, to] }
+
+      while queue.any?
+        path = queue.shift
+        curr = path.last
+
+        return path if curr == goal
+
+        graph[curr].each do |to|
+          next if path.include?(to)
+
+          queue << (path.clone << to)
+        end
+      end
+
+      raise
+    end
+
+    nodes = graph.keys
+
+    edge_counts = Hash.new(0)
+
+    # Sample 150 node pairs and tally the edges (node pairs) in the path
+    # It is possible to sample less than 150
+    #
+    # Note this doesn't work on the sample input, replace with
+    # nodes.combination(2).each ...
+    nodes.shuffle.first(150).zip(nodes.shuffle.first(150)).each do |from, to|
+      next if from == to
+
+      dfs(from, to, graph).each_cons(2).to_a.each do |pair|
+        edge_counts[pair.sort] += 1
+      end
+
+      print ?.
+      #pp edge_counts.sort_by(&:last).reverse.first(5)
+    end
+    puts
+
+    # Remove 3 most used edges from the graph
+    edge_counts.sort_by(&:last).last(3).each do |(from, to), _|
+      graph[from].delete(to)
+      graph[to].delete(from)
+    end
+
+    def flood(node, graph)
+      visited = [node].to_set
+      queue = [node]
+
+      while queue.any?
+        node = queue.shift
+
+        graph[node].each { |to|
+          next if visited.include?(to)
+          visited << to
+          queue << to
+        }
+      end
+
+      visited
+    end
+
+    # Count the number of nodes in one group
+    seen = flood(nodes.first, graph).count
+    pp (graph.keys.count - seen) * seen

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

@@ -0,0 +1,14 @@
+---
+- :name: day-01-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-01
+  :solution: |-
+    puts input.split(/\s+/)
+      .map(&:to_i)
+      .each_slice(2)
+      .to_a
+      .transpose
+      .map(&:sort)
+      .transpose
+      .map { _1.inject(&:-) }
+      .map(&:abs)
+      .sum

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

@@ -0,0 +1,17 @@
+---
+- :name: day-01-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-01
+  :solution: |-
+    left, right = input.split(/\s+/)
+      .map(&:to_i)
+      .each_slice(2)
+      .to_a
+      .transpose
+      .map(&:sort)
+      .map(&:tally)
+
+    right.default = 0
+
+    puts left
+      .map { |num, freq| num * freq * right[num] }
+      .sum

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

@@ -0,0 +1,15 @@
+---
+- :name: day-02-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-02
+  :solution: |-
+    puts input.split("\n")
+      .map(&:split)
+      .map { _1.map(&:to_i) }
+      .map {
+        _1
+          .each_cons(2).to_a
+          .map { |pair| pair.inject(:-) }
+      }
+      .select { _1.all?(&:positive?) || _1.all?(&:negative?) }
+      .select { _1.map(&:abs).all? { |diff| diff <= 3 } }
+      .count

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

@@ -0,0 +1,25 @@
+---
+- :name: day-02-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-02
+  :solution: |-
+    reports = input.split("\n")
+      .map(&:split)
+      .map { _1.map(&:to_i) }
+
+    def safe?(report, can_remove = false)
+      increasing = report[0] < report[1]
+
+      report.each_cons(2).with_index do |(a, b), idx|
+        if increasing != a < b || a == b || (a - b).abs > 3
+          return false if !can_remove
+
+          return safe?(report.dup.tap { _1.delete_at(idx) }) ||
+            safe?(report.dup.tap { _1.delete_at(idx + 1) }) ||
+            safe?(report.dup.tap { _1.delete_at(idx - 1) })
+        end
+      end
+
+      true # for clarity
+    end
+
+    puts reports.count { safe?(_1, true) }

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

@@ -0,0 +1,17 @@
+---
+- :name: day-03-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-03
+  :solution: |-
+    regex = /
+      mul\(
+        (\d+),
+        (\d+)
+      \)
+    /x
+
+    puts input.scan(regex)
+      .flatten
+      .map(&:to_i)
+      .each_slice(2)
+      .map { _1.inject(:*) }
+      .sum

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

@@ -0,0 +1,29 @@
+---
+- :name: day-03-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-03
+  :solution: |-
+    regex = /
+      (
+        mul\(
+          (\d+),
+          (\d+)
+        \)
+      |
+        do[n't]*\(\)
+      )
+    /x
+
+    sum = 0
+    enabled = true
+
+    input.scan(regex).each do |instruction, a, b|
+      if instruction == "do()"
+        enabled = true
+      elsif instruction == "don't()"
+        enabled = false
+      end
+
+      sum += a.to_i * b.to_i if enabled
+    end
+
+    puts sum

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

@@ -0,0 +1,38 @@
+---
+- :name: day-04-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-04
+  :solution: |-
+    regex = /XMAS/
+
+    count = 0
+
+    count += input.scan(regex).count
+    count += input.reverse.scan(regex).count
+
+    rotated = input.split.map(&:chars)
+      .transpose.map(&:join).join("\n")
+
+    count += rotated.scan(regex).count
+    count += rotated.reverse.scan(regex).count
+
+    rows = input.split.map(&:chars)
+
+    rows[0..-4].each.with_index do |row, y|
+      row.each.with_index do |cell, x|
+        if x <= row.length - 4
+          str = cell + rows[y + 1][x + 1] + rows[y + 2][x + 2] + rows[y + 3][x + 3]
+
+          count += 1 if str.match?(regex)
+          count += 1 if str.reverse.match?(regex)
+        end
+
+        if x >= 4 - 1
+          str = cell + rows[y + 1][x - 1] + rows[y + 2][x - 2] + rows[y + 3][x - 3]
+
+          count += 1 if str.match?(regex)
+          count += 1 if str.reverse.match?(regex)
+        end
+      end
+    end
+
+    puts count

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

@@ -0,0 +1,24 @@
+---
+- :name: day-04-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-04
+  :solution: |-
+    count = 0
+
+    rows = input.split.map(&:chars)
+
+    rows[0..-3].each.with_index do |row, y|
+      row[0..-3].each.with_index do |_, x|
+        next unless rows[y + 1][x + 1] == ?A
+
+        next if rows[y][x, 3].rotate(-1)[0..1]
+          .zip(
+            rows[y + 2][x, 3].rotate(-1)[0..1].reverse
+          )
+          .map(&:sort)
+          .any? { _1 != [?M, ?S] }
+
+        count += 1
+      end
+    end
+
+    puts count

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

@@ -0,0 +1,26 @@
+---
+- :name: day-05-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-05
+  :solution: |-
+    input     = File.read(file_path)
+
+    rules, updates = input.split("\n\n")
+
+    rules_list = Hash.new { |h, k| h[k] = Set.new }
+
+    rules.split
+      .map { _1.split(?|).map(&:to_i) }
+      .each { rules_list[_1].add(_2) }
+
+    updates = updates.split
+      .map { _1.split(?,).map(&:to_i) }
+
+    updates
+      .select { |pages|
+        pages.each.with_index.all? do |page, idx|
+          pages[(idx + 1)..].all? { !rules_list[_1].include?(page) }
+        end
+      }
+      .map { _1[_1.length / 2] }
+      .inject(:+)
+      .tap { puts _1 }

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

@@ -0,0 +1,47 @@
+---
+- :name: day-05-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-05
+  :solution: |-
+    input     = File.read(file_path)
+
+    rules, updates = input.split("\n\n")
+
+    rules_list = Hash.new { |h, k| h[k] = Set.new }
+
+    rules.split
+      .map { _1.split(?|).map(&:to_i) }
+      .each { rules_list[_1].add(_2) }
+
+    updates = updates.split
+      .map { _1.split(?,).map(&:to_i) }
+
+    def reorder(pages, rules_list)
+      updates = []
+
+      while pages.any?
+        pages.lazy
+          .select { |page|
+            remain = pages.dup
+            remain.delete(page)
+
+            !remain.any? { rules_list[_1].include?(page) }
+          }
+          .first
+          .tap { updates << pages.delete(_1) }
+      end
+
+      updates
+    end
+
+    updates
+      .reject { |pages|
+        pages.each.with_index.all? do |page, idx|
+          pages[(idx + 1)..].all? { !rules_list[_1].include?(page) }
+        end
+      }
+      .map {
+        reorder(_1, rules_list)
+      }
+      .map { _1[_1.length / 2] }
+      .inject(:+)
+      .tap { puts _1 }

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

@@ -0,0 +1,36 @@
+---
+- :name: day-06-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-06
+  :solution: |-
+    input     = File.read(file_path)
+
+    grid = input.split.map(&:chars)
+
+    width = grid[0].size
+    height = grid.size
+
+    loc = input.split.join.index(?^)
+
+    x = loc % width
+    y = loc / width
+
+    dir = [0, -1]
+    pos = [x, y]
+
+    visited = Set.new([[x, y]])
+
+    while true
+      next_pos = pos.zip(dir).map { _1.inject(:+) }
+      x, y = next_pos
+
+      break if x < 0 || x >= width || y < 0 || y >= height
+
+      if grid[y] && grid[y][x] == ?#
+        dir = [-dir[1], dir[0]]
+      else
+        pos = next_pos
+        visited.add(pos)
+      end
+    end
+
+    puts visited.count

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

@@ -0,0 +1,64 @@
+---
+- :name: day-06-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-06
+  :solution: |-
+    input     = File.read(file_path)
+
+    grid = input.split.map(&:chars)
+
+    width = grid[0].size
+    height = grid.size
+
+    loc = input.split.join.index(?^)
+
+    x = loc % width
+    y = loc / width
+
+    pos = [x, y]
+
+    def travel(grid, start)
+      dir = [0, -1]
+      pos = start
+      visited = Set.new([[pos, dir]])
+
+      width = grid[0].size
+      height = grid.size
+
+      while true
+        next_pos = pos.zip(dir).map { _1.inject(:+) }
+        x, y = next_pos
+
+        if x < 0 || x >= width || y < 0 || y >= height
+          return visited.map { _1[0] }.uniq
+        end
+
+        if grid[y] && grid[y][x] == ?#
+          dir = [-dir[1], dir[0]]
+        else
+          pos = next_pos
+
+          # cycle detection
+          return if visited.include?([pos, dir])
+
+          visited.add([pos, dir])
+        end
+      end
+    end
+
+    visited = travel(grid, pos)
+
+    puts visited.count
+
+    # Part 2
+    visited.shift
+
+    count = 0
+    visited.each do |(x, y)|
+      grid[y][x] = ?#
+
+      count += 1 unless travel(grid, pos)
+
+      grid[y][x] = ?.
+    end
+
+    puts count