advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,299 @@
+---
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawj95t/
+  :body: |-
+    I mistyped 4 3 instead of 2 3 and got an obviously wrong answer which I wasn't smart enough to double check, so I had to wait one minute. Still got on top 100 though! [Imgur](https://i.imgur.com/ds13ZAy.png)
+
+    ```ruby
+    a=$<.map(&:chars).map{|x|x.group_by &:itself}
+    b=a.count{|x|x.any?{|x,y|y.count == 2}}
+    c=a.count{|x|x.any?{|x,y|y.count == 3}}
+    p b*c
+    #!ruby
+    a=$<.map(&:chars)
+    a.map{|x|a.map{|y|
+    d=x.zip(y).count{|x,y|x!=y}
+    (p x.join,y.join
+    1/0)if d==1
+    }}
+    ```
+
+    Doesn't actually compute part 2, you have to manually find and replace the character yourself, but better than nothing
+  :replies:
+  - :author: abnew123
+    :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawjn4w/
+    :body: Man, I'm always so sad when I look at other's solutions lol. While I wasn't particularly slow (177th), my code is 70+ lines lol. Oh well, I blame java
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawjoq3/
+      :body: Don't worry I got your back, I'll do a java one for you
+      :replies: []
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawmqct/
+      :body: |-
+        Part 1
+
+        ```ruby
+        import java.util.*;
+        import java.util.stream.*;
+
+        public class Main {
+
+            public static void main (String[] args) {
+                Scanner s = new Scanner(System.in);
+                int count2 = 0, count3 = 0;
+                while (s.hasNextLine()) {
+                    boolean check2 = true, check3 = true;
+                    for (int value : s.nextLine().chars().collect(HashMap<Integer, Integer>::new, (map, elem) -> map.put(elem, map.getOrDefault(elem, 0) + 1), HashMap::putAll).values())
+                        if (check2 && value == 2) {
+                            count2++;
+                            if (!check3) break;
+                            check2 = false;
+                        }
+                        else if (check3 && value == 3) {
+                            count3++;
+                            if (!check2) break;
+                            check3 = false;
+                        }
+                }
+                System.out.println(count2 * count3);
+            }
+
+        }
+        ```
+
+        It's getting long so I'm only including what's in main() for part 2
+
+        ```ruby
+        Scanner s = new Scanner(System.in);
+        Collection<char[]> all = new ArrayList<>();
+        while (s.hasNextLine()) {
+            String line = s.nextLine();
+            char[] current = line.toCharArray();
+            Optional<char[]> find = all.stream().filter((elem) -> {
+                boolean miss = false;
+                for (int i = 0; i < current.length; i++)
+                    if (current[i] != elem[i])
+                        if (miss) return false; else miss = true;
+            return miss;
+            }).findAny();
+            if (find.isPresent()) {
+                System.out.println(find.get());
+                System.out.println(line);
+            }
+            all.add(current);
+        }
+        ```
+      :replies: []
+    - :author: "[deleted]"
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawwe0m/
+      :body: |-
+        Another Java solution: Part 1:
+
+        ```ruby
+        public int getChecksum(BufferedReader reader) throws IOException {
+            String line;
+            int doubleDigits = 0;
+            int tripleDigits = 0;
+            while ((line = reader.readLine()) != null) {
+                Map<Character, Integer> frequencies = new HashMap<>();
+                for (char c : line.toCharArray()) {
+                    frequencies.merge(c, 1, (a, b) -> a + b);
+                }
+                Set<Integer> uniqueFrequencies = new HashSet<>(frequencies.values());
+                if (uniqueFrequencies.contains(2)) doubleDigits++;
+                if (uniqueFrequencies.contains(3)) tripleDigits++;
+            }
+            return doubleDigits * tripleDigits;
+        }
+        ```
+
+        Part2:
+
+        ```ruby
+        public String getCommonLetters(BufferedReader reader) {
+            List<String> lines = reader.lines().collect(Collectors.toList());
+            for (int i = 0; i < lines.size(); i++) {
+                String firstLine = lines.get(i);
+                for (int j = i + 1; j < lines.size(); j++) {
+                    String secondLine = lines.get(j);
+                    int distance = 0;
+                    StringBuilder commonLetters = new StringBuilder();
+                    for (int k = 0; k < firstLine.length(); k++) {
+                        if (firstLine.charAt(k) != secondLine.charAt(k)) {
+                            if (++distance > 1) {
+                                break;
+                            }
+                        } else {
+                            commonLetters.append(firstLine.charAt(k));
+                        }
+                    }
+                    if (distance == 1) {
+                        return commonLetters.toString();
+                    }
+                }
+            }
+            return "";
+        }
+        ```
+      :replies: []
+  - :author: DoodleFungus
+    :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawjlyk/
+    :body: Wow, our ruby answers have been remarkably similar both days (but I've barely missed the leaderboard both times, grrrrr)
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawjna2/
+      :body: Fastest gun in the west!
+      :replies: []
+  - :author: charismotron
+    :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawnzm8/
+    :body: |-
+      TIL: Array#count exists
+
+      TIL: Array#count takes a block.
+
+      I thought about zip but couldn't think of a way to make it work - forgetting there'd be nested arrays.
+    :replies:
+    - :author: _liquidlemon
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawvsgw/
+      :body: |-
+        I managed to do it using zip, you might like it
+
+        ```ruby
+        ids = DATA.readlines.map(&:chomp)
+        two = 0
+        three = 0
+        ids.each do |id|
+          counts = id.chars.group_by(&:itself).values.map(&:length).uniq
+          two += 1 if counts.include? 2
+          three += 1 if counts.include? 3
+        end
+        checksum = two * three
+        puts "Part 1: #{checksum}"
+
+        ids.product(ids) do |x, y|
+          same = x.chars.zip(y.chars).select { |a, b| a == b }.map(&:first)
+          if same.length == x.length - 1
+            puts "Part 2: #{same.join}"
+            break
+          end
+        end
+        ```
+      :replies: []
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawp4sp/
+      :body: It's actually also on Enumerable, so you can directly .count lines on STDIN, except unfortunately we need to use it twice in this case!
+      :replies: []
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eayay2l/
+    :body: Can you explain the x.join,y.join 1/0?
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eayuhrv/
+      :body: at this point both `x` and `y` are array of size-1 strings, so `.join` turns them back into non-split strings and feeds them through `p` which prints them. 1/0 crashes the program. it's faster to type than exit
+      :replies: []
+- :author: Frizkie
+  :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eawl9y6/
+  :body: |-
+    Ruby
+
+    ```ruby
+    data = File.read('data.txt').chomp.split("\n")
+    ```
+
+    **Part 1**
+
+    ```ruby
+    twos, threes = 0, 0
+    data.each do |d|
+      twos += 1 if d.each_char.select { |c| d.count(c) if d.count(c) == 2 }.uniq.count > 0
+      threes += 1 if d.each_char.select { |c| d.count(c) if d.count(c) == 3 }.uniq.count > 0
+    end
+    puts twos * threes
+    ```
+
+    **Part 2**
+
+    ```ruby
+    data.each_with_index do |d1, i|
+      data[i + 1..data.size].each do |d2|
+        diff = d1.each_char.with_index.count { |c, k| c != d2.chars[k] }
+        puts [d1, d2] if diff == 1
+      end
+    end
+    ```
+  :replies:
+  - :author: justinhj
+    :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eaxf0lv/
+    :body: |-
+      Nice, much more succinct than what I came up with
+
+      ```ruby
+          def count_twos_and_threes(str)
+            sa = str.scan(/\w/)
+
+            groups = sa.group_by { |c| c }.values
+
+            has_two = groups.any? { |g| g.length == 2 }
+            has_three = groups.any? { |g| g.length == 3 }
+
+            return has_two ? 1 : 0, has_three ? 1 : 0
+          end
+
+          counts = lines.reduce([0, 0]) do |acc, line|
+            twos, threes = count_twos_and_threes(line)
+
+            acc[0] = acc[0] + twos
+            acc[1] = acc[1] + threes
+
+            acc
+          end
+
+          puts counts[0] * counts[1]
+      ```
+    :replies: []
+- :author: omegaxLoL
+  :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eax092v/
+  :body: "[My solution in Ruby](https://github.com/aosousa/AdventOfCode2018/blob/master/day2.rb). Using Advent of Code to learn Ruby this year so any tips are welcome!"
+  :replies: []
+- :author: EngCanuck
+  :url: https://www.reddit.com/r/adventofcode/comments/a2aimr/2018_day_2_solutions/eayzzlt/
+  :body: |-
+    Ruby:
+
+    Here's my solution, using the damerau-levenshtein gem for part 2:
+
+    ```ruby
+    #!/usr/bin/env ruby
+    require 'damerau-levenshtein'
+
+    ids = File.readlines('ids.txt').map(&:strip)
+
+    # Part one
+    twos = 0
+    threes = 0
+    candidates = []
+    ids.each do |id|
+      counts = id.split('')
+                 .each_with_object(Hash.new(0)) { |letter, hash| hash[letter] += 1 }
+                 .values
+      continue unless counts.include?(2) || counts.include?(3)
+      twos += 1 if counts.include?(2)
+      threes += 1 if counts.include?(3)
+      candidates.push(id)
+    end
+
+    puts twos * threes
+
+    # Part two
+    prototypes = candidates.permutation(2).find do |a, b|
+      DamerauLevenshtein.distance(a, b) == 1
+    end
+
+    first = prototypes[0].split('')
+    second = prototypes[1].split('')
+    second -= ((first - second) | (second - first))
+
+    puts second.join
+    ```
+  :replies: []

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

@@ -0,0 +1,391 @@
+---
+- :author: Frizkie
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eazkl9g/
+  :body: |-
+    Ruby
+
+    ```ruby
+    data = File.read('data.txt').chomp.split("\n").map do |d|
+      d.match(/#(\d+) @ (\d+),(\d+): (\d+)x(\d+)/)
+    end
+    ```
+
+    **Part 1**
+
+    ```ruby
+    counts = Array.new(1000) { Array.new(1000, 0) }
+
+    data.map(&:to_a).map { |a| a.map(&:to_i) }.each do |_, _, left, top, width, height|
+      (top..top + height - 1).each do |row|
+        (left..left + width - 1).each do |col|
+          counts[row][col] += 1
+        end
+      end
+    end
+
+    puts counts.flatten.count { |e| e >= 2}
+    ```
+
+    **Part 2**
+
+    ```ruby
+    counts = Array.new(1000) { Array.new(1000) }
+    maps = []
+
+    data.map(&:to_a).map { |a| a.map(&:to_i) }.each do |_, id, left, top, width, height|
+      maps << [id, left, top, width, height]
+      (top..top + height - 1).each do |row|
+        (left..left + width - 1).each do |col|
+          counts[row][col] = [] unless counts[row][col]
+          counts[row][col] << id
+        end
+      end
+    end
+
+    puts maps.find { |id, _, _, width, height| counts.flatten(1).count { |a| a == [id] } == width * height }[0]
+    ```
+
+    This one kicked my ass. I barked up the wrong tree for a long time, took me over an hour to debug everything.
+  :replies:
+  - :author: "[deleted]"
+    :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb2rsqp/
+    :body: |-
+      Rances can actually be made inclusive simply by adding `...` instead of `..` as the range operator.
+
+      Great solution!
+    :replies: []
+  - :author: daybreaker
+    :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb0b4bm/
+    :body: |-
+      Went in sort of the same route for Part 1, using .times instead of .each
+
+      My part 2 was a little different, choosing to just use a boolean that fails when an id hits a cell claimed more than once. I make no claims at this being anywhere near optimal ruby though :-P
+
+      ```ruby
+      ids.each do |id_string|
+        id, left, top, width, height = split_id(id_string)
+
+        unblocked = true
+
+        width.to_i.times do |xindex|
+          height.to_i.times do |yindex|
+            unblocked = false and break if fabric[left.to_i + xindex][top.to_i + yindex] > 1
+          end
+        end
+
+        puts id if unblocked
+      end
+      ```
+    :replies: []
+- :author: moomaka
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb0dv9v/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    Plan = Struct.new(:id, :x, :y, :width, :height, keyword_init: true) do
+      def x_min; x + 1; end
+      def x_max; x_min + width; end
+      def y_min; y + 1; end
+      def y_max; y_min + height; end
+
+      def coords
+        @coords ||= (x_min...x_max).to_a.product (y_min...y_max).to_a
+      end
+    end
+
+    fabric = Hash.new(0)
+
+    PARSER = /#(?<id>\d+) @ (?<x>\d+),(?<y>\d+): (?<width>\d+)x(?<height>\d+)/
+    plans = File.readlines('input.txt').map do |input|
+      Plan.new(PARSER.match(input).named_captures.transform_values!(&:to_i)).tap do |plan|
+        plan.coords.each { |x, y| fabric[[x, y]] += 1 }
+      end
+    end
+
+    puts "Part 1: #{fabric.count { |_, v| v > 1 }}"
+
+    puts "Part 2: #{plans.find { |p| p.coords.all? { |x, y| fabric[[x, y]] == 1 } }.id}"
+    ```
+  :replies:
+  - :author: ZoDalek
+    :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb11gyo/
+    :body: Shame the struct definition is a little verbose because man the solution itself is so beautifully compact!
+    :replies:
+    - :author: moomaka
+      :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb141fd/
+      :body: |-
+        The Struct was just for readability, but you can code golf it down a bit and still keep it fairly easy to read:
+
+        ```ruby
+        coords = -> (p) { ((p[:x]+1)...(p[:x]+1+p[:w])).to_a.product ((p[:y]+1)...(p[:y]+1+p[:h])).to_a }
+        fabric = Hash.new(0)
+        PARSER = /#(?<id>\d+) @ (?<x>\d+),(?<y>\d+): (?<w>\d+)x(?<h>\d+)/
+        plans = File.readlines('input.txt').map do |input|
+          PARSER.match(input).named_captures.map { |k,v| [k.to_sym, v.to_i] }.to_h.tap do |p|
+            coords[p].each { |x, y| fabric[[x, y]] += 1 }
+          end
+        end
+        puts "Part 1: #{fabric.count { |_, v| v > 1 }}"
+        puts "Part 2: #{plans.find { |p| coords[p].all? { |x, y| fabric[[x, y]] == 1 } }[:id]}"
+        ```
+      :replies: []
+- :author: rock_neurotiko
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eazomdx/
+  :body: |-
+    Day 3 in Ruby:
+
+    ```ruby
+    format_r = /#(.+) @ (\d+),(\d+): (\d+)x(\d+)/
+
+    data = Hash.new 0
+
+    boxes = File.open("input").map do |line|
+      id, left, top, wide, tall = line.match(format_r).captures
+      left = left.to_i
+      top = top.to_i
+      wide = wide.to_i
+      tall = tall.to_i
+
+      right = left + wide - 1
+      bottom = top + tall - 1
+
+      (left..right).each do |i|
+        (top..bottom).each do |j|
+          coords = [i, j]
+          data[coords] += 1
+        end
+      end
+
+      [id, left, top, wide, tall]
+    end
+
+    puts "Solution 1:", data.values.select { |x| x > 1 }.count
+
+    def collides?(data, left, right, top, bottom)
+      for i in (left..right) do
+        for j in (top..bottom) do
+          coords = [i, j]
+          return false if data[coords] > 1
+        end
+      end
+
+      true
+    end
+
+    one_remain = boxes.select do |box|
+      _, left, top, wide, tall = box
+      right = left + wide - 1
+      bottom = top + tall - 1
+
+      collides?(data, left, right, top, bottom)
+    end
+
+    puts "Solution 2:", one_remain[0][0]
+    ```
+  :replies: []
+- :author: CommanderViral
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb0a1zv/
+  :body: |-
+    Crystal (both parts 1 and 2 computed together)
+
+    ```ruby
+    fabric = Array.new(1000) do
+        Array.new(1000) do
+            Array(Int32).new
+        end
+    end
+
+    input = File.open("input")
+    claim_regex = /#(\d+) @ (\d+),(\d+): (\d+)x(\d+)/
+    all_ids = [] of Int32
+    input.each_line do |line|
+        parse_match = claim_regex.match(line)
+        next if parse_match.nil?
+        id = parse_match[1].to_i
+        all_ids << id
+        left = parse_match[2].to_i
+        top = parse_match[3].to_i
+        width = parse_match[4].to_i
+        height = parse_match[5].to_i
+
+        (left...(left + width)).each do |l|
+            (top...(top + height)).each do |t|
+                fabric[l][t] << id
+            end
+        end
+    end
+
+    square_inches = 0
+    bad_ids = Set(Int32).new
+    fabric.each do |i|
+        i.each do |j|
+            square_inches += 1 if j.size > 1
+            bad_ids = bad_ids.concat(j) if j.size > 1
+        end
+    end
+
+    good_id = (all_ids - bad_ids.to_a).first
+
+    puts "part 1: #{square_inches}"
+    puts "part 2: #{good_id}"
+    ```
+
+    And what's fun is it's valid Ruby with a line added and 3 lines changed.
+  :replies: []
+- :author: jschulenklopper
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb0s050/
+  :body: |-
+    Ruby... but in a single pass over the claims. (I see a lot of double passes; one processing all the claims for marking the fabric, one processing all the claims again or the fabric to look for single-marked spots.)
+
+    ```ruby
+    fabric = Hash.new([])
+    all_ids = Array.new
+
+    while line = gets do
+        # Parse a line.
+        id, x, y, w, h = line.strip.match(/^#(\d+) @ (\d+),(\d+): (\d+)x(\d+)$/).captures.map(&:to_i
+
+        # Add id to list of all ids.
+        all_ids << id
+
+        w.times do |i|
+            h.times do |j|
+                # Enter claim on fabric; add id to list.
+                fabric[[x+i,y+j]] += [id]
+
+                # If there's more than one claim on the spot,
+                # remove id and other ids on that spot from all_ids.
+                if fabric[[x+i,y+j]].length > 1
+                   all_ids.delete(id)
+                   fabric[[x+i,y+j]].each { |id| all_ids.delete(id) }
+                end
+            end
+        end
+    end
+
+    puts all_ids.join(", ")
+    ```
+  :replies: []
+- :author: omegaxLoL
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb0txje/
+  :body: "[My solution in Ruby](https://github.com/aosousa/AdventOfCode2018/blob/master/day3.rb). Using Advent of Code to learn Ruby this year so any tips are welcome!"
+  :replies: []
+- :author: vanderzee94
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eb1q783/
+  :body: |-
+    Ruby Solution for both parts
+
+    ```ruby
+    data = File.readlines('input.txt')
+
+    parser = /\#(?<id>\d+) \@ (?<l>\d+),(?<t>\d+): (?<w>\d+)x(?<h>\d+)/
+
+    overlap = Hash.new
+    cloth = []
+    1000.times { cloth << Array.new( 1000, "." ) }
+
+    data.each do |claim|
+      match = parser.match(claim)
+      id, l, t, w, h = match["id"], match["l"].to_i, match["t"].to_i, match["w"].to_i, match["h"].to_i
+      overlap[id] = true
+      (l...l+w).each do |row|
+        (t...t+h).each do |column|
+          if cloth[row][column] == "."
+            cloth[row][column] = match["id"]
+          else
+            overlap[cloth[row][column]] = false
+            overlap[id] = false
+            cloth[row][column] = "x"
+          end
+        end
+      end
+    end
+    p cloth.flatten.count("x")
+    p overlap.key(true)
+    ```
+  :replies: []
+- :author: 121lazz
+  :url: https://www.reddit.com/r/adventofcode/comments/a2lesz/2018_day_3_solutions/eccbxf3/
+  :body: |-
+    Later than late to the party, but a party 'twas.
+
+    I found it easiest to deal with arrays of coordinates and to focus on readability. In Ruby:
+
+    ```ruby
+    class InchClaimer
+      attr_reader :claims
+
+      def initialize(inputs)
+        @claims = build_claims(inputs)
+      end
+
+      def overlaps
+        claims_per_coordinate
+          .count { |_coord, claims| claims.count > 1 }
+      end
+
+      def claim_without_overlaps
+        claims.each do |claim|
+          break claim.id if claim.coords.all? do |coord|
+            coords_without_overlap.include? coord
+          end
+        end
+      end
+
+      private
+
+      def build_claims(inputs)
+        inputs.map do |input|
+          Claim.new(parse(input))
+        end
+      end
+
+      def parse(input)
+        id = input.slice(/(?<=\#)(\d+)/)
+        left = input.slice(/(?<=\@\s)(\d+)/)
+        top = input.slice(/(?<=\d\,)(\d+)/)
+        rows = input.slice(/(?<=\dx)(\d+)/)
+        cols = input.slice(/(\d+)(?=x\d)/)
+
+        {
+          id: id,
+          left: left,
+          top: top,
+          cols: cols,
+          rows: rows
+        }.transform_values(&:to_i)
+      end
+
+      def claims_per_coordinate
+        @claims_per_coordinate ||=
+          claims
+          .flat_map(&:coords)
+          .group_by(&:itself)
+      end
+
+      def coords_without_overlap
+        @coords_without_overlap ||=
+          claims_per_coordinate
+          .select { |_coord, claims| claims.count == 1 }
+      end
+
+      Claim = Struct.new(:id, :left, :top, :cols, :rows, keyword_init: true) do
+        def coords
+          Array.new(rows) do |row|
+            Array.new(cols) do |col|
+              [row + top, col + left]
+            end
+          end.flatten(1)
+        end
+      end
+
+    end
+
+    input = IO.readlines('3_input.txt', chomp: true)
+
+    inch_claimer = InchClaimer.new(input)
+    puts "Square inches with overlap: #{inch_claimer.overlaps}"
+    puts "Claim id that does not overlap with anything: #{inch_claimer.claim_without_overlaps}"
+    ```
+  :replies: []