advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,683 @@
+---
+- :author: brushbox
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmyyybi/
+  :body: |-
+    # Ruby
+
+    input = File.read(“input.txt”).split(“\n”).map(&:to\_i)
+
+    # pt 1
+
+    input.each\_cons(2).select { |a,b| a \< b }.count
+
+    # pt 2
+
+    input.each_cons(3).map(&:sum).each_cons(2).select { |a,b| a \< b }.count
+  :replies:
+  - :author: waitingformsfs2020
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hqtops0/
+    :body: I was learning ruby and now I will start college so i gotta learn C. I hate how complicated C is.
+    :replies:
+    - :author: brushbox
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hquu30n/
+      :body: |-
+        C may be complicated but it is worth learning for many reasons. Not least is that many other languages are implemented in C (including Ruby). It helps you appreciate the work that has been put in to make your favourite language so pleasant to use.
+
+        Good luck in college!
+      :replies: []
+  - :author: zloth
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hoswr4d/
+    :body: |-
+      copy/paste typo perhaps?
+
+      ```ruby
+      select { |a, b| a < b }
+      ```
+    :replies: []
+- :author: retro__grade
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmylktx/
+  :body: |-
+    **Ruby (part 1):**
+
+    ```ruby
+    require 'csv'
+
+    INPUT = CSV.read('input.csv').flatten.map(&:to_i).freeze
+
+    def find_depth
+        result = 0
+        INPUT.each_with_index do |item, index|
+            break if INPUT[index + 1].nil?
+
+            result += 1 if item < INPUT[index + 1]
+        end
+        result
+    end
+    ```
+  :replies: []
+- :author: dtinth
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrf5u4/
+  :body: "```ruby\n# Ruby, 1381 / 452\np $<.read.split.map(&:to_i).each_cons(2).count{|a,b|b>a}\np $<.read.split.map(&:to_i).each_cons(3).map(&:sum).each_cons(2).count{|a,b|b>a}\n```\n\nI made 2 silly mistakes (e.g. forgot to convert to int and used the wrong comparison operator). Next time I will remember to test with example data first \U0001F604\n\nEdit: Thanks to the suggestions by u/gurgeous, u/BluFoot, u/442401, the above can be improved like this:\n\n```ruby\np $<.each_cons(2).count{_2.to_i>_1.to_i}\np $<.map(&:to_i).each_cons(3).each_cons(2).count{_2.sum>_1.sum}\n```"
+  :replies:
+  - :author: BluFoot
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrgkpw/
+    :body: |-
+      Nice, I golfed mine down to the same thing with a couple extra simplifications. The `.read.split` isn't necessary
+
+      ```ruby
+      p $<.map(&:to_i).each_cons(3).map(&:sum).each_cons(2).count{|a,b|a<b}
+      ```
+    :replies:
+    - :author: '442401'
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrhejm/
+      :body: |-
+        Save a few bytes by not mapping
+
+        `p $<.map(&:to_i).each_cons(3).each_cons(2).count{|a,b|a.sum<b.sum}`
+      :replies:
+      - :author: BluFoot
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrlbs0/
+        :body: |-
+          And I upgrade to ruby 3 just to save a few more! Down to **63 bytes** , pretty good.
+
+          ```ruby
+          p $<.map(&:to_i).each_cons(3).each_cons(2).count{_1.sum<_2.sum}
+          ```
+        :replies:
+        - :author: '442401'
+          :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmryop9/
+          :body: |-
+            edit: **48 bytes**
+
+            Hat-tip to /u/CodeIsTheEnd
+
+            This blew my mind when I [saw it on Youtube](https://www.youtube.com/watch?v=gw8aNa8AuyA)
+
+            `p $<.map(&:to_i).each_cons(4).count{_1[0]<_1[3]}`
+          :replies:
+          - :author: BluFoot
+            :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmszy2s/
+            :body: |-
+              What is this sorcery??
+
+              Edit: ahhh, the middle ones cancel out, makes sense.
+            :replies: []
+    - :author: dtinth
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrh40r/
+      :body: 'Thanks! TIL: `$\<` is an Enumerable that yields each line from stdin.'
+      :replies:
+      - :author: "[deleted]"
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrslua/
+        :body: i think it's the same as ARGF
+        :replies:
+        - :author: dtinth
+          :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms8pys/
+          :body: I just checked, you're right, `$<` is `ARGF`. I didn't know until today that `ARGF` is also an Enumerable.
+          :replies: []
+  - :author: gurgeous
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmri8mc/
+    :body: Also try using \_1 and \_2 instead of a & b. Added in 2.7. Once you start using numbered params you'll never go back!
+    :replies:
+    - :author: dtinth
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrl0yo/
+      :body: That’s another TIL. My Ruby is so rusty.
+      :replies: []
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrnyjp/
+    :body: |-
+      Like you, I also wasted an awful lot of time by not converting to int. But, I don't understand why the result would differ? (For me, it was off by 1)
+
+      The `String` class includes the `Comparable` module and `"1" < "2" #=> true`, so why didn't we find the correct solution?
+
+      (Part 2 would have got us in the end anyway)
+    :replies:
+    - :author: dtinth
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms8uoh/
+      :body: Probably because `'120' < '50'` but `120 > 50`.
+      :replies:
+      - :author: '442401'
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms9dlv/
+        :body: |-
+          Ahhh! Of course!
+
+          The same reason why "track_11" comes before "track_2"
+
+          I should have known this from my Napster days.
+
+          Thank you.
+        :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrkw73/
+  :body: |-
+    **Ruby** : 1:37/3:44, 370/280
+
+    Here's a [recording](https://youtu.be/gw8aNa8AuyA) of me solving it, and the code is [here](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2021/dec01.rb). I stream myself solving every day's problem on [Twitch](https://twitch.tv/codeistheend)!
+
+    Pretty standard Day 1. Might've made the leaderboard for Part 1 if I didn't get a 504, who knows though. Definitely not for Part 2.
+  :replies:
+  - :author: _jstanley
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrn4y5/
+    :body: Rotten luck on the 504s! Nice work.
+    :replies: []
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms181y/
+    :body: "Wow!\n\nThanks for sharing.\n\nIt's this type of thinking that blows my mind every year. Here's me doing `each_cons(3).each_cons(2).count{...}` and you're just like \"nah, as long as the one 4 in front is bigger, we're good\"\n\n\U0001F92F"
+    :replies: []
+- :author: damyvv
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms968d/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    input = File.read("day01_input.txt").lines.map(&:to_i)
+    p input.each_cons(2).count {|a,b| b > a }
+    p input.each_cons(3).map(&:sum).each_cons(2).count {|a,b| b > a }
+    ```
+  :replies:
+  - :author: Initial_Soil_9261
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms9h99/
+    :body: |-
+      similar to mine:
+
+      ```ruby
+      depths = File.readlines("day1.txt").map(&:to_i)
+      p depths.each_cons(2).count { |a, b| a < b }
+      p depths.each_cons(4).count { |a, *, b| a < b }
+      ```
+    :replies:
+    - :author: damyvv
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmsae2s/
+      :body: Nice one! I didn't actually think about comparing the outer values of the sliding window. Good find.
+      :replies: []
+  - :author: petercooper
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmsgjyv/
+    :body: |-
+      Just for the sake of anyone who finds it interesting, you can now also do this in Ruby 3.0+:
+
+      ```ruby
+      p input.each_cons(2).count { _2 > _1 }
+      ```
+
+      I imagine some may prefer or not prefer this - definitely a matter of taste!
+    :replies: []
+  - :author: SadBunnyNL
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms9ae6/
+    :body: I really gotta start learning that stuff... It always looks so powerful and generally purposeful, yet I never get around to it! Thanks for your solution.
+    :replies:
+    - :author: damyvv
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms9v1q/
+      :body: Hallo mede-Nederlander ;). Thanks for your comment, I will post all my solutions [here]([https://github.com/damyvv/advent-of-code-2021](https://github.com/damyvv/advent-of-code-2021)). And you can find all my solutions from last year [here]([https://github.com/damyvv/AoC\_2020](https://github.com/damyvv/AoC_2020)). Ruby is so powerful, I truly enjoy coding with it. If you have any questions about Ruby, let me know, I'll be happy to answer them if I can.
+      :replies: []
+- :author: gurgeous
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrfgli/
+  :body: |-
+    Ruby. I was fast, but not as fast as you guys!
+
+    ```ruby
+    p data.each_cons(2).count { _1 < _2 }
+    p data.map.each_cons(3).map(&:sum).each_cons(2).count { _1 < _2 }
+    ```
+  :replies:
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrh2io/
+    :body: |-
+      Nice.
+
+      For part 2 I did
+
+      `p data.each_cons(3).each_cons(2).count { _1.sum < _2.sum }`
+    :replies: []
+  - :author: flwyd
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmri827/
+    :body: Whoa, I didn't realize Ruby had implicit block parameters (which is what I assume `_1` is). Is that a relatively new feature?
+    :replies:
+    - :author: gurgeous
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrih3f/
+      :body: Added in 2.7 and quite handy! I use it everywhere now, both at work and for advent. I appreciate not having to make up silly param names for simple code.
+      :replies: []
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrsexd/
+    :body: why do you need the `.map` in `.map.each_cons`?
+    :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrky8s/
+  :body: |-
+    Ruby
+
+    https://github.com/sreedevk/advent-of-code/blob/master/ruby/2021/day1/main.rb
+  :replies:
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrlox0/
+    :body: |-
+      Nice.
+
+      No need to `select` & `count`, just `count` ;-)
+    :replies:
+    - :author: "[deleted]"
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrmjlk/
+      :body: Thank you! :D Updated!
+      :replies: []
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrmz20/
+  :body: |-
+    ### Ruby
+
+    Okay so for this one all you have to do is just sort the input and... what do you mean I wasn't supposed to do it this way?
+
+    ```ruby
+    depths = ARGF.each_line.map(&method(:Integer)).each_with_index.sort_by { |a, b| [a, -b] }.map(&:freeze).freeze
+    def count_increases(xs, delta)
+      smaller = Array.new(xs.size)
+      xs.count { |_, i| smaller[i] = true; i >= delta && smaller[i - delta] }
+    end
+    [1, 3].each { |delta| p count_increases(depths, delta) }
+    ```
+
+    Yes this solution actually works. No you don't need to tell me [the better way to do it](https://github.com/petertseng/adventofcode-rb-2021/blob/master/01_sonar_sweep.rb), thanks :)
+  :replies:
+  - :author: jenneh03
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrpxy4/
+    :body: Can someone explain this to me? I'm not too familiar with Ruby
+    :replies:
+    - :author: p_tseng
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrtf4p/
+      :body: |-
+        Try on the example input. Result of annotating each element with its index, and then sorting them by (value ascending, index descending):
+
+        [[199, 0], [200, 4], [200, 1], [207, 5], [208, 2], [210, 3], [240, 6], [260, 8], [263, 9], [269, 7]]
+
+        Now take a look at each (value, index) pair in turn. By the sorting order, they will come in ascending order of value. To see if a measurement value is larger than the one that **originally** (in the original input) came before it, just check whether you've already seen the index that it should be larger than. For part 1, subtract 1 from the index. For part 2, subtract 3.
+
+        Part 1:
+
+        - 199 at index 0: Since this is index 0, nothing comes before it.
+        - 200 at index 4: Is index 3 smaller? No, haven't seen it yet.
+        - 200 at index 1: Is index 0 smaller? Yes, saw it earlier.
+        - 207 at index 5: Is index 4 smaller? Yes, saw it earlier.
+        - 208 at index 2: Is index 1 smaller? Yes, saw it earlier.
+        - 210 at index 3: Is index 2 smaller? Yes, saw it earlier.
+        - 240 at index 6: Is index 5 smaller? Yes, saw it earlier.
+        - 260 at index 8: Is index 7 smaller? No, haven't seen it yet.
+        - 263 at index 9: Is index 8 smaller? Yes, saw it earlier.
+        - 267 at index 7: Is index 6 smaller? Yes, saw it earlier.
+
+        That's 7 yeses so the answer to part 1 is 7.
+
+        For part 2 it's: No, no, no, no, no, yes, yes, yes, yes, yes, for an answer of 5.
+      :replies:
+      - :author: jenneh03
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrtprz/
+        :body: "Thank you for the explanation. I love this \U0001F601"
+        :replies: []
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrqazv/
+    :body: "\U0001F92F"
+    :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrq8km/
+  :body: |-
+    ## Ruby
+
+    ```ruby
+    INPUTS = File.readlines("input1.txt").map(&:to_i)
+
+    def count_increasing arr
+      arr.each_cons(2).count{ _2 > _1 }
+    end
+
+    # part 1
+    p count_increasing INPUTS
+
+    # part 2
+    p count_increasing INPUTS.each_cons(3).map(&:sum)
+    ```
+  :replies: []
+- :author: mddubey
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmwgxfw/
+  :body: |-
+    Love ruby and how rich it is in terms of different methods.
+
+    My day 1 solution of GitHub
+
+    (https://github.com/mddubey/AoC/blob/main/2021/001/solution.rb)
+  :replies: []
+- :author: joeyGibson
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmu09qs/
+  :body: |-
+    I'm doing it all in Python this year, after doing it all in Ruby last year. Here's today's solution.
+
+    ```ruby
+    #! /usr/bin/env python3
+    import sys
+
+    def part1(lst: list) -> int:
+        res = [ind + 1 for ind, x in enumerate(lst) if ind + 1 < len(lst) and lst[ind + 1] > x]
+        return len(res)
+
+    def part2(lst: list) -> int:
+        groups = [x + lst[ind + 1] + lst[ind + 2] for ind, x in enumerate(lst) if ind + 2 < len(lst)]
+        return part1(groups)
+
+    def get_data(path):
+        with open(path) as f:
+            return [int(x) for x in f.readlines()]
+
+    if __name__ == ' __main__':
+        if len(sys.argv) == 1:
+            print('Usage: main.py <filename>')
+            sys.exit(1)
+
+        lines = get_data(sys.argv[1])
+
+        r1 = part1(lines)
+        r2 = part2(lines)
+
+        print(f'part 1: {r1}')
+        print(f'part 2: {r2}')
+    ```
+  :replies: []
+- :author: snowe2010
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmv10v7/
+  :body: |-
+    Ruby:
+
+    ```ruby
+    execute(1) do |lines|
+      lines.map(&:to_i).each_cons(2).count { |a, b| b > a }
+    end
+
+    execute(2) do |lines|
+      lines.map(&:to_i).each_cons(3).map { |a, b, c| a + b + c }.each_cons(2).count { |a, b| b > a }
+    end
+    ```
+
+    https://github.com/snowe2010/advent-of-code/blob/81f560f4f84bae2dad08a114606fe22960c07a19/ruby\_aoc/2021/day01/day01.rb
+
+    Kotlin:
+
+    ```ruby
+    execute(1) { lines ->
+        lines.map { it.toInt() }.windowed(2).count { (a, b) -> b > a }
+    }
+
+    execute(2) { lines ->
+        // turns out that b + c + d > a + b + c is the same as d > a since b and c cancel out
+        lines.map { it.toInt() }
+            .windowed(4)
+            .count { (a, _, _, d) -> d > a }
+    }
+    ```
+
+    https://github.com/snowe2010/advent-of-code/blob/81f560f4f84bae2dad08a114606fe22960c07a19/kotlin\_aoc/src/main/kotlin/aoc2021/day01.kt
+
+    I've modified the kotlin one quite a number of times using discoveries from this thread.
+  :replies: []
+- :author: zxywx
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrr4l8/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    module Year2021
+      class Day01
+        def part_1(input)
+          input.lines(chomp: true).map(&:to_i).each_cons(2).inject(0) do |count, depths|
+            depths[0] < depths[1] ? count + 1 : count
+          end
+        end
+
+        def part_2(input)
+          input.lines(chomp: true).map(&:to_i).each_cons(3).map(&:sum).each_cons(2).inject(0) do |count, depths|
+            depths[0] < depths[1] ? count + 1 : count
+          end
+        end
+      end
+    end
+    ```
+  :replies:
+  - :author: riffraff
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrsn0t/
+    :body: you don't need `chomp`, as `"1\n".to_i` is the same as `"1".to_i` . Also, you can use `.count` rather than `inject` :)
+    :replies:
+    - :author: zxywx
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrt8gk/
+      :body: Good call! Thanks
+      :replies: []
+    - :author: zxywx
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms0thz/
+      :body: |-
+        Refactored ... much tidier, thanks!
+
+        ```ruby
+        module Year2021
+          class Day01
+            def part_1(input)
+              count_increasing_depths process_input(input)
+            end
+
+            def part_2(input)
+              count_increasing_depths process_input(input).each_cons(3).map(&:sum)
+            end
+
+            private
+              def process_input(input)
+                input.lines.map(&:to_i)
+              end
+
+              def count_increasing_depths(data)
+                data.each_cons(2).count { |a, b| a < b }
+              end
+          end
+        end
+        ```
+      :replies: []
+- :author: LyleiLanar
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hms2ee2/
+  :body: |-
+    My ruby solution: [[2021 Day 1]](https://github.com/LyleiLanar/advent-of-code/blob/main/2021/day_1.rb)
+
+    Not the best, but Ruby is very new for me.
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmsqyxj/
+  :body: |-
+    # Ruby (4644/4137)
+
+    Knocked quite a bit of data manipulation rust off tonight. I like to see the inputs in-line on the page so I use the DATA/ **END** pattern.
+
+    ```ruby
+    @data = DATA.each_line.map(&:chomp)
+
+    @data.map(&:to_i).each_cons(4).map do |a, b, c, d|
+      [b > a, [b, c, d].sum > [a, b, c].sum]
+    end.transpose.map { |e| e.count(true) }.tap(&method(:puts))
+
+    __END__...input
+    ```
+  :replies:
+  - :author: Albeit-it-does-move
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hq6rjd9/
+    :body: I like the idea but if this code is giving you the right answer it might be by pure luck... Since you are reading triplets for part 2 it means neither will the last b will be compared to c, nor the last c to the last d for part 1. So if the two last values of your input are increases over previous values then the final count for part 1 will be two lower than it should be.
+    :replies: []
+- :author: KennyEvil
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmsrqka/
+  :body: |-
+    Day 1 Ruby (I loaded the values into an array called depths)
+
+    increase\_count = 0
+
+    (1..1999).each { |x| increase\_count += 1 if depths[x] \> depths[x-1] }
+
+    puts increase\_count
+
+    increase\_count = 0
+
+    (3..1999).each { |x| increase\_count += 1 if depths[x] \> depths[x-3] }
+
+    puts increase\_count
+  :replies:
+  - :author: oantolin
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmsui9j/
+    :body: Avoiding computing the sums of the sliding windows in the second part is clever!
+    :replies:
+    - :author: KennyEvil
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmt32ch/
+      :body: Thanks. It was just something I realised when I was working it out in my head, that the difference between the first and fourth input was ultimately what mattered. Meant I could keep it to one line as well.
+      :replies: []
+  - :author: oantolin
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmt3jqm/
+    :body: |-
+      My Ruby is rusty, but I think there is a count method that would let you eliminate the increase\_count variable:
+
+      ```ruby
+      puts (1..1999).count { |x| depths[x] > depths[x-1] }
+      ```
+    :replies: []
+  - :author: ywecur
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmto3j9/
+    :body: |-
+      Ruby has `each_cons` which implements the sliding window method
+
+      https://apidock.com/ruby/Enumerable/each\_cons
+    :replies: []
+- :author: jeffers0n
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmtw0cl/
+  :body: 'Got a late start today but here''s my solution in ruby: https://git.doublehack.me/s00ner/AoC2021/src/branch/master/day01/solution.rb'
+  :replies: []
+- :author: roundscribehector5
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmxrx3s/
+  :body: |-
+    [OOP Ruby Solution](https://topaz.github.io/paste/#XQAAAQD/BAAAAAAAAAA5GUqKNoFH6SMnPH0B27EPd7phjZ68/oO/XvGYmYMktKdLulbGgcNEq/E84SnUm1E0wSzPmrFBBtb4l860QuYAXUa0V1ZoR3tERaCFhLQxpDPGY0kSeBv9tfnd5kV9ZhqpO/Zz4Mi7w3Sw2u8hFBScffCn2eLyc6NeS7ui1/J9OXx4t1yqxGelCWouCPTaW1Qe4WnHz24r+hSmMa4zXqoho94I9f/HW5X2+jrjCU/jDL3fHgC+dugtCUAGg+B3sfeLg9s6FMGa0NSbSNzV0cBJV4LzMUHI5ToaK1k8r0gscf2zqieY3xAmJmqhNC0l1YoeocPd13/sFQYlkTQf3bJSCtFcJWAjhPW5A3Ce8PLVEc/F/+zWKxwj4KhqhDPrTj7Kw4MMcKKhCPpia8y+Z9IYu0oEIDj+iS4e0qIieI/DC792ipEUtWIyUaulWckc84PSFLg2p+68x/asb2H5qFuwCb/MatJXaETHQyHZt83LVdgAGmQaV5mNt5uTEbHluHBXtw+oURed5fCK/FI/TFi+UxmKhawHMebxwLNqMw276noz1bXgeCuxEahvgKwmahh4W7Op6doHZmD8c8blHP/7gaEY)
+
+    I'd appreciate any feedback.
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmrel8t/
+  :body: |-
+    Ruby 930/626
+
+    [paste](https://topaz.github.io/paste/#XQAAAQDLAQAAAAAAAAARiAqGkkN7pOxE/i+5OLDe05IXgS2qncloTxIqhlc9i6FuSU224aGk++UCtFvqS/pAFLhmHr2+ryAX6wkyWrE/xAWAY66qogr6zl3OnESY8FEIXZBLlC+f3MD8UmbUkyCP4SHfO7irP0dTJAEOvviNiuYn5/O4GzFfwnmGduXdbaAvR3qH1uTDzkkb4C+B+dUq7cYkcSXT+OHYBOtnQDTDZWQ4fDVHZRFtYitXRg0RHtn9SCXFngt4Id39RhiVxQeoY0wOUQBMFuAOZi4rvMYWPrnmwM0WQgh1CGD+9T+7Aw==)
+  :replies: []
+- :author: Happy_Laulo_33
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmu2d91/
+  :body: |-
+    In ruby :
+
+    def count
+
+     result = []
+
+     measures = File.read('puzzle1.txt').split(' ')
+
+     measures[0...-1].each\_cons(2) do |first, second|
+
+    if second.to\_i \> first.to\_i
+
+    result \<\< second
+
+    end
+
+     end
+
+     puts result.count
+
+    end
+
+    count
+  :replies: []
+- :author: Robert_TT
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmuc4p0/
+  :body: |-
+    [Part1(Ruby)](https://imgur.com/a/OBn7fA1)
+
+    [Part2[Ruby]](https://imgur.com/a/dPwGJT0)
+  :replies:
+  - :author: snowe2010
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmv4m2n/
+    :body: |-
+      can you indent your code so it's put in code blocks?
+
+      also, have you seen the ruby method [`each_cons`](https://ruby-doc.org/core-3.0.2/Enumerable.html#method-i-each_cons)?
+    :replies:
+    - :author: Robert_TT
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmwcpgg/
+      :body: I did, I am extremely sorry, I did it like 5 times and it doesn't work in the reddit code blocks for some reason :(. Sorry
+      :replies:
+      - :author: snowe2010
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmydf36/
+        :body: You have to add 4 spaces before every line, and you also have to have blank lines before and after your code.
+        :replies:
+        - :author: Robert_TT
+          :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmyf4r0/
+          :body: thank you for explaining !
+          :replies: []
+    - :author: Robert_TT
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmyf3ht/
+      :body: I haven't used the each cons method yet, thank you for the suggestion!
+      :replies: []
+- :author: antoniotto
+  :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmucq9b/
+  :body: |-
+    This is my solution in Ruby:
+
+    depths = File.readlines('input\_day1.txt', chomp: true).map(&:to\_i)
+
+    increments = depths.each\_cons(2)
+
+    .map { |x, y| x \< y ? 'increased' : 'decreased' }
+
+    answer1 = increments.count('increased')
+
+    increments\_by3 = depths.each\_cons(3).to\_a
+
+    .each\_cons(2)
+
+    .map { |x, y| x \< y ? 'increased' : 'decreased' }
+
+    answer2 = increments\_by3.count('increased')
+  :replies:
+  - :author: snowe2010
+    :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmv1anu/
+    :body: |-
+      several suggestions for shortening your code and making it a bit more readable
+
+      - you don't need `chomp: true`, your `map(&:to_i)` will parse the newlines just fine
+      - you don't need to map to 'increased' or 'decreased', you can simply count using the block option, e.g. `count { x < y }`
+      - I'm not sure how your part 2 works, it doesn't seem like you're summing your each\_cons(3), so you're going to be getting the wrong answer there.
+
+      Here's my solution if you care. https://github.com/snowe2010/advent-of-code/blob/master/ruby\_aoc/2021/day01/day01.rb
+    :replies:
+    - :author: '442401'
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmve0d5/
+      :body: I haven't tested it, but I'm confident part 2 works. Summing is not necessary. The middle 2 values cancel each other out.
+      :replies:
+      - :author: snowe2010
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmvgddu/
+        :body: I learned that from another comment, thank you. Wouldn’t you need to each\_cons(4) though?
+        :replies:
+        - :author: '442401'
+          :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmvs6r3/
+          :body: |-
+            I would imagine that if OP posted it here, it works.
+
+            I really don't want to look at it any longer than possible though, because the absence of formatting makes my eyes hurt.
+          :replies: []
+    - :author: antoniotto
+      :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmvef6w/
+      :body: |-
+        Thank you for your suggestions, I realize now the second part should be, in my original style, like:
+
+        increments\_by3 = depths.each\_cons(3)
+
+        .map(&:sum)
+
+        .each\_cons(2)
+
+        .map { |x, y| x \< y ? 'increased' : 'decreased' }
+
+        Still have to try the count block option.
+      :replies:
+      - :author: snowe2010
+        :url: https://www.reddit.com/r/adventofcode/comments/r66vow/2021_day_1_solutions/hmvgwlt/
+        :body: Somebody actually pointed out that you don’t actually have to do any summing, which means you were actually almost right the first time. I think you just have to each\_cons(4) instead.
+        :replies: []