2023-12 Ruby part 2

Author: dominikb

2023/day12/ruby/solution.rb

@@ -10,184 +10,65 @@
 ?###???????? 3,2,1
 EXAMPLE
 
-"""
-?###????????
-.###.##.#...
-.###..##.#..
-.###...##.#.  x
-.###....##.#  x
-.###.##..#..
-.###.##...#.  x
-.###.##....#  x
-.###..##..#.  x
-.###..##...#  x
-.###...##..#  x
-
-.###....##.#  x
-.###...##..#  x
-.###...##.#.  x
-.###..##...#  x
-.###..##..#.  x
-.###.##....#  x
-.###.##...#.  x
-
-???????
-...##.#
-..##..#
-..##.#.
-.##...#
-.##..#.
-##....#
-##...#.
-"""
-
 example = example.split("\n").map(&:strip)
 
-class Cell
-    attr_accessor :status
-
-    STATUS = {
-        :working => ".",
-        :broken => "#",
-        :unknown => "?",
-    }
-
-    STATUS.keys.each do |status|
-        define_method("#{status}?") do
-            @status == status
-        end
-        self.class.send(:define_method, status) do
-            new(STATUS[status])
-        end
-    end
-
-    def initialize(char)
-        @status = STATUS.key(char)
-    end
-
-    def to_s
-        STATUS[status]
-    end
-
-    def inspect
-        to_s
-        # "Cell<#{status}>"
-    end
-end
-
 def parse(input)
     input.map do |line|
-        springs = line.split(" ").first.chars.map(&Cell.method(:new))
+        # Add a working spring at the end of a line to be able to ignore the possiblity of a broken spring at the end
+        springs = line.split(" ").first.chars + ['.']
         groups = line.split(" ").last.split(",").map(&:to_i)
 
         { springs: springs, groups: groups }
     end
 end
 
-def assert(condition, message)
-    raise StandardError.new(message) unless condition 
-end
-
-def debug_puts(*args)
-#    puts(*args)
-end
-
-def consume_group(springs, groups)
-    assert(groups.size >= 1, "No group left to consume, but broken springs expected")
-    size, *tail_groups = groups
-
-    consumed = springs.take(size)
-    peek, *tail_springs = springs.drop(size)
-
-    valid_consume = consumed.all? { _1.broken? || _1.unknown? } && (peek.nil? || peek.working? || peek.unknown?)
-
-    debug_puts "Consume #{size}: [#{consumed.map(&:to_s).join('')}|#{peek&.to_s}|#{tail_springs.map(&:to_s).join('')}] -> #{valid_consume}"
-
-    return valid_consume
-end
-
 CACHE = {}
-def key(springs, groups)
-    [springs.map(&:to_s).join(''), groups.join(',')]
+def cached_count(s, groups, prev_broken = 0)
+    cache_key = [s, groups, prev_broken].hash
+    CACHE[cache_key] ||= count(s, groups, prev_broken)
 end
-
-def memoized_possible_arrangements(springs, groups)
-    CACHE[key(springs, groups)] ||= possible_arrangements(springs, groups)
-end
-
-def possible_arrangements(springs, groups)
-    debug_puts "Check [#{springs.map(&:to_s).join()}] #{groups}"
-    # Early stop
-    if (groups.sum > springs.size)
-        debug_puts "Early stop"
-        return [false]
+def count(s, groups, prev_broken = 0)
+    if groups.empty? && s.any? { _1 == '#' }
+        return 0
     end
-    if groups.empty?
-        if springs.any?(&:broken?)
-            return [false] # Illegal solution
-        else
-            return [springs.map { Cell.working }]
-        end
+
+    if s.empty? && groups.empty?
+        return 1
     end
-    if springs.empty? && groups.any?
-        return [false] # Illegal solution
+    
+    total = 0
+    if s[0] == '.' && prev_broken == 0
+        total += cached_count(s[1..], groups)
     end
 
-    head, *tail = springs
-    if head.working?
-        return possible_arrangements(tail, groups).filter_map do |arrangement|
-            next if arrangement == false # no solution
-            [head, *arrangement]
-        end
+    if s[0] == '.' && prev_broken == groups&.first
+        total += cached_count(s[1..], groups[1..])
     end
 
-    if head.broken?
-        return [false] unless consume_group(springs, groups) # Group can not be consumed
-
-        group, *tail_groups = groups
-        spring_rest = springs.drop(group + 1)
-        prefix = [Cell.broken] * group + (if springs.size > group then [Cell.working] else [] end)
-
-        debug_puts "Group #{group}, Prefix #{prefix.map(&:to_s).join('')}, Rest: #{springs.drop(group + 1).map(&:to_s).join('')}"
-
-        return possible_arrangements(springs.drop(group + 1), tail_groups).filter_map do |arrangement|
-            next if arrangement == false # no solution
-            [*prefix, *arrangement]
-        end
+    if s[0] == '#' && prev_broken < (groups.first || 0)
+        total += cached_count(s[1..], groups, prev_broken + 1)
     end
 
-    if head.unknown?
-        assume_working = [Cell.working, *tail]
-        assume_broken = [Cell.broken, *tail]
-
-        debug_puts "Assume working: #{assume_working.map(&:to_s).join('')}"
-        working = possible_arrangements(assume_working, groups)
-        debug_puts "Working: [#{working.map(&:to_s).join('')}]"
+    if s[0] == '?' && prev_broken == 0
+        total += cached_count(s[1..], groups)
+    end
 
-        debug_puts "Assume broken: #{assume_broken.map(&:to_s).join('')}"
-        broken = possible_arrangements(assume_broken, groups)
-        debug_puts "Broken: [#{broken.map(&:to_s).join('')}]"
+    if s[0] == '?' && prev_broken == groups&.first
+        total += cached_count(s[1..], groups[1..])
+    end
 
-        return (broken + working).reject { _1 == false }
+    if s[0] == '?' && prev_broken < (groups.first || 0)
+        total += cached_count(s[1..], groups, prev_broken + 1)
     end
-end
 
+    total
+end
 
 def part1(input)
     grid = parse(input)
 
-    # puts possible_arrangements("???????".chars.map { Cell.new(_1) }, [2, 1]).map { _1.join('') }.join("\n")
-
-    grid.sum do |row|
-        row => { springs:, groups: }
-        arrangements = possible_arrangements(springs, groups)
-
-        # puts "#{springs.map(&:to_s).join('').rjust(20, ' ')} #{arrangements.size.to_s.rjust(3, ' ')}"
-        # puts arrangements.map { _1.join('') }.join(', ')
-        # puts "#{arrangements.map { _1.map(&:to_s).join('') }.join("\n")}"
-        # puts "\n" * 2
-
-        arrangements.size
+    grid.sum do |row, i|
+        count(*row.values_at(:springs, :groups))
     end
 end
 
@@ -205,4 +86,4 @@ def part2(input)
 puts "Part 1 (Example): #{part1(example)}"
 puts "Part 1: #{part1(input)}"
 puts "Part 2 (Example): #{part2(example)}"
-# puts "Part 2: #{part2(input)}"
+puts "Part 2: #{part2(input)}"