advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/github/erikw/2020/16_2.yml

@@ -0,0 +1,68 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/16
+  :solution: |-
+    in_rules, in_ticket_mine, in_ticket_nearby = ARGF.readlines.join.split("\n\n")
+
+    rules = []
+    departure_idxs = []
+    in_rules.lines.each.with_index do |rule, i|
+      field = rule.split(':').first
+      departure_idxs << i if field.start_with?('departure')
+      rules << rule.scan(/\d+/).map(&:to_i).each_slice(2).to_a
+    end
+
+    ticket_mine = in_ticket_mine.lines.last.split(',').map(&:to_i)
+    tickets_nearby = in_ticket_nearby.lines.drop(1).map { |l| l.split(',').map(&:to_i) }
+
+    tickets_nearby.select! do |ticket_nearby|
+      ticket_nearby.all? do |value|
+        rules.any? do |range1, range2|
+          value.between?(*range1) || value.between?(*range2)
+        end
+      end
+    end
+
+    # BF would be trying all permutations => 20!. Not reasonable
+    # Instead strike out possible assignements per field until all have only one.
+    # valid_assignments[f] are positions in rules that are valid (so far) for ticket field f.
+    valid_assignments = Array.new(rules.length) { (0...rules.length).to_a }
+
+    t = 0
+    while t < tickets_nearby.length && valid_assignments.any? { |assign| assign.length > 1 }
+      tickets_nearby[t].each_with_index do |value, f|
+        a = 0
+        while a < valid_assignments[f].length
+          range1, range2 = rules[valid_assignments[f][a]]
+          if value.between?(*range1) || value.between?(*range2)
+            a += 1
+          else
+            valid_assignments[f].delete_at(a)
+          end
+        end
+      end
+      t += 1
+    end
+
+    # Now continuously reduce assignments by removing the 1-1 mappings we found from all other field assignments.
+    while valid_assignments.any? { |assign| assign.length > 1 }
+      valid_assignments.each_index do |i|
+        next unless valid_assignments[i].length == 1
+
+        valid_assignments.each_index do |j|
+          next if j == i
+
+          valid_assignments[j].delete(valid_assignments[i][0])
+        end
+      end
+    end
+
+    valid_assignments.flatten!(1)
+
+    departure_values = departure_idxs.map do |di|
+      # Reverse mapping: rule nbr -> ticket field nbr
+      ticket_pos = valid_assignments.index(di)
+      ticket_mine[ticket_pos]
+    end.inject(&:*)
+
+    puts departure_values

data/data/solutions/github/erikw/2020/17_1.yml

@@ -0,0 +1,15 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/17
+  :solution: |-
+    require_relative 'lib'
+
+    cubes = Hash.new(false) # [x, y, z] -> state
+    ARGF.each_line.with_index do |line, x|
+      line.chomp.each_char.with_index do |char, y|
+        cubes[[x, y, 0]] = char == SYM_ACTIVE
+      end
+    end
+
+    run(cubes, BOOT_CYCLES)
+    puts cubes.values.count { |s| s }

data/data/solutions/github/erikw/2020/17_2.yml

@@ -0,0 +1,15 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/17
+  :solution: |-
+    require_relative 'lib'
+
+    cubes = Hash.new(false) # [x, y, z, w] -> state
+    ARGF.each_line.with_index do |line, x|
+      line.chomp.each_char.with_index do |char, y|
+        cubes[[x, y, 0, 0]] = char == SYM_ACTIVE
+      end
+    end
+
+    run(cubes, BOOT_CYCLES)
+    puts cubes.values.count { |s| s }

data/data/solutions/github/erikw/2020/18_1.yml

@@ -0,0 +1,69 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/18
+  :solution: |-
+    # Home-cooked algorithm:
+    # * keep a stack of "un-folded" values, operators and opening parentesis.
+    # * when encountering a number; pop of the operator and lhs and evaluate, put value back in stack.
+    # * when encoutinging a closing paren, same as above + handle cases when multiple nested parens are used."
+    #
+    # Should have used Reverse Polish Notation if I had remembered. I knew it was something with a stack...
+
+    OP_ADD = '+'
+    OP_MUL = '*'
+    EXPR_PAREN_OPEN = '('
+    EXPR_PAREN_CLOSE = ')'
+
+    def evaluate(exprs)
+      stack = []
+      i = 0
+      while i < exprs.length
+        cur_char = exprs[i]
+        case cur_char
+        when /\d/
+          cur_digit = cur_char.to_i
+          if stack.empty?
+            stack << cur_digit
+          else
+            op = stack.pop
+            case op
+            when OP_ADD
+              lhs = stack.pop
+              stack << lhs + cur_digit
+            when OP_MUL
+              lhs = stack.pop
+              stack << lhs * cur_digit
+            when EXPR_PAREN_OPEN
+              stack << op << cur_digit
+            end
+          end
+        when EXPR_PAREN_CLOSE
+          rhs = stack.pop
+          _open_paren = stack.pop
+          op = stack.pop
+          if op.nil?
+            stack << rhs
+          elsif op == EXPR_PAREN_OPEN
+            stack << op
+            stack << rhs
+          else
+            lhs = stack.pop
+            stack << case op
+                     when OP_ADD then lhs + rhs
+                     when OP_MUL then lhs * rhs
+                     end
+          end
+        when ' ' then nil
+        else
+          stack << exprs[i]
+        end
+        i += 1
+      end
+      stack.pop
+    end
+
+    sum = ARGF.each_line.sum do |line|
+      evaluate(line.chomp)
+    end
+
+    puts sum

data/data/solutions/github/erikw/2020/18_2.yml

@@ -0,0 +1,24 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/18
+  :solution: |-
+    # Sometimes you just got to hack when you're too tired for the proper solution ...
+
+    class Integer
+      alias old_add +
+      alias old_mul *
+
+      def +(other)
+        old_mul(other)
+      end
+
+      def *(other)
+        old_add(other)
+      end
+    end
+
+    sum = ARGF.each_line.sum do |line|
+      eval line.chomp.tr('+*', '*+')
+    end
+
+    puts sum

data/data/solutions/github/erikw/2020/19_1.yml

@@ -0,0 +1,41 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/19
+  :solution: |-
+    CHAR_OR = '|'
+
+    def valid(rules, message, rule = '0', pos = 0)
+      pos_alt = nil
+      full_match = rules[rule].any? do |rule_alt|
+        pos_alt = pos
+        rule_alt.all? do |rule_elem|
+          if rule_elem.match(/\d+/)
+            valid_rec, pos_alt = valid(rules, message, rule_elem, pos_alt)
+            valid_rec
+          else
+            v = message[pos_alt] == rule_elem
+            pos_alt += 1
+            v
+          end
+        end
+      end
+      if rule == '0'
+        [full_match && pos_alt == message.length, pos_alt]
+      else
+        [full_match, pos_alt]
+      end
+    end
+
+    in_rules, in_messages = ARGF.readlines.join.split("\n\n")
+
+    rules = {} # rule_nbr -> [[x, y], [z, w]] rule alternations
+    in_rules.each_line do |rule_str|
+      nbr, rule = rule_str.chomp.split(': ')
+      rules[nbr] = rule.split(CHAR_OR).map { |p| p.split(' ').map { |e| e.tr('""', '') } }
+    end
+
+    num_valid = in_messages.each_line.count do |message|
+      valid(rules, message.chomp)[0]
+    end
+
+    puts num_valid

data/data/solutions/github/erikw/2020/19_2.yml

@@ -0,0 +1,63 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/19
+  :solution: |-
+    require 'set'
+
+    CHAR_OR = '|'
+
+    # Merge of part1 solution + caching + https://www.reddit.com/r/adventofcode/comments/kg1mro/comment/ggcj4fm/
+    def valid(rules, message, rule = '0', pos = 0, cache = {})
+      cache_key = [rule, pos]
+      unless cache.has_key?(cache_key)
+        if pos >= message.length
+          cache[cache_key] = Set.new
+        elsif rules[rule].length == 1 && rules[rule][0].length == 1 && rules[rule][0] !~ /\d+/
+          cache[cache_key] = if message[pos] == rules[rule][0][0]
+                               Set[pos + 1]
+                             else
+                               Set.new
+                             end
+        else
+          poss = Set.new # All end+1 positions
+          rules[rule].each do |rule_alt|
+            poss_alts = Set[pos]
+            rule_alt.each do |rule_elem|
+              poss_alts_next = Set.new
+              poss_alts.each do |pos_alt|
+                poss_alts_next |= valid(rules, message, rule_elem, pos_alt, cache)
+              end
+              poss_alts = poss_alts_next
+            end
+            poss |= poss_alts
+          end
+          cache[cache_key] = poss
+        end
+      end
+
+      if rule == '0'
+        cache[cache_key].include?(message.length)
+      else
+        cache[cache_key]
+      end
+    end
+
+    in_rules, in_messages = ARGF.readlines.join.split("\n\n")
+
+    rules = {} # rule_nbr -> [[x, y], [z, w]] rule alternations
+    in_rules.each_line do |rule_str|
+      nbr, rule = rule_str.chomp.split(': ')
+      if nbr == '8'
+        rule = '42 | 42 8'
+      elsif nbr == '11'
+        rule = '42 31 | 42 11 31'
+      end
+
+      rules[nbr] = rule.split(CHAR_OR).map { |p| p.split(' ').map { |e| e.tr('""', '') } }
+    end
+
+    num_valid = in_messages.each_line.count do |message|
+      valid(rules, message.chomp)
+    end
+
+    puts num_valid

data/data/solutions/github/erikw/2020/20_1.yml

@@ -0,0 +1,9 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/20
+  :solution: |-
+    require_relative 'lib'
+
+    tiles, edges = read_input
+    corners = find_corner_tiles(tiles, edges)
+    puts corners.inject(&:*)

data/data/solutions/github/erikw/2020/20_2.yml

@@ -0,0 +1,274 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/20
+  :solution: |-
+    require_relative 'lib'
+
+    SEA_MONSTER = [
+      '                  # ',
+      '#    ##    ##    ###',
+      ' #  #  #  #  #  #   '
+    ]
+
+    def print_tile(tile)
+      tile.each { |r| puts r.join }
+    end
+
+    def print_img_nbrs(img_tile_nbrs)
+      puts '====img_tile_nbrs======'
+      img_tile_nbrs.each do |row|
+        puts row.map { |n| n.nil? ? 'x   ' : n }.join(' ')
+      end
+      puts '====img_tile_nbrs END======'
+    end
+
+    def print_tile_image(img_tiles)
+      dim = img_tiles.length * img_tiles[0][0].length
+      img = Array.new(dim) { [] }
+      img_tiles.each_with_index do |tile_row, row|
+        tile_row.each do |tile|
+          tile.each_with_index do |tr, tr_row|
+            tr.each do |tc|
+              img[row * img_tiles[0][0].length + tr_row] << tc
+            end
+            img[row * img_tiles[0][0].length + tr_row] << '|'
+          end
+        end
+      end
+      puts '====img_tiles======'
+      print_tile(img)
+      puts '====img_tiles END======'
+    end
+
+    def print_image(img)
+      puts '====img======'
+      img.each do |row|
+        puts row.join
+      end
+      puts '====img END======'
+    end
+
+    def rotate_cw(tile)
+      tile.reverse.transpose
+    end
+
+    def flip_horizontal(tile)
+      tile.map(&:reverse)
+    end
+
+    def nbr_compatible_edges_of(edges, edge)
+      edges[edge].length - 1
+    end
+
+    # all matching tile nbrs for edge that is not self (tile_nbr)
+    def matching_tile_nbr(edges, edge, tile_nbr)
+      edges[edge] - [tile_nbr]
+    end
+
+    def matching_face(tile, edge, edge_dir)
+      2.times do
+        4.times do
+          tile_edges = edges_of(tile)
+          # TODO: should use real edges and not ID here, probably?
+          #  input1.0 finds no monsters then, but input finds 2 more than before
+          # tile_edges = edges_of_real(tile)
+          return tile if tile_edges[edge_dir] == edge
+
+          tile = rotate_cw(tile)
+        end
+        tile = flip_horizontal(tile)
+      end
+      raise 'no matching face!'
+      false
+    end
+
+    # h/t for the structure to https://www.reddit.com/r/adventofcode/comments/kgo01p/comment/ggg6k09/
+    def assemble_tiles(tiles, edges, corners)
+      dim = Math.sqrt(tiles.length).to_i
+      img_tiles = Array.new(dim) { Array.new(dim) { [] } }
+      img_tile_nbrs = Array.new(dim) { Array.new(dim) { nil } }
+
+      dim.times do |row|
+        dim.times do |col|
+          if [row, col] == [0, 0]
+            img_tile_nbrs[row][col] = corners.first
+            tile = tiles[img_tile_nbrs[row][col]]
+            loop do
+              tile_edges = edges_of(tile)
+
+              compat_north = nbr_compatible_edges_of(edges, tile_edges[:north])
+              compat_west = nbr_compatible_edges_of(edges, tile_edges[:west])
+              break if compat_north == 0 && compat_west == 0
+
+              tile = rotate_cw(tile)
+            end
+            img_tiles[row][col] = tile
+          elsif col == 0
+            edge_above = edges_of(img_tiles[row - 1][col])[:south]
+            # Assumption: every edge is unique; thus can pick first and only here
+            img_tile_nbrs[row][col] = matching_tile_nbr(edges, edge_above, img_tile_nbrs[row - 1][col]).first
+            img_tiles[row][col] = matching_face(tiles[img_tile_nbrs[row][col]], edge_above, :north)
+          else
+            edge_leftof = nil
+            1.times do
+              edge_leftof = edges_of(img_tiles[row][col - 1])[:east]
+              img_tile_nbrs[row][col] = matching_tile_nbr(edges, edge_leftof, img_tile_nbrs[row][col - 1]).first
+              break unless img_tile_nbrs[row][col].nil?
+
+              # If left edge didn't matched, we must have placed it with the wrong face; flip it and redo!
+              img_tiles[row][col - 1] = flip_horizontal(img_tiles[row][col - 1])
+              redo if col == 1
+            end
+
+            img_tiles[row][col] = matching_face(tiles[img_tile_nbrs[row][col]], edge_leftof, :west)
+          end
+        end
+      end
+
+      [img_tiles, img_tile_nbrs]
+    end
+
+    def extract_image(img_tiles)
+      dim_tile = img_tiles[0][0].length - 2 # remove 2x edge per side
+      dim_img = img_tiles.length * dim_tile
+      img = Array.new(dim_img) { [] }
+      img_tiles.each_with_index do |tile_row, row|
+        tile_row.each do |tile|
+          tile[1...-1].each_with_index do |tr, tr_row|
+            tr[1...-1].each do |tc|
+              img[row * dim_tile + tr_row] << tc
+            end
+          end
+        end
+      end
+      img
+    end
+
+    tiles, edges = read_input
+    corners = find_corner_tiles(tiles, edges)
+
+    img_tiles, img_tile_nbrs = assemble_tiles(tiles, edges, corners)
+
+    print_tile_image(img_tiles)
+    print_img_nbrs(img_tile_nbrs)
+
+    img = extract_image(img_tiles)
+
+    # Flip like the input1.0 example to easier debug
+    # img_tile_nbrs = flip_horizontal(rotate_cw(img_tile_nbrs))
+    # img = flip_horizontal(rotate_cw(img))
+
+    # print_img_nbrs(img_tile_nbrs)
+    # print_image(img)
+
+    def is_seamonster(img, sea_monster, row, col)
+      (0...sea_monster.length).each do |sm_row|
+        (0...sea_monster[0].length).each do |sm_col|
+          return false if sea_monster[sm_row][sm_col] == '#' && img[row + sm_row][col + sm_col] != '#'
+        end
+      end
+      true
+    end
+
+    def search_sea_monsters(img, sea_monster)
+      monsters = 0
+      (0...(img.length - sea_monster.length)).each do |row|
+        (0...(img[0].length - sea_monster[0].length)).each do |col|
+          monsters += 1 if is_seamonster(img, sea_monster, row, col)
+        end
+      end
+      monsters
+    end
+
+    def identified_monsters(img, sea_monster)
+      2.times do
+        4.times do
+          monsters = search_sea_monsters(img, sea_monster)
+          # TODO: problem is that I only find 6 monsters for input, py finds 41
+          #        my image has fewer # than py's, at the rotation where monsters are found.
+          #        dimensions are same
+          #        NOPE number of hashes are correct, but some of my tiles are not flip/rotated right! the tiles are in right place though
+          #        I have same tile numbers arrangement as py, but transposed!
+          if monsters > 0
+            print_image(img)
+            return monsters
+          end
+
+          img = rotate_cw(img)
+        end
+        img = flip_horizontal(img)
+      end
+      0
+    end
+    monsters = identified_monsters(img, SEA_MONSTER)
+    puts "found monsters #{monsters}"
+    hashes_monster = monsters * SEA_MONSTER.join.chars.count { |c| c == '#' }
+    hashes_img = img.join.chars.count { |c| c == '#' }
+
+    # water_roughness = hashes_img - hashes_monster
+    # the right tiles are selected and ordered, but something is not right with the assembly.
+    # It works all fine for input1.0, and I have no further energy to debug this, thus...
+    water_roughness = 1901
+
+    puts water_roughness
+
+    # Below solution should be more stable, as it can handle overlapping monsters + paints them out. Seems like it should not be needed though.
+    #
+    # def is_seamonster(img, sea_monster, row, col)
+    #  (0...sea_monster.length).each do |sm_row|
+    #    (0...sea_monster[0].length).each do |sm_col|
+    #      return false if sea_monster[sm_row][sm_col] == '#' && !['#', 'O'].include?(img[row + sm_row][col + sm_col])
+    #    end
+    #  end
+    #  true
+    # end
+
+    # def mark_seamonster(img, sea_monster, row, col)
+    #  (0...sea_monster.length).each do |sm_row|
+    #    (0...sea_monster[0].length).each do |sm_col|
+    #      img[row + sm_row][col + sm_col] = 'O' if sea_monster[sm_row][sm_col] == '#'
+    #    end
+    #  end
+    # end
+
+    # def search_sea_monsters(img, sea_monster)
+    #  monsters = 0
+    #  (0...(img.length - sea_monster.length)).each do |row|
+    #    (0...(img[0].length - sea_monster[0].length)).each do |col|
+    #      next unless is_seamonster(img, sea_monster, row, col)
+
+    #      mark_seamonster(img, sea_monster, row, col)
+    #      monsters += 1
+    #    end
+    #  end
+    #  monsters
+    # end
+
+    # def identify_monster_tiles(img, sea_monster)
+    #  2.times do
+    #    4.times do
+    #      monsters = search_sea_monsters(img, sea_monster)
+    #      if monsters > 0
+    #        print_image(img)
+    #        tiles_monster = img.join.chars.count { |c| c == 'O' }
+    #        tiles_hash = img.join.chars.count { |c| c == '#' }
+    #        puts "total #/o: #{tiles_hash + tiles_monster}"
+    #        return tiles_hash
+    #      end
+
+    #      img = rotate_cw(img)
+    #    end
+    #    img = flip_horizontal(img)
+    #  end
+    #  0
+    # end
+    # monster_tiles = identify_monster_tiles(img, SEA_MONSTER)
+    # water_roughness = monster_tiles
+    # puts water_roughness
+
+    # 2396 - too high
+    # 2426 - too high
+    #
+    # Py:
+    # found monsters  41
+    # 1901

data/data/solutions/github/erikw/2020/21_1.yml

@@ -0,0 +1,14 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/21
+  :solution: |-
+    require_relative 'lib'
+
+    ingredient_counts, ingredient2allergenscount = count_input
+    non_allergens = non_allergens(ingredient2allergenscount)
+
+    non_aller_occurences = non_allergens.sum do |nallergen|
+      ingredient_counts[nallergen]
+    end
+
+    puts non_aller_occurences

data/data/solutions/github/erikw/2020/21_2.yml

@@ -0,0 +1,32 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/21
+  :solution: |-
+    require_relative 'lib'
+
+    ingredient_counts, ingredient2allergenscount = count_input
+    non_allergens = non_allergens(ingredient2allergenscount)
+
+    non_allergens.each do |nallergen|
+      ingredient2allergenscount.delete(nallergen)
+    end
+
+    ingredient2allergen = {} # Final true mapping
+    loop do
+      eleminated_allergens = []
+      ingredient2allergenscount.each do |ingredient, counts|
+        if counts.length == 1
+          ingredient2allergen[ingredient] = counts.keys.first
+          eleminated_allergens << counts.keys.first
+        end
+      end
+      ingredient2allergenscount.each do |_ingredient, counts|
+        eleminated_allergens.each do |eleminated_allergen|
+          counts.delete(eleminated_allergen)
+        end
+      end
+      break if eleminated_allergens.empty?
+    end
+
+    canonical_list = ingredient2allergen.to_a.sort_by(&:last).map(&:first).join(',')
+    puts canonical_list

data/data/solutions/github/erikw/2020/22_1.yml

@@ -0,0 +1,24 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/22
+  :solution: |-
+    deck1, deck2 = ARGF.readlines('').map do |part|
+      part.chomp.lines.drop(1).map(&:to_i)
+    end
+
+    until deck1.empty? || deck2.empty?
+      card1 = deck1.shift
+      card2 = deck2.shift
+      if card1 > card2
+        deck1 << card1 << card2
+      else
+        deck2 << card2 << card1
+      end
+    end
+
+    deck_winner = deck1.empty? ? deck2 : deck1
+
+    score = deck_winner.reverse.each_with_index.sum do |card, i|
+      card * (i + 1)
+    end
+    puts score