advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,47 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/15
+  :solution: |-
+    require 'set'
+
+    def fetch_min_unvisited(distance, unvisited)
+      row, col = unvisited.min_by do |row, col|
+        distance[row][col]
+      end
+      unvisited.delete([row, col])
+      [row, col]
+    end
+
+    def update_neighbour(risk, distance, row_cur, col_cur, row_n, col_n)
+      if row_n.between?(0, risk.length - 1) && col_n.between?(0, risk[0].length - 1)
+        dist_contend = distance[row_cur][col_cur] + risk[row_n][col_n]
+        dist_now = distance[row_n][col_n]
+        distance[row_n][col_n] = [dist_contend, dist_now].min
+      end
+    end
+
+    risk = ARGF.each_line.map { |line| line.chomp.chars.map(&:to_i) }
+
+    distance = Array.new(risk.length)
+    unvisited = Set.new
+    (0...risk.length).each do |row|
+      distance[row] = Array.new(risk[0].length)
+      (0...risk[0].length).each do |col|
+        distance[row][col] = Float::INFINITY
+        unvisited << [row, col]
+      end
+    end
+    distance[0][0] = 0
+
+    until unvisited.empty?
+      row, col = fetch_min_unvisited(distance, unvisited)
+
+      break if [row, col] == [risk.length - 1, risk[0].length - 1]
+
+      update_neighbour(risk, distance, row, col, row, col - 1)
+      update_neighbour(risk, distance, row, col, row - 1, col)
+      update_neighbour(risk, distance, row, col, row, col + 1)
+      update_neighbour(risk, distance, row, col, row + 1, col)
+    end
+
+    puts distance[risk.length - 1][risk[0].length - 1]

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

@@ -0,0 +1,72 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/15
+  :solution: |-
+    DEST_MAP_FILE = 'input_full_map'
+    def create_tile(tile1, _nbr)
+      Array.new(tile1.length).tap do |tile|
+        (0...tile1.length).each do |row|
+          tile[row] = Array.new(tile1[0].length)
+          (0...tile1[0].length).each do |col|
+            value = (tile1[row][col] + 1) % 10
+            value = 1 if value == 0
+            tile[row][col] = value
+          end
+        end
+      end
+    end
+
+    def print_map(full_map)
+      full_map.each do |row|
+        row.each do |e|
+          print e
+        end
+        print "\n"
+      end
+    end
+
+    def write_map(full_map, dest_file)
+      File.open(dest_file, 'w') do |file|
+        full_map.each do |row|
+          row.each do |e|
+            file.write e
+          end
+          file.write "\n"
+        end
+      end
+    end
+
+    def insert_tile(full_map, tile, start_row, start_col)
+      (0...tile.length).each do |row|
+        (0..tile[0].length).each do |col|
+          full_map[start_row + row][start_col + col] = tile[row][col]
+        end
+      end
+    end
+
+    tiles = [ARGF.each_line.map { |line| line.chomp.chars.map(&:to_i) }]
+    (1..8).each do |i|
+      tiles << create_tile(tiles[i - 1], i)
+    end
+
+    full_map = Array.new(tiles[0].length * 5)
+    full_map.map! { |_row| Array.new(tiles[0].length * 5) }
+
+    # Tile pattern
+    # 1 2 3 4 5
+    # 2 3 4 5 6
+    # 3 4 5 6 7
+    # 4 5 6 7 8
+    # 5 6 7 8 9
+    (0...5).each do |row|
+      insert_tile(full_map, tiles[row], tiles[0].length * row, tiles[0].length * 0)
+      insert_tile(full_map, tiles[row + 1], tiles[0].length * row, tiles[0].length * 1)
+      insert_tile(full_map, tiles[row + 2], tiles[0].length * row, tiles[0].length * 2)
+      insert_tile(full_map, tiles[row + 3], tiles[0].length * row, tiles[0].length * 3)
+      insert_tile(full_map, tiles[row + 4], tiles[0].length * row, tiles[0].length * 4)
+    end
+
+    # print_map(full_map)
+    write_map(full_map, DEST_MAP_FILE)
+    puts "Wrote: #{DEST_MAP_FILE}"
+    puts 'Feed this to part1.rb to solve part 2 of puzzle.'

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

@@ -0,0 +1,69 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/16
+  :solution: |-
+    def consume_digits(digitstring, length)
+      digitstring.slice!(0, length)
+    end
+
+    def parse_subpacks_by_bits(digits, nobits)
+      start_len = digits.length
+      versions = 0
+      while start_len - digits.length < nobits
+        v = parse(digits)
+        break if v.nil?
+
+        versions += v
+      end
+      versions
+    end
+
+    def parse_subpacks_by_nopacks(digits, nopacks)
+      packs = 0
+      versions = 0
+      while packs < nopacks
+
+        v = parse(digits)
+        break if v.nil?
+
+        versions += v
+        packs += 1
+      end
+      versions
+    end
+
+    def parse_literal_value(digits)
+      literal_str = ''
+      loop do
+        chunk = consume_digits(digits, 5)
+        literal_str += chunk[1, 4]
+        break if chunk[0] == '0' || digits.length < 5
+      end
+      literal_str.to_i(2)
+    end
+
+    def parse(digits)
+      return nil if digits.length < 11
+
+      versions = consume_digits(digits, 3).to_i(2)
+      type_id = consume_digits(digits, 3).to_i(2)
+      case type_id
+      when 4
+        literal_value = parse_literal_value(digits)
+      else
+        length_type_id = consume_digits(digits, 1).to_i(2)
+        if length_type_id == 0
+          length = consume_digits(digits, 15).to_i(2)
+          versions += parse_subpacks_by_bits(digits, length)
+        else
+          length = consume_digits(digits, 11).to_i(2)
+          versions += parse_subpacks_by_nopacks(digits, length)
+        end
+      end
+      versions
+    end
+
+    ARGF.each_line do |line|
+      digits = line.hex.to_s(2)
+      puts parse(digits)
+    end

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

@@ -0,0 +1,83 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/16
+  :solution: |-
+    def consume_digits(digitstring, length)
+      digitstring.slice!(0, length)
+    end
+
+    def parse_subpacks_by_nbr_bits(digits, nbr_bits)
+      start_len = digits.length
+      values = []
+      while start_len - digits.length < nbr_bits
+        value = parse(digits)
+        break if value.nil?
+
+        values << value
+      end
+      values
+    end
+
+    def parse_subpacks_by_nbr_packs(digits, nbr_packs)
+      packs = 0
+      values = []
+      while packs < nbr_packs
+        value = parse(digits)
+        break if value.nil?
+
+        values << value
+        packs += 1
+      end
+      values
+    end
+
+    def parse_literal_value(digits)
+      literal_str = ''
+      loop do
+        chunk = consume_digits(digits, 5)
+        literal_str += chunk[1, 4]
+        break if chunk[0] == '0' || digits.length < 5
+      end
+      literal_str.to_i(2)
+    end
+
+    def parse_subpacks(digits)
+      length_type_id = consume_digits(digits, 1).to_i(2)
+      if length_type_id == 0
+        length = consume_digits(digits, 15).to_i(2)
+        parse_subpacks_by_nbr_bits(digits, length)
+      else
+        length = consume_digits(digits, 11).to_i(2)
+        parse_subpacks_by_nbr_packs(digits, length)
+      end
+    end
+
+    def parse(digits)
+      return nil if digits.length < 11
+
+      _version = consume_digits(digits, 3).to_i(2)
+      type_id = consume_digits(digits, 3).to_i(2)
+      case type_id
+      when 0
+        parse_subpacks(digits).sum
+      when 1
+        parse_subpacks(digits).inject(&:*)
+      when 2
+        parse_subpacks(digits).min
+      when 3
+        parse_subpacks(digits).max
+      when 4
+        parse_literal_value(digits)
+      when 5
+        parse_subpacks(digits).each_cons(2).all? { |a, b| a > b } ? 1 : 0
+      when 6
+        parse_subpacks(digits).each_cons(2).all? { |a, b| a < b } ? 1 : 0
+      when 7
+        parse_subpacks(digits).each_cons(2).all? { |a, b| a == b } ? 1 : 0
+      end
+    end
+
+    ARGF.each_line do |line|
+      digits = line.hex.to_s(2).rjust(4 * (line.length - 1), '0')
+      puts parse(digits)
+    end

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

@@ -0,0 +1,50 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/17
+  :solution: |-
+    x_range, y_range = ARGF.readline.chomp.delete_prefix!('target area: ').gsub!(/.=/, '').split(', ').map do |part|
+      part.split('..').map(&:to_i)
+    end
+
+    # h_max = -Float::INFINITY
+    # (1...x_range[1] + 1).each do |vx|
+    # (0...y_range[0].abs + 1).each do |vy|
+    ## (1..200).each do |t|
+    # t = 0
+    # loop do
+    # t += 1
+    # xd = (0..(t - 1)).map { |i| vx - i }.sum
+    # if vy <= 0
+    # h = 0
+    # yd = (0..(t - 1)).map { |i| vy + i }.sum
+    # else
+    # h = (0..vy).map { |i| vy - i }.sum
+    # yd = h - (1..(t - vy - 1)).sum
+    # end
+    ## puts "NEGATIVE Velocities (#{vx}, #{vy}) leeads to a landing at (#{xd}, #{yd}) in range (#{x_range}, #{y_range}) after time #{t} at max height #{h}"
+    # break if xd < 0 || yd < y_range[0]
+    # next unless xd.between?(*x_range) && yd.between?(*y_range)
+
+    # puts "POSITIVE Velocities (#{vx}, #{vy}) leeads to a landing at (#{xd}, #{yd}) in range after time #{t} at max height #{h}"
+    # if h > h_max
+    # h_max = h
+    # puts "\nNew h_max: #{h_max}"
+    # end
+    # end
+    # end
+    # end
+    # puts h_max
+
+    h_max = -Float::INFINITY
+    (0...y_range[0].abs + 1).each do |t|
+      (1..t).each do |vy|
+        # h = (0..vy).map { |i| i }.sum
+        # yd = h - (1..t).sum
+        h = vy * (vy + 1) / 2
+        yd = h - t * (t + 1) / 2
+        next unless yd.between?(*y_range)
+
+        h_max = [h, h_max].max
+      end
+    end
+    puts h_max

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

@@ -0,0 +1,22 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/17
+  :solution: |-
+    x1, x2, y1, y2 = ARGF.readline.chomp.delete_prefix!('target area: ').gsub!(/.=/, '').split(', ').map do |part|
+      part.split('..').map(&:to_i)
+    end.flatten
+
+    def step_simulate(vx, vy, x1, x2, y1, y2, pos_x = 0, pos_y = 0)
+      return 0 if pos_x > x2 || pos_y < y1
+      return 1 if pos_x >= x1 && pos_y <= y2
+
+      step_simulate(vx > 0 ? vx - 1 : 0, vy - 1, x1, x2, y1, y2, pos_x + vx, pos_y + vy)
+    end
+
+    hits = 0
+    (y1...-y1).each do |vy|
+      (1...(x2 + 1)).each do |vx|
+        hits += step_simulate(vx, vy, x1, x2, y1, y2)
+      end
+    end
+    puts hits

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

@@ -0,0 +1,11 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/18
+  :solution: |-
+    require_relative 'sfnumber'
+
+    lhs = ARGF.readline.to_sfnumber
+    ARGF.each_line.map(&:to_sfnumber).each do |rhs|
+      lhs += rhs
+    end
+    puts lhs.magnitude

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

@@ -0,0 +1,10 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/18
+  :solution: |-
+    require_relative 'sfnumber'
+
+    max = ARGF.each_line.map(&:to_sfnumber).combination(2).map do |nbr1, nbr2|
+      [(nbr1 + nbr2).magnitude, (nbr2 + nbr1).magnitude].max
+    end.max
+    puts max

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

@@ -0,0 +1,146 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/19
+  :solution: |-
+    require 'set'
+
+    scanners = []
+    ARGF.each_line do |line|
+      case line
+      when /-- scanner \d+ ---/
+        scanners << []
+      when /^$/
+
+      else
+        scanners[-1] << line.chomp.split(',').map(&:to_i)
+      end
+    end
+
+    # scanners.combination(2) do |sc1, sc2|
+    # %w[z y x].each do |orient_dim|
+    # (0...4).each do |rot|
+    # [-1, 1].each do |dir|
+    # sc2_oriented = sc2.map do |x, y, z|
+    # case orient_dim
+    # when 'z'
+    # c = Complex(x, y) * Complex('i')**rot
+    # x_o = c.real
+    # y_o = c.imag
+    # z_o = z * dir
+    # when 'y'
+    # c = Complex(x, z) * Complex('i')**rot
+    # x_o = c.real
+    # y_o = y * dir
+    # z_o = c.imag
+    # when 'x'
+    # c = Complex(z, y) * Complex('i')**rot
+    # x_o = x * dir
+    # y_o = c.imag
+    # z_o = c.real
+    # end
+    # [x_o, y_o, z_o]
+    # end
+    ## puts '=' * 20
+    ## (0...sc2.length).each do |i|
+    ## puts "odim: #{orient_dim}, rot: #{rot}, dir: #{dir}, sc2: #{sc2[i]}, sc2_o: #{sc2_oriented[i]}"
+    ## end
+
+    # intersection = sc1.to_set & sc2_oriented.to_set
+    ## next unless intersection.length >= 12
+    # next unless intersection.length >= 1
+
+    # puts '>' * 20
+    # puts "odim: #{orient_dim}, rot: #{rot}, dir: #{dir}:"
+    # pp intersection
+    ## pp intersection if intersection.length >= 12
+    ## pp intersection
+    # end
+    # end
+    # end
+    # end
+
+    # h/t https://www.reddit.com/r/adventofcode/comments/rjpf7f/comment/hp58zmu/?utm_source=share&utm_medium=web2x&context=3
+    def orient(orient_idx, x, y, z)
+      case orient_idx
+      when 0
+        [x,  y, z]
+      when 1
+        [x,  z, -y]
+      when 2
+        [x, -y, -z]
+      when 3
+        [x, -z, y]
+      when 4
+        [y,  x, -z]
+      when 5
+        [y,  z, x]
+      when 6
+        [y, -x, z]
+      when 7
+        [y, -z, -x]
+      when 8
+        [z,  x, y]
+      when 9
+        [z,  y, -x]
+      when 10
+        [z, -x, -y]
+      when 11
+        [z, -y, x]
+      when 12
+        [-x, y, -z]
+      when 13
+        [-x, z, y]
+      when 14
+        [-x, -y, z]
+      when 15
+        [-x, -z, -y]
+      when 16
+        [-y, x, z]
+      when 17
+        [-y, z, -x]
+      when 18
+        [-y, -x, -z]
+      when 19
+        [-y, -z, x]
+      when 20
+        [-z, x, -y]
+      when 21
+        [-z, y, x]
+      when 22
+        [-z, -x, y]
+      when 23
+        [-z, -y, -x]
+      end
+    end
+
+    def merged?(points_merged, points)
+      (0...24).each do |orient_idx|
+        points_oriented = points.map { |p| orient(orient_idx, *p) }
+        distances = points_merged.to_a.product(points_oriented).map do |p1, p2|
+          [p1[0] - p2[0], p1[1] - p2[1], p1[2] - p2[2]]
+        end
+        distances.each do |distance|
+          points_mapped = points_oriented.map { |x, y, z| [x + distance[0], y + distance[1], z + distance[2]] }
+          points_overlapping = points_merged & points_mapped.to_set
+          next unless points_overlapping.size >= 12
+
+          points_merged.merge(points_mapped)
+          return true
+        end
+      end
+      false
+    end
+
+    points_merged = Set.new(scanners.delete_at(0))
+    until scanners.empty?
+      to_delete = []
+      (0...scanners.length).reverse_each do |i|
+        next unless merged?(points_merged, scanners[i])
+
+        to_delete << scanners[i]
+      end
+      to_delete.each do |sc|
+        scanners.delete sc
+      end
+    end
+    puts points_merged.size

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

@@ -0,0 +1,109 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/19
+  :solution: |-
+    require 'set'
+
+    scanners = []
+    ARGF.each_line do |line|
+      case line
+      when /-- scanner \d+ ---/
+        scanners << []
+      when /^$/
+
+      else
+        scanners[-1] << line.chomp.split(',').map(&:to_i)
+      end
+    end
+
+    def orient(orient_idx, x, y, z)
+      case orient_idx
+      when 0
+        [x,  y, z]
+      when 1
+        [x,  z, -y]
+      when 2
+        [x, -y, -z]
+      when 3
+        [x, -z, y]
+      when 4
+        [y,  x, -z]
+      when 5
+        [y,  z, x]
+      when 6
+        [y, -x, z]
+      when 7
+        [y, -z, -x]
+      when 8
+        [z,  x, y]
+      when 9
+        [z,  y, -x]
+      when 10
+        [z, -x, -y]
+      when 11
+        [z, -y, x]
+      when 12
+        [-x, y, -z]
+      when 13
+        [-x, z, y]
+      when 14
+        [-x, -y, z]
+      when 15
+        [-x, -z, -y]
+      when 16
+        [-y, x, z]
+      when 17
+        [-y, z, -x]
+      when 18
+        [-y, -x, -z]
+      when 19
+        [-y, -z, x]
+      when 20
+        [-z, x, -y]
+      when 21
+        [-z, y, x]
+      when 22
+        [-z, -x, y]
+      when 23
+        [-z, -y, -x]
+      end
+    end
+
+    def merge(points_merged, points)
+      (0...24).each do |orient_idx|
+        points_oriented = points.map { |p| orient(orient_idx, *p) }
+        distances = points_merged.to_a.product(points_oriented).map do |p1, p2|
+          [p1[0] - p2[0], p1[1] - p2[1], p1[2] - p2[2]]
+        end
+        distances.each do |distance|
+          points_mapped = points_oriented.map { |x, y, z| [x + distance[0], y + distance[1], z + distance[2]] }
+          points_overlapping = points_merged & points_mapped.to_set
+          next unless points_overlapping.size >= 12
+
+          points_merged.merge(points_mapped)
+          return true, distance
+        end
+      end
+      false
+    end
+
+    points_merged = Set.new(scanners.delete_at(0))
+    distances = []
+    until scanners.empty?
+      to_delete = []
+      (0...scanners.length).reverse_each do |i|
+        merged, distance = merge(points_merged, scanners[i])
+        if merged
+          distances << distance
+          to_delete << scanners[i]
+        end
+      end
+      to_delete.each do |sc|
+        scanners.delete sc
+      end
+    end
+
+    max_dist = distances.combination(2).map do |p1, p2|
+      p1.zip(p2).flat_map { |a, b| (a - b).abs }.sum
+    end.max
+    puts max_dist

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

@@ -0,0 +1,52 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/20
+  :solution: |-
+    ALG_ITR = 2
+
+    def read_pixel(image_in, algorithm, itr, row, col)
+      if row.between?(0, image_in.length - 1) && col.between?(0, image_in[0].length - 1)
+        image_in[row][col]
+      elsif algorithm[0] == '.'
+        '.'
+      else
+        itr.even? ? '.' : '#'
+      end
+    end
+
+    def determine_value(image_in, algorithm, itr, row, col)
+      pixels = []
+      [-1, 0, 1].each do |drow|
+        [-1, 0, 1].each do |dcol|
+          pixels << read_pixel(image_in, algorithm, itr, row + drow - 1, col + dcol - 1)
+        end
+      end
+      alg_idx = pixels.map { |c| c == '.' ? 0 : 1 }.join('').to_i(2)
+      algorithm[alg_idx]
+    end
+
+    def print_image(image)
+      image.each do |row|
+        puts row.join('')
+      end
+    end
+
+    algorithm = ARGF.readline
+    ARGF.readline
+    image_in = ARGF.readlines.map(&:chomp).map(&:chars)
+
+    image_out = nil
+    ALG_ITR.times do |itr|
+      image_out = Array.new(image_in.length + 2)
+      (0...image_out.length).each do |row|
+        image_out[row] = Array.new(image_in[0].length + 2)
+        (0...image_out[row].length).each do |col|
+          image_out[row][col] = determine_value(image_in, algorithm, itr, row, col)
+        end
+      end
+      image_in = image_out
+    end
+
+    print_image(image_out)
+
+    puts image_out.map { |line| line.count('#') }.sum