advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,323 @@
+---
+- :author: gareve
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxtgagf/
+  :body: |-
+    Ruby solution for both parts of the problem :)
+
+    ```ruby
+    dist = {}
+    $stdin.readlines.map(&:split).each do |x, to, y, equals, d|
+        dist[[x,y].sort] = d.to_i
+    end
+
+    p dist.keys.flatten.uniq.permutation.map { |comb|
+        comb.each_cons(2).reduce(0) {|s, x| s + dist[x.sort] }
+    }.sort.rotate(-1).first(2)
+    ```
+  :replies:
+  - :author: a_dollar_sign_texas
+    :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxtqbtb/
+    :body: |-
+      I am in absolute awe of this. And I'm even familiar with the whole notation matters story of knuth vs. shell script: http://www.leancrew.com/all-this/2011/12/more-shell-less-egg/.
+
+      Wow. Just ... that is brilliant. May I ask why you approached the problem in such a way? I thought that TSP was going to have significant code, even for just a brute force solution.
+    :replies:
+    - :author: gareve
+      :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxtz4l1/
+      :body: Thanks, let's thank Ruby :) I started with the traditional solution and cleaned up the parts that I was uncomfortable with. The last improvement was the [x, y].sort
+      :replies: []
+- :author: _jonah
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxskk63/
+  :body: |-
+    Ruby:
+
+    ```ruby
+    input = DATA.read.chomp.split("\n").map do |line|
+      line.match(/(\w+) to (\w+) = (\d+)/).captures
+    end
+
+    cities = input.flat_map {|trip| trip[0..1]}.uniq
+
+    distances = input.reduce({}) { |m, trip| m[trip[0..1].join] = trip[2].to_i; m }
+
+    cities.permutation.map do |path|
+      path.each_cons(2).reduce(0) do |m,pair|
+        m += distances[pair.join('')] || distances[pair.rotate.join('')]
+      end
+    end.min.tap {|x| p x}
+    ```
+  :replies: []
+- :author: SnacksOnAPlane
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxsivkf/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    distances = Hash.new{ |h,k| h[k] = Hash.new }
+
+    File.readlines("9-1.data").each do |line|
+      line = line.chomp
+      places, dist = line.split(" = ")
+      dist = dist.to_i
+      p1, p2 = places.split(" to ")
+      distances[p1][p2] = dist
+      distances[p2][p1] = dist
+    end
+
+    shortest_dist = 9999999
+    shortest_perm = nil
+    longest_dist = 0
+    longest_perm = nil
+
+    distances.keys.permutation.each do |perm|
+      dist = 0
+      (0..perm.length - 2).each do |i|
+        p1 = perm[i]
+        p2 = perm[i+1]
+        dist += distances[p1][p2]
+      end
+      if dist < shortest_dist
+        puts "new shortest dist: #{dist}"
+        shortest_dist = dist
+        shortest_perm = perm
+      end
+      if dist > longest_dist
+        puts "new longest dist: #{dist}"
+        longest_dist = dist
+        longest_perm = perm
+      end
+    end
+
+    puts "shortest: #{shortest_dist}"
+    puts "longest: #{longest_dist}"
+    ```
+  :replies:
+  - :author: dubokk15
+    :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxsmv3h/
+    :body: |-
+      Here's the same solution with lots of Ruby shortcuts:
+
+      ```ruby
+      input = File.read("distances.txt").lines.map(&:strip)
+
+      distances = Hash.new { |h,k| h[k] = {} }
+
+      input.each do |line|
+        s, e, d = line.match(/(\w+) to (\w+) = (\d+)/)[1..3]
+        d = d.to_i
+        distances[s][e] = d
+        distances[e][s] = d
+      end
+
+      distances = distances.keys.permutation.map do |perm|
+        perm.each_cons(2).inject(0) do |c, (s, e)|
+          c + distances[s][e]
+        end
+      end.sort
+
+      puts distances[0]
+      puts distances[-1]
+      ```
+    :replies: []
+- :author: ericdykstra
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxsixwb/
+  :body: |-
+    Leveraging Ruby's permutation method...
+
+    ```ruby
+    cities = ["Faerun", "Tristram", "Tambi", "Norrath", "Snowdin", "Straylight", "AlphaCentauri", "Arbre"]
+    routes = {}
+    open("input.txt").each_line do |line|
+      c1, _, c2, _, dist = line.split
+      dist = dist.to_i
+      routes["#{c1}#{c2}"] = dist
+      routes["#{c2}#{c1}"] = dist
+    end
+    final = []
+    cities.permutation(8).map.with_index do |permutation, inx|
+      total = 0
+      0.upto(6).each do |i|
+        total += routes["#{permutation[i]}#{permutation[i+1]}"]
+      end
+      final << total
+
+      puts "#{inx} #{final.max}"
+    end
+    puts final.max
+    ```
+  :replies: []
+- :author: fnoco_xandy
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxsj2td/
+  :body: |-
+    brute force crystal/ruby solution, $find\_shortest with true for part 1, false for part 2.
+
+    ```ruby
+    $find_shortest = true
+    $dists = Hash(Tuple(String, String), Int32).new()
+    File.new("input_9").each_line.map { |line|
+        p = line.strip.split(" ")
+        from = p[0]
+        to = p[2]
+        le = p[4].to_i
+        $dists[{from, to}]=le
+    }.sum
+    lst = $dists.keys.map{|v|[v[0], v[1]]}.flatten.uniq.permutations.map {|p|
+        p.each_with_index.map {|xy|
+            t,i = xy[0], xy[1]
+            return 0 if i==0
+            if $dists[{p[i-1], t}]?
+                return $dists[{p[i-1], t}]
+            else
+                if $dists[{t, p[i-1]}]?
+                    return $dists[{t, p[i-1]}]
+                else
+                    if $find_shortest
+                        return 1000
+                    else
+                        return -1000
+                    end
+                end
+            end
+        }.sum
+    }.sort
+    if $find_shortest
+        p lst.first
+    else
+        p lst.last
+    end
+    ```
+  :replies: []
+- :author: tremendo
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxskeec/
+  :body: |-
+    Another Ruby, brute force (permutation) solution. My delay was I was trying to close the loop, assuming Santa had to return to the starting point
+
+    ```ruby
+    Distance = Struct.new(:towns, :distance)
+
+    all_distances = File.read(File.join(Dir.home, 'tmp', 'input9.txt'))
+    locations = []
+    distances = []
+
+    all_distances.each_line do |line|
+      parts = line.split(' = ')
+      towns = parts[0].split(' to ')
+      distances << Distance.new(towns, parts[1].to_i)
+      locations += towns
+    end
+
+    locations.uniq!
+    shortest_distance = 10_000_000
+    longest_distance = 0
+
+    locations.permutation.each do |route|
+      this_distance = 0
+      route.length.pred.times do |leg|
+        dist = distances.find do |d|
+          d[:towns].include?(route[leg]) && d[:towns].include?(route[leg.next])
+        end
+        this_distance += dist[:distance]
+      end
+      shortest_distance = this_distance if this_distance < shortest_distance
+      longest_distance = this_distance if this_distance > longest_distance
+    end
+
+    puts "shortest: #{shortest_distance}", "longest: #{longest_distance}"
+    ```
+  :replies: []
+- :author: HorizonShadow
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxt5zzn/
+  :body: |-
+    Ruby (All of my solutions [here](https://github.com/HorizonShadow/Advent-of-Code)):
+
+    ```ruby
+    require 'set'
+
+    class Map
+
+      attr_reader :paths
+
+      def initialize
+        @distances = {}
+        @paths = []
+      end
+
+      def init_from_file(file)
+        @distances = distances_from_file(file)
+        @paths = calc_all_paths
+      end
+
+      def shortest_path
+        @paths.min
+      end
+
+      def longest_path
+        @paths.max
+      end
+
+      private
+      def distances_from_file(file)
+        hash = {}
+        File.open(file, 'r') do |infile|
+          while(line = infile.gets)
+            cities, distance = parse(line)
+            hash[cities.to_set] = distance
+          end
+        end
+        hash
+      end
+
+      def parse(str)
+        s = str.split
+        [[s.first, s[2]], Integer(s.last)]
+      end
+
+      def calc_all_paths
+        all_routes = @distances.map {|k,v| k.to_a}.flatten.uniq.permutation.to_a
+        all_routes.each.with_object([]) do |cities, dists|
+          dists << calc_dist(cities)
+        end
+      end
+
+      def calc_dist(cities)
+        cities.each_cons(2).with_object([]) do |(o, t), sum|
+          sum << get_dist(o, t)
+        end.inject(:+)
+      end
+
+      def get_dist(one, two)
+        @distances[[one,two].to_set].to_i
+      end
+    end
+    ```
+  :replies: []
+- :author: mushy_plushy
+  :url: https://www.reddit.com/r/adventofcode/comments/3w192e/day_9_solutions/cxtahil/
+  :body: |-
+    Ruby brute force. Yields lowest value. For highest value 'min' is replaced by 'max' at end.
+
+    ```ruby
+    all_cities = []
+    combinations = {}
+    res = []
+
+    File.open("path").each_line do |line|
+        line =~ /(\d+)(\s+\w+\s+)(\d+)(\s+\S+\s)(\d+)/
+        all_cities << $1
+        all_cities << $3
+        combinations[[$1, $3]] = $5
+        combinations[[$3, $1]] = $5
+    end
+
+    all_combinations = all_cities.uniq.permutation.to_a
+    for i in 0..all_combinations.size-1
+        counter = 0
+        curr_combo = all_combinations[i]
+        for j in 0..curr_combo.size-2
+            counter += combinations[[curr_combo[j], curr_combo[j+1]]].to_i
+        end
+        res << counter
+    end
+    puts res.min
+    ```
+  :replies: []

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

@@ -0,0 +1,359 @@
+---
+- :author: ericdykstra
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtsxjs/
+  :body: |-
+    Ruby solution using the new (as of 2.2.0) slice\_when enum method.
+
+    ```ruby
+    def look_and_say(input)
+      input.slice_when{|i, j| i != j}.to_a.flat_map{|el| [el.length, el.first]}
+    end
+    answers = ["3113322113".split("").map(&:to_i)]
+    1.upto(50) {|x| answers << look_and_say(answers.last)}
+    puts answers.last.count
+    ```
+  :replies:
+  - :author: tomb0y
+    :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxttgxo/
+    :body: love the slice\_when! you could also use chars instead of split("") :)
+    :replies: []
+- :author: tomb0y
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtsvjq/
+  :body: |-
+    Being on the leaderboard feels awesome :)
+
+    Ruby solution:
+
+    ```ruby
+    input = '3113322113'
+    50.times { input = input.gsub(/(.)\1*/) { |s| s.size.to_s + s[0] } }
+    puts input.length
+    ```
+  :replies: []
+- :author: reacher
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtsc40/
+  :body: |-
+    My Ruby solution. I finally made the leaderboard!
+
+    ```ruby
+    s = '1113222113'
+
+    def foo(s)
+      r = ''
+      cnt = 1
+      for i in 0..s.size-1
+        c = s[i]
+        if s[i+1] != c
+          r << cnt.to_s
+          r << c
+          cnt = 1
+        else
+          cnt = cnt + 1
+        end
+      end
+      return r
+    end
+
+    1.upto(50) {
+      s = foo(s)
+    }
+
+    puts s.size
+    ```
+  :replies: []
+- :author: Axsuul
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtsvn9/
+  :body: |-
+    Recursive Ruby solution
+
+    ```ruby
+    def say(input)
+      saying = ""
+      input_split = input.split('')
+
+      count = 0
+
+      input_split.each_with_index do |char, i|
+        next_char = input_split[i+1]
+
+        count += 1
+
+        if char != next_char
+          saying << "#{count}#{char}"
+
+          count = 0
+        end
+      end
+
+      saying
+    end
+
+    def look_and_say(input, n, m = 1)
+      saying = say(input)
+
+      if n == m
+        saying
+      else
+        look_and_say(saying, n, m+1)
+      end
+    end
+
+    puts look_and_say(INPUT, 40).length
+    puts look_and_say(INPUT, 50).length
+    ```
+  :replies:
+  - :author: Axsuul
+    :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtt00p/
+    :body: |-
+      I also like to write specs
+
+      ```ruby
+      RSpec.describe '#say' do
+        it "says" do
+          expect(say("21")).to eq "1211"
+          expect(say("1211")).to eq "111221"
+          expect(say("111221")).to eq "312211"
+        end
+      end
+
+      RSpec.describe '#look_and_say' do
+        it "returns for n sequence for starting input" do
+          expect(look_and_say("1", 1)).to eq "11"
+          expect(look_and_say("1", 2)).to eq "21"
+          expect(look_and_say("1", 3)).to eq "1211"
+          expect(look_and_say("1", 4)).to eq "111221"
+          expect(look_and_say("1", 5)).to eq "312211"
+        end
+      end
+      ```
+    :replies: []
+- :author: gnuconsulting
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtthdu/
+  :body: |-
+    My initial (braindead) copy finished the first part in a few seconds. The second run is still going, 15 minutes in. In fact, it took long enough for me to remember something vague about there being a difference in speed between various methods of string concatenation in ruby, look it up, copy my program, change two instances of += to \<\<, run the modified script, get the right answer, and finish the challenge.
+
+    Wow.
+
+    So the lesson here is - small changes can make a big difference. Also, my laptop gets warm after this much intensive CPU utilization. Ouch. This is the fixed script:
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    data = '1113122113'
+
+    def speak(z)
+      previous = ""
+      current = z[0]
+      count = 0
+      final = ""
+      z.each_char do |x|
+        if x != current
+          previous = current
+          current = x
+          final << count.to_s + previous
+          count = 0
+        end
+        count += 1
+      end
+      final << count.to_s + current
+      return final
+    end
+
+    1.upto(50) {
+      data = speak(data)
+    }
+
+    p data.length
+    ```
+
+    I'll reply to this with the total time the first copy takes (if it ever finishes).
+  :replies:
+  - :author: gnuconsulting
+    :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtuvnr/
+    :body: Almost exactly an hour! Vs. 5 seconds using \<\<
+    :replies: []
+  - :author: dalfgan
+    :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtuxzx/
+    :body: 'ahah I did the same thing (but I used "#{x}#{y}"). After 2 or 3 min, I was like something is not correct. What about doing this in your code: final \<\< count.to\_s \<\< current'
+    :replies:
+    - :author: gnuconsulting
+      :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtv7xw/
+      :body: No noticeable change. Still takes about 5.5 seconds for 50 iterations. I believe it's because it does the right-hand concat first (between `count.to_s` and `current`) which are both tiny strings, before appending the result onto `final` (the death-blow if you use `+=`).
+      :replies: []
+- :author: segfaultvicta
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtuu0n/
+  :body: |-
+    Golang - there's probably a slightly cleaner way to do this.
+
+    I originally used string concatenation, ran into a brick wall at iteration 44, was DEEPLY confused because I wasn't memory-bound or CPU-bound, scratched my head for a while until I remembered that go's naive string concatenation is a giant pile of string-copying because strings are immutable, realised they were just byte arrays under the sheets, laughed INCREDIBLY HARD, cancelled the process, made a few adjustments, am still laughing. I think this is the first time I've ever had a process bound by /the speed at which it can copy stuff in RAM/.
+
+    This is DEFINITELY my favourite puzzle so far in terms of "B-side slapping me in the face with a trout", and I definitely learned a thing about golang. Ruby or Perl would have made the solution obvious and a nice clean one-liner, I think, but honestly one of the reasons I'm doing these in golang is deliberately to run into these sort of issues - I plan to do at -least- the first ten days in Elixir sometime next month while I try to learn it, and I feel like I'll run into a complementary set of issues. I'm really looking forward to comparing the two experiences!
+
+    ```ruby
+    func indexToEndRun(s []byte, from int) int {
+    for i := from + 1; i < len(s); i++ {
+        if s[i] != s[from] {
+            return i - 1
+        }
+    }
+    return len(s) - 1
+    }
+
+    func day10sideB(lines []string) string {
+    bytes := []byte(lines[0])
+    for i := 0; i < 50; i++ {
+        newString := []byte{}
+        for j := 0; j < len(bytes); {
+            runEndsAt := indexToEndRun(bytes, j)
+            runSize := byte((runEndsAt + 1) - j)
+
+            newString = append(newString, runSize+byte(48)) //shens
+            newString = append(newString, bytes[j])
+
+            j = runEndsAt + 1
+        }
+        bytes = newString
+    }
+    return strconv.Itoa(len(bytes))
+    }
+    ```
+  :replies:
+  - :author: metamatic
+    :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxwhtoh/
+    :body: |-
+      > Ruby or Perl would have made the solution obvious and a nice clean one-liner, I think, but honestly one of the reasons I'm doing these in golang is deliberately to run into these sort of issues
+
+      Yes. I'm using these exercises as a way to learn to write Go usefully, and that means "belt and braces" error handling, unit tests, and not writing "clever" code.
+
+      Anyhow, I guessed that speed was going to be an issue, so I checked and read that [byte buffers are the way to do character appends in Go](http://golang-examples.tumblr.com/post/86169510884/fastest-string-contatenation). I went that route and the code finishes in half a second. You might want to compare your code's speed with a byte buffer version?
+    :replies:
+    - :author: segfaultvicta
+      :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxwymqg/
+      :body: |-
+        Huh, neat, thanks for the link! I think I will try that sometime and speed-compare just for funsies.
+
+        Writing to a byte buffer is definitely a lot cleaner-looking, to me, too, so.
+      :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxtw6vi/
+  :body: |-
+    **Ruby solution**
+
+    Avoids using strings altogether, just arrays....
+
+    ```ruby
+    def looksay(s)
+        result = []
+        prev = s[0]
+        count = 1
+        for i in 1..s.length-1 do
+            digit = s[i]
+            if digit != prev then
+                result.push(count)
+                result.push(prev)
+                prev = digit
+                count = 1
+            else
+                count = count + 1
+            end
+        end
+        result.push(count)
+        result.push(prev)
+        return result
+    end
+    input = [1,3,2,1,1,3,1,1,1,2]
+    for i in 1..50
+        input = looksay(input)
+        puts i.to_s + ", " + input.length.to_s
+    end
+    ```
+  :replies: []
+- :author: tremendo
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxu2gu7/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    def look_and_say(n)
+      rs = []
+      all_chars = n.chars
+      cur_chr = all_chars[0]
+      kount = 0
+      all_chars.each do |c|
+        if c != cur_chr
+          rs << kount.to_s
+          rs << cur_chr
+          cur_chr = c
+          kount = 0
+        end
+        kount += 1
+      end
+      rs << kount.to_s
+      rs << cur_chr
+      return rs.join
+    end
+
+    def solve(input, n)
+      n.times do |i|
+        input = look_and_say(input)
+      end
+      puts '-> ' + input.length.to_s
+    end
+
+    solve('1', 5)
+    input = '1113122113'
+    solve(input, 40)
+    solve(input, 50)
+    ```
+  :replies: []
+- :author: vanderzee94
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxub4t6/
+  :body: |-
+    My solution in ruby
+
+    ```ruby
+    def lns(inuput)
+        chunks = inuput.chars.chunk{|e| e}.map{|e| e[1].join }.compact
+        return chunks.map{ |s| s.length.to_s + s[0] }.join('')
+    end
+    input = "3113322113"
+    1.upto(50) { input = lns input }
+    puts input.size
+    ```
+  :replies: []
+- :author: zacwaz
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxuxeku/
+  :body: |-
+    Simple, functional **Ruby** solution:
+
+    ```ruby
+    def look_and_say(input)
+      input.chars.chunk{|e| e}.map{|e| e.last.length.to_s + e.first }.join
+    end
+
+    input = "1113122113"
+    puts 40.times.reduce(input) {|memo| look_and_say memo }.length
+    ```
+  :replies: []
+- :author: talkb1nary
+  :url: https://www.reddit.com/r/adventofcode/comments/3w6h3m/day_10_solutions/cxwr955/
+  :body: |-
+    Late to party, but i liked my result in Ruby
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    def look_and_say inp
+        inp.scan(/((\d)\2*)/).map(&:first).map { |a|
+            [a.size, a[0] ]
+        }.flatten.join('')
+    end
+
+    num = ARGV[0]
+    40.times { num = look_and_say(num) }
+    puts num.size
+
+    10.times { num = look_and_say(num) }
+    puts num.size
+    ```
+  :replies: []