advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/erikw/2021/07_1.yml

@@ -0,0 +1,9 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/07
+  :solution: |-
+    require_relative 'array'
+
+    positions = gets.split(',').map(&:to_i)
+    median = positions.median
+    puts positions.map { |pos| (pos - median).abs }.sum.to_i

data/data/solutions/github/erikw/2021/07_2.yml

@@ -0,0 +1,20 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/07
+  :solution: |-
+    require_relative 'array'
+
+    positions = gets.split(',').map(&:to_i)
+    avg = positions.avg
+
+    cost_floor = positions.map do |pos|
+      start, stop = [pos, avg.floor].sort
+      (start...stop).map { |n| n - start + 1 }.sum
+    end.sum.to_i
+
+    cost_ceil = positions.map do |pos|
+      start, stop = [pos, avg.ceil].sort
+      (start...stop).map { |n| n - start + 1 }.sum
+    end.sum.to_i
+
+    puts [cost_floor, cost_ceil].min

data/data/solutions/github/erikw/2021/08_1.yml

@@ -0,0 +1,31 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/08
+  :solution: |-
+    DIGIT_MAP = {
+      '0' => 'abcefg',      # Len = 6
+      '1' => 'cf',          # Len = 2 UNIQUE
+      '2' => 'acdeg',       # Len = 5
+      '3' => 'acdfg',       # Len = 5
+      '4' => 'bcdf',        # Len = 4 UNIQUE
+      '5' => 'abdfg',       # Len = 5
+      '6' => 'abdefg',      # Len = 6
+      '7' => 'acf',         # Len = 3 UNIQUE
+      '8' => 'abcdefg',     # Len = 7 UNIQUE
+      '9' => 'abcdfg'       # Len = 6
+    }
+
+    def digit_lens
+      DIGIT_MAP.transform_values { |v| v.length }.sort_by { |_k, v| v }
+    end
+    # patterns, output = gets.split('|').map { |part| part.split }
+    count = 0
+    ARGF.each_line do |line|
+      patterns, outputs = line.split('|').map { |part| part.split.map { |e| e.chars.sort.join } }
+
+      # p patterns, output
+      # pp digit_lens
+
+      count += outputs.count { |output| [2, 4, 3, 7].include?(output.length) }
+    end
+    puts count

data/data/solutions/github/erikw/2021/08_2.yml

@@ -0,0 +1,36 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/08
+  :solution: |-
+    DIGIT_MAP = {
+      '0' => 'abcefg',      # Len = 6
+      '1' => 'cf',          # Len = 2 UNIQUE
+      '2' => 'acdeg',       # Len = 5
+      '3' => 'acdfg',       # Len = 5
+      '4' => 'bcdf',        # Len = 4 UNIQUE
+      '5' => 'abdfg',       # Len = 5
+      '6' => 'abdefg',      # Len = 6
+      '7' => 'acf',         # Len = 3 UNIQUE
+      '8' => 'abcdefg',     # Len = 7 UNIQUE
+      '9' => 'abcdfg'       # Len = 6
+    }
+
+    # h/t https://www.reddit.com/r/adventofcode/comments/rbj87a/comment/hnpad75/?utm_source=share&utm_medium=web2x&context=3
+
+    count_map = DIGIT_MAP.map(&:last).join.chars.group_by(&:itself).map { |k, v| [k, v.length] }.to_h
+    countpattern2digit = DIGIT_MAP.map do |digit, pattern|
+      pattern = pattern.each_char.map { |c| count_map[c] }.sort.join
+      [pattern, digit]
+    end.to_h
+
+    sum = 0
+    puts(ARGF.each_line.map do |line|
+      patterns, outputs = line.split('|').map { |part| part.split.map { |e| e.chars.sort.join } }
+
+      count_map_pattern = patterns.join.chars.group_by(&:itself).map { |k, v| [k, v.length] }.to_h
+
+      outputs.map do |output|
+        countpattern = output.each_char.map { |c| count_map_pattern[c] }.sort.join
+        countpattern2digit[countpattern]
+      end.join.to_i
+    end.sum)

data/data/solutions/github/erikw/2021/09_1.yml

@@ -0,0 +1,27 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/09
+  :solution: |-
+    def smaller_than(values, row1, col1, row2, col2)
+      # puts "Testing values[#{row1}][#{col1}]=#{values[row1][col1]} against values[#{row2}][#{col2}]=#{values[row2][col2]}"
+      if row2.between?(0, values.length - 1) && col2.between?(0, values[0].length - 1)
+        values[row1][col1] < values[row2][col2]
+      else
+        true
+      end
+    end
+
+    heightmap = ARGF.each_line.map { |line| line.chomp.split('').map(&:to_i) }
+
+    lowpoints = []
+    (0...heightmap.length).each do |row|
+      (0...heightmap[0].length).each do |col|
+        next unless [[row, col - 1], [row - 1, col], [row, col + 1], [row + 1, col]].all? do |r, c|
+                      smaller_than(heightmap, row, col, r, c)
+                    end
+
+        lowpoints << heightmap[row][col]
+      end
+    end
+    risk = lowpoints.map { |p| p + 1 }.sum
+    puts risk

data/data/solutions/github/erikw/2021/09_2.yml

@@ -0,0 +1,49 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/09
+  :solution: |-
+    require 'set'
+
+    def smaller_than(values, row1, col1, row2, col2)
+      # puts "Testing values[#{row1}][#{col1}]=#{values[row1][col1]} against values[#{row2}][#{col2}]=#{values[row2][col2]}"
+      if row2.between?(0, values.length - 1) && col2.between?(0, values[0].length - 1)
+        values[row1][col1] < values[row2][col2]
+      else
+        true
+      end
+    end
+
+    def find_lowpoints(heightmap)
+      [].tap do |lowpoints|
+        (0...heightmap.length).each do |row|
+          (0...heightmap[0].length).each do |col|
+            next unless [[row, col - 1], [row - 1, col], [row, col + 1], [row + 1, col]].all? do |r, c|
+              smaller_than(heightmap, row, col, r, c)
+            end
+
+            lowpoints << [row, col]
+          end
+        end
+      end
+    end
+
+    def search_basin(basin, heightmap, row, col)
+      return unless !basin.member?([row, col]) &&
+                    row.between?(0, heightmap.length - 1) &&
+                    col.between?(0, heightmap[0].length - 1) &&
+                    heightmap[row][col] != 9
+
+      basin << [row, col]
+      search_basin(basin, heightmap, row, col - 1)
+      search_basin(basin, heightmap, row - 1, col)
+      search_basin(basin, heightmap, row, col + 1)
+      search_basin(basin, heightmap, row + 1, col)
+      basin
+    end
+
+    heightmap = ARGF.each_line.map { |line| line.chomp.split('').map(&:to_i) }
+    lowpoints = find_lowpoints(heightmap)
+    top_basins = lowpoints.map do |row, col|
+      search_basin(Set.new, heightmap, row, col)
+    end.map(&:length).sort.last(3).inject(&:*)
+    puts top_basins

data/data/solutions/github/erikw/2021/10_1.yml

@@ -0,0 +1,36 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/10
+  :solution: |-
+    PAIRS = {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+      '<' => '>'
+    }
+
+    POINTS = {
+      ')' => 3,
+      ']' => 57,
+      '}' => 1197,
+      '>' => 25_137
+    }
+
+    score = ARGF.each_line.map do |line|
+      stack = []
+      broken_char = nil
+      line.chomp.chars.each do |char|
+        if PAIRS.keys.include?(char)
+          stack.push(char)
+        else
+          opening = stack.pop
+          if PAIRS[opening] != char
+            broken_char = char
+            break
+          end
+        end
+      end
+      broken_char
+    end.reject(&:nil?).map { |c| POINTS[c] }.sum
+
+    puts score

data/data/solutions/github/erikw/2021/10_2.yml

@@ -0,0 +1,53 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/10
+  :solution: |-
+    class Array
+      def median
+        sorted = sort
+        if length.even?
+          (sorted[length / 2 - 1] + sorted[length / 2]) / 2.0
+        else
+          sorted[length / 2]
+        end
+      end
+    end
+
+    PAIRS = {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+      '<' => '>'
+    }
+
+    POINTS = {
+      ')' => 1,
+      ']' => 2,
+      '}' => 3,
+      '>' => 4
+    }
+
+    score = ARGF.each_line.map do |line|
+      stack = []
+      broken = false
+      score = 0
+      line.chomp.chars.each do |char|
+        if PAIRS.keys.include?(char)
+          stack.push(char)
+        else
+          opening = stack.pop
+          if PAIRS[opening] != char
+            broken = true
+            break
+          end
+        end
+      end
+      unless broken
+        stack.reverse_each do |open_char|
+          score = score * 5 + POINTS[PAIRS[open_char]]
+        end
+      end
+      score
+    end.reject { |s| s == 0 }.median
+
+    puts score

data/data/solutions/github/erikw/2021/11_1.yml

@@ -0,0 +1,55 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/11
+  :solution: |-
+    ITERATIONS = 100
+
+    NEIGHBOUR_DELTAS = [-1, 0, 1]
+
+    def update_neighbour(octopi, row, col)
+      octopi[row][col] += 1 if row.between?(0, octopi.length - 1) &&
+                               col.between?(0, octopi[0].length - 1) &&
+                               octopi[row][col] != 0
+    end
+
+    def update_neighbours(octopi, row, col)
+      NEIGHBOUR_DELTAS.each do |dr|
+        NEIGHBOUR_DELTAS.each do |dc|
+          next if dr == 0 && dc == 0
+
+          update_neighbour(octopi, row + dr, col + dc)
+        end
+      end
+    end
+
+    octopi = ARGF.each_line.map do |line|
+      line.chomp.chars.map(&:to_i)
+    end
+
+    flashes = 0
+    ITERATIONS.times do
+      (0...octopi.length).each do |row|
+        (0...octopi[0].length).each do |col|
+          octopi[row][col] += 1
+        end
+      end
+
+      loop do
+        new_flashers = 0
+
+        (0...octopi.length).each do |row|
+          (0...octopi[0].length).each do |col|
+            next unless octopi[row][col] > 9
+
+            new_flashers += 1
+            octopi[row][col] = 0
+            update_neighbours(octopi, row, col)
+          end
+        end
+
+        flashes += new_flashers
+        break if new_flashers == 0
+      end
+    end
+
+    puts flashes

data/data/solutions/github/erikw/2021/11_2.yml

@@ -0,0 +1,56 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/11
+  :solution: |-
+    NEIGHBOUR_DELTAS = [-1, 0, 1]
+
+    def update_neighbour(octopi, row, col)
+      octopi[row][col] += 1 if row.between?(0, octopi.length - 1) &&
+                               col.between?(0, octopi[0].length - 1) &&
+                               octopi[row][col] != 0
+    end
+
+    def update_neighbours(octopi, row, col)
+      NEIGHBOUR_DELTAS.each do |dr|
+        NEIGHBOUR_DELTAS.each do |dc|
+          next if dr == 0 && dc == 0
+
+          update_neighbour(octopi, row + dr, col + dc)
+        end
+      end
+    end
+
+    octopi = ARGF.each_line.map do |line|
+      line.chomp.chars.map(&:to_i)
+    end
+
+    flashes = 0
+    steps = 0
+    loop do
+      steps += 1
+      (0...octopi.length).each do |row|
+        (0...octopi[0].length).each do |col|
+          octopi[row][col] += 1
+        end
+      end
+
+      loop do
+        new_flashers = 0
+
+        (0...octopi.length).each do |row|
+          (0...octopi[0].length).each do |col|
+            next unless octopi[row][col] > 9
+
+            new_flashers += 1
+            octopi[row][col] = 0
+            update_neighbours(octopi, row, col)
+          end
+        end
+
+        flashes += new_flashers
+        break if new_flashers == 0
+      end
+      break if octopi.map { |row| row.sum }.sum == 0
+    end
+
+    puts steps

data/data/solutions/github/erikw/2021/12_1.yml

@@ -0,0 +1,43 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/12
+  :solution: |-
+    require 'set'
+
+    require_relative 'node'
+
+    def find_paths(nodes, node_cur, paths_all, path_cur)
+      path_cur << node_cur
+      if node_cur == nodes['end']
+        paths_all << path_cur.dup
+      else
+        node_cur.neighbours.each do |neighbour|
+          unless neighbour.name == 'start' || neighbour.is_small? && path_cur.include?(neighbour)
+            find_paths(nodes, neighbour, paths_all, path_cur)
+          end
+        end
+      end
+      path_cur.pop
+    end
+
+    def find_all_paths(nodes)
+      paths_all = []
+      path_cur = []
+      start = nodes['start']
+      find_paths(nodes, start, paths_all, path_cur)
+      paths_all
+    end
+
+    nodes = {} # str -> Node
+    ARGF.each_line.map { |line| line.chomp.split('-') }.each do |left, right|
+      node_left = nodes.fetch(left, Node.new(left))
+      node_right = nodes.fetch(right, Node.new(right))
+      nodes[left] = node_left
+      nodes[right] = node_right
+
+      node_left.edge_to(node_right)
+      node_right.edge_to(node_left)
+    end
+
+    all_paths = find_all_paths(nodes)
+    puts all_paths.length

data/data/solutions/github/erikw/2021/12_2.yml

@@ -0,0 +1,44 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/12
+  :solution: |-
+    require 'set'
+
+    require_relative 'node'
+
+    def find_paths(nodes, node_cur, paths_all, path_cur)
+      path_cur << node_cur
+      if node_cur == nodes['end']
+        paths_all << path_cur.dup
+      else
+        node_cur.neighbours.each do |neighbour|
+          has_small_twice = path_cur.select(&:is_small?).group_by(&:itself).map(&:last).map(&:length).max == 2
+          if neighbour.name != 'start' && (!neighbour.is_small? || !has_small_twice || !path_cur.include?(neighbour))
+            find_paths(nodes, neighbour, paths_all, path_cur)
+          end
+        end
+      end
+      path_cur.pop
+    end
+
+    def find_all_paths(nodes)
+      paths_all = []
+      path_cur = []
+      start = nodes['start']
+      find_paths(nodes, start, paths_all, path_cur)
+      paths_all
+    end
+
+    nodes = {} # str -> Node
+    ARGF.each_line.map { |line| line.chomp.split('-') }.each do |left, right|
+      node_left = nodes.fetch(left, Node.new(left))
+      node_right = nodes.fetch(right, Node.new(right))
+      nodes[left] = node_left
+      nodes[right] = node_right
+
+      node_left.edge_to(node_right)
+      node_right.edge_to(node_left)
+    end
+
+    all_paths = find_all_paths(nodes)
+    puts all_paths.length

data/data/solutions/github/erikw/2021/13_1.yml

@@ -0,0 +1,33 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/13
+  :solution: |-
+    coords = []
+    loop do
+      line = ARGF.readline.chomp
+      break if line.empty?
+
+      x, y = line.split(',').map(&:to_i)
+      coords << [x, y]
+    end
+
+    count = 0
+    ARGF.each_line do |line|
+      break if count == 1
+
+      count += 1
+
+      axis, fold_coord = line.delete_prefix('fold along ').split('=')
+      fold_coord = fold_coord.to_i
+
+      coords.map! do |x, y|
+        if axis == 'x' && x > fold_coord
+          x = 2 * fold_coord - x
+        elsif axis == 'y' && y > fold_coord
+          y = 2 * fold_coord - y
+        end
+        [x, y]
+      end
+    end
+
+    puts coords.uniq.count

data/data/solutions/github/erikw/2021/13_2.yml

@@ -0,0 +1,45 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/13
+  :solution: |-
+    require 'set'
+
+    coords = []
+    loop do
+      line = ARGF.readline.chomp
+      break if line.empty?
+
+      x, y = line.split(',').map(&:to_i)
+
+      coords << [x, y]
+    end
+
+    x_max = -1
+    y_max = -1
+    ARGF.each_line do |line|
+      axis, fold_coord = line.delete_prefix('fold along ').split('=')
+      fold_coord = fold_coord.to_i
+
+      coords.map! do |x, y|
+        if axis == 'x' && x > fold_coord
+          x = 2 * fold_coord - x
+        elsif axis == 'y' && y > fold_coord
+          y = 2 * fold_coord - y
+        end
+        [x, y]
+      end
+      if axis == 'x'
+        x_max = fold_coord
+      else
+        y_max = fold_coord
+      end
+    end
+
+    coordset = Set.new(coords)
+    (0..y_max).each do |y|
+      (0..x_max).each do |x|
+        #print coordset.member?([x, y]) ? '#' : '.'
+        print coordset.member?([x, y]) ? '#' : ' '
+      end
+      puts
+    end

data/data/solutions/github/erikw/2021/14_1.yml

@@ -0,0 +1,80 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/14
+  :solution: |-
+    ITERATIONS = 10
+
+    class Node
+      attr_reader :value
+      attr_accessor :next
+
+      def initialize(value, next_node = nil)
+        @value = value
+        @next = next_node
+      end
+
+      def to_s
+        @value.to_s
+      end
+      alias inspect to_s
+    end
+
+    def print_list(head)
+      out = ''
+      until head.nil?
+        out += "#{head} -> "
+        head = head.next
+      end
+      puts out
+    end
+
+    head = nil
+    cur = nil
+    ARGF.readline.chomp.each_char do |c|
+      node = Node.new(c)
+      if head.nil?
+        head = node
+        cur = head
+      else
+        cur.next = node
+        cur = node
+      end
+    end
+    ARGF.readline
+
+    # print_list(head)
+
+    rules = {}
+    ARGF.each_line do |line|
+      lhs, rhs = line.chomp.split(' -> ')
+      rules[lhs] = rhs
+    end
+
+    # pp rules
+
+    ITERATIONS.times do
+      node = head
+      until node.nil?
+        break if node.next.nil?
+
+        from = node.value + node.next.value
+        prod = rules.fetch(from, nil)
+        unless prod.nil?
+          prod_node = Node.new(prod, node.next)
+          node.next = prod_node
+          node = node.next
+        end
+        node = node.next
+      end
+    end
+
+    # print_list(head)
+
+    freq = Hash.new(0)
+    node = head
+    until node.nil?
+      freq[node.value] += 1
+      node = node.next
+    end
+
+    puts freq.minmax_by { |_k, v| v }.map(&:last).sort.reverse.inject(&:-)

data/data/solutions/github/erikw/2021/14_2.yml

@@ -0,0 +1,29 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/14
+  :solution: |-
+    ITERATIONS = 40
+
+    pair_counts = Hash.new(0) # pair -> count
+    char_counts = Hash.new(0) # "char" ->count
+    polymer = ARGF.readline.chomp.chars
+    polymer.each_cons(2) { |a, b| pair_counts[a + b] += 1 }
+    polymer.each { |c| char_counts[c] += 1 }
+
+    prod = {}  # pair -> char
+    ARGF.readline
+    ARGF.each_line do |line|
+      prod.merge! [line.chomp.split(' -> ')].to_h
+    end
+
+    ITERATIONS.times do
+      updates = Hash.new(0)
+      pair_counts.each do |pair, count|
+        updates[pair[0] + prod[pair]] += count
+        updates[prod[pair] + pair[1]] += count
+        char_counts[prod[pair]]       += count
+      end
+      pair_counts = updates
+    end
+
+    puts char_counts.values.minmax.sort.reverse.inject(&:-)