advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,352 @@
+---
+- :author: mkigikm
+  :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cy9tczw/
+  :body: |-
+    So proud of this ridiculous ruby. It has everything: monkey-patching basic classes, awful variable names, and the use of begin and rescue as a goto statement. It's fun to see what you can come up with when you aren't worried about a code review.
+
+    ```ruby
+    input="""1
+    2
+    3
+    5
+    7
+    13
+    17
+    19
+    23
+    29
+    31
+    37
+    41
+    43
+    53
+    59
+    61
+    67
+    71
+    73
+    79
+    83
+    89
+    97
+    101
+    103
+    107
+    109
+    113"""
+
+    class Array
+      def sum
+        self.reduce(:+)
+      end
+
+      def quantum
+        self.reduce(:*)
+      end
+    end
+
+    packages = input.each_line.map(&:to_i)
+    total = packages.length
+    target_weight = packages.sum / 4
+    best = nil
+    smallest = 4
+    tries = 0
+
+    if packages.combination(smallest).any? { |front| front.sum == target_weight }
+      puts "at least 1 sol"
+    else
+      puts "no candidates"
+      exit
+    end
+    packages.combination(smallest) do |front|
+      tries += 1
+      puts "tried #{tries}" if tries % 10000 == 0
+      next if front.sum != target_weight
+      #puts "candidate #{front} #{front.sum}"
+      begin
+        (smallest..(total - 3 * smallest)).each do |middle|
+          (packages - front).combination(middle) do |left|
+            next if left.sum != target_weight
+            (middle..(total - 3 * smallest)).each do |upper|
+              (packages - front - left).combination(upper).each do |right|
+                trunk = packages - front - left - right
+                if right.sum == target_weight && trunk.sum == target_weight
+                  #puts "found a solution! #{front} #{front.sum} #{left} #{left.sum} #{right} #{right.sum} #{trunk} #{trunk.sum}"
+                  best = front.quantum if !best || best > front.quantum
+                  puts best
+                  raise "found one!"
+                end
+              end
+            end
+          end
+        end
+      rescue
+        nil
+      end
+    end
+
+    puts best
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cyehlh1/
+    :body: I've got a real think for code like this. Love it.
+    :replies: []
+- :author: cort_troc
+  :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cy9syc6/
+  :body: |-
+    **Ruby**. Couldn't work out how to build in picking only array elements of the smallest length after the select so broke it out manually. Guessed on the ranges because it was computationally expensive. Took me 15 minutes before I realized working out the algorithm on the example inputs was much faster than doing 4..18 brute force on the full input!
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    @input = File.readlines('input.txt').map(&:to_i)
+
+    def find_smallest_quantum(wanted_weight)
+      all = (4..7).flat_map{|size| @input.combination(size).select {|a|a.reduce(:+) == wanted_weight}.sort}
+      smallest = nil
+      quantum_smallest = nil
+      all.each do |e|
+        smallest = e.length if smallest.nil?
+        break if e.length > smallest
+        quantum = e.reduce(:*)
+        if (quantum_smallest.nil? || quantum < quantum_smallest)
+          quantum_smallest = quantum
+        end
+      end
+      quantum_smallest
+    end
+
+    total_weight = @input.reduce(:+)
+
+    puts "part1: #{find_smallest_quantum(total_weight/3)}"
+    puts "part2: #{find_smallest_quantum(total_weight/4)}"
+    ```
+  :replies: []
+- :author: ericdykstra
+  :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cya5tre/
+  :body: |-
+    **5th in 9:25 using Ruby!**
+
+    Late posting this, but I like my solution! It's the greedy version without verifying the other packages, otherwise the code would be slightly longer. Here are the basic steps:
+
+    1. Look for combinations that add up to the correct amount (total divided by number of groups) starting with combinations of one package, then two, until it finds an amount of packages that has a combination that adds up to that number. This takes care of equal weights, and lowest number of packages.
+
+    2. Sort all the combinations in that set by the QE factor and take the first one!
+
+    `
+
+    ```ruby
+    array = []
+    num_groups = 3 # Replace with 4 for part 2
+    start = 1
+    until answer = array.combination(start).select{|c| c.inject(:+) == (array.inject(:+) / num_groups)}.sort_by{|c| c.inject(:*)}.first
+      start += 1
+    end
+    p answer.inject(:*)
+    ```
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cya7f1f/
+    :body: "[deleted]"
+    :replies:
+    - :author: cort_troc
+      :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cyadzcw/
+      :body: |-
+        Nice! I got stuck in mine trying to select the smallest array size from multiple, because i'd put a range to loop the combinations. That's much better.
+
+        Trying to get it yours down to a 1 liner but can't. Can anyone?
+
+        ```ruby
+        start, groups = 0, 3
+        until answer = array.combination(start+=1).select{|a|a.reduce(:+)==(array.reduce(:+)/groups)}.map{|a|a.reduce(:*)}.min
+        end
+        p answer
+        ```
+      :replies:
+      - :author: cort_troc
+        :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cyaeyqm/
+        :body: |-
+          recursive makes it look a bit smaller. I guess it's fair to call that a one liner.
+
+          ```ruby
+          f=->(l,g,i=1){l.combination(i).select{|a|a.reduce(:+)==(l.reduce(:+)/g)}.map{|a|a.reduce(:*)}.min||f.(l,g,i+1)}
+
+          p f.(array, 3)
+          p f.(array, 4)
+          ```
+        :replies: []
+  - :author: TheNiXXeD
+    :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cya81r6/
+    :body: Nice, that's the same logic I used for my JS solution.
+    :replies: []
+- :author: iodiot
+  :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cy9u7wo/
+  :body: |-
+    **Ruby**. Simple bfs. My guess was to add the heaviest gift into initial solution.
+
+    ```ruby
+    gifts = []
+    File.open('24.txt').each {|line| gifts << line.chomp.to_i}
+
+    gifts.reverse!
+
+    def compute_weight(gifts)
+      gifts.inject(0) {|sum, x| sum += x}
+    end
+
+    def compute_qe(gifts)
+      gifts.inject(1) {|prod, x| prod *= x}
+    end
+
+    groups_count = 3
+
+    # for part 2
+    #groups_count = 4
+
+    min_qe = -1
+    min_count = gifts.count / groups_count
+    exact_weight = compute_weight(gifts) / groups_count
+
+    ways = [[gifts[0]]]
+
+    n = 0
+
+    while not ways.empty?
+      way = ways.shift
+
+      next if compute_weight(way) > exact_weight
+      next if way.count > min_count
+      next if (min_qe != -1) and (compute_qe(way) >= min_qe)
+
+      if compute_weight(way) == exact_weight
+        min_qe = (min_qe == -1) ? compute_qe(way) : [min_qe, compute_qe(way)].min
+        min_count = [min_count, way.count].min
+        next
+      end
+
+      rem_gifts = gifts - way
+      rem_gifts.each {|gift| ways << (way + [gift])}
+    end
+
+    p min_qe
+    ```
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cyabdk1/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    # Convenience methods for the Array class
+    class Array
+      def sum
+        return self.reduce(:+)
+      end
+      def product
+        return self.reduce(1,:*)
+      end
+    end
+
+    # Order the weights largest first, to find the combos with the fewest number of elements
+    weights = [1,2,3,5,7,13,17,19,23,29,31,37,41,43,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113].reverse
+
+    def find_combo(w,size)
+        r = []
+        if w.length == 0
+            return r
+        end
+        for i in 1..w.length-1 do
+            # All combinations with i elements
+            # First combo found will have the smallest number of elements
+            combos = w.combination(i).to_a
+            for c in combos do
+                if c.sum == size then
+                    r.push(c)
+                    # Recursively find a combo of the right size in the remaining elements
+                    #
+                    r.push(find_combo(w - c,size))
+                    return r
+                end
+            end
+        end
+    end
+
+    # Output product of weights in the first combo (with the smallest number of weights)
+
+    puts "Part 1 solution = " + find_combo(weights,weights.sum/3)[0].product.to_s
+
+    puts "Part 2 solution = " + find_combo(weights,weights.sum/4)[0].product.to_s
+    ```
+  :replies: []
+- :author: SomebodyTookMyHandle
+  :url: https://www.reddit.com/r/adventofcode/comments/3y1s7f/day_24_solutions/cyaeja9/
+  :body: |-
+    Ruby solution that actually checks the remaining present weights for validity. More verbose than others and more dependent on doing some preliminary math beforehand. First, solutions to the first part of the problem (fewest number of packages) are generated and sorted by "quantum entanglement". Then and only then are each of these checked in order to see whether the remaining presents can be split up properly.
+
+    Definitely not as slick as some of the other recursive solutions I've seen here, but what can you do?
+
+    ```ruby
+    present_weights = [1,3,5,11,13,17,19,23,29,31,37,41,43,47,53,59,67,71,73,79,83,89,97,101,103,107,109,113]
+
+    def passenger_seat_combos(arr, items, weight)
+      valid_combos = []
+      arr.combination(items).to_a.each do |combo|
+        valid_combos << combo if combo.inject(:+) == weight
+      end
+      # return combos sorted by "quantum entanglement"
+      valid_combos.sort_by { |combo| quantum_entanglement(combo) }
+    end
+
+    def quantum_entanglement(arr)
+      arr.inject(:*)
+    end
+
+    def find_min_that_can_be_balanced(arr, combos, groups, weight)
+      # because combos are already sorted by quantum entanglement in #passenger_seat_combos,
+      # we can just return the first one we find that has remaining subsets capable of
+      # being balanced properly
+      combos.each do |combo|
+        remaining = arr - combo
+        if can_be_balanced?(remaining, groups, weight)
+          return quantum_entanglement(combo)
+        end
+      end
+      nil
+    end
+
+    def can_be_balanced?(arr, groups, weight)
+      return true if groups == 1 && arr.inject(:+) == weight
+
+      (1..(arr.length - 1)).to_a.each do |combo_size|
+        arr.combination(combo_size).to_a.each do |combo|
+          if combo.inject(:+) == weight
+            remaining = arr - combo
+            return can_be_balanced?(remaining, groups - 1, weight)
+          end
+        end
+      end
+      false
+    end
+
+    # Part One
+    # desired_weight = present_weights.inject(:+) / 3
+    # p desired_weight # 508
+
+    # Since all present weights are odd, that means the minimum amount of packages
+    # we can put in the passenger seat is 6, so search for combinations of 6 that add up to 508
+
+    sorted_combos_3_partitions = passenger_seat_combos(present_weights, 6, 508)
+    p find_min_that_can_be_balanced(present_weights, sorted_combos_3_partitions, 2, 508)
+
+    # Part Two
+    # desired_weight = present_weights.inject(:+) / 4
+    # p desired_weight # 381
+
+    # Since all present weights are odd, that means the minimum amount of packages
+    # we can put in the passenger seat is now 5, so search for combinations of 5 that add up to 381
+
+    sorted_combos_4_partitions = passenger_seat_combos(present_weights, 5, 381)
+    p find_min_that_can_be_balanced(present_weights, sorted_combos_4_partitions, 3, 381)
+    ```
+  :replies: []

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

@@ -0,0 +1,91 @@
+---
+- :author: ross314
+  :url: https://www.reddit.com/r/adventofcode/comments/3y5jco/day_25_solutions/cyaq8zx/
+  :body: |-
+    First time on the leaderboard (#62)! I was able to come up with a formula for how many times to apply the multiplication and remainder and then just repeated the steps that many times.
+
+    Ruby:
+
+    ```ruby
+    row = 2947
+    column = 3029
+    n = row + column - 2
+    iterations = (n * (n + 1)) / 2 + column - 1
+    result = 20151125
+    iterations.times do
+      result = (result * 252533) % 33554393
+    end
+
+    puts "Value at (#{row}, #{column}): #{result}"
+    ```
+  :replies:
+  - :author: Blecki
+    :url: https://www.reddit.com/r/adventofcode/comments/3y5jco/day_25_solutions/cyaqjg7/
+    :body: Really no time before this counts. There are no more days, you're on the leaderboard and shall stay there forever.
+    :replies:
+    - :author: topaz2078
+      :url: https://www.reddit.com/r/adventofcode/comments/3y5jco/day_25_solutions/cyar7bu/
+      :body: I intend to release a much more thorough set of completion data; this leaderboard won't be the only one.
+      :replies: []
+- :author: ericdykstra
+  :url: https://www.reddit.com/r/adventofcode/comments/3y5jco/day_25_solutions/cyaqbvw/
+  :body: |-
+    **Ruby #36 - 10:50**
+
+    Pretty simple one overall, but I'm happy it ended on a quick one rather than one of the knock-down, drag-out ones that took an hour or more to complete.
+
+    ```ruby
+    end_row = 2981
+    end_col = 3075
+    row = 1
+    col = 1
+    max_row = 1
+    acc = 20151125
+    until row == end_row && col == end_col
+      acc = (acc * 252533) % 33554393
+      if max_row == col
+        row = max_row + 1
+        max_row = row
+        col = 1
+      else
+        row -= 1
+        col += 1
+      end
+    end
+
+    p acc
+    ```
+
+    Going to throw a donation to /u/topaz2078 when I have money in my paypal account. Enjoyed going through these and will use some of them as practice for learning new languages. Enjoyed learning from all of you here, as well, by looking through your code and reading your comments/suggestions on mine. Merry Christmas!!
+  :replies: []
+- :author: JurgenKesker
+  :url: https://www.reddit.com/r/adventofcode/comments/3y5jco/day_25_solutions/cyiarkc/
+  :body: |-
+    Ruby, this day felt as the easiest in a long time. Thanks for Advent of Code, it was great!
+
+    ```ruby
+    def index(x,y)
+
+        y_value = loop(y,1,1)
+        x_value = loop(x,y_value,(y+1))
+    end
+
+    def loop(target, start, start_step)
+    current = start
+        for i in (1...target)
+            current += (i + (start_step -1))
+        end
+        current
+    end
+
+    index_of_answer = index(3083,2978)
+    #index_of_answer = index(6,6)
+    last_answer = 20151125
+    index_of_answer.times do |i|
+        next if (i == 0)
+        puts "#{i}/#{index_of_answer}" if (i% 1000 == 0)
+        last_answer = ((last_answer * 252533) %33554393)
+    end
+    puts last_answer
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2016/01.yml

@@ -0,0 +1,166 @@
+---
+- :author: anadhdguy
+  :url: https://www.reddit.com/r/adventofcode/comments/5fur6q/2016_day_1_solutions/daocnfp/
+  :body: |-
+    My solution for part1...
+
+    **Oneliner in ruby (114 characters)**:
+
+    ```ruby
+    cat input | ruby -pe '_=0,0;d=1;$_.scan(/([LR])(\d+)/).each{|c,n|
+    d=(d+(c.ord&2)-1)%4;_[d%2]+=n.to_i*((d%3>0)?1:-1)};$_=_[0].abs+_[1].abs'
+    ```
+
+    **Oneliner in C (245 characters)**:
+
+    ```ruby
+    void main(){char c;int n=0,d=1,_[2]={0};while(read(0,&c,1))c>57?
+    d=(d+(c&2)+3)%4:c>47?n=n*10+(c&15):n>0?_[d%2]+=d%3>0?
+    n:-n,n=0:0;for(d=0;d<2;d++)n+=_[d]<0?-_[d]:_[d];d=10000000;
+    while(!(n/d)&&(d/=10));do{c=n/d+48;write(1,&c,1);}while(n%=d,d/=10);}
+    ```
+  :replies: []
+- :author: ericdykstra
+  :url: https://www.reddit.com/r/adventofcode/comments/5fur6q/2016_day_1_solutions/dane3zx/
+  :body: |-
+    Here's my pattern-matching-heavy Elixir answer for part 1! https://gist.github.com/EricDykstra/41b46c9a40bf499f97252a81ef32dd8a
+
+    Will work on part 2 later, still don't have a great idea in my head of how to do it in a functional style. Might look at some of the other answers around here.
+
+    I used Ruby to initially to get on the leaderboard and this was my answer (slightly cleaned up and refactored). Part 2 answer changes only a couple of lines :) https://gist.github.com/EricDykstra/cbbb9b87209814d93e5bb0d252646d0d
+  :replies: []
+- :author: dontfup
+  :url: https://www.reddit.com/r/adventofcode/comments/5fur6q/2016_day_1_solutions/daq39t1/
+  :body: |-
+    Clever enough go at part 1 in ruby, but this won't do well for part 2:
+
+    ```ruby
+    # Read the input
+    input = File.read(File.dirname( __FILE__ ) + "/input").rstrip.split(", ")
+
+    # Imagine a compass
+    orientations = %w{ N E S W }
+
+    # Wake up our navigator
+    navigator = Hash.new(0)
+
+    # Translate instructions
+    instructions = input.map do |instruction|
+      case instruction[0]
+      when "L"
+        orientations.rotate! -1
+      when "R"
+        orientations.rotate!
+      else
+        raise "flibbedy flook"
+      end
+
+      navigator[orientations[0] ] += instruction[1..-1].to_i
+    end
+
+    # Ask our navigator about a shortcut
+    puts navigator["E"] - navigator["W"] + navigator["N"] - navigator["S"]
+    ```
+  :replies:
+  - :author: dontfup
+    :url: https://www.reddit.com/r/adventofcode/comments/5fur6q/2016_day_1_solutions/daqq9c0/
+    :body: |-
+      Okay, I've adapted the same code to solve part 2
+
+      ```ruby
+      # Read the input
+      input = File.read(File.dirname( __FILE__ ) + "/input").rstrip.split(", ")
+
+      # Declare starting position
+      position = [0,0]
+
+      # Imagine a compass
+      orientations = %w{ N E S W }
+
+      # Wake up our navigator
+      navigator = Hash.new(0)
+      previous_positions = Array.new
+
+      # Teach navigator some orienteering
+      def hit_the_road(route, previous_positions)
+        route.detect { |point| previous_positions.include?(point) }
+      end
+
+      def path(a,b)
+        path = a.send(a < b ? :upto : :downto, b).to_a[1..-1]
+      end
+
+      # Translate instructions
+      instructions = input.map do |instruction|
+        case instruction[0]
+        when "L"
+          orientations.rotate! -1
+        when "R"
+          orientations.rotate!
+        else
+          raise "flibbedy flook"
+        end
+
+        # Identify destination
+        navigator[orientations[0] ] += instruction[1..-1].to_i
+
+        # Move toward destination
+        exit_condition = case orientations[0]
+        when "N"
+          p = path(position[-1], position[-1] + instruction[1..-1].to_i)
+          z = Array.new(p.length, position[0])
+          route = z.zip(p)
+          hit_the_road(route, previous_positions)
+        when "E"
+          p = path(position[0], position[0] + instruction[1..-1].to_i)
+          z = Array.new(p.length, position[-1])
+          route = p.zip(z)
+          hit_the_road(route, previous_positions)
+        when "S"
+          p = path(position[-1], position[-1] - instruction[1..-1].to_i)
+          z = Array.new(p.length, position[0])
+          route = z.zip(p)
+          hit_the_road(route, previous_positions)
+        when "W"
+          p = path(position[0], position[0] - instruction[1..-1].to_i)
+          z = Array.new(p.length, position[-1])
+          route = p.zip(z)
+          hit_the_road(route, previous_positions)
+        end
+
+        if exit_condition
+          position = exit_condition
+          break
+        else
+          previous_positions = previous_positions | route
+          position = [navigator["E"] - navigator["W"], navigator["N"] - navigator["S"]]
+        end
+      end
+
+      puts position[0].abs + position[1].abs
+      ```
+    :replies: []
+- :author: jchook
+  :url: https://www.reddit.com/r/adventofcode/comments/5fur6q/2016_day_1_solutions/dau2kcf/
+  :body: |-
+    Sorry I'm late to the party!
+
+    I like this solution because you can easily expand to any number of dimensions just by updating the configuration at the top.
+
+    **Ruby**
+
+    ```ruby
+    d = 0
+    l = [0,0]
+    m = [[0,1],[1,0],[0,-1],[-1,0]]
+    t = {'R' => 1, 'L' => -1}
+
+    ARGF.first.split(', ').each do |c|
+      d = (d + t[c[0]]) % m.length
+      a = c[1..-1].to_i
+      l = l.zip(m[d].map{|i| i*a}).map{|i| i.reduce(&:+)}
+    end
+
+    p l.map(&:abs).reduce(&:+)
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2016/02.yml

@@ -0,0 +1,26 @@
+---
+- :author: anadhdguy
+  :url: https://www.reddit.com/r/adventofcode/comments/5g1hfm/2016_day_2_solutions/dap9xzs/
+  :body: |-
+    **Oneliner in ruby (117 characters)**:
+
+    ```ruby
+    cat input | ruby -e '_=[1,1];c=0;gets(nil).each_byte{|b|b>64?(a=(b/3)&1;
+    d=((b/3)&2)-1;_[a]=[0,_[a]+d,2].sort[1]):c=c*10+_[0]*3+_[1]+1};p c'
+    ```
+  :replies:
+  - :author: givdwiel
+    :url: https://www.reddit.com/r/adventofcode/comments/5g1hfm/2016_day_2_solutions/daplj48/
+    :body: I suppose this only works for part 1 and not for part 2, since there's a gap in the ASCII table between the numbers and letters
+    :replies:
+    - :author: anadhdguy
+      :url: https://www.reddit.com/r/adventofcode/comments/5g1hfm/2016_day_2_solutions/daqfal3/
+      :body: |-
+        yup, this solution is only for part1.
+
+        For the part2, the gap wasn't the biggest problem (as I didn't OR 0x30 like the one in C, so I can just multiply by 16 instead of 10, and then display the result with `.to_s(16)`), but rather that it's not a nice rectangle.
+
+        Basically, I solved this by using the center of the keypad as origin (`7` as `(0,0)` for the 2nd keypad, so it starts at `(0,-2)`), and checking that it's in the grid with `abs(x)+abs(y) < 2`.
+
+        The oneliner for the part2 (not posted) is 192char, i'm not too happy with it, but don't have time to fix it.
+      :replies: []

data/data/solutions/reddit/ruby/2016/03.yml

@@ -0,0 +1,23 @@
+---
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/5g80ck/2016_day_3_solutions/dazzvd1/
+  :body: |-
+    Ruby. A little late to the party, but I'm really pleased with this one:
+
+    ```ruby
+    check_triangle = ->(tuple) { a,b,c = tuple.sort; a + b > c }
+
+    input = File.readlines('03_input.txt').map { |line| line.split.map(&:to_i) }
+
+    # Part 1
+    p input.count(&check_triangle)
+
+    # Part 2
+    p input
+      .each_slice(3)
+      .flat_map(&:transpose)
+      .count(&check_triangle)
+    ```
+
+    https://github.com/daniero/code-challenges/blob/master/aoc2016/03.rb
+  :replies: []