advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,189 @@
+---
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk4sfe/
+  :body: |-
+    # irb (26th, 23rd)
+
+    I am solving this problem interatively in the Ruby’s REPL.
+
+    A pattern is represented as an array of string: ['.#.', '..#', '###']
+
+    Loading the rulebook:
+
+    ```ruby
+    IN = `pbpaste`
+    rules = {}; IN.scan(/(\S+) => (\S+)/).map { |a, b| [a.split('/'), b.split('/')] }.each { |a, b| rules[a] = b }; rules
+    ```
+
+    Set up the initial state and flipping/rotating logic:
+
+    ```ruby
+    data = ['.#.', '..#', '###']
+    flip = -> m { m.reverse }
+    flip2 = -> m { m.map(&:reverse) }
+    flip3 = -> m { m.reverse.map(&:reverse) }
+    flip4 = -> m { m.map(&:chars).transpose.map(&:join) }
+    flip5 = -> m { m.map(&:chars).transpose.map(&:join).reverse }
+    flip6 = -> m { m.map(&:chars).transpose.map(&:join).map(&:reverse) }
+    flip7 = -> m { m.map(&:chars).transpose.map(&:join).map(&:reverse).reverse }
+    ```
+
+    Pattern enhancement algorithm:
+
+    ```ruby
+    nx = -> m { pz = m.length.even? ? 2 : 3; l = m.length / pz; (0...l).map { |i| (0...l).map { |j| inp = (0...pz).map { |k| (0...pz).map { |l| m[k+i*pz][l+j*pz] }.join }; rules[inp] || rules[flip[inp]] || rules[flip2[inp]] || rules[flip3[inp]] || rules[flip4[inp]] || rules[flip5[inp]] || rules[flip6[inp]] || rules[flip7[inp]] }.transpose.map(&:join) }.flatten(1) }
+    ```
+
+    In Ruby, you can use an Array as Hash key, so it’s trivial to match the pattern against the rulebook: `rules[inp] || rules[flip[inp]] || rules[flip2[inp]] || ...`.
+
+    To combine them, I look at an array containing patterns: `[['##.', '#..', '...'], ['##.', '#..', '...']]`:
+
+    - To put them side by side: `_.transpose.map(&:join)` → `["##.##.", "#..#..", "......"]`
+    - To stack them vertically: `_.flatten(1)` → ["##.", "#..", "...", "##.", "#..", "..."]
+
+    Part 1:
+
+    ```ruby
+    puts nx[nx[nx[nx[nx[data]]]]].join.count('#')
+    ```
+
+    Part 2:
+
+    ```ruby
+    puts nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[nx[data]]]]]]]]]]]]]]]]]].join.count('#')
+    ```
+  :replies:
+  - :author: BumpitySnook
+    :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk5bmx/
+    :body: |-
+      > I am solving this problem interatively in the Ruby’s REPL.
+
+      I would be terrified of accidentally exiting the interpreter. Do you not ever make mistakes?
+
+      > In Ruby, you can use an Array as Hash key
+
+      Coming from Python: Grrrr :-(.
+    :replies:
+    - :author: dtinth
+      :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk5w2a/
+      :body: |-
+        I actually wrote the code in the text editor, and I setup a hotkey (Cmd+Enter) to send the current line into the Terminal. Like what Lisp people like to do ;).
+
+        If I accidentally exited the REPL, I would just reopen it and send each line from the editor to it.
+      :replies:
+      - :author: BumpitySnook
+        :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk6515/
+        :body: That sounds a lot less stressful :-).
+        :replies: []
+    - :author: znuxor
+      :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk695e/
+      :body: |-
+        > Coming from Python: Grrrr :-(.
+
+        I had this problem too, I decided to transform my blocks into tuples (so, immutable -\> hashing ok) prior to insertion into a dictionary, using this method (works with lists of lists or numpy 2D matrices):
+
+        > old_pattern_key2 = tuple(map(tuple, old\_pattern2))
+      :replies:
+      - :author: BumpitySnook
+        :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk7p9y/
+        :body: Yes, I used the same trick. Still, I'd rather not have to :-).
+        :replies:
+        - :author: dtinth
+          :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drm9ov7/
+          :body: |-
+            When you use an array (or any other object) as a hash key, you must make sure not to mutate the key. Otherwise, really weird things happen. **The hash code of the key changes** causing lookups to fail.
+
+            I got hit by this caveat on day 22:
+
+            ```ruby
+            map[pos] = …; pos[0] += direction[0]; pos[1] += direction[1]
+            ```
+
+            This corrupts the map since the key has been mutated. To fix, I have to do this instead:
+
+            ```ruby
+            map[pos] = …; pos = [pos[0] + direction[0], pos[1] + direction[1]]
+            ```
+
+            I think it is very reasonable for Python to disallow this. :)
+          :replies:
+          - :author: BumpitySnook
+            :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drn4jl1/
+            :body: |-
+              I understand that, but Python could reasonably handle this in a number of less obnoxious ways:
+
+              1. Freeze hash keys (make them immutable)
+              2. CoW hash key objects
+              3. Automatically deepcopy / intern mutable hash keys
+            :replies: []
+  - :author: Unihedron
+    :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk5cq9/
+    :body: "`5.times{data=nx[data]}` might be easier to write than that, by the way."
+    :replies:
+    - :author: dtinth
+      :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk6dm0/
+      :body: |-
+        I avoided mutating `data`, that’s why I didn’t overwrite the `data` variable. I also did it manually to avoid off-by-one errors (e.g. it ran 4 times or 6 times instead due to logic error).
+
+        If I was in a less hurry, I would have written `5.times.reduce(data) { |c, _| nx[c] }` instead :).
+      :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7l78eb/2017_day_21_solutions/drk4r6h/
+  :body: |-
+    Ruby; 25/21. I think I got a headache from this, but I managed to get back on the board after a streak of fails, so I'm happy. Functional programming was being a helpful friend day.
+
+    ```ruby
+    p g='.#.
+    ..#
+    ###'.split
+    h={}
+    r=$<.map{|x|x=~/([#.\/]+) => ([#.\/]+)/
+    p $1,h[$1]=$2.split(?/)}
+    # part 1: 5
+    18.times{v=g.size
+    v.even? ? (#div 2
+    g=g.each_slice(2).map{|x|x.map{|x|[*x.chars.each_slice(2)]}.transpose}.map{|x|
+    x.map{|x|u=x.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    u=x.reverse.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.reverse.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    u=x.transpose.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.transpose.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    u=x.transpose.reverse.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.transpose.reverse.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    warn 'not found'}.transpose.map(&:join)
+    }.flatten(1)
+    ) : (
+    g=g.each_slice(3).map{|x|x.map{|x|[*x.chars.each_slice(3)]}.transpose}.map{|x|
+    x.map{|x|u=x.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    u=x.reverse.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.reverse.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    u=x.transpose.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.transpose.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    u=x.transpose.reverse.map(&:join)*'/'
+    next h[u] if h[u]
+    u=x.transpose.reverse.map{|x|x.reverse.join}*'/'
+    next h[u] if h[u]
+    warn('not found')
+    }.transpose.map(&:join)
+    }.flatten(1)
+    )
+    }
+    p g.join.count ?#
+    ```
+  :replies: []

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

@@ -0,0 +1,60 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7lf943/2017_day_22_solutions/drlufhn/
+  :body: |-
+    Ruby; run time: 22 seconds, fun factor: 4/10, I was too worried about bugs and ran on all the sample test cases. Thankfully it worked first time.
+
+    ```ruby
+    g=$<.map &:chomp
+    g.map!{|x|t=?.*1000
+    t+x+t}
+    t=Array.new(1000){?.*g[0].size}
+    g=t+g+t
+    p x=g[0].size/2
+    p y=g.size/2
+    #g[y][x]=?!
+    d=:u
+    tc=->{d=case d
+    when :u then :l
+    when :l then :d
+    when :d then :r
+    when :r then :u
+    end}
+    ti=->{d=case d
+    when :u then :r
+    when :l then :u
+    when :d then :l
+    when :r then :d
+    end}
+    tf=->{d=case d
+    when :u then :d
+    when :l then :r
+    when :d then :u
+    when :r then :l
+    end}
+    yy=0
+    10000000.times{tt=g[y][x]
+    g[y][x]=case tt
+    when ?#
+    ti[]
+    ?F
+    when ?W
+    yy+=1
+    ?#
+    when ?F
+    tf[]
+    ?.
+    when ?.
+    tc[]
+    ?W
+    end
+    case d
+    when :u then y-=1
+    when :l then x-=1
+    when :d then y+=1
+    when :r then x+=1
+    end
+    }
+    puts yy
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2017/23.yml

@@ -0,0 +1,29 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7lms6p/2017_day_23_solutions/drngoc3/
+  :body: |-
+    Ruby; rank 80 for part 2. Ruby has continuation (like goto but only backflip) so it made porting the code easier. I actually converted the code pretty quick, but it took a lot of staring to realize what it was actually doing... I blame the lack of sleep!
+
+    For fun, unoptimized version: https://gist.github.com/Unihedro/962b3c66f0ed500cb66530fd9b775bb9
+
+    ```ruby
+    require'continuation'
+    d=e=f=g=h=0
+    c=b=93
+    b*=100
+    b+=100000
+    c=b
+    c+=17000
+    j2 = callcc {|cc| cc}
+    p h+=1 if (2...(b**0.5).to_i).any?{|d|
+    b%d==0
+    }
+    g=b
+    g-=c
+    (p h;exit)if g==0
+    b+=17
+    j2.call(j2)
+    ```
+
+    ^[postscript](https://cdn.discordapp.com/attachments/293355384436162560/394006646596304896/unknown.png)
+  :replies: []

data/data/solutions/reddit/ruby/2017/24.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/reddit/ruby/2017/25.yml

@@ -0,0 +1,101 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7lzo3l/2017_day_25_solutions/drqarsn/
+  :body: "Ruby; 35/33; tfw it was easy but I'm slow\n\n```ruby\ns=:A\na=Hash.new{|x,y|x[y]=0}\nu=0\n12523873.times{v=a[u]\ns=case s\nwhen :A\nv==0 ? (a[u]=1;u+=1;:B) : (a[u]=1;u-=1;:E)\nwhen :B\nv==0 ? (a[u]=1;u+=1;:C) : (a[u]=1;u+=1;:F)\nwhen :C\nv==0 ? (a[u]=1;u-=1;:D) : (a[u]=0;u+=1;:B)\nwhen :D\nv==0 ? (a[u]=1;u+=1;:E) : (a[u]=0;u-=1;:C)\nwhen :E\nv==0 ? (a[u]=1;u-=1;:A) : (a[u]=0;u+=1;:D)\nwhen :F\nv==0 ? (a[u]=1;u+=1;:A) : (a[u]=1;u+=1;:C)\nend\n}\np a.values.sum\n```\n\n✨\U0001F623 Merry christmas! \U0001F384"
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/7lzo3l/2017_day_25_solutions/drqot7y/
+  :body: |-
+    # Ruby, gsub and eval
+
+    First I wrote a little generic Turing machine, with none of the states implemented
+
+    ```ruby
+    class TuringMachine
+      attr_reader :checksum_steps, :tape
+
+      def initialize()
+        @tape = []
+        @cursor = 0
+      end
+
+      def read
+        @tape[@cursor] || 0
+      end
+
+      def write(value)
+        @tape[@cursor] = value
+      end
+
+      def move_right
+        @cursor+= 1
+      end
+
+      def move_left
+        if @cursor > 0
+          @cursor-= 1
+        else
+          @tape.unshift(0)
+        end
+      end
+
+      def step
+        @state = self.method(@state).call
+      end
+    end
+    ```
+
+    Then I transformed the input into Ruby code
+
+    ```ruby
+    instructions = File.read('../input25.txt')
+      .downcase
+      .gsub(/begin in state (\w)./) { "@state = :#$1" }
+      .gsub(/perform a diagnostic checksum after (\d+) steps.\n/) { "@checksum_steps = #$1" }
+      .gsub(/in state (\w):/) { "def #$1" }
+      .gsub(/if .* 0:/) { "if read == 0" }
+      .gsub(/if .* 1:/) { "else" }
+      .gsub(/- write the value (\d)./) { "write #$1" }
+      .gsub(/- move one slot to the (\w+)./) { "move_#$1" }
+      .gsub(/- continue with state (\w)./) { ":#$1" }
+      .gsub(/^$|\z$/) { " end\nend\n" }
+    ```
+
+    This returns something like this:
+
+    ```ruby
+    def a
+      if read == 0
+        write 1
+        move_right
+        :b
+      else
+        write 0
+        move_right
+        :c
+      end
+    end
+    # etc
+    ```
+
+    This can be run like this:
+
+    ```ruby
+    tm = TuringMachine.new
+    tm.instance_eval instructions
+
+    tm.checksum_steps.times { tm.step }
+    puts tm.tape.count(1)
+    ```
+  :replies:
+  - :author: twinkiac
+    :url: https://www.reddit.com/r/adventofcode/comments/7lzo3l/2017_day_25_solutions/dwz296p/
+    :body: |-
+      [@tape's latest tweet](https://i.imgur.com/1tB4iOu.jpg)
+
+      [@tape on Twitter](https://twitter.com/tape)
+
+      -
+
+      ^I ^am ^a ^bot ^| ^[feedback](https://www.reddit.com/message/compose/?to=twinkiac)
+    :replies: []