advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,480 @@
+---
+- :author: blafunke
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gesnj0d/
+  :body: |-
+    Ruby
+
+    ```ruby
+    #!/usr/bin/ruby
+
+    def trees(input,right, down)
+      pos = -1 * right
+      input.each_with_index.map { |line,i|
+        pos += right if i%down == 0
+        (i%down == 0 && line[pos % (line.length - 1)] == "#") ? 1 : 0
+      }.sum
+    end
+
+    input = $stdin.readlines
+    puts "part 1: #{trees(input,3,1)}"
+    puts "part 2: #{
+                    trees(input,1,1) *
+                    trees(input,3,1) *
+                    trees(input,5,1) *
+                    trees(input,7,1) *
+                    trees(input,1,2)
+                   }"
+    ```
+  :replies: []
+- :author: Krakhan
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/geojvcd/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    area_map = File.readlines("day3input.txt").map{|line| line.chomp.split('')}
+
+    def tree_count(map, vel)
+        trees = 0
+        pos = [0, 0]
+
+        line_length = map[0].length
+        map_length = map.length
+
+        loop do
+            pos[0] += vel[0]
+            pos[1] += vel[1]
+
+            break unless pos[0] < map_length
+
+            pos[1] %= line_length
+            trees += 1 if map[pos[0]][pos[1]] == "#"
+        end
+
+        trees
+    end
+
+    # Part 1
+    puts "#{tree_count(area_map, [1, 3])}"
+
+    # Part 2
+    puts "#{[[1, 1], [1, 3], [1, 5], [1, 7], [2, 1]].map{|v| tree_count(area_map, v)}.reduce(:*)}"
+    ```
+  :replies: []
+- :author: odlp
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gehbw6b/
+  :body: |-
+    My solution in [Ruby](https://github.com/odlp/advent-of-code-2020/blob/main/day-3/path.rb):
+
+    ```ruby
+    TREE = "#"
+
+    def count_trees(matrix, step_x, step_y)
+      row_size = matrix.first.size
+      x = 0
+
+      (0...matrix.size).step(step_y).count do |y|
+        square = matrix.fetch(y).fetch(x % row_size)
+        x += step_x
+        square == TREE
+      end
+    end
+
+    matrix = ARGF.map { |line| line.chomp.chars }
+
+    puts "Part 1:", count_trees(matrix, 3, 1)
+
+    approaches = [
+      [1, 1],
+      [3, 1],
+      [5, 1],
+      [7, 1],
+      [1, 2]
+    ]
+
+    puts "Part 2:", approaches.map { |x, y| count_trees(matrix, x, y) }.inject(:*)
+    ```
+  :replies: []
+- :author: Karl_Marxxx
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/geiu43e/
+  :body: |-
+    Ruby
+
+    ```ruby
+    lines = ARGF.readlines.map{|l| l.strip}.drop(1) # ignore first line
+
+    # part 1
+    trees = 0
+    x = 3
+    lines.each_with_index do |line, i|
+        trees += 1 if line[(x*(i+1)) % line.length] == "#"
+    end
+    puts trees
+
+    # part 2
+    trees = [0, 0, 0, 0, 0]
+    xs = [1, 3, 5, 7, 1]
+    ys = [1, 1, 1, 1, 2]
+    lines.each_with_index do |line, i|
+        ys.each_with_index do |y, j|
+            if (i+1) % y == 0
+                real_x = ((i+1)/y * xs[j]) % line.length
+                trees[j] += 1 if line[real_x] == "#"
+            end
+        end
+    end
+    p trees.reduce(1,:*)
+    ```
+  :replies: []
+- :author: Piggelinmannen
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gegu4yf/
+  :body: |-
+    Kind of dirty ruby solution...
+
+    ```ruby
+    input = File.readlines('./input.txt')
+
+    trees_encountered = input.each_with_index.count do |line, i|
+      line[i * 3 % (line.length - 1)].eql?('#')
+    end
+    puts "Solution for day 3 part a: #{trees_encountered}"
+
+    slope_instructions = [[1, 1], [3, 1], [5, 1], [7, 1], [1, 2]]
+    trees_per_slope = slope_instructions.map do |x_jump, y_jump|
+      input.each_with_index.count do |line, i|
+        next unless (i % y_jump).zero?
+
+        line[i * x_jump / y_jump % (line.length - 1)].eql?('#')
+     end
+    end
+    slopes_multiplied = trees_per_slope.reduce(:*)
+    puts "Solution for day 3 part a: #{slopes_multiplied}"
+    ```
+  :replies: []
+- :author: CodeIsTheEnd
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gegzjz1/
+  :body: |-
+    **Ruby:** 3:52/6:31, 345/279
+
+    I think a small helper for reading the input into a grid would be helpful...
+
+    Here's a [recording](https://youtu.be/EPE6d_sHp7I), and the [code](https://github.com/PaulJuliusMartinez/advent-of-code/blob/master/2020/dec03.rb).
+
+    I'll be streaming every day on [Twitch](https://twitch.tv/codeistheend).
+  :replies: []
+- :author: DropkickFish
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gehbt8x/
+  :body: |-
+    Ruby part 1, I'll do part 2 after work
+
+    ```ruby
+    matrix = []
+    x, y, trees, slope = 0, 0, 0, -1
+
+    File.foreach('3.txt') { |line| matrix << line.strip.split('') and slope += 1 }
+
+    while y < slope
+      x += 3
+      y += 1
+      if x > 30
+        x -= 31
+      end
+      pos = matrix[y][x]
+      if pos == '#'
+        trees += 1
+      end
+    end
+
+    puts trees
+    ```
+  :replies: []
+- :author: jeffers0n
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gehtsaw/
+  :body: |-
+    My solution in Ruby. It's a little sloppy but it got the job done.
+
+    ```ruby
+    #!/bin/env ruby
+
+    slopes = {
+        :one => { :right => 1, :down => 1},
+        :two => { :right => 3, :down => 1},
+        :three => { :right => 5, :down => 1},
+        :four => { :right => 7, :down => 1},
+        :five => { :right => 1, :down => 2}
+    }
+
+    input = Array.new
+    File.readlines('./input').each.with_index do |line, i|
+        line.strip!
+        input[i] = line.split('')
+    end
+
+    input.each do |x|
+        x.map! do |y|
+            y == '#' ? true : false
+        end
+    end
+
+    collisions = Array.new
+    slopes.each do |num, slope|
+        i = 0
+        trees = 0
+        len = input[0].length
+        input.each.with_index do |row, row_num|
+            next if (slope[:down] == 2 and row_num.odd?)
+            trees += 1 if row[i]
+            i +=slope[:right]
+            i = i - len if i >= len
+        end
+        collisions.push(trees)
+        puts "On slope #{num.to_s} We hit #{trees} trees"
+    end
+
+    puts "Multiplied together we get: #{collisions.inject(:*)}"
+    ```
+  :replies: []
+- :author: DropkickFish
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/geigsid/
+  :body: |-
+    Ruby Pt 2, bad day edition. Silver lining: Looking at other solutions it looks like I should learn more about matrices and how to traverse them. One thing I'm loving about Advent of Code is I'm learning a lot more about gaps in my knowledge that I'd probably not have encountered in my own projects.
+
+    ```ruby
+    matrix = []
+    $totaltrees = []
+    x, y, $trees, slope = 0, 0, 0, -1
+
+    File.foreach('3.txt') { |line| matrix << line.strip.split('') and slope += 1 }
+
+    possibilities = [[1,1],
+                     [3,1],
+                     [5,1],
+                     [7,1],
+                     [1,2]]
+
+    possibilities.each do |possibility|
+      xtrav = possibility[0]
+      ytrav = possibility[1]
+        while y < slope
+          x += xtrav
+          y += ytrav
+          if x > 30
+            x -= 31
+          end
+          pos = matrix[y][x]
+          if pos == '#'
+            $trees += 1
+          end
+        end
+        $totaltrees << $trees
+        x, y, $trees = 0, 0, 0
+    end
+
+    puts $totaltrees.reduce(:*)
+    ```
+  :replies: []
+- :author: nata79
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gej2w5a/
+  :body: |-
+    **Ruby**
+
+    ```ruby
+    map = File.read('day3.txt').split("\n").map(&:chars).map { |line| line * 100 }
+
+    slopes = [
+      [1, 1],
+      [3, 1],
+      [5, 1],
+      [7, 1],
+      [1, 2]
+    ]
+
+    result = slopes.map do |slope|
+      trees = 0
+
+      x = 0
+      y = 0
+
+      while y < map.size
+        trees += 1 if map[y][x] == '#'
+        x += slope[0]
+        y += slope[1]
+      end
+
+      trees
+    end.reduce { |acc, res| acc * res }
+
+    p result
+    ```
+  :replies: []
+- :author: readyready15728
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gehpi47/
+  :body: |-
+    A lot of solutions seem needlessly complex. Here's how I did it in Ruby:
+
+    ```ruby
+    map = []
+
+    File.readlines('03.txt').each do |line|
+      map.push line.strip.each_char.to_a
+    end
+
+    i, j = 0, 0
+    width, height = map[0].length, map.length
+    tree_count = 0
+
+    while j < height
+      tree_count += 1 if map[j][i] == '#'
+      i, j = (i + 3) % width, j + 1
+    end
+
+    puts tree_count
+    ```
+  :replies: []
+- :author: frontpageminus
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gegiesj/
+  :body: |-
+    Ruby, 81/104. I wasn't sure if this code would have an off-by-one error when I submitted the answers, but I guess it worked.
+
+    ```ruby
+    rows = File.read('03.txt').lines(chomp: true)
+    pos = [0,0]
+    trees = 0
+    while pos[1] < rows.size
+      row = rows[pos[1]]
+      trees += 1 if row[pos[0] % row.size] == '#'
+      pos = [pos[0]+3, pos[1]+1]
+    end
+    puts trees
+    ```
+
+    Part two:
+
+    ```ruby
+    rows = File.read('03.txt').lines(chomp: true)
+    puts [[1,1], [3,1], [5,1], [7,1], [1, 2]].map { |change|
+      pos = [0,0]
+      trees = 0
+      while pos[1] < rows.size
+        row = rows[pos[1]]
+        trees += 1 if row[pos[0] % row.size] == '#'
+        pos = [pos[0]+change[0], pos[1]+change[1]]
+      end
+      trees
+    }.reduce(&:*)
+    ```
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gegk1u6/
+  :body: |-
+    ### [Ruby (1525/1057)](https://github.com/Sharparam/advent-of-code/blob/master/2020/day3/solution.rb)
+
+    ```ruby
+    input = ARGF.readlines.map(&:strip)
+
+    def count(map, step)
+      map.size.times.sum { |t|
+        y = t * step[1]
+        map[y]&.[]((t * step[0]) % map[y].size) == ?# ? 1 : 0
+      }
+    end
+
+    part1 = count input, [3, 1]
+    puts part1
+
+    rest = [[1, 1], [5, 1], [7, 1], [1, 2]].map { |s| count input, s }
+
+    puts (rest + [part1]).reduce(:*)
+    ```
+  :replies: []
+- :author: qaisjp
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gegk33c/
+  :body: |-
+    # Ruby
+
+    I've hopped over from Go to Ruby. https://github.com/qaisjp/adventofcode/blob/master/2020/day03/main.rb
+
+    ```ruby
+    def check(line, x)
+        max = line.length
+        line[x % max]
+    end
+
+    $ys = lines2.split("\n")
+
+    def one
+        y = 0
+        x = 0
+        found = 0
+        loop do
+            item = check($ys[y], x)
+            if item == "#"
+                found += 1
+            end
+            print(item, found, "\n")
+            y += 1
+            x += 3
+        end
+    end
+
+    def incr(xx, yy)
+        y = 0
+        x = 0
+        found = 0
+        loop do
+            break if y >= $ys.length
+            item = check($ys[y], x)
+            if item == "#"
+                found += 1
+            end
+            # print(item, found, "\n")
+            y += yy
+            x += xx
+        end
+        found
+    end
+
+    def two
+        puts(incr(1, 1) * incr(3,1) * incr(5,1) * incr(7,1) * incr(1,2))
+    end
+    ```
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/gegkvqj/
+  :body: |-
+    # Ruby
+
+    ```ruby
+    input = DATA.each_line.map do |line|
+      line.chomp.split('').map { |spot| spot == '#' ? 1 : 0 }
+    end
+
+    [[1, 1], [3, 1], [5, 1], [7, 1], [1, 2]].map do |x, y|
+      input.each_slice(y).map.with_index do |lines, i|
+        lines.first.rotate(i * x).first
+      end.sum.tap { |r| x == 3 && puts(r) }
+    end.reduce(&:*).tap(&method(:puts))
+
+    __END__.....##.#.....#........#....##.
+    ```
+  :replies: []
+- :author: chaelcodes
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/geglwgo/
+  :body: Ruby https://github.com/ChaelCodes/Advent-of-Code-2020/pull/4
+  :replies: []
+- :author: maccosmo
+  :url: https://www.reddit.com/r/adventofcode/comments/k5qsrk/2020_day_03_solutions/geh8qkj/
+  :body: |-
+    My solution in Ruby
+
+    ```ruby
+    def slide(x, y)
+      File.readlines('input.txt').each_with_index.reduce(0) do |sum, (line, i)|
+        column = ((i / y) * x % line.strip.size)
+        sum + (i % y == 0 && line[column] == "#" ? 1 : 0)
+      end
+    end
+
+    puts [[1,1], [3,1], [5,1], [7,1], [1,2]].map{|a|slide(*a)}.inject(:*)
+    ```
+  :replies: []