advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2015/11.yml

@@ -0,0 +1,199 @@
+---
+- :author: '0x0dea'
+  :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv1vx5/
+  :body: |-
+    I finally "won" one! Thanks, Ruby.
+
+    ```ruby
+    s = 'cqjxjnds'
+    r = Regexp.union [*?a..?z].each_cons(3).map(&:join)
+    s.succ! until s[r] && s !~ /[iol]/ && s.scan(/(.)\1/).size > 1
+    p s
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv2ayw/
+    :body: "[deleted]"
+    :replies:
+    - :author: _jonah
+      :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv38y5/
+      :body: "`s.succ!` is doing more magic than the regexps."
+      :replies:
+      - :author: KrzaQ2
+        :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv7ln7/
+        :body: Not that much, I used `(n.to_i(36)+1).to_s(36).gsub('0', 'a')` to get the next string.
+        :replies: []
+      - :author: gfixler
+        :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv44uz/
+        :body: What's scary is knowing that these things are probably in car braking systems and pacemakers.
+        :replies: []
+  - :author: _jonah
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv2ror/
+    :body: This is beautiful. And TIL succ could be applied to str, and `!~` exists. And as long as we're golfing, you can shave off a bit by replacing your scan with `s =~ /(.)\1.*(.)\2/`
+    :replies: []
+  - :author: gareve
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv7uat/
+    :body: |-
+      Nice, I've discovered Regexp.union :) Without that I was trying with:
+
+      ```ruby
+      r.bytes.each_cons(3).any? {|a,b,c| a + 1 == b and b + 1 == c}
+      ```
+    :replies: []
+  - :author: takeitonben
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxvp7z6/
+    :body: code like this is almost like magic to me.
+    :replies: []
+  - :author: crossbrowser
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxvb4s5/
+    :body: |-
+      Doesn't this fail rule #3?
+
+      > Passwords must contain at least two different, non-overlapping pairs of letters, like aa, bb, or zz.
+
+      Or is `"aabaa"` valid?
+    :replies:
+    - :author: jmorais
+      :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxveg1y/
+      :body: |-
+        None of my inputs had this problem. To solve just put a uniq.
+
+        ```ruby
+        s.scan(/(.)\1/).size > 1
+        ```
+
+        becomes
+
+        ```ruby
+        s.scan(/(.)\1/).uniq.size > 1
+        ```
+      :replies:
+      - :author: crossbrowser
+        :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxvetmy/
+        :body: Nice, I was trying to do something similar but didn't know about scan. Useful.
+        :replies: []
+  - :author: segfaultvicta
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxvcfqo/
+    :body: |-
+      > r = Regexp.union [\*?a..?z].each\_cons(3).map(&:join)
+
+      WOAH.
+
+      What the balls is actually happening here? I'm rusty and did it in boring non-functional style, haha. This is hot, though.
+
+      Also, A+ for s.succ, I remember going "man I bet Ruby has a built-in for this..." when I was implementing it myself. xD
+
+      How long does this take to run, out of curiosity?
+    :replies: []
+- :author: tremendo
+  :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv34sv/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    def min_length(str); 8 <= str.length; end
+    def repeats?(str); str.match(/(\w)\1+.*(\w)\2+/) ? true : false; end
+    def disallowed?(str); str =~ /[iol]/; end
+    def consecutive_three?(str)
+      r, p, chars = false, 0, str.chars
+      while !r && p < (str.length - 2)
+        r = chars[p].next == chars[p + 1] && chars[p + 1].next == chars[p + 2]
+        p += 1
+      end
+      return r
+    end
+    def pwd_valid?(str)
+      min_length(str) && repeats?(str) &&
+        !disallowed?(str) && consecutive_three?(str)
+    end
+
+    input = 'vzbxkghb'
+    while !pwd_valid?(input); input = input.next; end
+    puts input
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv79ev/
+    :body: "[deleted]"
+    :replies:
+    - :author: tremendo
+      :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxvajgu/
+      :body: Indeed! thanks for that.
+      :replies: []
+- :author: gnuconsulting
+  :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv3oyr/
+  :body: |-
+    Ruby's .next operator for strings made this really easy. As per usual, I know my regex is bad and should feel bad, but I don't care. Also, I gotta stop with the social life - second night in a row that it cost me a spot on the board.
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    data = 'hepxxzaa'
+
+    until false do
+      if data !~ /i|o|l/
+        if data =~ /abc|bcd|cde|def|efg|fgh|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz/
+          if data =~ /(aa|bb|cc|dd|ee|ff|gg|hh|jj|kk|mm|nn|pp|qq|rr|ss|tt|uu|vv|ww|xx|yy|zz).*(aa|bb|cc|dd|ee|ff|gg|hh|jj|kk|mm|nn|pp|qq|rr|ss|tt|uu|vv|ww|xx|yy|zz)/
+            p data
+            break
+          end
+        end
+      end
+      data = data.next
+    end
+    ```
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv5hua/
+    :body: |-
+      DISREGARD SOCIALIZING
+
+      ACQUIRE STARS
+    :replies: []
+- :author: amnn9
+  :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxv77ns/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    def iterate(seed) # yields
+      Enumerator.new do |y|
+        loop do
+          y << seed
+          seed = yield seed
+        end
+      end
+    end
+
+    SEQS = ('a'..'x').map { |c| iterate(c, &:next).take(3).join }
+    CONDITIONS = [/^[^iol]*$/, /(.)\1.*(.)\2/, Regexp.union(*SEQS)]
+
+    def check(from: 'a')
+      iterate(from, &:next).find do |candidate|
+        CONDITIONS.all? { |c| candidate =~ c }
+      end
+    end
+    ```
+
+    My Haskell side yearned for an _iterate_ function, so that's what drove this implementation.
+  :replies: []
+- :author: beefamaka
+  :url: https://www.reddit.com/r/adventofcode/comments/3wbzyv/day_11_solutions/cxvqlz7/
+  :body: |-
+    here's my solution in F#. Feeling jealous of the Ruby 'succ' function so I tried to create my own.
+
+    ```ruby
+    let inc = "abcdefghjkmnpqrstuvwxyz" |> Seq.pairwise |> dict
+    let (&) c s = sprintf "%c%s" c s
+    let nextc (c,str) ch = match c, ch with | 0, n -> 0, n & str | 1, 'z' -> 1, "a" + str | 1, n -> 0, inc.[n] & str
+    let succ = Seq.rev >> Seq.fold nextc (1,"") >> snd
+    let succseq = Seq.unfold (fun f -> Some (f, succ f)) >> Seq.skip 1
+
+    let (=~) s p = Regex.IsMatch(s,p)
+    let run = [|'a'..'z'|] |> Seq.windowed 3 |> Seq.map String |> String.concat "|"
+    let isValid (p:string) = p =~ @"(\w)\1.*(\w)\2" && p =~ run
+    let findNext = succseq >> Seq.find isValid
+
+    findNext "vzbxkghb" |> printfn "%s"
+    ```
+  :replies: []

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

@@ -0,0 +1,313 @@
+---
+- :author: gareve
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxw7q3o/
+  :body: |-
+    Ruby
+
+    ```ruby
+    require 'json'
+    mp = JSON.parse($stdin.readlines.join())
+    $sum = 0
+    def dfs(mp)
+        return if mp.is_a? Hash and mp.values.include?('red')
+
+        (mp.is_a?(Array) ? mp : mp.values).each { |y| dfs(y) } if mp.class.method_defined? :each
+        $sum += mp if mp.is_a? Integer
+    end
+    dfs(mp)
+    p $sum
+    ```
+
+    For part 1 I just did the regex /(-)\*\d+/ on my editor and copied the values on a spreadsheet xD. The funny part is that this regex it fails with strings like "asd123def"
+  :replies: []
+- :author: Axsuul
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxw7uw8/
+  :body: |-
+    Ruby recursive solution
+
+    ```ruby
+    def count(struct, blacklisted = nil)
+      case struct
+      when Array
+        struct.map { |s| count(s, blacklisted) }.inject(:+)
+      when Hash
+        struct.values.include?(blacklisted) ? 0 : count(struct.values, blacklisted)
+      when Fixnum
+        struct
+      else
+        0
+      end
+    end
+
+    total = 0
+    red_total = 0
+
+    JSON.parse(read_input(12)).each do |struct|
+      total += count(struct)
+      red_total += count(struct, 'red')
+    end
+
+    puts total
+    puts red_total
+    ```
+  :replies: []
+- :author: tremendo
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxw8sxq/
+  :body: |-
+    Here's mine. Another **Ruby** one:
+
+    ```ruby
+    require 'json'
+    input = JSON.parse(File.read('input_file.json'))
+    def parse(json)
+      sum = 0
+      if json.respond_to? :keys
+        return 0 if json.values.include? "red"
+        json.keys.each do |k|
+          sum += json[k].is_a?(Fixnum) ? json[k] : parse(json[k])
+        end
+      elsif json.is_a?(Array)
+        json.each do |v|
+          sum += v.is_a?(Fixnum) ? v : parse(v)
+        end
+      elsif json.is_a?(Fixnum)
+        sum += json
+      end
+      return sum
+    end
+    puts parse(input)
+    ```
+  :replies:
+  - :author: tremendo
+    :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxwj2t0/
+    :body: |-
+      Looking at it a few hours later, bored, felt the need to compact it a little bit:
+
+      ```ruby
+      require 'json'
+      input = JSON.parse(File.read('input_file.json'))
+      def parse(json, except=nil)
+        if json.respond_to? :values
+          json = json.values
+          return 0 if !except.nil? && json.include?(except)
+        end
+        return 0 if json.is_a?(String)
+        json = [json] if !json.is_a?(Array)
+        return json.inject(0) {|s, v| s += v.is_a?(Fixnum) ? v : parse(v, except)}
+      end
+      puts parse(input), parse(input, 'red')
+      ```
+    :replies: []
+- :author: gnuconsulting
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxway30/
+  :body: |-
+    Day 3 of not being home at 9. It's starting to kill me a little (on the inside). But that's ok, a bug in my part 2 logic would have easily cost me a place on the leaderboard anyway. I did the 'smart' thing and parsed the JSON for part 1 so the bones were all there for part 2. And like most people, this just cried out for recursion.
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    require 'json'
+
+    data = JSON.load(File.read('input.txt'))
+
+    def traverseHash(x)
+      count = 0
+      x.each do |y,z|
+        if z.class == Hash
+           count += traverseHash(z)
+        end
+        if z.class == Array
+           count += traverseArray(z)
+        end
+        if z.class == Fixnum
+          count += z
+        end
+        if y.class == Fixnum
+          count += y
+        end
+      end
+      return count
+    end
+
+    def traverseArray(x)
+      count = 0
+      x.each do |y|
+        if y.class == Array
+           count += traverseArray(y)
+        end
+        if y.class == Hash
+           count += traverseHash(y)
+        end
+        if y.class == Fixnum
+          count += y
+        end
+      end
+      return count
+    end
+
+    p traverseHash(data)
+    ```
+
+    Part two, the bug was that I forgot to add the 'skip if red' logic to traverseArray. Turns Out™ you need it in both places. Who knew?!
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    require 'json'
+
+    data = JSON.load(File.read('input.txt'))
+
+    def traverseHash(x)
+      count = 0
+      x.each do |y,z|
+        if y.class == Fixnum
+          count += y
+        end
+        if z.class == Hash
+          if z.has_value?("red")
+            next
+          end
+           count += traverseHash(z)
+        elsif z.class == Array
+           count += traverseArray(z)
+        elsif z.class == Fixnum
+          count += z
+        end
+      end
+      return count
+    end
+
+    def traverseArray(x)
+      count = 0
+      x.each do |y|
+        if y.class == Array
+           count += traverseArray(y)
+        end
+        if y.class == Hash
+          if y.has_value?("red")
+            next
+          end
+           count += traverseHash(y)
+        end
+        if y.class == Fixnum
+          count += y
+        end
+      end
+      return count
+    end
+
+    p traverseHash(data)
+    ```
+  :replies:
+  - :author: topaz2078
+    :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxwcgcz/
+    :body: You could have put the `"red"` check at the top of traverseHash instead of before calling traverseHash everywhere.
+    :replies: []
+- :author: phpaoc
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxwcgn1/
+  :body: |-
+    Part1, Ruby, golfed:
+
+    ```ruby
+    p$<.read.scan(/-?\d+/).map(&:to_i).reduce(:+)
+    ```
+
+    _You will not encounter any strings containing numbers._ clearly was an invitation for not actually parsing JSON.
+  :replies: []
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxwpauu/
+  :body: |-
+    ruby, not too happy with it..
+
+    ```ruby
+    require 'json'
+    input = File.read "input"
+
+    def sum_str str
+     str.scan(/-?\d+/).map(&:to_i).reduce(:+)
+    end
+
+    class Hash
+      def iterate &b
+          self.each do |k,v|
+            v.iterate(&b) if v.is_a?(Hash) or v.is_a?(Array)
+            k.iterate(&b) if k.is_a?(Hash) or k.is_a?(Array)
+            yield(self, k, v)
+          end
+      end
+    end
+    class Array
+      def iterate &b
+          self.each do |k|
+            k.iterate(&b) if k.is_a?(Hash) or k.is_a?(Array)
+            yield(self, k, nil)
+          end
+      end
+    end
+
+    obj = JSON.parse input
+
+    obj.iterate do |hsh, k, v|
+      hsh.clear if hsh.is_a?(Hash) and hsh.value? "red"
+    end
+
+    puts sum_str input
+    puts sum_str(obj.to_json)
+    ```
+
+    at first i tried to add the same method to both the array and hash class with this approach
+
+    ```ruby
+    [Array, Hash].each do |c|
+      c.class_eval do
+        def iterate &b
+          self.each do |k,v|
+            v.iterate(&b) if v.is_a?(Hash) or v.is_a?(Array)
+            k.iterate(&b) if k.is_a?(Hash) or k.is_a?(Array)
+
+            yield(self, k, v)
+          end
+        end
+      end
+    end
+    ```
+
+    but i eventually discovered that when using more than one block param in the call to `Array#each` results in pattern matching kicking in and you lose elements that don't have an appropriate variable to map to... yuk
+  :replies: []
+- :author: aprosepro
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxwpi3y/
+  :body: |-
+    part 2 in ruby, i enjoyed this one. of course, like others said... i saw part 1 and thought the entire challenge would be a cakewalk. total re-write from my single line regex for part 1.
+
+    ```ruby
+    require 'json'
+    @sum = 0
+    def process(obj, parent)
+      if obj.respond_to? :each
+        if !( obj.is_a?(Hash) && obj.has_value?("red") )
+          obj.each{ |inner| process(inner, obj) }
+        end
+      else
+        @sum += obj.to_i
+      end
+      @sum
+    end
+    puts 'SUM: ' + process( JSON.parse( File.open('day12_input.txt').first ) , nil).to_s
+    ```
+  :replies: []
+- :author: jchook
+  :url: https://www.reddit.com/r/adventofcode/comments/3wh73d/day_12_solutions/cxwqecp/
+  :body: |-
+    Ruby, golfed slightly
+
+    ```ruby
+    require 'json'
+
+    def rsum(val)
+      return 0 if val.respond_to?(:has_value?) && val.has_value?("red")
+      val.respond_to?(:each) ? val.each.reduce(0) {|sum, v| sum + rsum(v)} : val.to_i
+    end
+
+    p rsum(JSON.parse(ARGF.read))
+    ```
+  :replies: []