advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,44 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/22
+  :solution: |-
+    # NO_CARDS = 10
+    NO_CARDS = 10_007
+
+    SEARCH_CARD = 2019
+
+    def deal(deck)
+      deck.reverse!
+    end
+
+    def cut(deck, cut)
+      deck.rotate!(cut)
+    end
+
+    def deal_increment(deck, increment)
+      new = Array.new(deck.length)
+      i = 0
+      j = 0
+      deck.length.times do
+        new[i % deck.length] = deck[j]
+        i += increment
+        j += 1
+      end
+      deck.replace(new)
+    end
+
+    deck = (0...NO_CARDS).to_a
+    ARGF.each_line do |line|
+      case line.chomp
+      when /deal into new stack/
+        deal(deck)
+      when /cut (-?\d+)/
+        cut = Regexp.last_match(1).to_i
+        cut(deck, cut)
+      when /deal with increment (\d+)/
+        inc = Regexp.last_match(1).to_i
+        deal_increment(deck, inc)
+      end
+    end
+
+    puts deck.index(SEARCH_CARD)

data/data/solutions/github/erikw/2019/22_2.yml

@@ -0,0 +1,64 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/22
+  :solution: |-
+    # h/t https://www.reddit.com/r/adventofcode/comments/ee0rqi/comment/fbnifwk/
+
+    NO_CARDS = 119_315_717_514_047
+    NO_SHUFFLES = 101_741_582_076_661
+    SEARCH_CARD = 2020
+
+    def undeal(deck_size, pos)
+      deck_size - 1 - pos
+    end
+
+    def uncut(deck_size, pos, cut)
+      (pos + cut + deck_size) % deck_size
+    end
+
+    def egcd(a, b)
+      return [b, 0, 1] if a == 0
+
+      g, y, x = egcd(b % a, a)
+      [g, x - (b / a) * y, y]
+    end
+
+    # Ref: https://stackoverflow.com/a/9758173/265508
+    def modinv(a, m)
+      g, x, y = egcd(a, m)
+      raise 'modular inverse does not exist' unless g == 1
+
+      x % m
+    end
+
+    def undeal_increment(deck_size, pos, increment)
+      modinv(increment, deck_size) * pos % deck_size
+    end
+
+    def backtrack_pos(shuffles, search_card)
+      pos = search_card
+      shuffles.reverse_each do |line|
+        case line
+        when /deal into new stack/
+          pos = undeal(NO_CARDS, pos)
+        when /cut (-?\d+)/
+          cut = Regexp.last_match(1).to_i
+          pos = uncut(NO_CARDS, pos, cut)
+        when /deal with increment (\d+)/
+          inc = Regexp.last_match(1).to_i
+          pos = undeal_increment(NO_CARDS, pos, inc)
+        end
+      end
+      pos
+    end
+
+    shuffles = ARGF.each_line.map(&:chomp)
+
+    x = SEARCH_CARD
+    y = backtrack_pos(shuffles, x)
+    z = backtrack_pos(shuffles, y)
+    a = (y - z) * modinv(x - y + NO_CARDS, NO_CARDS) % NO_CARDS
+    b = (y - a * x) % NO_CARDS
+
+    pos = (a.pow(NO_SHUFFLES, NO_CARDS) * x + (a.pow(NO_SHUFFLES, NO_CARDS) - 1) * modinv(a - 1, NO_CARDS) * b) % NO_CARDS
+    puts pos

data/data/solutions/github/erikw/2019/23_1.yml

@@ -0,0 +1,37 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/23
+  :solution: |-
+    require '../09/computer_iter'
+
+    COMPUTERS = 50
+    ADDR_SEARCH = 255
+    EMPTY_RECV = -1
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computers = COMPUTERS.times.map do |i|
+      Computer.new(intcode).tap do |computer|
+        computer.stdin << i
+        computer.execute
+      end
+    end
+
+    loop do
+      computers.each.with_index do |computer, _i|
+        case computer.execute
+        when Computer::STATUS_OUTPUT
+          computer.execute
+          computer.execute
+          addr_dest, x, y = 3.times.map { computer.stdout.pop }
+          if addr_dest == ADDR_SEARCH
+            puts y
+            exit
+          end
+          computers[addr_dest].stdin << x
+          computers[addr_dest].stdin << y
+
+        when Computer::STATUS_INPUT_NEEDED
+          computer.stdin << EMPTY_RECV
+        end
+      end
+    end

data/data/solutions/github/erikw/2019/23_2.yml

@@ -0,0 +1,54 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/23
+  :solution: |-
+    require '../09/computer_iter'
+
+    COMPUTERS = 50
+    ADDR_NAT = 255
+    ADDR_WAKEUP = 0
+    EMPTY_RECV = -1
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computers = COMPUTERS.times.map do |i|
+      Computer.new(intcode).tap do |computer|
+        computer.stdin << i
+        computer.execute
+      end
+    end
+
+    nat_last = nil
+    wakeup_y_last = nil
+    loop do
+      idle = true
+      computers.each.with_index do |computer, _i|
+        case computer.execute
+        when Computer::STATUS_OUTPUT
+          idle = false
+          computer.execute
+          computer.execute
+          addr_dest, x, y = 3.times.map { computer.stdout.pop }
+
+          if addr_dest == ADDR_NAT
+            nat_last = [x, y]
+          else
+            computers[addr_dest].stdin << x
+            computers[addr_dest].stdin << y
+          end
+        when Computer::STATUS_INPUT_NEEDED
+          computer.stdin << EMPTY_RECV
+        end
+      end
+
+      next unless idle && !nat_last.nil?
+
+      computers[ADDR_WAKEUP].stdin << nat_last[0]
+      computers[ADDR_WAKEUP].stdin << nat_last[1]
+
+      if nat_last[1] == wakeup_y_last
+        puts nat_last[1]
+        exit
+      else
+        wakeup_y_last = nat_last[1]
+      end
+    end

data/data/solutions/github/erikw/2019/24_1.yml

@@ -0,0 +1,65 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/24
+  :solution: |-
+    require 'set'
+
+    SYM_BUG = '#'
+    SYM_EMPTY = '.'
+
+    DIM = 5
+    CORD_DELTA_NEIGHBOURS = [[-1, 0], [0, 1], [1, 0], [0, -1]]
+
+    def update_neighbours(tiles, neighbours)
+      tiles.length.times do |row|
+        tiles[0].length.times do |col|
+          neighbours[row][col] = 0
+          CORD_DELTA_NEIGHBOURS.each do |dr, dc|
+            rown = row + dr
+            coln = col + dc
+            next unless rown.between?(0, tiles.length - 1) && coln.between?(0, tiles[0].length - 1)
+
+            neighbours[row][col] += 1 if tiles[rown][coln] == SYM_BUG
+          end
+        end
+      end
+    end
+
+    def tick(tiles, neighbours)
+      tiles.length.times do |row|
+        tiles[0].length.times do |col|
+          if tiles[row][col] == SYM_BUG && neighbours[row][col] != 1
+            tiles[row][col] = SYM_EMPTY
+          elsif tiles[row][col] == SYM_EMPTY && [1, 2].include?(neighbours[row][col])
+            tiles[row][col] = SYM_BUG
+          end
+        end
+      end
+    end
+
+    def biodiversity(tiles)
+      tiles.flatten.each_with_index.sum do |t, i|
+        t == SYM_BUG ? 2**i : 0
+      end
+    end
+
+    def print_tiles(tiles)
+      tiles.each do |row|
+        puts row.join
+      end
+    end
+
+    tiles = ARGF.each_line.map { |line| line.chomp.chars }
+    neighbours = Array.new(DIM) { Array.new(DIM) }
+    seen = Set.new
+
+    loop do
+      update_neighbours(tiles, neighbours)
+      tick(tiles, neighbours)
+      biodiv = biodiversity(tiles)
+      if seen.include?(biodiv)
+        puts biodiv
+        exit
+      end
+      seen << biodiv
+    end

data/data/solutions/github/erikw/2019/24_2.yml

@@ -0,0 +1,150 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/24
+  :solution: |-
+    # Algorithm:
+    # * Instead of storing a grid like in part1, store sparse matrix of current bugs as a array of [layer, x, y]
+    #   * Specifically it becomes more efficient to store as Hash[layer] -> Set[[x,y]]
+    # * For each tick:
+    #   * create a copy of current state
+    #   * check each stored bug, if they will die from not having exactly 1 neighbour (in new state version, using logic to go to inner/outer layer on borders)
+    #   * check each stored bug, in a circle around it the empty spaces, if they have one additional bug neighbour => space becomes bug (in new state version, also with inner/outer layer logic)
+
+    require 'set'
+
+    SYM_BUG = '#'
+    SYM_EMPTY = '.'
+    SYM_MIDDLE = '?'
+
+    DIM = 5
+    NEIGHBOUR_DELTAS = {
+      north: [-1, 0],
+      west: [0, -1],
+      east: [0, 1],
+      south: [1, 0]
+    }
+
+    # MINUTES = 10
+    MINUTES = 200
+
+    def neighbour_coordinates(layer, row, col)
+      neighbours = Hash.new { |h, k| h[k] = Set.new } # layer -> Set[x, y]
+      NEIGHBOUR_DELTAS.values.each do |dr, dc|
+        rown = row + dr
+        coln = col + dc
+        layern = layer
+        middle = (DIM / 2)
+        if [rown, coln] == [middle, middle] # To inner layer
+          layern += 1
+          case [dr, dc]
+          when NEIGHBOUR_DELTAS[:north] # cell 18 moving up
+            (0...DIM).each do |coln|
+              neighbours[layern] << [DIM - 1, coln]
+            end
+          when NEIGHBOUR_DELTAS[:east] # cell 12 moving right
+            (0...DIM).each do |rown|
+              neighbours[layern] << [rown, 0]
+            end
+          when NEIGHBOUR_DELTAS[:south] # cell 8 moving down
+            (0...DIM).each do |coln|
+              neighbours[layern] << [0, coln]
+            end
+          when NEIGHBOUR_DELTAS[:west] # cell 14 moving left
+            (0...DIM).each do |rown|
+              neighbours[layern] << [rown, DIM - 1]
+            end
+          end
+        else
+          # Handle outer layer
+          if rown == -1
+            layern -= 1
+            rown = 1
+            coln = 2
+          elsif rown == DIM
+            layern -= 1
+            rown = 3
+            coln = 2
+          elsif coln == -1
+            layern -= 1
+            rown = 2
+            coln = 1
+          elsif coln == DIM
+            layern -= 1
+            rown = 2
+            coln = 3
+          end
+          neighbours[layern] << [rown, coln]
+        end
+      end
+      neighbours
+    end
+
+    def neighbours(bugs, layer, row, col)
+      neighbours = [] # [layer, row, col]
+      neighbour_coordinates(layer, row, col).each do |layern, neighbour_coords|
+        neighbour_coords.count do |neighbour|
+          neighbours << [layern, *neighbour] if bugs[layern].include?(neighbour)
+        end
+      end
+      neighbours
+    end
+
+    def tick(bugs)
+      # Can't Marshal dump hash with default proc.
+      defproc = bugs.default_proc
+      bugs.default = nil
+      bugs_prev = Marshal.load(Marshal.dump(bugs))
+      bugs.default_proc = defproc
+      bugs_prev.default_proc = defproc
+
+      bugs_prev.keys.each do |layer|
+        bugs_prev[layer].each do |row, col|
+          # Condition for bugs
+          bugs[layer].delete([row, col]) unless neighbours(bugs_prev, layer, row, col).length == 1
+
+          # Condition for empty
+          neighbour_coordinates(layer, row, col).sum do |layern, neighbour_coords|
+            neighbour_coords.count do |neighbour|
+              next if bugs_prev[layern].include?(neighbour) # Not empty tile
+
+              emptys_neighbours = neighbours(bugs_prev, layern, *neighbour)
+              bugs[layern] << neighbour if [1, 2].include?(emptys_neighbours.length)
+            end
+          end
+        end
+        bugs.delete(layer) if bugs[layer].empty?
+      end
+    end
+
+    def print_tiles(bugs)
+      middle = (DIM / 2)
+      bugs.keys.sort.each do |layer|
+        next if bugs[layer].empty? # Weird bug
+
+        puts "Depth #{layer}:"
+        DIM.times do |row|
+          DIM.times do |col|
+            if [row, col] == [middle, middle]
+              print SYM_MIDDLE
+            else
+              print bugs[layer].include?([row, col]) ? SYM_BUG : SYM_EMPTY
+            end
+          end
+          puts
+        end
+      end
+    end
+
+    bugs = Hash.new { |h, k| h[k] = Set.new } # layer -> Set[x, y]
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |char, col|
+        bugs[0] << [row, col] if char == SYM_BUG
+      end
+    end
+
+    MINUTES.times do |_i|
+      tick(bugs)
+      # puts "===== After minute #{i + 1} ====="
+      # print_tiles(bugs, i)
+    end
+    puts bugs.values.map(&:to_a).flatten(1).size

data/data/solutions/github/erikw/2019/25_1.yml

@@ -0,0 +1,73 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2019/25
+  :solution: |-
+    # The scripted version after manually finding the answer with part1_interactive.rb.
+    # Need: sand, astronaut ice cream, boule, mutex
+
+    require '../09/computer_iter'
+
+    COMMANDS = [
+      'north',
+      'west',
+      'take sand',
+      'east',
+      'south',
+      'east',
+      'east',
+      'north',
+      'east',
+      'east',
+      'take astronaut ice cream',
+      'west',
+      'west',
+      'south',
+      'west',
+      'west',
+      'south',
+      'south',
+      'take mutex',
+      'south',
+      'take boulder',
+      'east',
+      'south',
+      'east'
+    ]
+
+    def read(computer)
+      line = []
+      lines = []
+      until computer.stdout.empty?
+        line << computer.stdout.pop
+        next unless line.last == "\n".ord
+
+        lines << line.map(&:chr).join
+      end
+      lines.join("\n")
+    end
+
+    def answer(computer, answer)
+      answer += "\n"
+      answer.each_char.map(&:ord).each do |char|
+        computer.stdin << char
+      end
+    end
+
+    def run(computer)
+      next until [Computer::STATUS_INPUT_NEEDED, Computer::STATUS_DONE].include? computer.execute
+    end
+
+    intcode = ARGF.readline.split(',').map(&:to_i)
+    computer = Computer.new(intcode)
+
+    run(computer)
+    read(computer)
+    output = nil
+    COMMANDS.each do |command|
+      answer(computer, command)
+      run(computer)
+      output = read(computer)
+    end
+
+    password = output.scan(/\d+/)
+    puts password

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

@@ -0,0 +1,17 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/01
+  :solution: |-
+    require 'set'
+
+    SUM = 2020
+
+    expenses = ARGF.each_line.map(&:to_i).to_set
+
+    expenses.each do |expense|
+      complement = SUM - expense
+      if expenses.include?(complement)
+        puts expense * complement
+        exit
+      end
+    end

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

@@ -0,0 +1,17 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/01
+  :solution: |-
+    require 'set'
+
+    SUM = 2020
+
+    expenses = ARGF.each_line.map(&:to_i).to_set
+
+    expenses.to_a.combination(2) do |exp1, exp2|
+      exp3 = SUM - exp1 - exp2
+      if expenses.include?(exp3)
+        puts exp1 * exp2 * exp3
+        exit
+      end
+    end

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

@@ -0,0 +1,12 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/02
+  :solution: |-
+    INPUT_PATTERN = /(?<lo>\d+)-(?<hi>\d+) (?<char>\w)/
+
+    valid = ARGF.each_line.count do |line|
+      rule, password = line.chomp.split(': ')
+      m = INPUT_PATTERN.match(rule)
+      password.count(m[:char]).between?(m[:lo].to_i, m[:hi].to_i)
+    end
+    puts valid

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

@@ -0,0 +1,14 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/02
+  :solution: |-
+    INPUT_PATTERN = /(?<lo>\d+)-(?<hi>\d+) (?<char>\w)/
+
+    valid = ARGF.each_line.count do |line|
+      rule, password = line.chomp.split(': ')
+      m = INPUT_PATTERN.match(rule)
+      present1 = password[m[:lo].to_i - 1] == m[:char]
+      present2 = password[m[:hi].to_i - 1] == m[:char]
+      present1 ^ present2
+    end
+    puts valid

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

@@ -0,0 +1,10 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/03
+  :solution: |-
+    require_relative 'lib'
+
+    SLOPE = 1 + 3i
+
+    map = read_input
+    puts trees_hit(map, SLOPE)

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

@@ -0,0 +1,18 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/03
+  :solution: |-
+    require_relative 'lib'
+
+    SLOPES = [
+
+      1 + 1i,
+      1 + 3i,
+      1 + 5i,
+      1 + 7i,
+      2 + 1i
+    ]
+
+    map = read_input
+    hits_product = SLOPES.map { |s| trees_hit(map, s) }.inject(&:*)
+    puts hits_product

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

@@ -0,0 +1,24 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/04
+  :solution: |-
+    require 'set'
+
+    REQUIRED_ATTRS = Set['byr', 'iyr', 'eyr', 'hgt', 'hcl', 'ecl', 'pid']
+
+    lines = ARGF.readlines.map(&:chomp)
+    valid = 0
+    passport = []
+
+    lines.each_with_index do |line, lineno|
+      if line.empty? || lineno == (lines.length - 1)
+        attributes = passport.join(' ').split(' ')
+        present = attributes.map { |a| a.split(':') }.map(&:first).to_set
+        valid += 1 if present >= REQUIRED_ATTRS
+        passport.clear
+      else
+        passport << line
+      end
+    end
+
+    puts valid

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

@@ -0,0 +1,59 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/04
+  :solution: |-
+    require 'set'
+
+    REQUIRED_ATTRS = Set['byr', 'iyr', 'eyr', 'hgt', 'hcl', 'ecl', 'pid']
+
+    def attribute_valid?(field, value)
+      case field
+      when 'byr'
+        value.length == 4 && value.to_i.between?(1920, 2002)
+      when 'iyr'
+        value.length == 4 && value.to_i.between?(2010, 2020)
+      when 'eyr'
+        value.length == 4 && value.to_i.between?(2020, 2030)
+      when 'hgt'
+        if /^\d+cm$/ =~ value
+          value.to_i.between?(150, 193)
+        elsif /^\d+in$/ =~ value
+          value.to_i.between?(59, 76)
+        else
+          false
+        end
+      when 'hcl'
+        /^#[0-9a-f]{6}$/ =~ value
+      when 'ecl'
+        %w[amb blu brn gry grn hzl oth].include?(value)
+      when 'pid'
+        /^\d{9}$/ =~ value
+      when 'cid'
+        true
+      else
+        false
+      end
+    end
+
+    def passport_valid?(passport_str)
+      attributes = passport_str.split(' ').map { |a| a.split(':') }
+      present = attributes.map(&:first).to_set
+      present >= REQUIRED_ATTRS && attributes.all? { |a| attribute_valid?(*a) }
+    end
+
+    lines = ARGF.readlines.map(&:chomp)
+    valid = 0
+    passport = []
+
+    lines.each_with_index do |line, lineno|
+      if line.empty? || lineno == (lines.length - 1)
+        passport << line if lineno == (lines.length - 1)
+
+        valid += 1 if passport_valid?(passport.join(' '))
+        passport.clear
+      else
+        passport << line
+      end
+    end
+
+    puts valid

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

@@ -0,0 +1,7 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/05
+  :solution: |-
+    require_relative 'lib'
+
+    puts ARGF.each_line.map { |l| seat_id(*calc_row_col(l.chomp)) }.max