advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,20 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/05
+  :solution: |-
+    require 'set'
+    require_relative 'lib'
+
+    ROWS_MISSING_FRONT = 5
+    ROWS_MISSING_BACK = 6
+
+    act_seats = ARGF.each_line.map { |l| calc_row_col(l.chomp) }
+    exp_seats = []
+    (ROWS_MISSING_FRONT...(ROWS - ROWS_MISSING_BACK)).each do |row|
+      (0...COLS).each do |col|
+        exp_seats << [row, col]
+      end
+    end
+
+    my_seat = (Set.new(exp_seats) - Set.new(act_seats)).to_a.first
+    puts seat_id(*my_seat)

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

@@ -0,0 +1,22 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/06
+  :solution: |-
+    require 'set'
+
+    answers = ARGF.each_line.map(&:chomp)
+
+    group = Set.new
+    total = 0
+    answers.each_with_index do |answer, i|
+      last = i == (answers.length - 1)
+      if answer.empty? || last
+        group += Set.new(answer.chars) if last
+        total += group.count
+        group.clear
+      else
+        group += Set.new(answer.chars)
+      end
+    end
+
+    puts total

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

@@ -0,0 +1,20 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/06
+  :solution: |-
+    require 'set'
+
+    group = nil
+    total = 0
+    ARGF.each_line.map(&:chomp).each do |answer|
+      if answer.empty?
+        total += group.count
+        group = nil
+      else
+        chars = Set.new(answer.chars)
+        group = group.nil? ? chars : group & chars
+      end
+    end
+    total += group.count
+
+    puts total

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

@@ -0,0 +1,36 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/07
+  :solution: |-
+    require 'set'
+
+    MY_BAG = 'shiny gold'
+
+    def component(dag, start)
+      discovered = Set[start]
+      queue = Thread::Queue.new([start])
+      until queue.empty?
+        node = queue.pop
+        dag[node].each do |child|
+          queue << child unless discovered.include?(child)
+          discovered << child
+        end
+      end
+      discovered
+    end
+
+    # contain = Hash.new { |h, k| h[k] = [] }
+    container = Hash.new { |h, k| h[k] = [] }
+    ARGF.each_line do |line|
+      container_bag, bags_contained = line.chomp.split(' bags contain ')
+      next if bags_contained == 'no other bags.'
+
+      bags_contained.split(', ') do |bag_contained|
+        match = bag_contained.match(/\d+ (\w+ \w+) bags?\.?/)
+        # contain[container_bag] << match[1]
+        container[match[1]] << container_bag
+      end
+    end
+
+    nbr_container = component(container, MY_BAG).size - 1
+    puts nbr_container

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

@@ -0,0 +1,29 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/07
+  :solution: |-
+    require 'set'
+
+    MY_BAG = 'shiny gold'
+
+    def sub_bags(contain, current_bag)
+      bags = 0
+      contain[current_bag].each do |amount, bag|
+        bags += amount
+        bags += amount * sub_bags(contain, bag)
+      end
+      bags
+    end
+
+    contain = Hash.new { |h, k| h[k] = [] }
+    ARGF.each_line do |line|
+      container_bag, bags_contained = line.chomp.split(' bags contain ')
+      next if bags_contained == 'no other bags.'
+
+      bags_contained.split(', ') do |bag_contained|
+        m = bag_contained.match(/(?<nbr>\d+) (?<bag>\w+ \w+) bags?\.?/)
+        contain[container_bag] << [m['nbr'].to_i, m['bag']]
+      end
+    end
+
+    puts sub_bags(contain, MY_BAG)

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

@@ -0,0 +1,10 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/08
+  :solution: |-
+    require_relative 'computer_iter'
+
+    program = ARGF.readlines.map { |l| l.chomp.split }
+    computer = Computer.new
+    computer.execute(program)
+    puts computer.memory[:acc]

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

@@ -0,0 +1,23 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/08
+  :solution: |-
+    require_relative 'computer_iter'
+
+    program = ARGF.readlines.map { |l| l.chomp.split }
+    computer = Computer.new
+
+    instr_old = nil
+    program.length.times do |i|
+      next if program[i][0] == 'acc'
+
+      program[i][0], instr_old = program[i][0] == 'jmp' ? %w[nop jmp] : %w[jmp nop]
+      status = computer.execute(program)
+
+      if status == Computer::STATUS_DONE
+        puts computer.memory[:acc]
+        break
+      end
+
+      program[i][0] = instr_old
+    end

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

@@ -0,0 +1,8 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/09
+  :solution: |-
+    require_relative 'lib'
+
+    numbers = ARGF.each_line.map(&:to_i)
+    puts first_invalid(numbers)

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

@@ -0,0 +1,27 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/09
+  :solution: |-
+    require_relative 'lib'
+
+    numbers = ARGF.each_line.map(&:to_i)
+    num_invalid = first_invalid(numbers)
+
+    # BF
+    (0...numbers.length).each do |i|
+      sum = 0
+      min = Float::INFINITY
+      max = 0
+      (i...numbers.length).each do |j|
+        min = [min, numbers[j]].min
+        max = [max, numbers[j]].max
+        sum += numbers[j]
+
+        if j > i && sum == num_invalid
+          puts min + max
+          exit
+        elsif sum > num_invalid
+          break
+        end
+      end
+    end

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

@@ -0,0 +1,19 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/10
+  :solution: |-
+    def jolt_differencdes(chain)
+      diffs = Hash.new(0)
+      diffs[chain.first] += 1
+      diffs[3] += 1
+      (1...chain.length).each do |i|
+        diff = chain[i] - chain[i - 1]
+        diffs[diff] += 1
+      end
+      diffs
+    end
+
+    adapters = ARGF.each_line.map(&:to_i).sort
+
+    diffs = jolt_differencdes(adapters)
+    puts diffs[1] * diffs[3]

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

@@ -0,0 +1,21 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/10
+  :solution: |-
+    adapters = ARGF.each_line.map(&:to_i).sort
+    adapters.unshift(0)
+    adapters << adapters.last + 3
+
+    # dp[i] is the number of ways a chain can be constructed ending on adapter[i].
+    dp = Array.new(adapters.length, 0)
+    dp[0] = 1
+
+    (1...dp.length).each do |i|
+      j = i - 1
+      # Sum up different possibilities (the adapter[j]s) to end the chain at adapter[i].
+      while j >= 0 && (adapters[i] - adapters[j]) <= 3
+        dp[i] += dp[j]
+        j -= 1
+      end
+    end
+    puts dp.last

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

@@ -0,0 +1,69 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/11
+  :solution: |-
+    SYM_FLOOR = '.'
+    SYM_EMPTY = 'L'
+    SYM_OCCUPIED = '#'
+
+    ADJ = [-1, 0, 1]
+
+    def print_grid(seats)
+      rmin, rmax = seats.keys.map(&:real).minmax
+      cmin, cmax = seats.keys.map(&:imag).minmax
+      (rmin..rmax).each do |row|
+        (cmin..cmax).each do |col|
+          pos = Complex(row, col)
+          print seats[pos]
+        end
+        puts
+      end
+    end
+
+    def adjacent_occupied(seats, pos)
+      occupied = 0
+      ADJ.each do |dr|
+        ADJ.each do |dc|
+          next if dr == 0 && dc == 0
+
+          pos_adj = Complex(pos.real + dr, pos.imag + dc)
+          occupied += 1 if seats[pos_adj] == SYM_OCCUPIED
+        end
+      end
+      occupied
+    end
+
+    seats = Hash.new(SYM_FLOOR) # Complex -> floor tile
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |c, col|
+        pos = Complex(row, col)
+        seats[pos] = c
+      end
+    end
+
+    # print_grid(seats)
+
+    rmin, rmax = seats.keys.map(&:real).minmax
+    cmin, cmax = seats.keys.map(&:imag).minmax
+    loop do
+      seats_next = seats.dup
+      (rmin..rmax).each do |row|
+        (cmin..cmax).each do |col|
+          pos = Complex(row, col)
+          next if seats[pos] == SYM_FLOOR
+
+          pos = Complex(row, col)
+          adj_occupant = adjacent_occupied(seats, pos)
+          if seats[pos] == SYM_EMPTY && adj_occupant == 0
+            seats_next[pos] = SYM_OCCUPIED
+          elsif seats[pos] == SYM_OCCUPIED && adj_occupant >= 4
+            seats_next[pos] = SYM_EMPTY
+          end
+        end
+      end
+      break if seats == seats_next
+
+      seats = seats_next
+    end
+
+    puts seats.values.count { |s| s == SYM_OCCUPIED }

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

@@ -0,0 +1,74 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/11
+  :solution: |-
+    SYM_FLOOR = '.'
+    SYM_EMPTY = 'L'
+    SYM_OCCUPIED = '#'
+
+    ADJ_DELTA = [
+      0 - 1i,
+      -1 - 1i,
+      -1 + 0i,
+      -1 + 1i,
+      0 + 1i,
+      1 + 1i,
+      1 + 0i,
+      1 - 1i
+    ]
+
+    def print_grid(seats)
+      rmin, rmax = seats.keys.map(&:real).minmax
+      cmin, cmax = seats.keys.map(&:imag).minmax
+      (rmin..rmax).each do |row|
+        (cmin..cmax).each do |col|
+          pos = Complex(row, col)
+          print seats[pos]
+        end
+        puts
+      end
+    end
+
+    def adjacent_occupied(seats, pos)
+      ADJ_DELTA.count do |delta|
+        pos_adj = pos + delta
+        pos_adj += delta while seats.has_key?(pos_adj) && seats[pos_adj] == SYM_FLOOR
+        seats[pos_adj] == SYM_OCCUPIED
+      end
+    end
+
+    seats = Hash.new(SYM_FLOOR) # Complex -> floor tile
+    ARGF.each_line.with_index do |line, row|
+      line.chomp.each_char.with_index do |c, col|
+        pos = Complex(row, col)
+        seats[pos] = c
+      end
+    end
+
+    # print_grid(seats)
+
+    rmin, rmax = seats.keys.map(&:real).minmax
+    cmin, cmax = seats.keys.map(&:imag).minmax
+    loop do
+      seats_next = seats.dup
+      (rmin..rmax).each do |row|
+        (cmin..cmax).each do |col|
+          pos = Complex(row, col)
+          next if seats[pos] == SYM_FLOOR
+
+          pos = Complex(row, col)
+          adj_occupant = adjacent_occupied(seats, pos)
+          if seats[pos] == SYM_EMPTY && adj_occupant == 0
+            seats_next[pos] = SYM_OCCUPIED
+          elsif seats[pos] == SYM_OCCUPIED && adj_occupant >= 5
+            seats_next[pos] = SYM_EMPTY
+          end
+        end
+      end
+      # print_grid(seats_next)
+      break if seats == seats_next
+
+      seats = seats_next
+    end
+
+    puts seats.values.count { |s| s == SYM_OCCUPIED }

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

@@ -0,0 +1,31 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/12
+  :solution: |-
+    IPATTERN = /(\w)(\d+)/
+
+    pos = 0 + 0i
+    dir = 0 + 1i
+    ARGF.each_line.map { |l| l.match(IPATTERN)[1..] }.each do |action, value|
+      value = value.to_i
+      case action
+      when 'N'
+        pos += Complex(-value, 0)
+      when 'E'
+        pos += Complex(0, value)
+      when 'S'
+        pos += Complex(value, 0)
+      when 'W'
+        pos += Complex(0, -value)
+      when 'L'
+        turns = value / 90
+        dir *= Complex(0, 1)**turns
+      when 'R'
+        turns = value / 90
+        dir *= Complex(0, -1)**turns
+      when 'F'
+        pos += value * dir
+      end
+    end
+
+    puts pos.real.abs + pos.imag.abs

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

@@ -0,0 +1,31 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/12
+  :solution: |-
+    IPATTERN = /(\w)(\d+)/
+
+    pos = 0 + 0i
+    waypoint = -1 + 10i
+    ARGF.each_line.map { |l| l.match(IPATTERN)[1..] }.each do |action, value|
+      value = value.to_i
+      case action
+      when 'N'
+        waypoint += Complex(-value, 0)
+      when 'E'
+        waypoint += Complex(0, value)
+      when 'S'
+        waypoint += Complex(value, 0)
+      when 'W'
+        waypoint += Complex(0, -value)
+      when 'L'
+        turns = value / 90
+        waypoint *= Complex(0, 1)**turns
+      when 'R'
+        turns = value / 90
+        waypoint *= Complex(0, -1)**turns
+      when 'F'
+        pos += value * waypoint
+      end
+    end
+
+    puts pos.real.abs + pos.imag.abs

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

@@ -0,0 +1,14 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/13
+  :solution: |-
+    time_arrival = ARGF.readline.to_i
+    bus_ids = ARGF.readline.chomp.split(',').reject { |c| c == 'x' }.map(&:to_i)
+
+    best_bus, time_departure = bus_ids.map do |bus_id|
+      x = (time_arrival / bus_id.to_f).ceil
+      [bus_id, bus_id * x]
+    end.min_by(&:last)
+
+    time_wait = time_departure - time_arrival
+    puts best_bus * time_wait

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

@@ -0,0 +1,50 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/13
+  :solution: |-
+    # h/t https://www.reddit.com/r/adventofcode/comments/kc4njx/comment/gfnbwzc/?utm_source=share&utm_medium=web2x&context=3
+
+    def ext_gcd(a, b, values)
+      d = a
+
+      if b.zero?
+        values[:x] = 1
+        values[:y] = 0
+      else
+        d = ext_gcd(b, a % b, values)
+
+        x = values[:x]
+        y = values[:y]
+        values[:x] = y
+        values[:y] = x - (a / b) * y
+      end
+
+      d
+    end
+
+    # Implementation stolen from https://linuxtut.com/en/f652d4941298a9842dfc/
+    def chineese_reminder(b, m)
+      r = 0
+      mM = 1
+      b.zip(m) do |bi, mi|
+        val = {}
+        d = ext_gcd(mM, mi, val)
+        p = val[:x]
+        q = val[:y]
+        return [0, -1] if (bi - r) % d != 0
+
+        tmp = (bi - r) / d * p % (mi / d)
+        r += mM * tmp
+        mM *= mi / d
+      end
+
+      [r % mM, mM]
+    end
+
+    _time_arrival = ARGF.readline.to_i
+    busses = ARGF.readline.chomp.split(',').map(&:to_i).each_with_index.reject { |t, _i| t == 0 } # [bus_id, index]
+
+    mods = busses.map(&:first)
+    remainders = busses.map { |b, i| (-i) % b }
+
+    puts chineese_reminder(remainders, mods)[0]

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

@@ -0,0 +1,21 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/14
+  :solution: |-
+    mask_1 = nil
+    mask_0 = nil
+    mem = Hash.new(0)
+
+    ARGF.each_line do |line|
+      lhs, rhs = line.chomp.split(' = ')
+      if lhs == 'mask'
+        mask_1 = rhs.each_char.map { |c| c == '1' ? '1' : '0' }.join.to_i(2)
+        mask_0 = rhs.each_char.map { |c| c == '0' ? '0' : '1' }.join.to_i(2)
+      else
+        addr = lhs.scan(/\d+/).first.to_i
+        val = (rhs.to_i | mask_1) & mask_0
+        mem[addr] = val
+      end
+    end
+
+    puts mem.values.sum

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

@@ -0,0 +1,49 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/14
+  :solution: |-
+    masks = [] # [mask_0, mask_1]
+    mem = Hash.new(0)
+
+    ARGF.each_line do |line|
+      lhs, rhs = line.chomp.split(' = ')
+      if lhs == 'mask'
+        masks.clear
+        # 1 in mask should be 1
+        mask_1_base = rhs.each_char.map { |c| c == '1' ? '1' : '0' }.join.to_i(2)
+
+        # Generate all subsets of the n floats (i.e. powerset), by means of binary number 2^n
+        n_floats = rhs.chars.count { |c| c == 'X' }
+        (2**n_floats).times do |i|
+          # The subset
+          f_mask = i.to_s(2).rjust(n_floats, '0')
+          f_pos = 0
+          # Create a version of the mask corresponding to the subset of floats.
+          mask_s = rhs.each_char.with_index.map do |c, _j|
+            if c == 'X'
+              f_pos += 1
+              f_mask[f_pos - 1]
+            else
+              'X' # maps to problem1, so mask_s can be treated for same conversion as mask in prob1
+            end
+          end
+
+          # Same as problem 1
+          mask_1 = mask_s.each.map { |c| c == '1' ? '1' : '0' }.join.to_i(2)
+          mask_0 = mask_s.each.map { |c| c == '0' ? '0' : '1' }.join.to_i(2)
+
+          # Add the base 1s as they should be set always!
+          masks << [mask_0, mask_1 | mask_1_base]
+        end
+      else
+        val = rhs.to_i
+        masks.each do |mask_0, mask_1|
+          addr = lhs.scan(/\d+/).first.to_i
+          addr |= mask_1
+          addr &= mask_0
+          mem[addr] = val
+        end
+      end
+    end
+
+    puts mem.values.sum

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

@@ -0,0 +1,10 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/15
+  :solution: |-
+    require_relative 'lib'
+
+    NTH_NUMBER = 2020
+
+    nums_start = ARGF.readline.split(',').map(&:to_i)
+    puts nth_spoken(nums_start, NTH_NUMBER)

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

@@ -0,0 +1,10 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/15
+  :solution: |-
+    require_relative 'lib'
+
+    NTH_NUMBER = 30_000_000
+
+    nums_start = ARGF.readline.split(',').map(&:to_i)
+    puts nth_spoken(nums_start, NTH_NUMBER)

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

@@ -0,0 +1,25 @@
+---
+- :name: part1.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 = []
+    in_rules.lines.each do |rule|
+      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) }
+
+    tser = 0
+    tickets_nearby.each do |ticket_nearby|
+      ticket_nearby.each do |value|
+        valid = rules.any? do |range1, range2|
+          value.between?(*range1) || value.between?(*range2)
+        end
+        tser += value unless valid
+      end
+    end
+
+    puts tser