advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2022/04.yml

@@ -0,0 +1,631 @@
+---
+- :author: ffrkAnonymous
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iz7zyhh/
+  :body: |-
+    Ruby
+
+    [paste](https://topaz.github.io/paste/#XQAAAQBXDQAAAAAAAAARiAlH8dxNBu7dkgwpusw3/1N9B7LsXMI7hyVChWl1esX/VYUvuckt47qc849AGx2bqC6Mz07VInqrh4crIFXyrI4CfGTNzODpbSnHXixOMvXuVlWHF9UJRmB2q2yZmBjsbfPWSTWTXe6AMsrfqcBGONMVbaXI539vvlT+d4o9MJ7nPEQ0gNhlHDMFso2lwZOxb6LOesx4b+CFQccWvA1a6xavmY6AVBaPgm+4pp9W7j1XOLX3+COpisJ12iCMarQrxDIjeN2ThjdA2h0OGSHF5CVhO1i8RFoJZpRnnty/Qs56EiU6V1Q3RnhoMWV7rt2g8nNz6Z9wBEyxlaS8V9DWg8+YQgMem12lhKUUIDDWgkl966X3lxBL01LaiRtVGFE7ElPbgrqS9P1o62MdxukImt89fIRGBltorXYmr+w0u1tvyYCN6gAK6wlBZwbw2gH4DYYavaQZrqcfOURfDWj+/OGOAVUYUnzPy6Mxjjf3DSgd/RJ6J9CKLdoCfMfP6N7mMjEz8aDxCMJcOMc8+5OtGWh9WL3pTGKrYlZiFfJscZlV1o+6v90QIdk+cU7fHCDidUcPcK6Ljpimq8uZjoS9xHPbB4NvR7pHt8TbeJkp2RGDZVN1BF2nKQHLEaUKGFKhRE2/5NoEahEYpYNhG629iuDzVnYYrL6mmOHuPkIB/m42Vc93PmWB2CaEruoOxP5RnXtF152XdXBxA8XtVtAOaP7tzo9SOmhuyTqfMn3jTNVUunS9y1D0L8M28rwd81HTyIMkFrMtxH9yNl5OTbU3bxGBwIN49AM+FSCNk6yYEWfRqow9E49ft/kPEG9wsKoz+fCEoPgn7BSgDfKU2ggNY0zhUPdSGpKg7gOyiBqoLlmwyd8ip+vG2aL7zTWmbXM/0JBHZ054pMeRDRRUpS7CWoqlY2pht/LrwWDp556ID6nZ5AA7TpBxRk/S8+zFQ4voXVEeWMHWV55nOhg05LnR/Sto3zbtb8D9thhpRTcbYHdCUwi4aX9NEr6x2joxuHc5FU9wuzakOQJQ+x3Ua0LflqOeMS/xx0ErrmbgGD3I6AAsFCSTzRkBA5LPZT8JMG6tfCpePAj/oLFDgg==)
+
+    Learning ruby. Very clunky.
+  :replies:
+  - :author: PiurEwil
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/j1p89i4/
+    :body: |-
+      That's actually not _very_ clunky! :) Just a few common Ruby idioms, and it will be perfectly nice code!
+
+      - Awesome that you are testing! Check out [minitest](http://docs.seattlerb.org/minitest/) - it's a no-overhead testing library. You will not have to write your own comparison/assertion method, and - if you write separate test methods for each sample case - you will get a nice summary of what's passing and what's failing. Also `gem install minitest-rg` (if you are not colorblind) and optionally `fivemat` for nicer output.
+      - If your blocks are multiline, use `do` ... `end` instead of `{ }`. Block indentation helps follow the structure of code!
+      - Your methods are reasonably sized and easy to understand :)
+      - When you have a ton of (test) data, put them in one variable you can iterate over, instead of multiple variables:
+
+      - I see you are using `Array#map()`, that's cool - there are other methods on `Array` and `Enumerable` that can help you, like the different overloads for [Enumerable#count()](https://ruby-doc.org/core-3.0.0/Enumerable.html#method-i-count)!
+
+      - BTW, you can deconstruct `Array`s passed as block arguments easily, instead of assigning manually - don't write `room_assignments.map { |assignment|`, write `room_assignments.map { |first_start, first_end, second_start, second_end|`
+
+      - In Ruby, it's less common to use `0` and `1` for `false` and `true`, than using, well, `false` and `true` ;) - and _clever_ programmers sometimes use `nil` instead of `false` for tricks like [Array#compact()](https://ruby-doc.org/core-3.0.0/Array.html#method-i-compact) (clever isn't always readable/maintainable, though).
+
+      - If you don't hardcode `"input4.txt"`, but instead use something like `ARGV.first`, it will be easy for you to run your code with different inputs (testing, real data).
+
+      - In the long term, same goes for testing data - many people like putting that in separate files, like YAML instead of that `Hash` I suggested earlier. Opinion-based, I guess.
+
+      Keep up the good work! :)
+    :replies:
+    - :author: ffrkAnonymous
+      :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/j1rr1v9/
+      :body: |-
+        wow, thanks for the thoughtful christmas present. I'm glad my 4th day of ruby wasn't totally awful.
+
+        - Other people pair program with rubber duckies. I have a testing goat. I couldn't find anything similar to python doctest. Minitest was too intimidating but now that I have more experience, and the puzzles are more complex I'll look into it again. I also received a suggestion to organize the entire year into a test structure that can run every day altogether. Minitest would probably be good for that.
+
+        - I love your idea of organizing test data into the iterable. Someone else taught me about doing the same for printing debug output with `[] * ","`
+
+        - Yes, I've spend more time reading and re-reading the docs than actually writing code.
+
+        - For the 1, 0, I was probably tunnel vision into adding. I've since learned about `filter()`, so refactoring to true/false would be cleaner.
+
+        - I didn't know to use argv in ruby. Thank you.
+
+        - I found the autoformatter and it has admonished me many times about the {} vs. do-end. And about long methods.
+
+        Might I pick your brain about multi-dimensional data-structure? For Day 8, 12, 14? I played with Hash of complex `0+0i` which felt clean but not extendable to 3d, and I'm trying out hashes of hashes for day 14. Array of Array doesn't seem any easier, and 500\*500 nil rubs me the wrong way.
+      :replies:
+      - :author: PiurEwil
+        :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/j1wm0wk/
+        :body: |-
+          The good thing about Advent of Code, as opposed to some other programming contests, is that it's entirely optional to optimize your code (for speed, memory usage, complexity class etc.), so you can focus on whatever pleases you. I typically write the most straightforward and "readable" code that comes to me, even if in the back of my mind something is nagging me about red-black trees and other less enjoyable things :D So, if you feel that a `Hash` of `Hash`es represents the problem nicely, then go forward and have no regrets ;)
+
+          Then again, there's something called "primitive obsession", that is overusing basic data structures, when it would be nicer to organize your code into classes. Say, for day 7 (filesystem), I definitely enjoyed object-oriented-modelling the heck out of the problem - creating classes for `File`, `Directory`, `Cmd`, and so on. Can it be done using just `Hash`es and `Array`s? Yeah...but in my code, I was able to implement a bunch of cute helpers for traversing subdirectories, printing a nice `tree` and all that. So I liked it.
+
+          On the other hand, for day 8 (tree visibility), I went with an `Array` of `Array`s, and it was just what I needed for this particular input/model (a rectangular, not-sparse 2D grid). Well, the Array then had `Tree` objects, with `attr_reader :height` and `attr_accessor :visible`, but that's another story.
+
+          > I've spend more time reading and re-reading the docs than actually writing code.
+
+          AoC is perfect for learning a new language this way, as it challenges you to dive into different problem domains and get a quick overview of the entire standard library :)
+
+          > Minitest was too intimidating
+
+          Now that you know a bit more Ruby, it should be much less so. In a new file, you just require `minitest/autorun` and your code file, then every method starting with `test_` in a class inheriting from `< Minitest::Test` will automagically become a test case. [Minitest::Assertions](https://docs.seattlerb.org/minitest/Minitest/Assertions.html) is plenty for AoC, I don't think I even had to use [Mocha mocks](https://github.com/freerange/mocha) for most days.
+
+          > I found the autoformatter and it has admonished me many times about the {} vs. do-end. And about long methods.
+
+          Yeah, there's a bunch of these (autoformatters/linters). These built into IDEs and standalone, like `rubocop`. Just try not to overdo them - they are supposed to help you, not make your life harder. For me a linter is only requires when I work on a project with multiple people - to enforce an agreed-upon coding standard. Then again, I already have a somewhat quirky preferred style ;)
+        :replies:
+        - :author: ffrkAnonymous
+          :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/j1x1mex/
+          :body: "Yeah, for day9 monkeys i learned classes. I was very confused why ruby complained that my methods (attributes) didn't exist. \U0001F61B\n\nYour tree array demonstrated something I read long ago: choose the right data structure and your code writes itself. For now I'm just getting familiar with the basic structures (and limitations). `Hash` of `Hash`es is more \"dunno what other options/structures to choose from\". So just experiementing before I reach the wacky trees and graphs for the later days.\n\nThank you again for your advice and wisdom."
+          :replies: []
+- :author: SolarBear
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvahdo/
+  :body: |-
+    Ruby solution. Again, using Ruby felt like cheating.
+
+    ```ruby
+    file = File.open('input4.txt')
+
+    overlaps1 = 0
+    overlaps2 = 0
+
+    def elf_range(line)
+      min, max = line.split('-')
+      (min.to_i..max.to_i).to_a
+    end
+
+    file.readlines.each do |line|
+      first, second = line.split(',')
+      first = elf_range(first)
+      second = elf_range(second)
+
+      overlaps1 += 1 if first.difference(second).empty? || second.difference(first).empty?
+
+      overlaps2 += 1 if first.intersect?(second) || second.intersect?(first)
+    end
+
+    file.close
+    puts overlaps1
+    puts overlaps2
+    ```
+  :replies:
+  - :author: dikkie91
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvdq3d/
+    :body: Your solution looks quite similar to what I did in Scala..
+    :replies: []
+- :author: Alleyria
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iywoenf/
+  :body: |-
+    Ruby:
+
+    ```ruby
+    pairs = File.readlines('4.input').map { eval("[#{_1.gsub('-', '..')}]") }
+
+    # Part 1
+    puts(pairs.count { |(a, b)| a.cover?(b) || b.cover?(a) })
+
+    # Part 2
+    puts(pairs.count { |(a, b)| (a.to_a & b.to_a).any? })
+    ```
+  :replies: []
+- :author: Arakiyda
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyudv3p/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    puts File.open('input.txt').each_line
+      .select{|line|
+        pair = line.chomp.split(',').map{|assignment|
+          range = assignment.split('-').map(&:to_i)
+          (range[0]..range[1])
+        }
+        pair[0].cover?(pair[1].begin) || pair[0].cover?(pair[1].end) ||
+        pair[1].cover?(pair[0].begin) || pair[1].cover?(pair[0].end)
+      }.count
+    ```
+  :replies:
+  - :author: mathem17
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyueqa6/
+    :body: Huh neat, I didn't realize cover? was a thing. It feels like there's a ruby function for everything you need.
+    :replies:
+    - :author: Arakiyda
+      :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyuf50x/
+      :body: Right? I love Ruby for how often I find exactly what I'm looking for when I read the docs for a class
+      :replies:
+      - :author: MartinSch64
+        :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyx6nwt/
+        :body: Rubys standart library is indeed very nice.
+        :replies: []
+- :author: jeffers0n
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvs13d/
+  :body: |-
+    Ruby
+
+    Did everything with Range objects and the "cover?" method. https://git.doublehack.me/s00ner/AoC2022/src/branch/main/day04/solution.rb
+  :replies: []
+- :author: DanZuko420
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iywjta7/
+  :body: |-
+    Day 4 solution with Ruby. I had an easier time grokking today's than previous days, for some reason. I tried to do that last loop in one line, but I was getting my syntax or formatting wrong or something and it didn't work. I don't like the extra lines but I'm not golfing
+
+    ```ruby
+    assignments = File.read('input').split("\n")
+    inclusive_count = 0
+    overlap_count = 0
+
+    def to_range(input_array)
+      Range.new(input_array[0], input_array[1])
+    end
+
+    assignments.each do |pairings|
+      one, two = pairings.split(',').map {|x| to_range(x.split('-').map(&:to_i)) }
+
+      inclusive_count += 1 if one.cover?(two) || two.cover?(one)
+
+      one.each do |x|
+        if two.to_a.include?(x)
+          overlap_count +=1
+          break
+        end
+      end
+    end
+
+    puts inclusive_count
+    puts overlap_count
+    ```
+  :replies:
+  - :author: '442401'
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyxjrrp/
+    :body: |-
+      is
+
+      ```ruby
+      one.each { break overlap_count += 1 if two.to_a.include?(_1) }
+      ```
+
+      what you were looking for?
+    :replies:
+    - :author: DanZuko420
+      :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyxn19q/
+      :body: Yes! Thank you. I was doing `overlap_count +=1; break if two.to_a.include?(_1)`
+      :replies:
+      - :author: '442401'
+        :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyxot0k/
+        :body: |-
+          Ah yes, that would increment with every iteration until the break condition is met.
+
+          Happy to help.
+        :replies: []
+- :author: thedjotaku
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iywyqb2/
+  :body: |-
+    Ruby
+
+    [https://github.com/djotaku/adventofcode/blob/4b9bbc34642ca87a4bf898e6964e3cccaac07a2c/2022/Day\_04/Ruby/solution.rb](https://github.com/djotaku/adventofcode/blob/4b9bbc34642ca87a4bf898e6964e3cccaac07a2c/2022/Day_04/Ruby/solution.rb)
+
+    I know it's not idiomatic (I think?). It's a cross between what I did with Python and some Ruby idioms.
+  :replies: []
+- :author: CSEcon
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iywzjrk/
+  :body: |-
+    ruby
+
+    [gist](https://gist.github.com/mehryar-m/d19c99cc65f12d248e7c18ae385e56c9)
+  :replies: []
+- :author: tobyaw
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyx9z0g/
+  :body: |-
+    Ruby
+
+    https://github.com/tobyaw/advent-of-code-2022/blob/master/day\_04.rb
+
+    ```ruby
+    input = File.read('day_04_input.txt')
+                .scan(/\d+/)
+                .each_slice(2)
+                .map { |i| Array(Range.new(*i)) }
+                .each_slice(2)
+
+    puts input.filter { |i| i.include? i.reduce(:&) }
+              .count
+    puts input.reject { |i| i.reduce(:&).empty? }
+              .count
+    ```
+  :replies: []
+- :author: antoniotto
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyxapgy/
+  :body: |-
+    Ruby
+
+    ```ruby
+    require 'set'
+
+    input = File.readlines('inputs/day04.txt', chomp: true)
+                .map { _1.scan(/\d+/) }
+                .map { [Set.new(_1[0].._1[1]), Set.new(_1[2].._1[3])] }
+
+    puts solution1 = input.count { (_1[0] <= _1[1]) || (_1[0] >= _1[1]) }
+
+    puts solution2 = input.count { (_1[0].intersect? _1[1]) }
+    ```
+  :replies: []
+- :author: nithinbekal
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyubm0h/
+  :body: |-
+    ### Ruby
+
+    ```ruby
+    def part1
+      ranges.count { |r1, r2|
+        overlap = r1.to_a & r2.to_a
+        r1.to_a == overlap || r2.to_a == overlap
+      }
+    end
+
+    def part2
+      ranges.count { (_1.to_a & _2.to_a).any? }
+    end
+
+    private
+
+    def lines = File.readlines("input/04.txt", chomp: true)
+
+    def ranges
+      lines
+        .map { _1.split(",") }
+        .map { |range| range.map { _1.split("-").map(&:to_i) }.map { _1.._2 } }
+    end
+    ```
+
+    [Github](https://github.com/nithinbekal/advent-of-code/blob/e7af75a86b7ff9160e6f95b3b9dd5c41a6b8845f/lib/04.rb)
+  :replies: []
+- :author: BluFoot
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyubrfg/
+  :body: |-
+    **Ruby** , golfed to 81 bytes
+
+    I must be missing something here, but I can't figure it out.
+
+    ```ruby
+    p$<.count{|l|
+    x,y=l.split(?,).map{a,b=_1.split ?-
+    (a.to_i..b.to_i).to_a}
+    x&y!=[]}
+    ```
+
+    OR
+
+    ```ruby
+    p$<.count{|l|
+    x,y=l.split(?,).map{a,b=_1.split ?-
+    a.to_i..b.to_i}
+    x.any?{y===_1}}
+    ```
+  :replies:
+  - :author: damagednoob
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyuzi5z/
+    :body: |-
+      My version at 76 bytes:
+
+      ```ruby
+      p$<.count{a,b,c,d=_1.split(/\W/).map(&:to_i);((a..b).to_a&(c..d).to_a).any?}
+      ```
+    :replies:
+    - :author: BluFoot
+      :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyviqrl/
+      :body: |-
+        Ahh, the regex, nice!! I also realized that `to_i` is unnecessary. Down to ~~65~~  ~~63~~ 60 bytes!
+
+        ```ruby
+        p$<.count{a,b,c,d=_1.split /\W/
+        (a..b).to_a&(c..d).to_a!=[]}
+        ```
+      :replies:
+      - :author: '442401'
+        :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyxlefn/
+        :body: |-
+          Nice getting rid of `to_i`.
+
+          It's funny how our brains work. "These look like numbers so I better make sure they are numbers"
+
+          I fell for it, as did almost all others here.
+        :replies: []
+- :author: ScaredOfMyRawr
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyv0ifs/
+  :body: |-
+    [My solution in Ruby](https://medium.com/@ashley-peacock/advent-of-code-2022-day-4-solution-overlapping-sections-d22b9f9467d2). Pretty simple overall, but I think it can be improved.
+
+    I think there's a jazzy algorithm to do this, but I can't quite recall what it is, would love to know though! All my brain could think about was sliding windows but I don't think that's useful here as we're not trying to find an overall range etc.
+  :replies: []
+- :author: hdf1986
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyv6mux/
+  :body: |-
+    **Ruby**
+
+    Parsing part ended up a little confusing, but tried to do it quickly
+
+    Part 1: [https://github.com/hdf1986/advent-of-code/blob/master/2022/4/1.rb](https://github.com/hdf1986/advent-of-code/blob/master/2022/4/1.rb)
+
+    ```ruby
+    pairs = File.read(File.join( __dir__ , 'input.txt'))
+                .split("\n")
+                .map do |pair|
+                  pair.split(',').map do |assignment|
+                    first, last = assignment.split('-').map(&:to_i)
+
+                    Range.new(first, last)
+                  end
+                end
+
+    result = pairs.count do |pair|
+      pair[0].cover?(pair[1]) || pair[1].cover?(pair[0])
+    end
+
+    pp result
+    ```
+
+    Part 2: [https://github.com/hdf1986/advent-of-code/blob/master/2022/4/2.rb](https://github.com/hdf1986/advent-of-code/blob/master/2022/4/2.rb)
+
+    ```ruby
+    pairs = File.read(File.join( __dir__ , 'input.txt'))
+                .split("\n")
+                .map do |pair|
+                  pair.split(',').map do |assignment|
+                    first, last = assignment.split('-').map(&:to_i)
+
+                    Range.new(first, last).to_a
+                  end
+                end
+
+    result = pairs.count do |pair|
+      (pair[0] & pair[1]).any?
+    end
+
+    pp result
+    ```
+  :replies: []
+- :author: vinc686
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyv8jy8/
+  :body: |-
+    [**ruby**](https://github.com/vinc/advent-of-code/tree/master/ruby/2022/04)
+
+    ```ruby
+    input = ARGF.read.split("\n")
+    p input.count { |x| a, b = x.split(",").map { |x| i, j = x.split("-").map(&:to_i); i..j }; a.cover?(b) || b.cover?(a) }
+    p input.count { |x| a, b = x.split(",").map { |x| i, j = x.split("-").map(&:to_i); i..j }; (a.to_a & b.to_a).any? }
+    ```
+  :replies: []
+- :author: d_chae
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvdrob/
+  :body: |-
+    Ruby one-liner (p2):
+
+    ```ruby
+    p File.read("2022/day4/input.txt").split("\n").map { |pair| pair.split(",").map { |s| s.split("-").map(&:to_i) } }.reduce(0) { |sum, (a, b)| sum + (a.first > b.last || a.last < b.first ? 0 : 1) }
+    ```
+  :replies:
+  - :author: jstanley0
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvm1m0/
+    :body: |-
+      props for not writing an O(N\*\*2) range overlap test like others here did ;)
+
+      I would suggest using `count` rather than `reduce` here though
+    :replies:
+    - :author: d_chae
+      :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyxc4f0/
+      :body: Ah, I totally forgot about count! Thank you
+      :replies: []
+- :author: jstanley0
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvidjd/
+  :body: |-
+    **Ruby**
+
+    I have a headache and I didn't want to think through Range overlap logic, although I'm certain I've written it multiple times before in past Advents. So I decided to see whether `Range` has these capabilities built-in. Turns out it has `cover?`, which can solve Part 1, and ActiveSupport adds `overlaps?`. So here's what I ended with.
+
+    ```ruby
+    require 'active_support'
+    require 'active_support/core_ext'
+    pairs = []
+    ARGF.map do |line|
+      pairs << line.split(',').map{_1.split('-').map(&:to_i)}.map{Range.new(*_1)}
+    end
+    p pairs.count { |a, b| a.cover?(b) || b.cover?(a) }
+    p pairs.count { |a, b| a.overlaps?(b) }
+    ```
+
+    EDIT: I didn't think of converting each `Range` to an array and using `&` to detect overlap, like I've seen in other solutions here. That's great for getting onto the leaderboard but a highly inefficient range overlap algorithm.
+
+    EDIT 2: I looked at ActiveSupport to see the source for `Range#overlaps?` and it's dead simple: `cover?(other.first) || other.cover?(first)`. Should have thought of that. At least now I know how to use ActiveSupport outside Rails.
+  :replies: []
+- :author: OwnAttention3370
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iywhjds/
+  :body: |-
+    Ruby - My solution to AoC day 4
+
+    ```ruby
+    # Part 1
+    f = File.open('aoc_day4.txt')
+    duplicate_activity = 0
+    f.each do |line|
+        assignments = line.chomp.split(',')
+        elf1_min = assignments[0].split('-')[0]
+        elf1_max = assignments[0].split('-')[1]
+        elf2_min = assignments[1].split('-')[0]
+        elf2_max = assignments[1].split('-')[1]
+        elf1_assignment = (elf1_min..elf1_max).to_a
+        elf2_assignment = (elf2_min..elf2_max).to_a
+
+        if (elf1_assignment - elf2_assignment).empty? || (elf2_assignment -
+        elf1_assignment).empty?
+            duplicate_activity += 1
+        end
+    end
+
+    puts "First part of the duplicates problem"
+    puts "Duplicates: #{duplicate_activity}"
+
+    # Part 2
+
+    puts "Second part of the duplicates problem"
+
+    f = File.open('aoc_day4.txt')
+    duplicate_activity_2 = 0
+    f.each do |line|
+        assignments = line.chomp.split(',')
+        elf1_min = assignments[0].split('-')[0]
+        elf1_max = assignments[0].split('-')[1]
+        elf2_min = assignments[1].split('-')[0]
+        elf2_max = assignments[1].split('-')[1]
+        elf1_assignment = (elf1_min..elf1_max).to_a
+        elf2_assignment = (elf2_min..elf2_max).to_a
+
+        if elf1_assignment.intersect?(elf2_assignment)
+            duplicate_activity_2 += 1
+        end
+    end
+
+    puts "Duplicates: #{duplicate_activity_2}"
+    ```
+  :replies: []
+- :author: "[deleted]"
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyx2d80/
+  :body: "# [Ruby](https://github.com/sreedevk/advent-of-code/blob/main/ruby/2022/day4/main.rb)"
+  :replies: []
+- :author: snowe2010
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyuqkjp/
+  :body: |-
+    # Ruby
+
+    https://github.com/snowe2010/advent-of-code/blob/master/ruby\_aoc/2022/day04/day04.rb
+
+    with golfed solutions
+
+    ```ruby
+      $;=?,
+    execute(1) do |lines|
+      lines.map(&:split).map do |elf_1, elf_2|
+        elf_1_start, elf_1_end = elf_1.split('-').map(&:to_i)
+        elf_2_start, elf_2_end = elf_2.split('-').map(&:to_i)
+        elf_1_range = (elf_1_start..elf_1_end).to_set
+        elf_2_range = (elf_2_start..elf_2_end).to_set
+        elf_1_range.subset?(elf_2_range) || elf_2_range.subset?(elf_1_range)
+      end.count(&:itself)
+    end
+
+    execute(2) do |lines|
+      lines.map { |a| a.split(',') }.map do |elf_1, elf_2|
+        elf_1_start, elf_1_end = elf_1.split('-').map(&:to_i)
+        elf_2_start, elf_2_end = elf_2.split('-').map(&:to_i)
+        elf_1_range = (elf_1_start..elf_1_end).to_set
+        elf_2_range = (elf_2_start..elf_2_end).to_set
+        elf_1_range.intersect?(elf_2_range)
+      end.count(&:itself)
+    end
+
+    $;=?,
+
+    execute("1: Code Golf") do |lines|
+      lines.map(&:split).map{|a|a.map{|x|b,c=x.split(?-).map(&:to_i);(b..c).to_set}}.map{|a,b|a.subset?(b)||b.subset?(a)}.count(true)
+    end
+
+    execute("2: Code Golf") do |lines|
+      lines.map(&:split).map{|a|a.map{|x|b,c=x.split(?-).map(&:to_i);(b..c).to_set}}.map{|a,b|a.intersect? b}.count(true)
+    end
+    ```
+
+    Edit: I just realized I’m an idiot and this was trivially solvable with regex and I’m over here doing complicated splits. Ugh. I’ll fix it tomorrow.
+  :replies: []
+- :author: craigontour
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyurpvn/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    part1 = 0
+    part2 = 0
+
+    File.open("#{ARGV[0]}.txt").each_line.map { |line|
+    line
+        .chomp
+        .split(',')
+    }.map { |a, b|
+    a1, a2 = a.split('-').map(&:to_i)
+    b1, b2 = b.split('-').map(&:to_i)
+    arrA = (a1..a2).to_a
+    arrB = (b1..b2).to_a
+    part1 += 1 if arrA.intersection(arrB) == arrA || arrA.intersection(arrB) == arrB
+    part2 += 1 if !arrA.intersection(arrB).empty?
+    }
+
+    pp "Part1: #{part1}"
+    pp "Part2: #{part2}"
+    ```
+
+    Update: reformatted for Reddit.
+  :replies:
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyurtrq/
+    :body: |-
+      HELP! I pasted in from vcode (MacOS), where using spaces for indentation and CRLF, but it would not format properly as code block. I had to paste and reformat line by line to get it right.
+
+      Is this vcode, CRLF or ?
+
+      Cheers
+    :replies:
+    - :author: nysra
+      :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyuxj24/
+      :body: Reddit needs 4 spaces in front of every single line of a codeblock. Generally selecting the entire code, pressing tab once, and then copying from VSC into Reddit works (on every platform and CRLF doesn't matter). Your output looks very much like you simply copied the code without indenting it first, but hard to say without you telling us exactly what you did.
+      :replies: []
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iz02e3q/
+    :body: did as instructed and got it now. thanks.
+    :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyuyg1z/
+  :body: |-
+    Ruby
+
+    Code: https://github.com/careyi3/aoc\_2022/tree/master/solutions/4
+
+    Video Walkthrough: https://youtu.be/ZiPmNii7faU
+  :replies: []
+- :author: InevitableYak1979
+  :url: https://www.reddit.com/r/adventofcode/comments/zc0zta/2022_day_4_solutions/iyvuc6m/
+  :body: |-
+    Ruby
+
+    ```ruby
+    input = File.read("2022/day4input.txt").split("\n")
+
+    def part1(assignment_pairs)
+        assignment_pairs.count { |a, b| a.cover?(b) or b.cover?(a) }
+    end
+
+    def part2(assignment_pairs)
+        assignment_pairs.count { |a, b| !a.to_a.intersection(b.to_a).empty? }
+    end
+
+    # "1-2,3-4" -> [1..2, 3..4]
+    assignment_pairs = input.map { |pair| pair.split(",").map { |range_s| range_s.split("-").map(&:to_i) }.map { |b, e| b..e } }
+
+    p part1(assignment_pairs)
+    p part2(assignment_pairs)
+    ```
+  :replies: []