advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,52 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/22
+  :solution: |-
+    require 'set'
+
+    def round_winner(deck1, deck2, cache)
+      states1 = Set.new
+      states2 = Set.new
+      until deck1.empty? || deck2.empty?
+        return  :p1 if states1.include?(deck1.hash) || states2.include?(deck2.hash)
+
+        states1 << deck1.hash
+        states2 << deck2.hash
+
+        card1 = deck1.shift
+        card2 = deck2.shift
+
+        winner = if deck1.length >= card1 && deck2.length >= card2
+                   recursive_combat(deck1.take(card1), deck2.take(card2), cache)
+                 else
+                   card1 > card2 ? :p1 : :p2
+                 end
+
+        if winner == :p1
+          deck1 << card1 << card2
+        else
+          deck2 << card2 << card1
+        end
+      end
+
+      deck1.empty? ? :p2 : :p1
+    end
+
+    def recursive_combat(deck1, deck2, cache = {})
+      cache_key = (deck1 + deck2).hash
+      cache[cache_key] ||= round_winner(deck1, deck2, cache)
+      cache[cache_key]
+    end
+
+    def score(deck)
+      deck.reverse.each_with_index.sum do |card, i|
+        card * (i + 1)
+      end
+    end
+
+    deck1, deck2 = ARGF.readlines('').map do |part|
+      part.chomp.lines.drop(1).map(&:to_i)
+    end
+
+    winner = recursive_combat(deck1, deck2)
+    puts score(winner == :p1 ? deck1 : deck2)

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

@@ -0,0 +1,117 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/23
+  :solution: |-
+    require 'set'
+
+    # MOVES = 10
+    MOVES = 100
+
+    DEBUG = false
+
+    class Node
+      attr_accessor :prev, :next
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        "Node(#{@value})"
+      end
+    end
+
+    def debug(message)
+      puts message if DEBUG
+    end
+
+    def cups_string(node_start)
+      cur = node_start
+      values = []
+      loop do
+        values << cur.value
+        cur = cur.next
+
+        break if cur == node_start
+      end
+      values.join(' ')
+    end
+
+    def print_cups(node_start)
+      debug cups_string(node_start)
+    end
+
+    first = nil
+    cur = nil
+    val_max = 0
+    val_min = Float::INFINITY
+    ARGF.readline.chomp.split('').map(&:to_i).each do |num|
+      val_max = [num, val_max].max
+      val_min = [num, val_min].min
+
+      node = Node.new(num)
+      if first.nil?
+        first = node
+      else
+        cur.next = node
+        node.prev = cur
+      end
+      cur = node
+    end
+    cur.next = first
+    first.prev = cur
+
+    cur = first
+
+    MOVES.times do |i|
+      debug "-- move #{i + 1} --"
+      pick_first = cur.next
+      pick_last = cur.next.next.next
+
+      pick_values = [pick_first.value, pick_first.next.value, pick_last.value]
+      debug "cups: #{cups_string(cur)}"
+      debug "cur: #{cur.value}"
+      debug "pickup: #{pick_values.join(' ')}"
+
+      cur.next = pick_last.next
+      pick_last.prev = cur
+
+      pick_first.prev = nil
+      pick_last.next = nil
+
+      debug "cups reduced: #{cups_string(cur)}"
+
+      val_next = cur.value - 1
+
+      dest = cur.next
+      loop do
+        debug "DestSearch: #{val_next}"
+        dest = dest.next until dest.value == val_next || dest == cur
+        break if dest.value == val_next
+
+        val_next -= 1
+        val_next = val_max if val_next < val_min
+        dest = cur.next
+      end
+
+      debug "destination: #{dest.value}\n\n"
+
+      pick_last.next = dest.next
+      dest.next.prev = pick_last
+      pick_first.prev = dest
+      dest.next = pick_first
+
+      cur = cur.next
+    end
+
+    cur = cur.next until cur.value == 1
+
+    values = []
+    itr = cur.next
+    until itr == cur
+      values << itr.value
+      itr = itr.next
+    end
+
+    puts values.join

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

@@ -0,0 +1,65 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/23
+  :solution: |-
+    require 'set'
+
+    MOVES = 10_000_000
+    CUPS = 1_000_000
+
+    def cups_string(cups, start)
+      cur = start
+      values = []
+      loop do
+        values << cur
+        cur = cups[cur]
+
+        break if cur == start
+      end
+      values.join(' ')
+    end
+
+    numbers = ARGF.readline.chomp.split('').map(&:to_i)
+    min, max = numbers.minmax
+
+    cups = Array.new(CUPS + 1)
+    numbers.each_cons(2) do |n1, n2|
+      cups[n1] = n2
+    end
+    cups[numbers.last] = max + 1
+
+    ((max + 1)..CUPS).each do |num|
+      cups[num] = num + 1
+    end
+    cups[-1] = numbers.first
+
+    cur = numbers.first
+    max = CUPS
+
+    MOVES.times do
+      itr = cur
+
+      picked = Set.new
+      3.times do
+        itr = cups[itr]
+        picked << itr
+      end
+
+      dest = cur - 1
+      dest = max if dest < min
+
+      while picked.include?(dest)
+        dest -= 1
+        dest = max if dest < min
+      end
+
+      nxt = cups[itr] # after the 3 picked cups
+      cups[itr] = cups[dest] # last of 3 picked point to dest's next
+      cups[dest] = cups[cur] # dest's next is first of the 3 picked
+      cups[cur] = nxt
+      cur = nxt
+    end
+
+    next1 = cups[1]
+    next2 = cups[next1]
+    puts next1 * next2

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

@@ -0,0 +1,13 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/24
+  :solution: |-
+    require_relative 'lib'
+
+    tiles = Hash.new(TILE_WHITE) # [cube_coord] -> tile_color
+    ARGF.each_line do |line|
+      coord = track_path(tiles, parse_directions(line.chomp))
+      tiles[coord] = !tiles[coord]
+    end
+
+    puts tiles.values.count { |v| v == TILE_BLACK }

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

@@ -0,0 +1,57 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/24
+  :solution: |-
+    require_relative 'lib'
+
+    DAYS = 100
+
+    # [r, s, q]
+    NEIGHBOUR_DELTAS = [
+      [0, -1, 1],
+      [1, -1, 0],
+      [1, 0, -1],
+      [0, 1, -1],
+      [-1, 1, 0],
+      [-1, 0, 1]
+    ]
+
+    def neighbour_coords(coord)
+      NEIGHBOUR_DELTAS.map do |delta|
+        coord.zip(delta).map { |c, d| c + d }
+      end
+    end
+
+    def color(tiles, tiles_next, coord)
+      nbr_black = neighbour_coords(coord).count { |n| tiles[n] == TILE_BLACK }
+
+      if tiles[coord] == TILE_BLACK && (nbr_black == 0 || nbr_black > 2)
+        tiles_next[coord] = TILE_WHITE
+      elsif tiles[coord] == TILE_WHITE && nbr_black == 2
+        tiles_next[coord] = TILE_BLACK
+      end
+    end
+
+    tiles = Hash.new(TILE_WHITE) # [cube_coord] -> tile_color
+    ARGF.each_line do |line|
+      coord = track_path(tiles, parse_directions(line.chomp))
+      tiles[coord] = !tiles[coord]
+    end
+
+    DAYS.times do |_day|
+      tiles_next = tiles.dup
+
+      tiles.each_key do |coord|
+        color(tiles, tiles_next, coord)
+        neighbour_coords(coord).each do |ncoord|
+          color(tiles, tiles_next, ncoord)
+        end
+      end
+
+      tiles = tiles_next
+
+      # nbr_black = tiles.values.count { |v| v == TILE_BLACK }
+      # puts "Day #{day + 1}: #{nbr_black}"
+    end
+
+    puts tiles.values.count { |v| v == TILE_BLACK }

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

@@ -0,0 +1,30 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2020/25
+  :solution: |-
+    SUBJECT_NR = 7
+    DIV = 20_201_227
+
+    def bf_loops(pub_key)
+      value = 1
+      loops = 0
+      until value == pub_key
+        value *= SUBJECT_NR
+        value %= DIV
+        loops += 1
+      end
+      loops
+    end
+
+    card_pub, door_pub = ARGF.each_line.map(&:to_i)
+
+    card_loops = bf_loops(card_pub)
+    door_loops = bf_loops(door_pub)
+
+    enc_key = 1
+    door_loops.times do
+      enc_key *= card_pub
+      enc_key %= DIV
+    end
+
+    puts enc_key

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

@@ -0,0 +1,7 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/01
+  :solution: |-
+    measurements = ARGF.each_line.map(&:to_i)
+    count = (1...measurements.length).count { |i| measurements[i] > measurements[i - 1] }
+    puts count

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

@@ -0,0 +1,11 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/01
+  :solution: |-
+    measurements = ARGF.each_line.map(&:to_i)
+    count = (3...measurements.length).count do |i|
+      win = measurements[i - 2] + measurements[i - 1] + measurements[i]
+      win_prev = measurements[i - 3] + measurements[i - 2] + measurements[i - 1]
+      win > win_prev
+    end
+    puts count

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

@@ -0,0 +1,33 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/02
+  :solution: |-
+    def s1
+      horiz = 0
+      depth = 0
+      ARGF.each_line.map(&:split).map { |cmd, units| [cmd, units.to_i] }.each do |cmd, units|
+        horiz += units if cmd == 'forward'
+        depth -= units if cmd == 'up'
+        depth += units if cmd == 'down'
+      end
+      puts horiz * depth
+    end
+
+    def s2
+      horiz = 0
+      depth = 0
+      ARGF.each_line.map(&:split).map { |cmd, units| [cmd, units.to_i] }.each do |cmd, units|
+        case cmd
+        when 'forward'
+          horiz += units
+        when 'up'
+          depth -= units
+        when 'down'
+          depth += units
+        end
+      end
+      puts horiz * depth
+    end
+
+    # s1
+    s2

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

@@ -0,0 +1,19 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/02
+  :solution: |-
+    horiz = 0
+    depth = 0
+    aim = 0
+    ARGF.each_line.map(&:split).map { |cmd, units| [cmd, units.to_i] }.each do |cmd, units|
+      case cmd
+      when 'forward'
+        horiz += units
+        depth += aim * units
+      when 'up'
+        aim -= units
+      when 'down'
+        aim += units
+      end
+    end
+    puts horiz * depth

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

@@ -0,0 +1,25 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/03
+  :solution: |-
+    def s1
+      gamma = ARGF.each_line.map { |line| line.chomp.split('').map(&:to_i) }.transpose.map do |colchars|
+        colchars.sum >= colchars.length / 2 ? '1' : '0'
+      end.join.to_i(2)
+      epsilon = (~gamma) & ~((~0) << gamma.to_s(2).length)
+
+      puts gamma * epsilon
+    end
+
+    def s2
+      gamma = ''
+      epsilon = ''
+      ARGF.each_line.map { |line| line.chomp.split('').map(&:to_i) }.transpose.each do |colchars|
+        gamma += colchars.sum >= colchars.length / 2 ? '1' : '0'
+        epsilon += ((gamma[-1].to_i + 1) % 2).to_s
+      end
+      puts gamma.to_i(2) * epsilon.to_i(2)
+    end
+
+    # s1
+    s2

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

@@ -0,0 +1,27 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/03
+  :solution: |-
+    def most_common(array, col)
+      array.transpose.map { |colchars| (colchars.sum / colchars.length.to_f).round }[col]
+    end
+
+    report = ARGF.each_line.map { |line| line.chomp.split('').map(&:to_i) }
+
+    i = 0
+    r = report
+    until r.length == 1
+      r = r.select { |n| n[i] == most_common(r, i) }
+      i += 1
+    end
+    oxygen_rate = r[0].join.to_i(2)
+
+    i = 0
+    r = report
+    until r.length == 1
+      r = r.select { |n| n[i] == (most_common(r, i) + 1) % 2 }
+      i += 1
+    end
+    scrub_rate = r[0].join.to_i(2)
+
+    puts oxygen_rate * scrub_rate

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

@@ -0,0 +1,48 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/04
+  :solution: |-
+    def bingo(board, row, col)
+      board[row].all?(&:negative?) || board.transpose[col].all?(&:negative?)
+    end
+
+    def game(boards, draw_nbrs)
+      draw_idx = -1
+      while draw_idx < draw_nbrs.length
+        draw_idx += 1
+        boards.each do |board|
+          (0...board.length).each do |row|
+            (0...board[row].length).each do |col|
+              if board[row][col] == draw_nbrs[draw_idx]
+                board[row][col] *= -1
+                return [draw_nbrs[draw_idx], board] if bingo(board, row, col)
+              end
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    draw_nbrs = ARGF.readline.split(',').map(&:to_i)
+    ARGF.readline
+
+    boards = []
+    cur_board = []
+
+    ARGF.each_line.map(&:chomp).each do |line|
+      if line.empty?
+        boards << cur_board
+        cur_board = []
+      else
+        cur_board << line.split.map(&:to_i)
+      end
+    end
+    boards << cur_board
+
+    draw_nbr, winning_board = game(boards, draw_nbrs)
+
+    unmarked_sum = winning_board.map do |row|
+      row.reject(&:negative?).sum
+    end.sum
+    puts draw_nbr * unmarked_sum

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

@@ -0,0 +1,58 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/04
+  :solution: |-
+    def bingo(board, row, col)
+      board[row].all?(&:negative?) || board.transpose[col].all?(&:negative?)
+    end
+
+    def game(boards, draw_nbrs)
+      draw_idx = -1
+      while draw_idx < draw_nbrs.length
+        draw_idx += 1
+        round_winners = []
+        boards.each do |board|
+          (0...board.length).each do |row|
+            (0...board[row].length).each do |col|
+              next unless board[row][col] == draw_nbrs[draw_idx]
+
+              board[row][col] = -1
+              next unless bingo(board, row, col)
+
+              if boards.length == 1 || boards.length - round_winners.length == 1
+                return [draw_nbrs[draw_idx], board]
+              else
+                round_winners << board
+              end
+            end
+          end
+        end
+        round_winners.each do |round_winner|
+          boards.delete(round_winner)
+        end
+      end
+      nil
+    end
+
+    draw_nbrs = ARGF.readline.split(',').map(&:to_i)
+    ARGF.readline
+
+    boards = []
+    cur_board = []
+
+    ARGF.each_line.map(&:chomp).each do |line|
+      if line.empty?
+        boards << cur_board
+        cur_board = []
+      else
+        cur_board << line.split.map(&:to_i)
+      end
+    end
+    boards << cur_board
+
+    draw_nbr, winning_board = game(boards, draw_nbrs)
+
+    unmarked_sum = winning_board.map do |row|
+      row.reject(&:negative?).sum
+    end.sum
+    puts draw_nbr * unmarked_sum

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

@@ -0,0 +1,26 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/05
+  :solution: |-
+    require_relative 'point'
+
+    point_counts = Hash.new(0)
+    ARGF.each_line.map { |line| line.chomp.split(/ -> |,/).map(&:to_i) }.each do |x_col, x_row, y_col, y_row|
+      next unless x_col == y_col || x_row == y_row
+
+      if x_col == y_col
+        r_start, r_end = [x_row, y_row].sort
+        (r_start..r_end).each do |row|
+          point = Point.new(x_col, row)
+          point_counts[point] += 1
+        end
+      else
+        c_start, c_end = [x_col, y_col].sort
+        (c_start..c_end).each do |col|
+          point = Point.new(col, x_row)
+          point_counts[point] += 1
+        end
+      end
+    end
+
+    puts point_counts.count { |_point, count| count >= 2 }

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

@@ -0,0 +1,35 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/05
+  :solution: |-
+    require_relative 'point'
+
+    point_counts = Hash.new(0)
+    ARGF.each_line.map { |line| line.chomp.split(/ -> |,/).map(&:to_i) }.each do |x_col, x_row, y_col, y_row|
+      if x_col == y_col
+        r_start, r_end = [x_row, y_row].sort
+        (r_start..r_end).each do |row|
+          point = Point.new(x_col, row)
+          point_counts[point] += 1
+        end
+      elsif x_row == y_row
+        c_start, c_end = [x_col, y_col].sort
+        (c_start..c_end).each do |col|
+          point = Point.new(col, x_row)
+          point_counts[point] += 1
+        end
+      else
+        col = x_col
+        row = x_row
+        col_asc = x_col < y_col
+        row_asc = x_row < y_row
+        until col == (col_asc ? y_col + 1 : y_col - 1)
+          point = Point.new(col, row)
+          point_counts[point] += 1
+          col += col_asc ? 1 : -1
+          row += row_asc ? 1 : -1
+        end
+      end
+    end
+
+    puts point_counts.count { |_point, count| count >= 2 }

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

@@ -0,0 +1,18 @@
+---
+- :name: part1.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/06
+  :solution: |-
+    fishes = gets.split(',').map(&:to_i)
+
+    80.times do
+      fishlings = []
+      fishes.map! do |fish|
+        if (fish - 1) == -1
+          fish = 7
+          fishlings << 8
+        end
+        fish - 1
+      end
+      fishes.concat(fishlings)
+    end
+    puts fishes.length

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

@@ -0,0 +1,42 @@
+---
+- :name: part2.rb
+  :url: https://github.com/erikw/advent-of-code-solutions/blob/main/2021/06
+  :solution: |-
+    # DAYS_TOTAL = 18
+    # DAYS_TOTAL = 80
+    DAYS_TOTAL = 256
+
+    def s_que
+      que = Queue.new
+      gets.split(',').map(&:to_i).each do |fish|
+        que << [fish, 0]
+      end
+      total_fishes = que.length
+
+      until que.empty?
+        fish, spawn_day = que.pop
+        day = spawn_day + fish + 1
+        until day > DAYS_TOTAL
+          que << [8, day]
+          total_fishes += 1
+          day += 7
+        end
+      end
+
+      puts total_fishes
+    end
+
+    def s_count
+      fishes = Array.new(9, 0)
+      gets.split(',').map(&:to_i).each do |fish|
+        fishes[fish] += 1
+      end
+
+      (0...DAYS_TOTAL).each do |day|
+        fishes[(day + 7) % 9] += fishes[day % 9]
+      end
+      puts fishes.sum
+    end
+
+    # s_que
+    s_count