advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2021/07.yml

@@ -0,0 +1,462 @@
+---
+- :author: arnoldboy123
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnnkebn/
+  :body: |-
+    # Ruby Solution
+
+    ```ruby
+    # ---------------------------------- Part 1 ------------------------------
+    inputs = [16,1,2,0,4,2,7,1,2,14]
+
+    fuel = 0
+    fuels = []
+
+    (inputs.min..inputs.max).each do |num|
+        inputs.each do |input|
+            fuel += (input - num).abs
+        end
+        fuels << fuel
+        fuel = 0
+    end
+
+    p fuels.min
+    ---------------------------------- Part 2 --------------------------------
+    inputs = [16,1,2,0,4,2,7,1,2,14]
+
+    fuel = 0
+    fuels = []
+
+    (inputs.min..inputs.max).each do |num|
+        inputs.each do |input|
+            fuel += ((input - num).abs * ((input - num).abs + 1))/2
+        end
+        fuels << fuel
+        fuel = 0
+    end
+    p fuels.min
+    ```
+
+    This is my quick and dirty solution. Not trying to code something perfect but just good enough to do the job of giving me the result in console.
+  :replies: []
+- :author: ignurant
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk9rkd/
+  :body: |-
+    Ruby:
+
+    Pt 1: I'm not sure if this was just luck, but median felt intuitively like "something". It worked for the sample dataset, and (somewhat surprisingly) worked for the official set. I also perhaps got lucky with this chumpy version of median, where I'm not averaging the middle two if the input set was even.
+
+    ```ruby
+    crabs = File.read('input.txt').scan(/\d+/).map(&:to_i)
+    target_position = crabs.sort[crabs.size / 2]
+    puts crabs.map{|crab| (target_position - crab).abs}.sum
+    ```
+
+    Pt 2:
+
+    Median no longer feels intuitive, but I figured there's gotta be a mathy pattern. I suppose I'll try avg. Surprisingly, the avg of the sample dataset came to 4.9, which was suspiciously near 5, which the example says is the right target number.
+
+    .round ended up giving the right answer in the sample dataset, but not the larger set. Assuming the idea of using the average is helpful in some way (it seems like it could be?) I figured the right answer was somewhere around there.
+
+    To get the answer I printed the results for the target position range of -10..+10 just as a sanity check and was delighted to find the low fuel point was actually burried in there, right at the equivalent of Math.floor...
+
+    I'm not sure if this was just luck or not, but here's my "followed through" version:
+
+    ```ruby
+    crabs = File.read('input.txt').scan(/\d+/).map(&:to_i)
+    avg = (1.0 * crabs.sum / crabs.size)
+    fuel = [avg.floor, avg.ceil].map do |target_position|
+      crabs.map do |crab|
+        moves = (target_position - crab).abs
+        1.upto(moves).sum
+      end.sum
+    end.min
+
+    puts fuel
+    ```
+  :replies:
+  - :author: bunceandbean
+    :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnka1xd/
+    :body: I think this has to be on purpose, as the median and mean worked for me as well. I think it probably might be tailored for computer science in the sense that converting (casting) doubles to ints floors the value?
+    :replies:
+    - :author: KT421
+      :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkfzp0/
+      :body: That's actually dependent on language. R will round to the nearest even number unless you explicitly use `floor()` or `ceiling()`. Other languages floor it.
+      :replies: []
+  - :author: marshalofthemark
+    :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkbq1j/
+    :body: |-
+      If N crabs are to your right and M crabs are to your left, then every step to the right will decrease your fuel needed by N - M. So if you plot fuel needed (y-axis) vs. horizontal position (x-axis) on a Cartesian x-y graph, it will have a slope of N - M.
+
+      The global minimum occurs when slope is 0, where there are an equal number of crabs on both sides ... and by definition that happens at the median.
+    :replies: []
+- :author: ACProctor
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnlnn23/
+  :body: |-
+    I'll be honest, I forgot about Gauss. But for anyone else thinking that today is just a one-trick solution, here's how I optimized using recursion with memoization.
+
+    Ruby:
+
+    ```ruby
+        # ... removed input reading into the array crabs.
+        # ... also determined min_val and max_val while reading input
+
+        def fuel_cost(delta, memo)
+            return 0 if delta < 1
+            return memo[delta] if memo.key?(delta)
+
+            cost = fuel_cost(delta - 1, memo) + delta
+            memo[delta] = cost
+
+            cost
+        end
+
+        min_fuel_required = 99999999999
+        optimal_index = nil
+        memo = {}
+        (min_val .. max_val).each do |i|
+            fuel_required = 0
+            crabs.each do |n|
+                fuel_required += fuel_cost((i - n).abs, memo)
+            end
+
+            if fuel_required < min_fuel_required
+                optimal_index = i
+                min_fuel_required = fuel_required
+            end
+        end
+
+        puts "Optimal fuel required (#{min_fuel_required}) at position #{optimal_index}"
+    ```
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk3yry/
+  :body: "```ruby\n# Ruby, 54 / 13\ncrabs = gets.split(',').map(&:to_i)\np (0..1000).map { |u| crabs.sum { |x| (x-u).abs } }.min\np (0..1000).map { |u| crabs.sum { |x| n = (x-u).abs; (n*(n+1))/2 } }.min\n```\n\nThe number 1000 was arbitrarily chosen, it was a total fluke that it worked \U0001F605"
+  :replies:
+  - :author: gurgeous
+    :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk6jpv/
+    :body: Ha, mine is nearly identical! Only difference is that I used \_1 and crabs.max instead of 1000.
+    :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk59fl/
+  :body: |-
+    **Ruby** 79 bytes
+
+    ```ruby
+    n=gets.split(?,).map &:to_i
+    p (0..n.max).map{|u|n.sum{(1..(_1-u).abs).sum}}.min
+    ```
+  :replies: []
+- :author: marshalofthemark
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk6ds2/
+  :body: |-
+    **Ruby (only runs in 3.0+)**
+
+    Easiest problem since day 2 IMO. Maybe even easier.
+
+    ```ruby
+    data = open("./input").read.split(",")
+    def triangular(num) = num * (num + 1) / 2
+    p [*0..1000].map{|n| data.map{(_1.to_i - n).abs}.sum}.sort.first
+    p [*0..1000].map{|n| data.map{triangular(_1.to_i - n).abs}.sum}.sort.first
+    ```
+  :replies:
+  - :author: ni3t
+    :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk9cny/
+    :body: |-
+      You could use `map(&:to_i)` and `min_by` to shorten these up:
+
+      ```ruby
+      data = open("./input").read.split(",").map(&:to_i)
+      def triangular(num) = num * (num + 1) / 2
+      p [*0..1000].map{|n| data.min_by{(_1 - n).abs}.sum}
+      p [*0..1000].map{|n| data.min_by{triangular(_1 - n).abs}.sum}
+      ```
+    :replies: []
+- :author: clarabellum
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnmfaet/
+  :body: |-
+    Came here feeling like "ugh this is inelegant but at least it worked, let's see what other people did" and now I feel validated because it doesn't sound like any of you are super happy with your solutions either haha
+
+    Unless someone is, in which case, i want to read it!
+
+    [Ruby solution (github)](https://github.com/csb324/advent-of-code/blob/main/day7.rb)
+
+    I hit my head against the wall trying to figure out why sometimes the answer was the mean and sometimes the answer was the mean + 1... so I ended up just doing a brute force search within 3 squares of the mean
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk5fjn/
+  :body: |-
+    Ruby 1712/1304
+
+    [paste](https://topaz.github.io/paste/#XQAAAQB/AQAAAAAAAAARiAqGkkN7pUjVWW5QYxj2CIMqqYvXYJRPYP/bLEpwScA00QMIIzV3y5DQ9XZf+B8zWbGmR8IAPA65zDdVORbjm13caysTw9my+BdK8Rc+SFE0v/r7OwT6/8tktIMeNGOJGmZBxLpMnK21YV+uhweGcwXsY64TkluTP9YGNd+VbPVbBdxmLNF4dlQFFLm0KNRU/9cQxXGAzqWQprhZ/8sHZbg72ffmgmLtbD9WYfJXk5n7ZsX/sWOBwA==)
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk90t4/
+  :body: |-
+    ### Ruby
+
+    I got impatient and didn't think about the data size when iterating. Final solution runs in \<1s brute force.
+
+    ```ruby
+    @data = DATA.each_line.map(&:chomp).first.split(',').map(&:to_i)
+
+    Range.new(*@data.minmax).map do |i|
+      [@data.sum { (i - _1).abs },
+       @data.sum { (1..(i - _1).abs).sum }]
+    end.transpose.map(&:min).map(&method(:puts))
+
+    __END__
+    1101,1,29,67,1102,0,1,65,1008...
+    ```
+  :replies: []
+- :author: madethemcry
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkbxsh/
+  :body: "# RUBY\n\n[georgiee/advent-of-code-2021/day-07 (GitHub)](https://github.com/georgiee/advent-of-code-2021/tree/main/day-07)\n\n# Notes\n\nOk I was SUPER fast for part 1 (well not fast enough for the leaderboard, ~10mins or so) but then part 2 got me like Day 6 got me: It was running forever. This time I had no immediate clue what was wrong. I tinkered around with the range which I calculated as `range = (input.min..input.max)` so covering the entire x-axis where the crabs are hanging around. In part 1 I was lucky and I could use `input.compact.uniq` instead but this is not working here as we might miss some ideal positions (like the `5` from the example).\n\nSo what now? Let's optimize in a classical way, maybe the code runs slow for all the given permutations. I was using `key.downto(1).inject(:+)` to add up the numbers. That's expensive so what do you do ? Cache it. I used the great `default_proc` fucntionality of the ruby hash. That's a proc invoked for not existing keys. That way I can calculate values for a new key and return previous calculations directly without calculation.`TRIANGLE_CACHE.default_proc = proc { |hash, key| hash[key] = key.downto(1).inject(:+) }`\n\nThis was the first time it worked with painful 6 or so seconds.\n\nI submitted the result but I wanted to see if I can bring that number down. When I searched for `factorial but with addition` I came across the triangle numbers which are familiar to me from statistics (but my mind did not conclude this before google). So instead of adding up all numbers manually I can shortcut and do the math with `n*(n+1)/2` \U0001F918 I removed the cache and replaced it with the direct calculation. It's now 2.7 seconds.\n\nIf I bring back the hash cache, I can shave another 0.75s probably because of the shear amount of permutations I'm processing. I had some ideas for precalculate all permutations to remove duplicates, then calculate and the group the results back to the specific positions to add them up again. But my stamina is gone for this day.\n\nSo it's 1.9s.\n\n# CODE (part 2 only)\n\n```ruby\nrequire 'benchmark'\n\npath = File.join( __dir__ , 'input.txt')\ninput = File.read(path).split(',').map(&:to_i)\n\nrange = (input.min..input.max)\n\n# create a cache for the calculation of the triangle number, saves 0.7s\nTRIANGLE_CACHE = {}\nTRIANGLE_CACHE.default_proc = proc do |hash, key|\n  hash[key] = triangle_number(key)\nend\n\n# search for factorial but with addition\n# and got my hands on the name of the \"algorithm\"\ndef triangle_number(n)\n  n*(n+1)/2\nend\n\ndef cost_to_align(input, position)\n  input.inject(0) do |memo, value|\n    memo + TRIANGLE_CACHE[(value - position).abs]\n  end\nend\n\n# 1.922631 0.008752 1.931383 ( 1.942595)\nputs Benchmark.measure {\n  result = range.to_a.map do |position|\n    fuel = cost_to_align(input, position)\n    [position, fuel]\n  end\n\n  puts result.min_by { _1[1]}[1]\n}\n```"
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkg35y/
+  :body: |-
+    I'm happy with the brute force ruby solution for part 2. I think one can be faster if instead of computing all values and doing #min you just terminate early when the previous value is smaller than the current one but I can't express that in a short way :)
+
+    ```ruby
+    def dist(to)
+      to * (to + 1) / 2
+    end
+    def fuel_to(input, median)
+      input.sum { |i| dist((i - median).abs) }
+    end
+    def solve2(input)
+      min, max = input.minmax
+      (min..max).map { |m| fuel_to(input, m) }.min
+    end
+    ```
+  :replies:
+  - :author: lygaret
+    :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkh3r7/
+    :body: |-
+      how to go from O(n) to O(log n)? binary search!
+
+      ```ruby
+      # find a minimum by binary search over slope
+      # numerically find the cost slope by looking at points next to the cursor
+      # if we're pointing upwards, alpha < cursor < beta, make cursor max and continue
+      # if we're pointing downwards, alpha > cursor > beta, make cursor min and continue
+      # if we're in a valley, we're at a minimum (hoping there's no local minima)
+      min = input.min
+      max = input.max
+      result = loop do
+        cursor = min + ((max - min) / 2)
+        ca, cc, cb = cost[cursor - 1], cost[cursor], cost[cursor + 1]
+
+        case
+        when ca < cc && cc < cb
+          max = cursor # slope is positive, move window down
+        when ca > cc && cc > cb
+          min = cursor # slope is negative, move window up
+        when ca > cc && cc < cb
+          break cursor # slope is at a minimum, what we're looking for
+        else
+          # slope is at a flat line or a local maximum, perturb
+          cursor += [-1, 1].sample
+        end
+      end
+      ```
+    :replies: []
+- :author: icyFur
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkk3ah/
+  :body: |-
+    I did this in Ruby: For part one ([full code](https://getsturdy.com/advent-of-code-2021-uoeIDQk/browse/day07/kiril/partone.rb)) the least fuel is at the median - def median(input) sorted = input.sort len = sorted.length (sorted[(len - 1) / 2] + sorted[len / 2]) / 2 end
+
+    ```ruby
+    target = median(input)
+
+    fuel = 0
+    input.each do |i|
+      if target > i
+        fuel += target - i
+      else
+        fuel += i - target
+      end
+    end
+    pp fuel
+    ```
+
+    And in part two ([full code](https://getsturdy.com/advent-of-code-2021-uoeIDQk/browse/day07/kiril/parttwo.rb)) the least fuel is at the average. I did a bit of a hack...
+
+    ```ruby
+    target = input.sum.to_f / input.size
+    pp target
+
+    fuel_1 = 0
+    fuel_2 = 0
+    input.each do |i|
+      delta_1 = (target.floor - i).abs
+      fuel_1 += (delta_1 * (delta_1 + 1)) / 2
+      delta_2 = (target.ceil - i).abs
+      fuel_2 += (delta_2 * (delta_2 + 1)) / 2
+    end
+
+    # Sorry - this is a bit dirty
+    pp fuel_1
+    pp fuel_2
+    ```
+  :replies: []
+- :author: bobtom8482
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnlholw/
+  :body: |-
+    Continuing trying to learn Ruby for my first job (!).
+
+    Memoisation improved my time by a factor of 100 (20s to 0.2s)
+
+    [linky](https://topaz.github.io/paste/#XQAAAQCKAwAAAAAAAAAxmwhIY/U9T3vi0RAbnIXPKO8G25aDTAtzs9PptRokuGsXXB+f8iGcRzobqJqEdB6RdPjOtf4bhTtlr/VEsbh9/Gj2J7g/UNSTfusRq973DNk7ZVkoRWqHamdfPjmc2YjbVZ0XsPgJINxElHlW2wNkTTPSvi8QqBkV68QSBTvQhsP7U9PX9U1YIDK266jldcHbnJ1eetuH5hX0krMpWHnln2eSxWKywWBRHobhzKB4IiZS8DFP7K18hO29FjLcPHRO3TCXJGCVOzYiFHxLQLYHIMdsIGAQHg7b4Ur5HnJKTfaBxfU4kUPrjO40jsRTbu6Xtb9YwX0MqrVBWOyfhbch8orUGDooYIRBsGyCTgVMJEfs2R4H0GP3llStQbh5bsMA9kBPu/GF3ve4E7XP2Pq82/lObN+Jbw59I3LXAskX8jszr8lkf5eHZy+wbP27K/qzsZs4IQZ1F8X0HKzUizgdrSAukiBoZ92yzoJsuz58wrgpHvRkRnGV1nu0wkILfm6oH+TAKEwr/kUetBusfEaLJvwCPTqLDzJ+RE6c8/+C/Gf2)
+  :replies: []
+- :author: BramboraSK
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnlqz8g/
+  :body: |-
+    My **Ruby** solution
+
+    ```ruby
+    $input = File.read("7.txt").strip.split(',').map(&:to_i)
+
+    # Part 1
+    def p1
+        median = $input.sort[$input.length / 2 - 1]
+        fuel = 0
+
+        $input.each { |pos| fuel += (pos - median).abs }
+        return fuel
+    end
+
+    puts p1
+
+    # Part 2
+    def p2
+        mean = ($input.reduce(:+) + 1) / $input.length
+        fuel = 0
+
+        $input.each { |pos| fuel += (pos - mean).abs * ((pos - mean).abs + 1) / 2 }
+        return fuel
+    end
+
+    puts p2
+    ```
+  :replies: []
+- :author: zxywx
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk6ssa/
+  :body: |-
+    # Ruby
+
+    Part 2 takes about 0.18s.
+
+    ```ruby
+    module Year2021
+      class Day07 < Solution
+        def part_1
+          calc_fuel { |x| x }
+        end
+
+        def part_2
+          fuel = Hash.new { |h, k| h[k] = (k == 0 ? 0 : (h[k - 1] + k)) }
+          calc_fuel { |x| fuel[x] }
+        end
+
+        private
+          def calc_fuel
+            min, max = data.keys.minmax
+            min.upto(max).map { |i| data.map { |c, v| yield((i - c).abs) * v }.sum }.min
+          end
+
+          def process_input(line)
+            crabs = Hash.new(0)
+            line.split(",").each { |crab| crabs[crab.to_i] += 1 }
+            crabs
+          end
+       end
+    end
+    ```
+  :replies:
+  - :author: zxywx
+    :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnka24h/
+    :body: |-
+      I realise now I could replace my brute-force fuel calculation with this:
+
+      ```ruby
+      def part_2
+        calc_fuel { |x| x * (x + 1) / 2 }
+      end
+      ```
+    :replies: []
+- :author: Archer_Winter
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnk7o4d/
+  :body: |-
+    Ruby Solution
+
+    `def parse\_fileFile.open('input.txt').readlines.map(&:chomp)[0].split(',').map(&:to\_i)endnumbers = parse\_filemax = numbers.maxp maxsums = []for i in 0..max
+
+    # part
+
+    sums[i] = numbers.map { |num| (num - i).abs }.sum
+
+    # part 2sums[i] = numbers.map { |num| (0..(num - i).abs).sum }.sump iendp sums.min`
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnklwsw/
+  :body: |-
+    Ruby: [https://github.com/sreedevk/advent-of-code/blob/main/ruby/2021/day7/main.rb](https://github.com/sreedevk/advent-of-code/blob/main/ruby/2021/day7/main.rb)
+
+    Elixir: https://github.com/sreedevk/advent-of-code/blob/main/elixir/lib/twenty21/day7.ex
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkmx1t/
+  :body: |-
+    **Ruby** : 5:00/10:26
+
+    Here's a [recording](https://youtu.be/26OIfAG7Uek) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec07.rb). I usually stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    Tried to outsmart Part 1 and jumped to using the average instead of just being inefficient and computing everything. Turns out that'd be useful for Part 2, but I had just rounded the average, it still would've been incorrect! I messed up computing triangle numbers too (did squares first). Just bad all around.
+  :replies: []
+- :author: ldhmachin
+  :url: https://www.reddit.com/r/adventofcode/comments/rar7ty/2021_day_7_solutions/hnkqmt1/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    module Day7
+
+        extend self
+
+        def part_one(crabs)
+            solution = -1
+            (crabs.min...crabs.max).each do |target_crab|
+                attempt = crabs.map { |crab| (target_crab - crab).abs }.sum
+                solution = attempt if ((attempt < solution) or (solution < 0))
+            end
+            return solution
+        end
+
+        def triangle(n)
+            return (n) * (n + 1) / 2
+        end
+
+        def part_two(crabs)
+            solution = -1
+            (crabs.min...crabs.max).each do |target_crab|
+                attempt = crabs.map { |crab| triangle((target_crab - crab).abs) }.sum
+                solution = attempt if ((attempt < solution) or (solution < 0))
+            end
+            return solution
+        end
+
+        def solve_part_one(lines)
+            list = lines.map { |n| n.chomp.split(",").map { |m| m.to_i } }.first
+            return part_one(list)
+        end
+
+        def solve_part_two(lines)
+            list = lines.map { |n| n.chomp.split(",").map { |m| m.to_i } }.first
+            return part_two(list)
+        end
+
+    end
+    ```
+  :replies: []