advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,123 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/a5eztl/2018_day_12_solutions/ebm4fz5/
+  :body: |-
+    Part 1: I got confused for a moment because I forgot to actually store the rules. You'll notice that I wrote a `fetch` which errors if the key doesn't exist, since I saw "all patterns are present" in the description. But this made me wonder whether I was missing a pattern, and I spent some time trying to figure out whether my input had accidentally gotten truncated. Then I realised, of course, 32 is in fact the correct number of lines in the input. And then I discovered I actually forgot to store the rules.
+
+    Part 2: I just printed out sums and tried to look for patterns, and then extrapolated from the pattern I was seeing. I had an off-by-one that cost a bit of time here. The process is now automated in code. Most of the rest of the code is as it was when I was going for the leaderboard.
+
+    I would consider writing it in terms of bit patterns and just do the mask/shift thing, but this code is not really suffering in terms of performance (runs in \< 1 second) so I'm not sure I want to spend the time on that.
+
+    Ruby:
+
+    ```ruby
+    input = (ARGV.empty? ? DATA : ARGF).each_line.map(&:chomp)
+
+    initial = input.shift.split(?:).last.strip.each_char.map { |c| c == ?# }
+    input.shift
+
+    rules = input.each_with_object({}) { |x, h|
+      l, r = x.split(' => ')
+      h[l.each_char.map { |c| c == ?# }] = r == ?#
+    }.freeze
+
+    sums = {}
+
+    leftmost = 0
+    # Arbitrarily choose to stop after this many iterations have same diff:
+    diffs = [nil] * 10
+
+    plants = initial
+    sums[0] = plants.zip(leftmost.step).sum { |p, i| p ? i : 0 }
+
+    gens_done = 1.step { |gen|
+      plants = ([false, false, false, false] + plants + [false, false, false, false]).each_cons(5).map { |c| rules.fetch(c) }
+      leftmost -= 2
+      sums[gen] = plants.zip(leftmost.step).sum { |p, i| p ? i : 0 }
+      diffs.shift
+      diffs << sums[gen] - sums[gen - 1]
+      break gen if diffs.uniq.size == 1
+    }
+
+    puts sums[20]
+    puts sums[gens_done] + diffs[0] * (50 * 10 ** 9 - gens_done)
+
+    __END__
+    initial state: #...#..###.#.###.####.####.#..#.##..#..##..#.....#.#.#.##.#...###.#..##..#.##..###..#..##.#..##...
+
+    ...#. => #
+    #..## => #
+    rest of input omitted for posting
+    ```
+  :replies:
+  - :author: OneParanoidDuck
+    :url: https://www.reddit.com/r/adventofcode/comments/a5eztl/2018_day_12_solutions/ebx6nm8/
+    :body: |-
+      Finally, someone else who mentions bit patterns.. Seems like I'm the only idiot to actually do it with bitwise operations on integers. Wanted to because I feel I'm getting a bit too comfortable using fancy language constructs.
+
+      Below my CPython 3.7 solution, part2 averages 60ms on an Intel i7 870. (edit: or am I supposed to include the interpreter startup time?)
+
+      ```ruby
+      import time
+      t_start = time.time()
+
+      char_to_bit = {'#': '1', '.': '0'}
+      bit_to_char = {'1': '#', '0': '.'}
+
+      def str_to_int(string: str) -> int:
+          return int(''.join(char_to_bit[c] for c in string), 2)
+
+      def int_to_str(number: int) -> str:
+          return ''.join(bit_to_char[c] for c in bin(number)[2:])
+
+      def lowest_enabled_bit(number: int) -> int:
+          binary = bin(number)[2:]
+          return len(binary) - binary.rfind('1') if '1' in binary else None
+
+      def num_bits(number: int) -> int:
+          return len(bin(number)[2:])
+
+      def sum_of_pots_with_plants(number: int, base_idx: int) -> int:
+          return sum(idx for idx, value in enumerate(int_to_str(number), base_idx) if value == '#')
+
+      start_string = '##.#..#.#..#.####.#########.#...#.#.#......##.#.#...##.....#...#...#.##.#...##...#.####.##..#.#..#.'
+      num_generations = 50000000000
+      combinations = [str_to_int(comb) for comb in [
+          '.#.#.', '.#...', '#####', '#..#.', '#...#', '###.#', '...##',
+          '#.##.', '.#.##', '##.#.', '..###', '###..', '##..#', '#..##',
+      ]]
+
+      current_number = str_to_int(start_string) << 3
+      base_idx = 0
+      current_sum = sum_of_pots_with_plants(current_number, base_idx)
+      current_sumchange = 0
+      for generation in range(num_generations):
+          if generation > 0:
+              new_sum = sum_of_pots_with_plants(current_number, base_idx)
+              new_sumchange = new_sum - current_sum
+              if current_sumchange == new_sumchange:
+                  remaining_generations = num_generations - generation
+                  final_sum = int(new_sum + (remaining_generations * new_sumchange))
+                  time_in_ms = (time.time() - t_start) * 1000
+                  raise Exception(
+                      f'Sum increases at constant rate. Calculated final value after {remaining_generations} more '
+                      f'generations: {final_sum}. (Took {time_in_ms:.5f}ms)')
+              current_sum = new_sum
+              current_sumchange = new_sumchange
+
+          if lowest_enabled_bit(current_number) <= 3:
+              current_number <<= 2
+
+          current_bit_count = num_bits(current_number)
+          next_number = 0
+          for current_bit in range(0, current_bit_count + 1):
+              bits_to_compare = (current_number & (0b11111 << current_bit)) >> current_bit
+              for comb in combinations:
+                  if (comb ^ bits_to_compare) == 0:
+                      next_number |= 2 ** (current_bit + 2)
+                      break
+
+          current_number = next_number
+          base_idx -= (num_bits(current_number) - current_bit_count)
+      ```
+    :replies: []

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

@@ -0,0 +1,225 @@
+---
+- :author: KeyboardFire
+  :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/eboleqg/
+  :body: |-
+    ruby 2nd/1st
+
+    sincere apologies for the monstrosity you're about to see (and this is the cleaned up version)
+
+    the main trick to save time was that instead of worrying about removing crashed carts from the list while iterating over it, i just set an `alive` flag to `false` and kept them
+
+    also i'm quite fond of sorting by `99999y + x`
+
+    an interesting piece of trivia is that the set of transformations [/, \, turn left, turn right] is swapping x and y followed by all permutations of signs:
+
+    ```ruby
+    / x y => -y -x
+    \ x y => y x
+    L x y => y -x
+    R x y => -y x
+    ```
+
+    code:
+
+    ```ruby
+    #!/usr/bin/ruby
+
+    class Cart
+        attr_accessor :x, :y, :xv, :yv, :t, :alive
+        def initialize x, y, xv, yv
+            @x = x
+            @y = y
+            @xv = xv
+            @yv = yv
+            @t = 0
+            @alive = true
+        end
+    end
+
+    ca = []
+    d = File.readlines('f').map.with_index do |line,y|
+        line.chomp.chars.map.with_index do |c,x|
+            case c
+            when ?< then ca.push Cart.new(x,y,-1,0); ?-
+            when ?> then ca.push Cart.new(x,y, 1,0); ?-
+            when ?^ then ca.push Cart.new(x,y,0,-1); ?|
+            when ?v then ca.push Cart.new(x,y,0, 1); ?|
+            else c
+            end
+        end
+    end
+
+    loop {
+        ca.sort_by!{|c| c.y*99999+c.x}
+        ca.each do |c|
+            next unless c.alive
+
+            cx = c.x + c.xv
+            cy = c.y + c.yv
+            crash = ca.find{|c2| c2.x == cx && c2.y == cy && c2.alive}
+            if crash
+                c.alive = false
+                crash.alive = false
+                asf = ca.select{|asdf|asdf.alive}
+                if asf.size == 1
+                    p asf[0].x
+                    p asf[0].y
+                    exit
+                end
+                next
+            end
+            c.x = cx
+            c.y = cy
+
+            case d[c.y][c.x]
+            when '\\' then c.xv, c.yv = c.yv, c.xv
+            when '/' then c.xv, c.yv = -c.yv, -c.xv
+            when '+'
+                case c.t
+                when 0 then c.xv, c.yv = c.yv, -c.xv
+                when 1 #nop
+                when 2 then c.xv, c.yv = -c.yv, c.xv
+                end
+                c.t = (c.t+1)%3
+            end
+
+        end
+    }
+    ```
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebolgt5/
+    :body: |-
+      > ruby 2nd/1st
+
+      Very nice!!
+
+      > also i'm quite fond of sorting by `99999y + x`
+
+      Note to self, make a 100000-wide grid next time.
+    :replies: []
+  - :author: dtinth
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebomfmk/
+    :body: |-
+      Congrats on getting 2nd/1st!
+
+      Just a bit of tip that you can sort an array by multiple values by using an Array as a sort key: `ca.sort_by!{|c|[c.y,c.x]}`
+    :replies:
+    - :author: KeyboardFire
+      :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebomq8c/
+      :body: oh cool, i didn't know that. thanks!
+      :replies: []
+  - :author: jonathan_paulson
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebom43c/
+    :body: Thanks for posting. Your code for handling the rotations (`\ / +`) is really concise!
+    :replies: []
+  - :author: markasoftware
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebomy9b/
+    :body: Holy shit, storing x and y component velocities never crossed my mind! Absolutely brilliant!
+    :replies: []
+  - :author: sigacuckoo
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebose9c/
+    :body: Directions as speed vector really cleans the code up! I used the transition maps like most of the people.
+    :replies: []
+  - :author: tobiasvl
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/eboxdwy/
+    :body: For me, part 2 seems to be off by one in the X coordinate (I had `54,66` while your code prints out `55\n66`).
+    :replies: []
+  - :author: VikeStep
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebp3lw0/
+    :body: |-
+      Just fyi, your example above the code has the permutations switched around for the corners. It should be the following as it appears in your code:
+
+      ```ruby
+      / x y => -y -x
+      \ x y => y x
+      ```
+    :replies:
+    - :author: KeyboardFire
+      :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebqu451/
+      :body: whoops, fixed that, thanks!
+      :replies: []
+  - :author: jtgorn
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebqm2re/
+    :body: Beautiful. What sort of syntax is it ?v ?^ etc.. ?
+    :replies:
+    - :author: KeyboardFire
+      :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebqu5d6/
+      :body: it's sugar for single-character strings (e.g. `?v == "v"`)
+      :replies:
+      - :author: jtgorn
+        :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ebtbonm/
+        :body: Thanks! I have learned one thing today :)
+        :replies: []
+  - :author: koordinate
+    :url: https://www.reddit.com/r/adventofcode/comments/a5qd71/2018_day_13_solutions/ecgbyjm/
+    :body: |-
+      Nice. Thank you for sharing.
+
+      A Swift translation:
+
+      ```ruby
+      class Cart {
+          var x: Int, y: Int
+          var vx: Int, vy: Int
+          var t = 0
+          var isAlive = true
+
+          init(x: Int, y: Int, vx: Int, vy: Int) {
+              (self.x, self.y, self.vx, self.vy) = (x, y, vx, vy)
+          }
+      }
+
+      var carts = [Cart]()
+      var d = [[Character]]()
+      while let line = readLine() {
+           d.append(line.enumerated().map { x, c in
+              switch c {
+              case "<": carts.append(Cart(x: x, y: d.count, vx: -1, vy: 0)); return "-"
+              case ">": carts.append(Cart(x: x, y: d.count, vx: +1, vy: 0)); return "-"
+              case "^": carts.append(Cart(x: x, y: d.count, vx: 0, vy: -1)); return "|"
+              case "v": carts.append(Cart(x: x, y: d.count, vx: 0, vy: +1)); return "|"
+              default: return c
+              }
+          })
+      }
+
+      var haveCrashed = false
+      while carts.count > 1 {
+          carts = carts.sorted(by: { $0.y == $1.y ? $0.x < $1.x : $0.y < $1.y })
+          for c in carts {
+              if !c.isAlive {
+                  continue
+              }
+
+              let (cx, cy) = (c.x + c.vx, c.y + c.vy)
+              if let crash = carts.first(where: { $0.x == cx && $0.y == cy && $0.isAlive }) {
+                  if !haveCrashed {
+                      print(cx, cy, separator: ",")
+                      haveCrashed = true
+                  }
+                  c.isAlive = false
+                  crash.isAlive = false
+              }
+              (c.x, c.y) = (cx, cy)
+
+              switch d[cy][cx] {
+              case "\\": (c.vx, c.vy) = (c.vy, c.vx)
+              case "/": (c.vx, c.vy) = (-c.vy, -c.vx)
+              case "+":
+                  switch c.t {
+                  case 0: (c.vx, c.vy) = (c.vy, -c.vx)
+                  case 2: (c.vx, c.vy) = (-c.vy, c.vx)
+                  default: break
+                  }
+                  c.t = (c.t + 1) % 3
+              default: break
+              }
+          }
+          carts = carts.filter { $0.isAlive }
+      }
+      if let c = carts.first {
+          print(c.x, c.y, separator: ",")
+      }
+      ```
+    :replies: []

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

@@ -0,0 +1,217 @@
+---
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/a61ojp/2018_day_14_solutions/ebr5ufg/
+  :body: |-
+    ## CARD The Christmas/Advent Research & Development (C.A.R.D.) department at AoC, Inc. just published a new white paper on Elf Chocolate Recipes.
+
+    wasn't bad today... unfortunately takes about 60s to run...<ruby></ruby>
+
+    ```ruby
+    require 'pp'
+    INPUT = 236021
+    START = 3710
+
+    @scores = START.to_s.chars.map(&:to_i)
+    @elves = [0,1]
+
+    20_000_000.times do
+        elf_scores = [@scores[@elves[0]],@scores[@elves[1]]]
+        @scores.concat(elf_scores.inject(&:+).to_s.chars.map(&:to_i))
+        @elves = @elves.each_with_index.map do |elf,i|
+            new_pos = (elf + 1 + elf_scores[i]) % @scores.length
+            new_pos
+        end
+    end
+
+    pp @scores[INPUT...(INPUT+10)].map(&:to_s).join
+
+    @cur_idx = 0
+    until @matched || @cur_idx >= 100
+        str = @scores[0...1e9].join
+        if str.match(/236021/)
+            idx = @cur_idx * 1_000_000
+            @matched = true
+            idx += str.index /236021/
+            puts idx
+        else
+            nil
+        end
+        @cur_idx += 1
+        @scores.rotate!(1e9)
+    end
+    ```
+  :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/a61ojp/2018_day_14_solutions/ebr3em5/
+  :body: |-
+    [Card] [image](https://i.imgur.com/w5qydaR.png)
+
+    Ruby, as coded by a guy who's not good in coding, who doesn't know how to implement a subarray search so strings it is:
+
+    part 1
+
+    ```ruby
+    p a=gets.to_i
+    b=[3,7]
+    c,d=0,1
+    a-=1
+    (
+    #p [b,b[c],b[d],c,d]
+    e=(b[c]+b[d]).digits.reverse
+    score=e.sum
+    b.push(*e)
+    c=(c+b[c]+1)%b.size
+    d=(d+b[d]+1)%b.size
+    )while b.size<=a+10
+
+    p b
+    puts b[a+1,10]*''
+    ```
+
+    part 2 (watching numbers being printed makes me feel like such an edgy hacker lmao)
+
+    ```ruby
+    p a=gets.to_i
+    b={0=>3,1=>7} # ???
+    size=2 # ???
+    c,d=0,1
+    a-=1
+    ee='37'
+    off=0
+    0.step{|tt|
+    (ki=(ee.size/1000)-1
+    off+=ki*1000
+    ee=ee[ki*1000..-1]
+    p tt,ee.size) if tt>0&&tt%10000==0
+    #p [b,b[c],b[d],c,d]
+    e=(b[c]+b[d])#.digits.reverse
+    #score=e > 10 ? 1+(e%10) : e
+    e>9 ? ( # ??? # ??? # ???
+    b[size]=1
+    b[size+=1]=e-10) : (b[size]=e
+    )
+    size+=1
+    ee+=e.to_s
+    #p ee
+    c=(c+b[c]+1)%size
+    d=(d+b[d]+1)%size
+    (
+    p off+(ee).index($_.chomp,-8)
+    1/0)if (ee).index($_.chomp,-8)
+    }
+    ```
+  :replies: []
+- :author: _liquidlemon
+  :url: https://www.reddit.com/r/adventofcode/comments/a61ojp/2018_day_14_solutions/ebrask4/
+  :body: |-
+    **Ruby**
+
+    Part 2 turned out to be a lot more demanding than I expected but in the end I managed to solve both in a single pass so I'm quite happy with the end result.
+
+    ```ruby
+    digits = nil
+    input = (ARGV[0] || DATA.read.chomp).tap { |s| digits = s.chars.map(&:to_i) }.to_i
+
+    def step
+      scoreboard = [3, 7]
+      first = 0
+      second = 1
+
+      loop do
+        score = scoreboard[first] + scoreboard[second]
+        (scoreboard << score / 10; yield scoreboard) if score > 9
+        scoreboard << score % 10
+        yield scoreboard
+        first = (first + scoreboard[first] + 1) % scoreboard.size
+        second = (second + scoreboard[second] + 1) % scoreboard.size
+      end
+    end
+
+    start = nil
+    len = 0
+    step do |board|
+      if board.size == input + 10
+        recipes = board[input, 10].map(&:to_s).join
+        puts "Part 1: #{recipes}"
+      end
+
+      if board.last == digits[len]
+        len += 1
+        start = board.size - 1 if start.nil?
+        break if len == digits.size
+      else
+        len = 0
+        start = nil
+      end
+    end
+
+    puts "Part 2: #{start}"
+
+    __END__
+    760221
+    ```
+  :replies:
+  - :author: kamireri
+    :url: https://www.reddit.com/r/adventofcode/comments/a61ojp/2018_day_14_solutions/ebvh39s/
+    :body: |-
+      There's a small bug in the last if/else statement in the block. When the next digit doesn't match the one that we're expecting in the pattern, it might be the first digit of the pattern. I've put a revised version below. It now produces the correct result for the '01245' test input.
+
+      ```ruby
+      digits = nil
+      input = (ARGV[0] || DATA.read.chomp).tap { |s| digits = s.chars.map(&:to_i) }.to_i
+
+      def step
+        scoreboard = [3, 7]
+        first = 0
+        second = 1
+
+        loop do
+          score = scoreboard[first] + scoreboard[second]
+          (scoreboard << score / 10; yield scoreboard) if score > 9
+          scoreboard << score % 10
+          yield scoreboard
+          first = (first + scoreboard[first] + 1) % scoreboard.size
+          second = (second + scoreboard[second] + 1) % scoreboard.size
+        end
+      end
+
+      start = nil
+      len = 0
+      step do |board|
+        if board.size == input + 10
+          recipes = board[input, 10].map(&:to_s).join
+          puts "Part 1: #{recipes}"
+        end
+
+        unless board.last == digits[len]
+          len = 0
+          start = nil
+        end
+
+        if board.last == digits[len]
+          len += 1
+          start = board.size - 1 if start.nil?
+          break if len == digits.size
+        end
+      end
+
+      puts "Part 2: #{start}"
+      ```
+    :replies: []
+- :author: jtgorn
+  :url: https://www.reddit.com/r/adventofcode/comments/a61ojp/2018_day_14_solutions/ebtfakm/
+  :body: |-
+    I love ruby
+
+    ```ruby
+    a = '37'; e = Vector[0,1]; j = Vector[1,1]
+
+    until /#{ARGV[0]}.?$/.match a do
+      n = e.map{|f| a[f % a.size].to_i }
+      a << n.sum.to_s
+      e = e+j+n
+    end
+
+    puts "String '#{ARGV[0]}' found after #{a.partition(pat)[0].size} receipts"
+    ```
+  :replies: []

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

@@ -0,0 +1,17 @@
+---
+- :author: leio10
+  :url: https://www.reddit.com/r/adventofcode/comments/a6chwa/2018_day_15_solutions/ebvjsbq/
+  :body: |-
+    [Ruby]
+
+    Before solving it, I even tried some Python solutions from here and they return wrong answers for my input. Here is my code, hope it helps somebody :) -\> [https://gist.github.com/leio10/6a73c9380348a2ff57d54185d1d40d25](https://gist.github.com/leio10/6a73c9380348a2ff57d54185d1d40d25)
+
+    My biggest problem was that I was considering the _reading order_ when choosing the next step for moving, but not doing it to choose the target adjacent square. I even passed the part 1 with this error, but not the part 2. I finally fixed adding the target to array in [https://gist.github.com/leio10/6a73c9380348a2ff57d54185d1d40d25#file-aoc-day15-rb-L85](https://gist.github.com/leio10/6a73c9380348a2ff57d54185d1d40d25#file-aoc-day15-rb-L85)
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/a6chwa/2018_day_15_solutions/ebxknfq/
+  :body: |-
+    This took me a while, and my solution in **Ruby** is a bit verbose - but I tried to make it easy to follow (at least for myself) to minimize mistakes.
+
+    [Advent of Code - December 15, 2018 in Ruby](https://github.com/davidelbe/advent-of-code/blob/master/2018/ruby/day15.rb)
+  :replies: []