Найти все трехзначные числа, средняя цифра которых равна сумме первой и второй цифр

module Pattern
  class Pattern
    include Enumerable
 
    def initialize(pattern)
      @pattern = pattern.map { |slot| validate slot }
    end
 
    def each
      return enum_for __method__ unless block_given?
 
      while has_digits?
        yield @digits if match_pattern? @digits
      end
    end
 
    private
    def match_pattern?(digits)
      @pattern.each_with_index.all? do |slot, idx|
        next true unless slot.is_a? Expr
 
        slot.eval(digits) == digits.fetch(idx)
      end
    end
 
    def has_digits?
      if !@digits
        @digits ||= initial_digits
      else
        @digits = next_digits
      end
    end
 
    def initial_digits
      @pattern.map do |slot|
        if const? slot
          slot
        else
          0
        end
      end
    end
 
    def next_digits
      enum = @digits.each_with_index
 
      continue = enum.find do |digit, idx|
 
        next false if const? @pattern.fetch(idx)
        next false if digit > 8
 
        true
      end
 
      return nil unless continue
 
      carry, first = false, true
 
      new_digits = enum.reverse_each.each_with_object([]) do |pair, obj|
        digit, idx = pair
 
        next_digit = digit
 
        if const? @pattern.fetch idx
          obj << next_digit
          next
        end
 
        next_digit += 1 if first
        next_digit += 1 if carry
        next_digit = 0 if next_digit > 9
 
        carry = next_digit == 0 && next_digit != digit
 
        first = false
 
        obj << next_digit
      end.reverse
 
      return nil if carry
 
      new_digits
    end
 
    def const?(slot)
      slot.is_a? Numeric
    end
 
    def validate(slot)
      case slot
      when 0..9 then slot
      when Numeric then raise ArgumentError, "Constants must be decimal digits"
      when :_ then slot
      when Symbol then Index.new slot
      when Expr then slot
      else raise ArgumentError, "Expected constant, placeholder, or expression; #{slot} given"
      end
    end
  end
 
  class Expr
    def self.create(thing)
      return thing if thing.is_a? Expr
      Index.new thing
    end
 
    def eval(digits)
      this = @this.eval digits
      that = @that.eval digits
 
      @op.to_proc.call this, that
    end
 
    def method_missing(meth, *args)
      return super if block_given?
      return super unless %i(+ - *).include? meth
      return super unless args.size == 1
 
      Expr.new self, args[0], meth
    end
 
    def initialize(this, that, op)
      @this = this
      @that = that
      @op = op
    end
 
    def to_s
      "#{show_operand @this} #{@op.to_s} #{show_operand @that}"
    end
 
    private
    def show_operand(op)
      return "(#{op})" unless op.is_a? Index
 
      op.to_s
    end
  end
 
  class Index < Expr
    def initialize(idx)
      raise ArgumentError, "Invalid index: #{idx}" unless /^_\d+/ =~ idx
      @idx = idx.to_s.gsub('_', '').to_i - 1
    end
 
    def eval(digits)
      digits.fetch @idx
    end
 
    def to_s
      "_" + (@idx + 1).to_s
    end
  end
 
  refine Symbol do
    def method_missing(meth, *args)
      super if block_given?
      super unless args.size == 1
      super unless %i(+ - *).include? meth
 
      Index.new(self).send meth, Expr.create(args[0])
    end
  end
 
  refine Array do
    def each_solution(&block)
      Pattern.new(self).each(&block)
    end
  end
end