你最大的问题在这里：

elsif number == 0 || 1

在Ruby中，1总是一个真值，所以这个条件总是满足的，导致return true的执行，终止你的方法，并返回true的任何值。
一旦你把它替换成

elsif number == 0 || number == 1

或

elsif [0,1].include? number

你还有一些问题需要解决-下一个问题是No implicit conversion of Integer into an Array，当你尝试将数字添加到数组中时。我希望你能自己解决这个问题。：）

我们在这里，一些小音符。

在Ruby中我们更喜欢duck-typing而不是strong类型（主要是因为我们没有强类型），所以任何形式的参数类型检查（如if number.class != Integer）都会被抛出（更不用说它不会工作得很好，因为你会拒绝大量其他的Numeric类--如果你必须检查类，使用is_a?或kind_of?）。请注意，如果你的方法执行的对象不是一个数字，你确实希望抛出一个异常，而不是让计算继续下去--防止系统进入坏状态要比调试坏状态和猜测你是如何到达那里容易得多。
这里可能是个人观点，但elsif很糟糕-几乎总是有更好的方法。在这种情况下，因为你在每种情况下都要返回，你可以这样做：

return false unless number.is_a? Integer # really unnecessary
return false if number.to_s.length > 3
return true if number == 0 || number == 1

require 'set'

def colorful?(n)
  digits = n.digits.reverse
  products = Set.new
  (1..digits.size-1).each do |n|
    digits.each_cons(n) { |a| return false unless products.add?(a.reduce(:*)) }
  end
  true
end

colorful? 263
  #=> true

colorful? 236
  #=> false

colorful? 3245
  #=> true

参见Set#add？
我可以通过添加一些puts语句并对上面的两个示例整数执行该方法来最好地展示该方法的工作原理。

def colorful?(n)
  digits = n.digits.reverse
  puts "digits = #{digits}"
  products = Set.new
  (1..digits.size-1).each do |n|
    puts "n = #{n}"
    puts "digits.each_cons(#{n}).to_a #=> #{digits.each_cons(n).to_a}"
    digits.each_cons(n) do |a|
      m = a.reduce(:*)
      puts "  a = #{a}, m = #{m}"
      puts "  products = #{products}"
      puts "  products.include?(#{m}) = #{products.include?(m)}"
      return false unless products.add?(m)
    end
  end
  puts "true is returned"
  true
end

colorful? 263
  #=> true

将显示以下内容。

digits = [2, 6, 3]
n = 1
digits.each_cons(1).to_a #=> [[2], [6], [3]]
  a = [2], m = 2
  products = #<Set: {}>
  products.include?(2) = false
  a = [6], m = 6
  products = #<Set: {2}>
  products.include?(6) = false
  a = [3], m = 3
  products = #<Set: {2, 6}>
  products.include?(3) = false
n = 2
digits.each_cons(2).to_a #=> [[2, 6], [6, 3]]
  a = [2, 6], m = 12
  products = #<Set: {2, 6, 3}>
  products.include?(12) = false
  a = [6, 3], m = 18
  products = #<Set: {2, 6, 3, 12}>
  products.include?(18) = false
true is returned

colorful? 236
  #=> false

将显示以下内容。

digits = [2, 3, 6]
n = 1
digits.each_cons(1).to_a #=> [[2], [3], [6]]
  a = [2], m = 2
  products = #<Set: {}>
  products.include?(2) = false
  a = [3], m = 3
  products = #<Set: {2}>
  products.include?(3) = false
  a = [6], m = 6
  products = #<Set: {2, 3}>
  products.include?(6) = false
n = 2
digits.each_cons(2).to_a #=> [[2, 3], [3, 6]]
  a = [2, 3], m = 6
  products = #<Set: {2, 3, 6}>
  products.include?(6) = true

因为发现products包含m（3），所以返回false。

所以最后我这样解决了它（我知道有更好的方法，但仍然，它现在工作（如可以判断一个数字是否是彩色的，如果它不超过3位数）：

def colorful?(number)
  return false unless number.is_a? Integer

  digits_arr = number.digits.reverse

  return false if digits_arr.length > 3

  return true if digits_arr.length == 1

  final_array = []
  final_array << digits_arr

  case digits_arr.length
  when 3
    product_one = digits_arr[0] * digits_arr[1]
    final_array << product_one
    product_two = digits_arr[1] * digits_arr[2]
    final_array << product_two
    product_three = digits_arr[0] * digits_arr[1] * digits_arr[2]
    final_array << product_three
  when 2
    product_one = digits_arr[0] * digits_arr[1]
    final_array << product_one
  end

  if final_array.flatten.uniq == final_array.flatten
    return true
  else
    return false
  end
end

def colorful?(number)
  return false unless number.is_a? Integer
  return false if number == 10
  digits_a = number.digits.reverse
  return false if digits_a.size > 3
  return true if number == 0 || number == 1 || digits_a.size < 3

  products = []
  digits_a.each_index do |i|
    digits_a.each_index do |j|
      next if i > j
      product = digits_a[i..j].reduce(:*)
      return false if products.include?(product)
      products << product
    end
  end

  true
end

所以这段代码对我很有用。我也是一个初学者，呵呵，刚刚结束了编码训练营