advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2018/18.yml

@@ -0,0 +1,279 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/a77xq6/2018_day_18_solutions/ec15imz/
+  :body: |-
+    The below is NOT the code I used to get into the leaderboard (since that was mostly vanilla)... it is instead kind of insane code. My leaderboard code took 3-4 seconds to run and I was not satisfied.
+
+    So I used a classic, the lookup tables approach like one you'd find at http://dotat.at/prog/life/life.html , except this time the neighbourhood is 18 bits so the lookup table now has 262144 elements (with a quarter of it being wasted space!)
+
+    Down to 1 second now. Should be decent if translating the lookup table approach to a compiled language.
+
+    (There's also double-buffering in there, but I found that double-buffering didn't really make a difference in runtime for me).
+
+    Note that I imagine the "compact representation" from that page could still be possible: Y coordinates would still be represented as negative numbers, trees' X coordinates as positive odd numbers, and lumber X coordinates as positive even numbers, or something. It would probably still work, I just haven't tried it yet. (In other words, "this isn't even my final form!!!")
+
+    Ruby:
+
+    ```ruby
+    require 'time'
+
+    # Nothing ever depends on the count of OPEN,
+    # so we are safe to make OPEN 0.
+    # Otherwise, we'd have to number elements 1, 2, 3.
+    # Not that it matters anyway; either way, space is being wasted.
+    # (two bits can represent four elements, but we only have three)
+    OPEN = 0
+    TREE = 1
+    LUMBER = 2
+
+    # 2 bits per cell, 9 cells in 3x3 neighbourhood,
+    # arranged in this way:
+    # 0 - 5: top left , left , bot left
+    # 6 - 11: top , self , bot
+    # 12 - 17: top right, right, bot right
+    # Move across the array, shifting off the left as we go.
+    # Index into a lookup table using this 18-bit integer.
+
+    BITS_PER_CELL = 2
+    CELLS_PER_ROW = 3
+    CELL_MASK = (1 << BITS_PER_CELL) - 1
+    MID_OFFSET = BITS_PER_CELL
+    TOP_OFFSET = BITS_PER_CELL * 2
+
+    COL_OFFSET = BITS_PER_CELL * CELLS_PER_ROW
+    RIGHT_COL_OFFSET = COL_OFFSET * 2
+
+    # Where the right column gets inserted
+    TOP_RIGHT_OFFSET = RIGHT_COL_OFFSET + TOP_OFFSET
+    MID_RIGHT_OFFSET = RIGHT_COL_OFFSET + MID_OFFSET
+    BOT_RIGHT_OFFSET = RIGHT_COL_OFFSET
+
+    ME = 4
+    NOT_ME = (0...9).to_a - [ME]
+
+    verbose = ARGV.delete('-v')
+
+    before_lookup = Time.now
+
+    # It takes about half a second to build the lookup table,
+    # but the time it saves makes it worth it!
+    NEXT_STATE = (1 << 18).times.map { |i|
+      trees = 0
+      lumber = 0
+      NOT_ME.each { |j|
+        n = (i >> (j * BITS_PER_CELL)) & CELL_MASK
+        if n == TREE
+          trees += 1
+        elsif n == LUMBER
+          lumber += 1
+        end
+      }
+      case (i >> (ME * BITS_PER_CELL)) & CELL_MASK
+      when OPEN
+        trees >= 3 ? TREE : OPEN
+      when TREE
+        lumber >= 3 ? LUMBER : TREE
+      when LUMBER
+        lumber > 0 && trees > 0 ? LUMBER : OPEN
+      else
+        # Note that 3 is unfortunately a waste of space.
+      end
+    }.freeze
+
+    puts "Lookup table in #{Time.now - before_lookup}" if verbose
+
+    # Next state resulting from `src` is written into `dest`
+    def iterate(src, dest)
+      dest.each_with_index { |write_row, y|
+        top = y == 0 ? nil : src[y - 1]
+        mid = src[y]
+        bot = src[y + 1]
+
+        # The first element in the row (which has no elements to its left)
+        bits = mid[0] << MID_RIGHT_OFFSET
+        bits |= top[0] << TOP_RIGHT_OFFSET if top
+        bits |= bot[0] << BOT_RIGHT_OFFSET if bot
+
+        (1...write_row.size).each { |right_of_write|
+          bits >>= COL_OFFSET
+          bits |= top[right_of_write] << TOP_RIGHT_OFFSET if top
+          bits |= mid[right_of_write] << MID_RIGHT_OFFSET
+          bits |= bot[right_of_write] << BOT_RIGHT_OFFSET if bot
+          write_row[right_of_write - 1] = NEXT_STATE[bits]
+        }
+
+        # The last element in the row (which has no elements to its right)
+        bits >>= COL_OFFSET
+        write_row[-1] = NEXT_STATE[bits]
+      }
+    end
+
+    def compress(grid)
+      # grid.flatten *does* work, of course,
+      # but let's see if we can do better.
+      grid.map { |r| r.reduce(0) { |acc, cell| (acc << BITS_PER_CELL) | cell } }
+    end
+
+    TESTDATA = <<SAMPLE
+    .#.#...|#.
+    .....#|##|
+    .|..|...#.
+    ..|#.....#
+    #.#|||#|#|
+    ...#.||...
+    .|....|...
+    ||...#|.#|
+    |.||||..|.
+    ...#.|..|.
+    SAMPLE
+
+    print_grid = ARGV.delete('-g')
+    current = (ARGV.include?('-t') ? TESTDATA : ARGV.empty? ? DATA : ARGF).each_line.map { |l|
+      l.chomp.each_char.map { |c|
+        case c
+        when ?.; OPEN
+        when ?|; TREE
+        when ?#; LUMBER
+        else raise "invalid #{c}"
+        end
+      }
+    }
+
+    def resources(grid, verbose)
+      flat = grid.flatten
+      trees = flat.count(TREE)
+      lumber = flat.count(LUMBER)
+      "#{"#{trees} * #{lumber} = " if verbose}#{trees * lumber}"
+    end
+
+    patterns = {}
+
+    buffer = current.map { |row| [nil] * row.size }
+
+    1.step { |t|
+      iterate(current, buffer)
+      current, buffer = buffer, current
+
+      puts resources(current, verbose) if t == 10
+
+      key = compress(current)
+
+      if (prev = patterns[key])
+        cycle_len = t - prev
+
+        # If we stored in `patterns` in a reasonable way,
+        # we could just look in `patterns`...
+        # instead we'll just iterate more.
+        more = (1000000000 - t) % cycle_len
+        previous = t + more - cycle_len
+        #prev_flat = patterns.reverse_each.find { |k, v| v == previous }[0]
+
+        puts "t=#{t} repeats t=#{prev}. #{more} more cycles needed (or rewind to #{previous})" if verbose
+
+        more.times {
+          iterate(current, buffer)
+          current, buffer = buffer, current
+        }
+
+        puts resources(current, verbose)
+
+        break
+      end
+
+      patterns[key] = t
+    }
+
+    current.each { |row|
+      puts row.map { |cell|
+        case cell
+        when OPEN; ?.
+        when TREE; ?|
+        when LUMBER; ?#
+        else raise "Unknown #{cell}"
+        end
+      }.join
+    } if print_grid
+
+    __END__..|.#...||..||.#|#..|...#.#..#.|#.|...|#|.#.|.||#.
+    .|#....##.#||.......|..|...|..#.#...#...|.#.......
+    omitted
+    ```
+  :replies:
+  - :author: evonfriedland
+    :url: https://www.reddit.com/r/adventofcode/comments/a77xq6/2018_day_18_solutions/ec2fdb2/
+    :body: Thanks for sharing your code, p\_tseng. Are there any good (perhaps with diagrams) walkthroughs of the lookup table approach you might recommend?
+    :replies:
+    - :author: p_tseng
+      :url: https://www.reddit.com/r/adventofcode/comments/a77xq6/2018_day_18_solutions/ec2qyur/
+      :body: |-
+        This is an interesting one because I don't think I found anything with diagrams, but I found Stack Exchange answer https://codereview.stackexchange.com/questions/42718/optimize-conways-game-of-life/42790#42790 to be useful.
+
+        (In case it hasn't already been mentioned, day 18 bears enough resemblance to Conway's Game of Life that the opportunities for speedups are similar between the two. Therefore, search results for "fast game of life" or "optimise game of life" are likely to be useful. I only knew this because this is not the first time it's come up in Advent of Code, since we had https://adventofcode.com/2015/day/18 )
+      :replies: []
+  - :author: xepherys
+    :url: https://www.reddit.com/r/adventofcode/comments/a77xq6/2018_day_18_solutions/ed9mx0t/
+    :body: Very nice. I'm trying desperately to rewrite this in C#, but not knowing Ruby is making it slightly difficult. Building your lookup table initially and your iterate func mostly make sense... I'm sure I can figure it out eventually lol.
+    :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/a77xq6/2018_day_18_solutions/ec1244r/
+  :body: |-
+    Ruby, 246/190.
+
+    ```ruby
+    lines = $<.readlines.map(&:strip)
+
+    OPEN = ?.
+    TREE = ?|
+    LUMBER = ?#
+
+    grid = lines
+
+    def adj(grid, y, x)
+      (-1..1).flat_map do |yd|
+        next if y+yd < 0 || y+yd >= grid.size
+        (-1..1).map do |xd|
+          next if x+xd < 0 || x+xd >= grid.first.size || (yd == 0 && xd == 0)
+          grid[y+yd][x+xd]
+        end
+      end
+    end
+
+    so_far = []
+    found = false
+
+    i = 0
+    ITER = 1000000000
+    until i == ITER do
+      p i
+      if !found && so_far.any? { |p| (0...grid.size).all? { |j| p[j] == grid[j] } }
+        i = ITER - ITER % i
+        found = true
+      else
+        so_far << grid.map { |l| l.dup }
+      end
+
+      new = grid.map { |l| l.dup }
+      grid.each.with_index do |l, y|
+        l.chars.each.with_index do |c, x|
+          adjac = adj(grid, y, x)
+          case c
+          when OPEN
+            new[y][x] = TREE if adjac.count(TREE) >= 3
+          when TREE
+            new[y][x] = LUMBER if adjac.count(LUMBER) >= 3
+          when LUMBER
+            new[y][x] = OPEN unless adjac.count(LUMBER) >= 1 && adjac.count(TREE) >= 1
+          end
+        end
+      end
+      grid = new
+      i += 1
+    end
+
+    p grid.sum { |l| l.chars.count(TREE) } * grid.sum { |l| l.chars.count(LUMBER) }
+    ```
+  :replies:
+  - :author: ka-splam
+    :url: https://www.reddit.com/r/adventofcode/comments/a77xq6/2018_day_18_solutions/ec14om3/
+    :body: Please, fix your code formatting?
+    :replies: []

data/data/solutions/reddit/ruby/2018/19.yml

@@ -0,0 +1,122 @@
+---
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/a7j9zc/2018_day_19_solutions/ec4s3z4/
+  :body: |-
+    # Ruby 2.5
+
+    214/280
+
+    ```ruby
+    require 'pp'
+
+    V = ARGV.delete('-v')
+
+    TESTDATA = <<TEST.freeze
+    #ip 0
+    seti 5 0 1
+    seti 6 0 2
+    addi 0 1 0
+    addr 1 2 3
+    setr 1 0 0
+    seti 8 0 4
+    seti 9 0 5
+    TEST
+
+    ## taken from day 16
+
+    OP_MAP = {
+      :gtri => ->(a,b,c,r){ r[c] = r[a] > b ? 1 : 0;r },
+      :gtrr => ->(a,b,c,r){ r[c] = r[a] > r[b] ? 1 : 0;r },
+      :eqri => ->(a,b,c,r){ r[c] = r[a] = b ? 1 : 0;r },
+      :eqir => ->(a,b,c,r){ r[c] = a == r[b] ? 1 : 0;r },
+      :eqrr => ->(a,b,c,r){ r[c] = r[a] == r[b] ? 1 : 0;r },
+      :gtir => ->(a,b,c,r){ r[c] = a > r[b] ? 1 : 0;r },
+      :banr => ->(a,b,c,r){ r[c] = r[a] & r[b];r },
+      :setr => ->(a,b,c,r){ r[c] = r[a];r },
+      :bani => ->(a,b,c,r){ r[c] = r[a] & b;r },
+      :seti => ->(a,b,c,r){ r[c] = a;r },
+      :addr => ->(a,b,c,r){ r[c] = r[a] + r[b];r },
+      :mulr => ->(a,b,c,r){ r[c] = r[a] * r[b];r },
+      :muli => ->(a,b,c,r){ r[c] = r[a] * b;r },
+      :addi => ->(a,b,c,r){ r[c] = r[a] + b;r },
+      :bori => ->(a,b,c,r){ r[c] = r[a] | b;r },
+      :borr => ->(a,b,c,r){ r[c] = r[a] | r[b];r}
+    }.freeze
+
+    instr = (ARGV.include?('-t') ? TESTDATA : ARGV.empty? ? DATA : ARGF).each_line.map do |line|
+      line.chomp
+    end
+
+    @pointer_register = (instr.shift).split("").pop.to_i
+    INSTRUCTIONS = instr.map{|i| i.split(" ")}.map{|i| [i.shift.to_sym, i.map(&:to_i)].flatten}.freeze
+
+    def perform initial_register
+      @pointer = 0
+      @perf_registers = initial_register
+      1.step do |i|
+        ip = INSTRUCTIONS[@pointer]
+        op,a,b,c = ip
+        @perf_registers[@pointer_register] = @pointer
+        @perf_registers = OP_MAP[op].call(a,b,c,@perf_registers)
+        @pointer = @perf_registers[@pointer_register]
+        @pointer += 1
+
+        if V
+          puts "*"*25
+          puts "#{i} -- #{@pointer} -- #{ip} -- #{@perf_registers}"
+        end
+
+        # the upper is set when the instruction pointer loops back to instruction 1
+        if @pointer == 1
+          # the number is set in register 2
+          upper = @perf_registers[2]
+          # the result is the sum of all the factors of the number
+          puts (1..upper).select{|i| upper % i == 0 }.sum
+          break
+        end
+      end
+    end
+
+    perform([0]*6)
+    perform([1].concat([0]*5))
+
+    __END__
+    #ip 5
+    addi 5 16 5
+    seti 1 0 4
+    seti 1 8 1
+    mulr 4 1 3
+    eqrr 3 2 3
+    addr 3 5 5
+    addi 5 1 5
+    addr 4 0 0
+    addi 1 1 1
+    gtrr 1 2 3
+    addr 5 3 5
+    seti 2 4 5
+    addi 4 1 4
+    gtrr 4 2 3
+    addr 3 5 5
+    seti 1 7 5
+    mulr 5 5 5
+    addi 2 2 2
+    mulr 2 2 2
+    mulr 5 2 2
+    muli 2 11 2
+    addi 3 6 3
+    mulr 3 5 3
+    addi 3 9 3
+    addr 2 3 2
+    addr 5 0 5
+    seti 0 5 5
+    setr 5 9 3
+    mulr 3 5 3
+    addr 5 3 3
+    mulr 5 3 3
+    muli 3 14 3
+    mulr 3 5 3
+    addr 2 3 2
+    seti 0 1 0
+    seti 0 0 5
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2018/20.yml

@@ -0,0 +1,138 @@
+---
+- :author: nuvan
+  :url: https://www.reddit.com/r/adventofcode/comments/a7uk3f/2018_day_20_solutions/ec5y7tq/
+  :body: |-
+    **Ruby** 117/91
+
+    I'm glad my guess that simply brute forcing all possible routes didn't take too long.
+
+    ```ruby
+    require_relative 'day'
+    require 'io/console'
+
+    class D20 < Day
+
+        def wait
+            puts "Press any key to continue..."
+            STDIN.getch
+        end
+
+        WIDTH = 5000
+        CENTER = 2500
+
+        R = Struct.new(:pieces,:choices,:parent)
+
+        def print_map(map)
+            map.each_slice(WIDTH) do |row|
+                puts row.join("")
+            end
+        end
+
+        def connected_rooms(map,x,y)
+            rooms = []
+            [-1,1].each do |off|
+                if x + off >= 0 && x + off < WIDTH && map[y * WIDTH + x + off] == ?|
+                    rooms << [x+(2*off),y]
+                end
+                if y + off >= 0 && y + off < WIDTH && map[(y + off) * WIDTH + x] == ?-
+                    rooms << [x, y+(2*off)]
+                end
+            end
+            rooms.map{|r| [[x,y],r]}
+        end
+
+        def flood(map,x,y)
+            rooms_to_check = connected_rooms(map,x,y)
+            routes = {[x,y] => {from: nil, dist: 0}}
+
+            while rooms_to_check.any?
+                from,room = rooms_to_check.shift
+                if !routes.key?(room)
+                    routes[room] = {from: from, dist: routes[from][:dist] + 1}
+                    rooms_to_check += connected_rooms(map,*room)
+                else
+                    old_dist = routes[room][:dist]
+                    new_dist = routes[from][:dist] + 1
+                    if new_dist < old_dist
+                        routes[room] = {from: from, dist: new_dist}
+                        rooms_to_check += connected_rooms(map,*room)
+                    end
+                end
+            end
+
+            routes
+        end
+
+        def part_one
+            base = Array.new(WIDTH * WIDTH, ??)
+            x, y = CENTER, CENTER
+            base[y * WIDTH + x] = ?X
+
+            group_starts = []
+
+            @input.chars.each_with_index do |c,i|
+                next if c == ?^
+                break if c == ?$
+
+                case c
+                when ?( then group_starts << [x,y]
+                when ?) then group_starts.pop
+                when ?| then x, y = group_starts.last
+                when ?N,?S,?E,?W
+                    case c
+                    when ?N
+                        y -= 1
+                        base[y * WIDTH + x] = ?-
+                        base[y * WIDTH + x - 1] = ?#
+                        base[y * WIDTH + x + 1] = ?#
+                        y -= 1
+                        base[y * WIDTH + x] = ?.
+                        base[(y-1) * WIDTH + x - 1] = ?#
+                        base[(y-1) * WIDTH + x + 1] = ?#
+                    when ?S
+                        y += 1
+                        base[y * WIDTH + x] = ?-
+                        base[y * WIDTH + x - 1] = ?#
+                        base[y * WIDTH + x + 1] = ?#
+                        y += 1
+                        base[y * WIDTH + x] = ?.
+                        base[(y+1) * WIDTH + x - 1] = ?#
+                        base[(y+1) * WIDTH + x + 1] = ?#
+                    when ?E
+                        x += 1
+                        base[y * WIDTH + x] = ?|
+                        base[(y-1) * WIDTH + x] = ?#
+                        base[(y+1) * WIDTH + x] = ?#
+                        x += 1
+                        base[y * WIDTH + x] = ?.
+                        base[(y-1) * WIDTH + x + 1] = ?#
+                        base[(y+1) * WIDTH + x + 1] = ?#
+                    when ?W
+                        x -= 1
+                        base[y * WIDTH + x] = ?|
+                        base[(y-1) * WIDTH + x] = ?#
+                        base[(y+1) * WIDTH + x] = ?#
+                        x -= 1
+                        base[y * WIDTH + x] = ?.
+                        base[(y-1) * WIDTH + x - 1] = ?#
+                        base[(y+1) * WIDTH + x - 1] = ?#
+                    end
+                else
+                    raise "Unexpected character: #{c} at index #{i}"
+                end
+            end
+
+            base.map!{|c| c == ?? ? ?# : c}
+
+            routes = flood(base,CENTER,CENTER)
+            puts "The shorted max path is #{routes.values.map{|r| r[:dist]}.max}"
+            puts routes.values.select{|r| r[:dist] >= 1000}.size
+        end
+
+        def part_two
+
+        end
+
+    end
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2018/21.yml

@@ -0,0 +1,84 @@
+---
+- :author: KeyboardFire
+  :url: https://www.reddit.com/r/adventofcode/comments/a86jgt/2018_day_21_solutions/ec8fsc5/
+  :body: |-
+    ruby, 21/24. i'm posting the interesting bit because this wasn't actually my part 2 code (i bruteforced it), but i'm glad i managed to finish the reverse engineering by hand before the leaderboard got capped, so:
+
+    ```ruby
+    #!/usr/bin/ruby
+
+    require 'set'
+    seen = Set.new
+
+    def f a;
+        a |= 0x10000
+        b = 8595037
+        b += a&0xff; b &= 0xffffff
+        b *= 65899; b &= 0xffffff
+        b += (a>>8)&0xff; b &= 0xffffff
+        b *= 65899; b &= 0xffffff
+        b += (a>>16)&0xff; b &= 0xffffff
+        b *= 65899; b &= 0xffffff
+        b
+    end
+
+    n = f 0
+    loop {
+        n2 = f n
+        abort "#{n}" if seen.include? n2
+        seen.add n
+        n = n2
+    }
+    ```
+
+    8595037 and 65899 are presumably per-user constants. all those bitwise ands with ffffff are just to make `b` behave as if it were an unsigned 24-bit int. this solves part 2 in a few milliseconds (my brute force took several minutes).
+  :replies:
+  - :author: jonathan_paulson
+    :url: https://www.reddit.com/r/adventofcode/comments/a86jgt/2018_day_21_solutions/ec8fycp/
+    :body: What do you mean by "I bruteforced it" for part 2? You have to know to look for a cycle to figure out when to print the answer, right?
+    :replies:
+    - :author: KeyboardFire
+      :url: https://www.reddit.com/r/adventofcode/comments/a86jgt/2018_day_21_solutions/ec8g32j/
+      :body: yeah, i knew based on the challenge description that it'd have to cycle, so i just ran the input through my "emulator" without any optimizations and printed the values of the register whenever they were compared to register 0, then found when that first started cycling.
+      :replies: []
+- :author: Etsap1
+  :url: https://www.reddit.com/r/adventofcode/comments/a86jgt/2018_day_21_solutions/ec9fybq/
+  :body: |-
+    My brute force solution took almost 30 minutes to run. Here is the optimized version in ruby, which usually runs in less than 20ms:
+
+    `require 'set'`
+
+    `def find_next_terminal_value(x = 0)`
+
+    `y = x | 65536`
+
+    `x = 733884`
+
+    `while y > 0`
+
+    `x = (((x + (y & 255)) & 16777215) * 65899) & 16777215`
+
+    `y >>= 8`
+
+    `end`
+
+    `return x`
+
+    `end`
+
+    `x = find_next_terminal_value`
+
+    `puts x`
+
+    `unique_outputs, part2 = Set[], nil`
+
+    `while unique_outputs.add?(x)`
+
+    `part2 = x`
+
+    `x = find_next_terminal_value(x)`
+
+    `end`
+
+    `puts part2`
+  :replies: []

data/data/solutions/reddit/ruby/2018/22.yml

@@ -0,0 +1,28 @@
+---
+- :author: Immediate_Channel
+  :url: https://www.reddit.com/r/adventofcode/comments/a8i1cy/2018_day_22_solutions/ecc2o5o/
+  :body: |-
+    My **ruby** solution takes 188 seconds to run with a handrolled A\*. What am I doing wrong?
+
+    https://pastebin.com/raw/WtZ8ALEK
+  :replies:
+  - :author: dark_terrax
+    :url: https://www.reddit.com/r/adventofcode/comments/a8i1cy/2018_day_22_solutions/ecc6n6k/
+    :body: |-
+      I don't know Ruby at all, but just glancing at your solution, my guess is that the inner loop of your pathfinding solution is going to be insanely expensive due to not using a proper priority\_queue.
+
+      You have the following line:
+
+      > current = open_set.keys.min_by { |t| est_full_travel\_score[t] }
+
+      Which is going to be an O(N) operation on your queue, which can be very large. This turns your algorithm from O(N log N) (priority queue) to be an O(N^2) which for the size of the inputs here is going to be significant.
+
+      I would try finding a decent priority\_queue implementation in Ruby and use that.
+    :replies:
+    - :author: Immediate_Channel
+      :url: https://www.reddit.com/r/adventofcode/comments/a8i1cy/2018_day_22_solutions/eccam6h/
+      :body: |-
+        Hey, thanks! I changed it to use a priority queue and my runtime went from 188 seconds to 5.
+
+        https://pastebin.com/raw/fWzPUcKe
+      :replies: []