advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,34 @@
+---
+- :name: day-19-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-19
+  :solution: |-
+    towels, designs = input.split("\n\n")
+
+    towels = Set.new(towels.split(?,).map(&:strip))
+    designs = designs.split("\n")
+
+    max_length = towels.map(&:size).max
+
+    designs.select {
+      valid = false
+      queue = [_1]
+
+      while queue.any?
+        design = queue.shift
+
+        (0...[max_length, design.size].min).each do |length|
+          target = design[0..length]
+
+          if towels.include?(target)
+            if target == design
+              valid = true
+              queue.clear
+            else
+              queue.unshift(design[length+1..])
+            end
+          end
+        end
+      end
+
+      valid
+    }.tap { puts _1.count }

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

@@ -0,0 +1,45 @@
+---
+- :name: day-19-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-19
+  :solution: |-
+    towels, designs = input.split("\n\n")
+
+    towels = Set.new(towels.split(?,).map(&:strip))
+    designs = designs.split("\n")
+
+    def path_count(design, towels, cache)
+      return 1 if design.empty?
+
+      cache[design] ||= towels
+        .select { |towel| design.start_with?(towel) }
+        .sum { |towel| path_count(design[towel.length..], towels, cache) }
+    end
+
+    cache = {}
+
+    designs
+      .sum { path_count(_1, towels, cache) }
+      .tap { puts _1 }
+
+    # Fast enough for sample input, too slow for larger inputs
+    #
+    # designs.sum {
+    #   queue = [_1]
+    #   count = 0
+    #
+    #   while queue.any?
+    #     design = queue.shift
+    #
+    #     towels
+    #       .select { |towel| design.start_with?(towel) }
+    #       .each { |towel|
+    #         if towel == design
+    #           count += 1
+    #         else
+    #           queue.unshift(design[towel.length..])
+    #         end
+    #       }
+    #   end
+    #
+    #   count
+    # }.tap { puts _1 }

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

@@ -0,0 +1,58 @@
+---
+- :name: day-20-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-20
+  :solution: |-
+    grid = input.split.map(&:chars)
+
+    width = grid[0].size
+    height = grid.size
+
+    start = input.split.join.index(?S)
+    start = [start % width, start / height]
+
+    visited = {}
+    visited[start] = 0
+
+    queue = []
+    queue << [0, start]
+
+    while queue.any?
+      queue.sort_by!(&:first)
+      steps, loc = queue.shift
+
+      x, y = loc
+      candidates = [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+
+      candidates
+        .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+        .reject { grid[_2][_1] == ?# }
+        .reject { visited[[_1, _2]] }
+        .each {
+          visited[[_1, _2]] = steps + 1
+
+          if grid[_2][_1] != ?E
+            queue.unshift([steps + 1, [_1, _2]])
+          end
+        }
+    end
+
+    visited
+      .flat_map { |loc, steps|
+        x, y = loc
+
+        savings = []
+        candidates = [[x + 2, y], [x - 2, y], [x, y + 2], [x, y - 2]]
+
+        candidates
+          .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+          .reject { grid[_2][_1] == ?# }
+          .select { (visited[[_1, _2]] - steps - 2) >= 100 }
+          .each {
+            savings << (visited[[_1, _2]] - steps - 2)
+          }
+
+        savings
+      }
+      .tally
+      .tap { puts _1.values.sum }
+      #.tap { _1.sort.each { |sav, freq| p [freq, sav] } }

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

@@ -0,0 +1,65 @@
+---
+- :name: day-20-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-20
+  :solution: |-
+    grid = input.split.map(&:chars)
+
+    width = grid[0].size
+    height = grid.size
+
+    start = input.split.join.index(?S)
+    start = [start % width, start / height]
+
+    visited = {}
+    visited[start] = 0
+
+    queue = []
+    queue << [0, start]
+
+    while queue.any?
+      queue.sort_by!(&:first)
+      steps, loc = queue.shift
+
+      x, y = loc
+      candidates = [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+
+      candidates
+        .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+        .reject { grid[_2][_1] == ?# }
+        .reject { visited[[_1, _2]] }
+        .each {
+          visited[[_1, _2]] = steps + 1
+
+          if grid[_2][_1] != ?E
+            queue.unshift([steps + 1, [_1, _2]])
+          end
+        }
+    end
+
+    visited
+      .flat_map { |loc, steps|
+        x, y = loc
+
+        savings = []
+
+        (-20..20).each do |dx|
+          (-20..20).each do |dy|
+              dur = dx.abs + dy.abs
+
+              x1 = x + dx
+              y1 = y + dy
+
+              next if dur > 20
+              next if x1 < 0 || y1 < 0 || x1 >= width || y1 >= height
+              next if grid[y1][x1] == ?#
+              next if (visited[[x1, y1]] - steps - dur) < 100
+
+              savings << (visited[[x1, y1]] - steps - dur)
+          end
+        end
+
+        savings
+      }
+      .tally
+      .tap { puts _1.values.sum }
+      #.tap { _1.sort.each { |sav, freq| p [freq, sav] } }

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

@@ -0,0 +1,126 @@
+---
+- :name: day-21-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-21
+  :solution: |-
+    def generate_paths(pad)
+      width = 3
+      pad_locs = {}
+      paths = {}
+
+      pad.each.with_index {
+        next if _1 == " "
+        pad_locs[_1] = [_2 % width, _2 / width]
+      }
+
+      pad.product(pad).each do |from, to|
+        next if from == " " || to == " "
+
+        if from == to
+          paths[[from, to]] = ["A"]
+          next
+        end
+
+        x1, y1 = pad_locs[from]
+        x2, y2 = pad_locs[to]
+
+        dx = x2 - x1
+        dy = y2 - y1
+
+        press = []
+
+        dx.times { press << ?> }
+        dy.times { press << ?v }
+        (-dx).times { press << ?< }
+        (-dy).times { press << ?^ }
+
+        press = press
+          .permutation(press.length)
+          .uniq
+          .map { _1 << ?A }
+          .select { |code|
+            x, y = pad_locs[from]
+
+            code.all? do |dir|
+              case dir
+              when ?^
+                y -= 1
+              when ?v
+                y += 1
+              when ?>
+                x += 1
+              when ?<
+                x -= 1
+              end
+
+              pad[x + y * width] != " "
+            end
+          }
+
+        paths[[from, to]] = press.map(&:join)
+      end
+
+      paths
+    end
+
+    pad = "789456123 0A".chars
+    robot = " ^A<v>".chars
+
+    r_paths = generate_paths(robot)
+    p_paths = generate_paths(pad)
+
+    def viable_sequences(code, paths)
+      code = [?A] + code.chars
+
+      seqs = [ "" ]
+
+      code.each_cons(2) { |from, to|
+        seqs = seqs
+          .product(paths[[from, to]])
+          .map(&:flatten)
+          .map(&:join)
+      }
+
+      seqs
+    end
+
+    def shortest_len(seq, iter, r_paths, cache)
+      return seq.length if iter == 0
+      return cache[[seq, iter]] if cache[[seq, iter]]
+
+      seqs = viable_sequences(seq, r_paths)
+
+      min_length = seqs.map { |seq|
+        seq.split(/(?<=A)/).sum {
+          shortest_len(_1, iter - 1, r_paths, cache)
+        }
+      }.min
+
+      cache[[seq, iter]] = min_length
+
+      min_length
+    end
+
+    cache = {}
+
+    input.split
+      .sum { |code|
+        seqs = viable_sequences(code, p_paths)
+
+        min_length = seqs.map { |seq|
+          seq.split(/(?<=A)/).sum {
+            shortest_len(_1, 2, r_paths, cache)
+          }
+        }.min
+
+        min = min_length
+        num = code.scan(/\d+/).first.to_i
+
+        # Debugging
+        #
+        # puts code
+        # p [min, num, min * num]
+        # puts
+
+        min * num
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,126 @@
+---
+- :name: day-21-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-21
+  :solution: |-
+    def generate_paths(pad)
+      width = 3
+      pad_locs = {}
+      paths = {}
+
+      pad.each.with_index {
+        next if _1 == " "
+        pad_locs[_1] = [_2 % width, _2 / width]
+      }
+
+      pad.product(pad).each do |from, to|
+        next if from == " " || to == " "
+
+        if from == to
+          paths[[from, to]] = ["A"]
+          next
+        end
+
+        x1, y1 = pad_locs[from]
+        x2, y2 = pad_locs[to]
+
+        dx = x2 - x1
+        dy = y2 - y1
+
+        press = []
+
+        dx.times { press << ?> }
+        dy.times { press << ?v }
+        (-dx).times { press << ?< }
+        (-dy).times { press << ?^ }
+
+        press = press
+          .permutation(press.length)
+          .uniq
+          .map { _1 << ?A }
+          .select { |code|
+            x, y = pad_locs[from]
+
+            code.all? do |dir|
+              case dir
+              when ?^
+                y -= 1
+              when ?v
+                y += 1
+              when ?>
+                x += 1
+              when ?<
+                x -= 1
+              end
+
+              pad[x + y * width] != " "
+            end
+          }
+
+        paths[[from, to]] = press.map(&:join)
+      end
+
+      paths
+    end
+
+    pad = "789456123 0A".chars
+    robot = " ^A<v>".chars
+
+    r_paths = generate_paths(robot)
+    p_paths = generate_paths(pad)
+
+    def viable_sequences(code, paths)
+      code = [?A] + code.chars
+
+      seqs = [ "" ]
+
+      code.each_cons(2) { |from, to|
+        seqs = seqs
+          .product(paths[[from, to]])
+          .map(&:flatten)
+          .map(&:join)
+      }
+
+      seqs
+    end
+
+    def shortest_len(seq, iter, r_paths, cache)
+      return seq.length if iter == 0
+      return cache[[seq, iter]] if cache[[seq, iter]]
+
+      seqs = viable_sequences(seq, r_paths)
+
+      min_length = seqs.map { |seq|
+        seq.split(/(?<=A)/).sum {
+          shortest_len(_1, iter - 1, r_paths, cache)
+        }
+      }.min
+
+      cache[[seq, iter]] = min_length
+
+      min_length
+    end
+
+    cache = {}
+
+    input.split
+      .sum { |code|
+        seqs = viable_sequences(code, p_paths)
+
+        min_length = seqs.map { |seq|
+          seq.split(/(?<=A)/).sum {
+            shortest_len(_1, 25, r_paths, cache)
+          }
+        }.min
+
+        min = min_length
+        num = code.scan(/\d+/).first.to_i
+
+        # Debugging
+        #
+        # puts code
+        # p [min, num, min * num]
+        # puts
+
+        min * num
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,17 @@
+---
+- :name: day-22-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-22
+  :solution: |-
+    input.split.map(&:to_i)
+      .sum {
+        s = _1
+
+        2000.times {
+          s = s.*(64).^(s).%(16777216)
+          s = s./(32).^(s).%(16777216)
+          s = s.*(2048).^(s).%(16777216)
+        }
+
+        s
+      }
+      .tap { p _1 }

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

@@ -0,0 +1,37 @@
+---
+- :name: day-22-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-22
+  :solution: |-
+    input.split.map(&:to_i)
+      .map {
+        s = _1
+
+        seqs = {}
+        diffs = []
+
+        2000.times {
+          ns = s.*(64).^(s).%(16777216)
+          ns = ns./(32).^(ns).%(16777216)
+          ns = ns.*(2048).^(ns).%(16777216)
+
+          diffs << (ns % 10 - s % 10)
+          diffs = diffs[-4..] if diffs.length > 4
+
+          if diffs.length == 4
+            seqs[diffs.join(?,)] ||= ns % 10
+          end
+
+          s = ns
+        }
+
+        seqs
+      }
+      .inject({}) { |sums, seqs|
+        seqs.each do |seq, sum|
+          sums[seq] ||= 0
+          sums[seq] += sum
+        end
+
+        sums
+      }
+      .tap { p _1.values.max }

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

@@ -0,0 +1,26 @@
+---
+- :name: day-23-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-23
+  :solution: |-
+    connections = Hash.new { |h, k| h[k] = Set.new }
+
+    input.split.each { |connection|
+      c1, c2 = connection.split(?-)
+
+      connections[c1].add(c2)
+      connections[c2].add(c1)
+    }
+
+    triplets = Set.new
+
+    connections.each { |c1, connected|
+      connected.to_a.combination(2).each { |c2, c3|
+        next if !connections[c2].include?(c3)
+        triplets.add([c1, c2, c3].sort)
+      }
+    }
+
+    triplets.to_a
+      .map { _1.join(?,) }
+      .count { _1.match?(/(\A|,)t/) }
+      .tap { puts _1 }

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

@@ -0,0 +1,38 @@
+---
+- :name: day-23-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-23
+  :solution: |-
+    connections = Hash.new { |h, k| h[k] = Set.new }
+
+    input.split.each { |connection|
+      c1, c2 = connection.split(?-)
+
+      connections[c1].add(c2)
+      connections[c2].add(c1)
+    }
+
+    sets = Set.new
+
+    input.split
+      .map { _1.split(?-) }
+      .each { |c1, c2| sets.add([c1, c2].sort) }
+
+    while sets.count > 1
+      p [sets.first.size, sets.count]
+
+      new_sets = Set.new
+
+      sets.each { |set|
+        c1 = set.first
+        connections[c1].each { |c2|
+          next if set.include?(c2)
+          next if set[1..].any? { |c3| !connections[c3].include?(c2) }
+
+          new_sets.add((set.clone << c2).sort)
+        }
+      }
+
+      sets = new_sets
+    end
+
+    puts sets.first.join(?,)

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

@@ -0,0 +1,61 @@
+---
+- :name: day-24-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-24
+  :solution: |-
+    wires, gates = input.split("\n\n")
+
+    wires = wires
+      .split(?\n)
+      .map { _1.split(": ") }
+      .map { [_1, _2.to_i ] }
+      .to_h
+
+    gates = gates.split(?\n)
+      .map { _1.gsub("->", "").split }
+
+    outputs = gates.map(&:last)
+
+    outputs.each { wires[_1] = nil }
+
+    deps = Hash.new { |h, k| h[k] = Set.new }
+
+    gates.each do
+      w1, _rule, w2, _out = _1
+
+      deps[w1].add(_1)
+      deps[w2].add(_1)
+    end
+
+    queue = wires
+      .select { _2 }
+      .map(&:first)
+
+    while queue.any?
+      wire = queue.shift
+
+      deps[wire].each { |gate|
+        w1, rule, w2, out = gate
+
+        next if wires[out]
+        next if wires[w1].nil?
+        next if wires[w2].nil?
+
+        output =
+          case rule
+          when "XOR"
+            wires[w1] ^ wires[w2]
+          when "AND"
+            wires[w1] & wires[w2]
+          when "OR"
+            wires[w1] | wires[w2]
+          end
+
+        wires[out] = output
+
+        queue << out
+      }
+    end
+
+    p wires.keys.sort
+      .select { _1.start_with?(?z) }
+      .map { wires[_1] }.join.reverse.to_i(2)