advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2024/10.yml

@@ -0,0 +1,196 @@
+---
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1bi93k/
+  :body: |-
+    ```ruby
+    require 'matrix'
+
+    GRID = ARGF.readlines(chomp: true).flat_map.with_index { |line, y|
+      line.chars.map.with_index { |h, x| [Vector[x, y], h.to_i] }
+    }.to_h.tap { _1.default = Float::INFINITY }
+
+    DIRS = [Vector[1, 0], Vector[-1, 0], Vector[0, 1], Vector[0, -1]].freeze
+
+    def neighbors(current)
+      DIRS.map { current + _1 }.select { GRID[_1] - GRID[current] == 1 }
+    end
+
+    puts GRID.filter_map { _2.zero? ? _1 : nil }.map { |start|
+      queue = [start]
+      seen = Set.new
+      score = 0
+      rating = 0
+
+      until queue.empty?
+        current = queue.pop
+        if GRID[current] == 9
+          score += 1 if seen.add? current
+          rating += 1
+        end
+        neighbors(current).each { queue.push _1 }
+      end
+
+      [score, rating]
+    }.transpose.map { _1.reduce(:+) }
+    ```
+
+    Today felt quite easy, probably because this type of problem has occurred several times in years past.
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1bxurp/
+  :body: |-
+    Reused once more my grid class to get neighbors. I misunderstood part 1 and solved it as part1, so it took nothing to to part2 after I finally did part1 :D
+
+    I hope we're done with grids for a while cause I don't want to implement another dijkstra/flood fill/TSP and fail at it this year too :D
+
+    ```ruby
+    def paths(grid, start, path, &accumulator)
+      grid.neighbors4(start).each_with_object(Set.new) do |neighbor, set|
+        if start.value == "8" && neighbor.value == "9"
+          set << accumulator.call(path + [neighbor])
+        elsif neighbor.value == start.value.succ
+          set.merge(paths(grid, neighbor, path + [neighbor], &accumulator))
+        end
+      end
+    end
+
+    def solve_easy(grid)
+      grid
+        .tiles_with_value("0")
+        .sum { |start| paths(grid, start, [start]) { |path| path.last }.size }
+    end
+
+    def solve_hard(grid)
+      grid
+        .tiles_with_value("0")
+        .sum { |start| paths(grid, start, [start]) { |path| path }.size }
+    end
+    ```
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1bgwpx/
+  :body: |-
+    Man, I was feeling good about this one. Thought I went so fast. I accidentally got the sample data result for part 2 while I was doing part 1 because I forgot to check my 'visited' set. So just had to comment out that line and part 2 was correct on first try. About a minute between part 1 completion and part 2.
+
+    ```ruby
+    def dfs(pos, visited, unique = true)
+      return 0 if(unique && visited.include?(pos))
+      visited << pos
+      curr = data[pos]
+      return 1 if curr == 9
+      [Vector[-1,0], Vector[1,0], Vector[0,-1], Vector[0,1]].sum { |d|
+        next 0 if(data[pos+d] != curr + 1)
+        dfs(pos+d, visited, unique)
+      }
+    end
+
+    def part_1
+      data.select { |k, v| v==0 }.keys.sum { |k| dfs(k, Set.new, true) }
+    end
+
+    def part_2
+      data.select { |k, v| v==0 }.keys.sum { |k| dfs(k, Set.new, false) }
+    end
+
+    private
+      def process_dataset(set)
+        set.each_with_index.with_object({}) { |(line, y), grid|
+          line.chars.each_with_index { |c, x|
+            grid[Vector[y, x]] = c.to_i
+          }
+        }
+      end
+    ```
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1cnys0/
+  :body: "[https://gist.github.com/thofoer/88bb2c1308a3beb5f822229c999bcd73](https://gist.github.com/thofoer/88bb2c1308a3beb5f822229c999bcd73)"
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1cpkyf/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day10.rb)"
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1cvcfo/
+  :body: |-
+    Frustrated myself by misreading the problem and overcomplicating it. It was actually a fairly simple recursive path finding algorithm. No real clever optimisations, runs in a few miliseconds.
+
+    EDIT: Also, managed to accidentally solve part 2 before part 1
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/10](https://github.com/careyi3/aoc_2024/tree/master/solutions/10)
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1dok13/
+  :body: |-
+    Yea I fell into the solve part 2 before part 1 trap because I did not read the question carefully. Initial hunch was to BFS from 0s but backtracking from 9s is much easier to implement.
+
+    ```ruby
+    require_relative 'utils'
+    require 'set'
+
+    grid = Grid.new(File.readlines('input10.txt', chomp: true).map { |line| line.chars.map(&:to_i) })
+    $trailhead_scores = {}
+    $trailhead_ratings = Hash.new(0)
+
+    def backtrack(grid, start_coord, current_coord)
+      if grid.at(*current_coord).zero?
+        ($trailhead_scores[current_coord] ||= Set.new) << start_coord
+        $trailhead_ratings[current_coord] += 1
+        return
+      end
+
+      grid.get_direct_neighbors(*current_coord).each do |next_coord, next_height|
+        backtrack(grid, start_coord, next_coord) if next_height == grid.at(*current_coord) - 1
+      end
+    end
+
+    grid.coords.each do |coord|
+      backtrack(grid, coord, coord) if grid.at(*coord) == 9
+    end
+
+    puts $trailhead_scores.values.map(&:length).sum
+    puts $trailhead_ratings.values.sum
+    ```
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1du98p/
+  :body: |-
+    I, too, accidentally solved part 2 before part 1.
+
+    ```ruby
+    def in_bounds(grid, x, y) = y >= 0 && y < grid.length && x >= 0 && x < grid[y].length
+
+    def find_trails(grid, v, x, y, steps=[[x,y]])
+      return [] unless in_bounds(grid, x, y) && grid[y][x] == v
+      return [steps] if v == 9
+
+      return [[0,-1], [1,0], [0,1], [-1,0]]
+        .map { |dx,dy| [x+dx, y+dy] }
+        .flat_map { |nx, ny| find_trails(grid, v+1, nx, ny, [*steps, [nx,ny]]) }
+    end
+
+    input = File
+      .readlines('input10.txt', chomp: true)
+      .map { _1.chars.map &:to_i }
+
+    trails = input
+      .each_with_index
+      .flat_map { |row,y|
+        row.each_index.flat_map { |x| find_trails(input, 0, x, y) }
+      }
+
+    p trails.group_by(&:first).sum { |_,trail| trail.map(&:last).uniq.size }
+    p trails.size
+    ```
+  :replies: []
+- :author: Infinite-Club4374
+  :url: https://www.reddit.com/r/adventofcode/comments/1hau6hl/2024_day_10_solutions/m1chhwm/
+  :body: |-
+    (the%20best%20duh)
+
+    Decided that this scenario would be perfect for a recursive solution, probably my most elegant lol?
+
+    Solution 1 was 27 lines and solution 2 is 22, I’ll take it
+
+    https://github.com/Leftyxiv/advent_of_code/blob/main/2024/day10/day10.rb
+  :replies: []

data/data/solutions/reddit/ruby/2024/11.yml

@@ -0,0 +1,289 @@
+---
+- :author: '442401'
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1ll9mf/
+  :body: |-
+    Very educational. I enjoyed today's puzzle.
+
+    p1: 5 ms
+
+    p2: 245 ms
+
+    [paste](https://topaz.github.io/paste/#XQAAAQCmBAAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw3D1UZFlD3WW8r2Z9pYT30X7PnBBcHhvVYDeawoIrg724t03bzRtEFKq3EaQt+aC2nR+OYZ4ictRUUGoc6jrCQVGb7WP1dLwVfa9/LKeRJi29rlBtKwnVWc4lWefLECWCktqIUoW+ZB6J7BaZfFkFGJOzYANtSlttzIq2Iz3IQRjI5tBoZvyQV4GGv8xFfmNYDJ1WTqxTWVl9u3qdRXUZMqzOuXpnmDVL/Zr5MVYGuP/hZwXkjyeLgoyKdhJuSqd6AX2tKF2X8NB49J/pwWJQFdIRRTUbnvgOy/9HZzkTaGEM82pY1TrjjI5DFEtR71rtVFxC0BTqaP0FISfyYxQvXNNssTTo8UUjXn6YqxG1/e7IZVKTJmE89Oy6CT0WlJ2YcsmwxTXyttFrM105lV0LVLtuNp0P8O3Oo2AgFaquxsbphYUoD8Y02TMTlnz17QWll4gWjG1ikQnFa8uJG6+0C7y3KPeNc7DCiTctA3xcnmIq3hKqWwNpfmcPWf7LLmOu9/k9qi4O9yXFOmCz8wmurFjA1Of7IshfqGJK8WrlAuEXStJ/ztkQanjW5vji0h+LSjyqDXXmrAnLJTrSGQLLaHf+/f9sgUhcaOkZAXMS9UIK7GL8HgjL0BnqSnLSF3Rhiu+MZtoMcL9h1ho9znbXq4uUtlrwdeTMe7kUrU2tuL0lz5627dFQ8L+uCP3)
+  :replies: []
+- :author: The_Jare
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1l8pbn/
+  :body: |-
+    I still see very few Ruby solutions, so happy to post mine. It just keeps a hash of different elements and how many of each there are, iterates the hash once per blink. I like this approach more than recursive + memo but I can't say why. I don't know which is faster.
+
+    Code solves one problem per line in the input which was convenient for testing, although testing proved unnecessary as it all just worked straight away.
+
+    ```ruby
+    stone_lines = ARGF.map { _1.split.map(&:to_i)}
+
+    def evolve_stone(v)
+      return [1] if v == 0
+      vs = v.to_s
+      l = vs.length
+      return [vs[...l/2].to_i, vs[l/2..].to_i] if l % 2 == 0
+      [v*2024]
+    end
+
+    Enumerator.product(stone_lines, [25, 75]) do |stones, blinks|
+      coll = Hash.new { |h,k| h[k] = 0 }
+      stones.each { coll[_1] += 1 }
+      (1..blinks).each do
+        co2 = Hash.new { |h,k| h[k] = 0 }
+        coll.each do |(v, n)|
+          nv = evolve_stone(v)
+          nv.each { |v| co2[v] += n }
+        end
+        coll = co2
+      end
+      p coll. sum { _1[1] }
+    end
+    ```
+  :replies:
+  - :author: feyn
+    :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1nsg5s/
+    :body: |-
+      > return [vs[...l/2].to_i, vs[l/2..].to_i] if l % 2 == 0
+
+      Instead of `vs[...l/2]`, I read it as `vs[...1/2]`. I was so surprised that you can use `1/2` in a range to take half of a string. I tried in in IRB and was sadly dissapointed :D
+    :replies:
+    - :author: The_Jare
+      :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1o2vrg/
+      :body: Haha yeah I need to avoid using lowercase L as a single-letter variable even if this case looks oddly appropriate:)
+      :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1htopa/
+  :body: |-
+    Took a bit of fiddling but here's a half-punchcard-sized full solution I'm happy with. Credit to /u/AlexTelon for the idea of dealing with the numbers as strings most of the time - my solutions with `Math.log10(n).to_i + 1` or `(d = n.digits.reverse).size` could fit (and ran about twice as fast), but the line breaks were awful.
+
+    ```ruby
+    @c = Hash.new{ |h, k| n, s = k; h[k] = s == 0 ? 1 : case n.sub!(/^0*/, '')
+      when ''; h[['1', s - 1]]
+      when /^(..)+$/; h[[n[0...n.size / 2], s - 1]] + h[[n[n.size / 2..-1], s - 1]]
+      else h[[(n.to_i * 2024).to_s, s - 1]]; end }
+    puts [25, 75].map{ |s| (@in ||= STDIN.read).split(' ').map{ @c[[_1, s]] }.sum }
+    ```
+
+    - Ruby's [hash default proc](https://ruby-doc.org/3.3.6/Hash.html#class-Hash-label-Default+Proc) is my favorite short method for implementing memoization. `Hash.new{ |hash, key| hash[key] = ... }` is no `@functools.cache`, but it's pretty clean (for a one-time script :])
+    - I used a `case` statement mostly so I could (mis)use Regexp to check if a number has an even number of digits. `/^(..)+$/`
+    - `@c` has about 127k entries when the program is finished. The largest number is 14 digits long, or 46 binary bits.
+  :replies:
+  - :author: AlexTelon
+    :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1hxyx1/
+    :body: |-
+      Nice one!
+
+      Now I feel tempted to look into using the re module in python for this days problem!
+
+      Nice trick with`(..)+` !
+    :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1i215l/
+  :body: |-
+    ```ruby
+    input = [125, 17]
+    tally = input.tally
+
+    75.times do
+      next_tally = Hash.new { 0 }
+
+      tally.each do |i,n|
+        case
+        when i == 0
+          next_tally[1] += n
+        when i.digits.length.even?
+          d = i.to_s
+          next_tally[d[0,d.size/2].to_i] += n
+          next_tally[d[d.size/2..].to_i] += n
+        else
+          next_tally[i*2024] += n
+        end
+      end
+
+      tally = next_tally
+    end
+
+    p tally.values.sum
+    ```
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1hv9va/
+  :body: |-
+    ```ruby
+    input = File.read("input.txt").split.map{|z| [z, 1]}.to_h
+
+    def blink(a, times)
+      times.times do
+        b = Hash.new(0)
+        a.entries.each do |n, c|
+          if n == ?0
+            b[?1] += c
+          elsif n.size.even?
+            b[n[0..(n.length/2-1)]] += c
+            b[n[(n.length/2)..].to_i.to_s] += c
+          else
+            b[(n.to_i * 2024).to_s] += c
+          end
+        end
+        a = b
+      end
+      a.values.sum
+    end
+    puts "Part 1: #{blink(input, 25)}", "Part 2: #{blink(input, 75)}"
+    ```
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1iy63k/
+  :body: |-
+    ```ruby
+    require_relative 'utils'
+
+    stones = ints(File.read('input11.txt', chomp: true))
+    stones_freq = Hash.new(0)
+    stones.map { |stone| stones_freq[stone] += 1 }
+
+    def blink(stone)
+      if stone.zero?
+        [1]
+      elsif ((Math.log10(stone).floor + 1) % 2).zero?
+        str = stone.to_s
+        [str[...str.length / 2], str[str.length / 2..]].map(&:to_i)
+      else
+        [stone * 2024]
+      end
+    end
+
+    def blink_all(stones_freq)
+      new_freq = Hash.new(0)
+      stones_freq.each_pair do |stone, freq|
+        blink(stone).map { |new_stone| new_freq[new_stone] += freq }
+      end
+      new_freq
+    end
+
+    75.times do
+      stones_freq = blink_all(stones_freq)
+    end
+
+    puts stones_freq.values.sum
+    ```
+
+    Looked up lantern fish after seeing all the posts referencing it. Looked it up and immediately knew this is the algorithm to go for. It was not obvious that the number of distinct stones scales slowly/converges!
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1hi4yx/
+  :body: |-
+    Wasted a bunch of time memoizing a dfs search before I abandoned it. Even cutting off large paths of the search with the cached counts was killing me in time/space. Then it dawned on me to just operate directly on the cache rather than using the call stack to hold it or an array in memory. This solution runs in 80ms.
+
+    ```ruby
+    def part_2
+      stones = data.split(" ").map(&:to_i)
+      counters = stones.zip(Array.new(stones.size, 1)).to_h
+      75.times {
+        counters = counters.each.with_object((Hash.new(0))) { |(stone, cnt), updated|
+          s = stone.to_s.chars
+          if(stone==0)
+            updated[1] += cnt
+          elsif(s.size.even?)
+            updated[s[0...s.size/2].join.to_i] += cnt
+            updated[s[s.size/2..-1].join.to_i] += cnt
+          else
+            updated[stone * 2024] += cnt
+          end
+        }
+      }
+      counters.values.sum
+    end
+    ```
+  :replies: []
+- :author: ni3t
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1hit82/
+  :body: |-
+    Since we don't get the fancy @cache annotation that pythonistas can use I had to implement it myself:
+
+    ```ruby
+    stones = "<input>".split
+    MAP = {}
+
+    def tick(x, i)
+      x = x.to_i.to_s
+      return MAP[[x,i]] if MAP[[x,i]]
+      if i == 0
+        1
+      elsif x == "0"
+        MAP[[x,i]] = tick("1", i - 1)
+      elsif x.length % 2 == 0
+        a = x[0..x.length/2-1]
+        b = x[x.length/2..-1]
+        MAP[[x,i]] = [
+          tick(a, i - 1),
+          tick(b, i - 1)
+        ].sum
+      else
+        MAP[[x,i]] = tick((x.to_i * 2024).to_s, i - 1)
+      end
+    end
+
+    puts stones.sum {|s| tick(s, 25)}
+    puts stones.sum {|s| tick(s, 75)}
+    ```
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1i5ox1/
+  :body: |-
+    Not too bad today, part 1, simple brute force approach to get the logic correct, second part, recursive solution with caching.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/11](https://github.com/careyi3/aoc_2024/tree/master/solutions/11)
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1ilqae/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day11.rb)"
+  :replies: []
+- :author: eggselent_folk
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1jwn7s/
+  :body: "~200ms for part 2\n\nI spent a lot of time finding optimization because simplest solution for part 1 does not work at all for part 2 \U0001F923\n\nAfter a while, finally I got to\\>!analyzing the pattern and found out it can be memoized.!\\<\n\n```ruby\ninput = '2701 64945 0 9959979 93 781524 620 1'.split(' ').map { |x| x.to_i }\n\n$memoize = {}\ndef blink(num, i)\n  return $memoize[\"#{num}-#{i}\"] if $memoize[\"#{num}-#{i}\"] != nil\n  return 1 if i > 75\n\n  return $memoize[\"#{num}-#{i}\"] = blink(1, i + 1) if num == 0\n\n  len = num.to_s.length\n  if len % 2 == 0\n    return $memoize[\"#{num}-#{i}\"] = blink(num.to_s[0...(len/2)].to_i, i + 1) +\n                                     blink(num.to_s[(len/2)...len].to_i, i + 1)\n  end\n\n  return $memoize[\"#{num}-#{i}\"] = blink(num * 2024, i + 1)\nend\n\ntotal = 0\ninput.each { |num| total += blink(num, 1) }\nputs total\n```"
+  :replies: []
+- :author: JAntaresN
+  :url: https://www.reddit.com/r/adventofcode/comments/1hbm0al/2024_day_11_solutions/m1kjzf7/
+  :body: |-
+    I treated it like a tree, and did a dfs with memoization, which worked quite well
+
+    ```ruby
+    $memo_table = {}
+
+    def dfs(number, depth)
+      return 1 if depth == 0
+      return $memo_table[number][depth] if $memo_table[number] && $memo_table[number][depth]
+
+      nodes = []
+      if number == "0"
+       nodes << "1"
+      elsif number.length % 2 == 0
+        nodes << number[0...number.length / 2].to_i.to_s
+        nodes << number[(number.length/2)..].to_i.to_s
+      else
+        nodes << "#{number.to_i * 2024}"
+      end
+
+      length = 0
+      nodes.each { |num|length += dfs(num, depth - 1)}
+
+      $memo_table[number] ||= {}
+      $memo_table[number][depth] = length
+      length
+    end
+
+    def solution(str)
+      total = 0
+      str.split(" ").each do |root|
+        t = dfs(root, ITERATION_LIMIT)
+        $memo_table[root][ITERATION_LIMIT] = t
+        total += t
+      end
+      total
+    end
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2024/12.yml

@@ -0,0 +1,89 @@
+---
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1ttukt/
+  :body: |-
+    Long and complicated solution, but finally it worked.
+
+    [https://gist.github.com/thofoer/fcdda1a0743f193f878590dd9042378f](https://gist.github.com/thofoer/fcdda1a0743f193f878590dd9042378f)
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1rqteo/
+  :body: |-
+    Not proud of this one. First instinct was to get all the distinct edges and do some sort of union find to collect them into sides. Was annoying to implement with the orientation and stuff. Eventually came to the sub for help and just decided to go with the counting corners and 16 different cases.
+
+    [paste](https://topaz.github.io/paste/#XQAAAQALCwAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8fKlEL/CNiVvHcK3eo2f1wG2uFy9c4gJqYPLUFmRQObk0r1ZXyU23Tm34gRt6y0eQyY1K3b+i262JFsBcUTwua3DLm6KTBbQg8CC8Rodb9gL52GlTW0N2qORt7dBV4CwUpm3lLu6RLl1ogK0d63e9tyuueHgAgtxDMoatd9vGGfGZnY21xRp25IJiEMKhh6Ke86I4FrZ8W9A37xgrFUJUloGcNqKnSchj7irMNiXDS00k5w9V9YulY2B59SdWfQ14ghDCtqD3XnYKarwPGUY07fC3AijJRjv8HS3WPreoiuTIRBr7jkEuNp+a5WplzZDFSvUA+SGvi/PwnaD6/ZivkZFvbyeGBve+j0ziP92qTpuA5DmMkD2uZQDd+y2oke9Tk70dnbo77SUwQW4eBW4AHYcFQ9W/I+dsop7XLo3cgYxJyi94YHJA5Vvh7jJXh9FAEoE9lQAeU0T1kuZFrNislGm9IDh1+f9nrO1HUPOnaovDrBljkmE7FeHjbjQHYGpKdAX2cognxu58PU7LwXRVCWlNbGSYa/60kDDAqw2gmNBJ74N2E6qTmkhe3vxmWX628uns27Zsp9WIQBOvdglNCGkAcbq1PLl9zIxjwYDAFZ86ZJXkfMZls0TiaLAN57rItao/tYvm9HaNAkrjlPMvcWl2QbkCPZgFl6j7upXZH8qJjP91A9cMAP6oww0PYbukUe/Oqt4VwubY1JScxdH7567llJM0gBq97AYi6UUUv/BD+crMh2ZoKCP5bR9xMub4YFHsJSbjNk8RfkIHoVa8SVXfWdN5ryqLk0c3iT+FRgTbd3gPOcKMgw35FIsTYCUah2N/Hvi9z6y7yA23tURikbXuDpMuIhiw/4Ve+nGvMGAsL6B/bWYABDb2btKaFeDRO+Yh/AidiuA6GgFTlbpJNkWgooMHH7n6hEs6THsdLxLwM5UpXNxwvD+F2RnUF/HzGFb6R424CjWQCsUzYpFIHF56/3z4m1SKfcODNZH2o13nGEsYhHv3lfuDLZheKTIDtldt0JBcCONc3mGHNCGSuiId8Z2Ue678cKufKm7MfB/0hnlAXs5yF9g3uimDv5ihxe20x1f3z1BKNmvVIUzxquHODfLhkYyLXv36hWmo5kW0841c9eGMdYrA5+P/+ggtgg==)
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1pa6ug/
+  :body: |-
+    Probably the most messy code I've written this year so far for finding side counts for part 2, but aside from that, straight forward version of the "count islands problem", easy solution with recursion. Part 2 usues part 1 as a tool to generate the data to compute the sides. I'm 100% sure there is a better way to do it, but this worked!
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/12](https://github.com/careyi3/aoc_2024/tree/master/solutions/12)
+  :replies:
+  - :author: Physium
+    :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1zyrxc/
+    :body: |-
+      I just want to say thank you for writing this in ruby. As messy as you think it is, i was able to visualise how you counted sides and implemented a similar approach to you.
+
+      You are the only one that use a dfs approach that i could understand and relate to. THANK YOU!
+    :replies:
+    - :author: careyi4
+      :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m21b5to/
+      :body: Ahh you are very welcome! Glad it helped!!
+      :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1p6fhq/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day12.rb)"
+  :replies: []
+- :author: firetech_SE
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1qhvc1/
+  :body: |-
+    Spent a lot of time thinking today, but happy to have come up with a solution without using any kinds of hints.
+
+    Started with a BFS-based Flood Fill algorithm, labeling all regions with an ID-number, and merging areas when needed. Then, for each region, find and store which of its plots that border something else (i.e. edge of map or other region). This is stored in one Set^1 per direction (up, down, left, right), and one plot can appear in multiple sets. The number of perimeters (for part 1) is the sum of the sizes of these sets.
+
+    For part 2, go through each of the four boundary sets, one plot at a time, and remove (from the set) any plot adjacent to it in any direction perpendicular to the direction its mismatching plot was found in. This leaves only one plot per side in the sets, and the sum of sizes of the sets after this gives the number of sides instead of perimeters.
+
+    [Code on github](https://github.com/firetech/advent-of-code/blob/%F0%9F%8E%84/2024/12/garden_groups.rb)
+
+    * * *
+
+    ^1) ^Using ^Set ^instead ^of ^Array ^for ^quicker ^deletion ^in ^part ^2.
+  :replies: []
+- :author: eggselent_folk
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1qtvud/
+  :body: |-
+    I stored direction of fences (perimeters), and then traverse all perimeters to only increase number of sides once for each continuous perimeters with the same direction.
+
+    [CODE](https://topaz.github.io/paste/#XQAAAQABDQAAAAAAAAA0m4poOBCMfthGvIqKnJBTU3eCvWf8e8dOecf0I5sIQTLtbcTd+HjCfYpKjvhIQVogm5aX2yu9Jh6koUIOjZBgppsFea2VpHS3B1Hw1hnHVet4Q3X4nWbYdyk1Fdj8ZETXiirCwsSaIuTtQS2Cf6RQdrrPc4iWsZq9WY0FeWxa7rzevx3vVvzzMvpf/2KddB/dnF3XEfrg4cuVuebBZSYZKbebtS/y84FY5p65+hRuUoOvrLmOYR7pg6ORXwYnidFYSxbwxgpUVMso/ehH87PNgziYVRAtA9wdB5gmqnYjUfSqQZFaoIzNTtofuCZDH1TJo9WkxvGM69CcelhxLB+rJJxQ6SePoEayFUpXcriKQM0ltyuBcXvz3/+RzR8exM577LPyezUWkU4Cdii1RCZDBEyF8VON66xlnjLJv5NVaIxrHTkb78hJZfmwDXudeAFuHMHM9jQ92+7nzRCsQXB/PwgYm0uq4YBiBSHhtg87uXifXW0V8FTlLNbagP1utEZEF2lQ4e6hboWY1roXQO/5G8FSl63dVdp3q4ZXKwxvuFnSYQM0fJWwVqEvT9QF3R1lityGYvuzw9a6/zBP9PEJpzdRYMroDuUQPG0aFRBWPMB7ikXEjZB+4jUC1opmUhNLFtSAUruQL72AcXRvHOYRrUTybUSIXt6U/W6SR6Wk0yXrYNfrL/WVXAcnVto4/BBF8/0Lg7rTuC3QLKjrKXGCRLzgMXM3RRon7IBnoNwzCqlm4HkbrlVvli81Q5gHfOQkREzKdVPJ4oSIvX/2U0NjExT7LYLsXxRMJREGOyKwBQkMBv0oM4wOlbwPStVaEknV7ExY0Wr93Z0bG3MT4bk1a53s7Wj56Ur+F+SvrJe6lXrfls+Ys0ELJy5sroWzwkhqpEv2JCYah+fRN2EYGIsj8K6UCY3SIO4Yt75yMBo6agnqDOkZYH39tERA+ZnB/20hIRR1rNHxNJwqQulaC3N4UtsEfF2Tlyj6gD9NoNrzQz6tAzriYQC3n+ZhkiLFbmROjwXOc8Otnv/F5ge+)
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1hcdnk0/2024_day_12_solutions/m1nplow/
+  :body: |-
+    I had to get out the old pencil and paper to figure out how to count unique sides of a shape. Happy with this solution. My get\_regions function is basically "go to every (unseen) point and do a bfs for that point's matching neighbors". Used Vector to make stepping in a given direction simple.
+
+    ```ruby
+    def part_2
+      get_regions.sum { |r|
+        r.size *
+        r.each.with_object(Set.new) { |p, sides|
+          # pick any perimeter point, find the edge that's the outside edge,
+          # turn 90 degrees and walk until you hit the next edge. This makes it so
+          # we are counting the outside border edge before every corner (clockwise)
+          DIR.each { |d|
+            next if r.include?(p + d) # not the border side
+            curr = p
+            walk_dir = Vector[d[1], -d[0]] # rotate 90 degrees
+            # step until you would leave region or leave border side
+            while r.include?(curr + walk_dir) && !r.include?(curr + d + walk_dir)
+              curr += walk_dir
+            end
+            sides << [curr, d] # keyed off the side we're testing, not walking
+          }
+        }.size
+      }
+    end
+    ```
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/12/solution.rb)
+  :replies: []