硬币改变递归哈希（解释）？

Question

Ruby non-greedy memoized hash，硬币找零解决方案：

def coin_change amt, denom_arr
  coins = Hash.new do |coin, key|
    coin[key] = if key < denom_arr.min
      []
    elsif denom_arr.include? key
      [key]
    else
      denom_arr.
      reject { |coin| coin > key }.
      reduce([]) { |memo, denom| memo.any? {|coin| coin%denom==0 } ? memo : memo+[denom] }.
      map {|denom| [denom] + coin[key-denom]}.
      min { |a, b| a.size <=> b.size } 
    end 
  end
  coins[amt]
end

p coin_change 6, [4,3,1]
#=> [3,3]

究竟是什么被发送到这条线？ .reduce([]) { |memo, denom| memo.any? {|coin| coin%denom==0 } ? memo : memo+[denom] }（据我所知，它是一个硬币数组

我也知道如果{|coin| coin%denom==0 } 是真的返回memo 但memo+[denom] 到底是什么？

我了解如果块返回 false 或 nil 以外的值，.any? 方法如何返回 true。

我以为memo 是一个数组，但我在上面调用了类，它返回了Class？

[4,3,8,7].inject([]) { |memo, denom| memo.class } 
#=> Class

总之，有人可以用步骤中的示例输出来解释这一点：

• 此行：.reduce([]) { |memo, denom| memo.any? {|coin| coin%denom==0 } ? memo : memo+[denom] }
• 您能否举例说明每次迭代中的递归代码哈希键/值是什么？ **

** 即。 denom_arr = 4,3,1 和 amt = 6 在第一遍中，哈希是什么样的？在第二遍时，哈希是什么样的？在第三遍等直到完成......哈希是什么样的？

Answer 1

.reduce([]) { |memo, denom| memo.any? {|coin| coin%denom==0 } ? memo : memo+[denom] }

从没有大于key 的元素的denom_arr 开始，此表达式通过

构建一个新的Array 实例

• reduce方法以空数组作为累加器的初始值
• memo.any? { … } ? memo : memo+[denom] - 如果累加器中至少有一个元素传递的块为真，则保持累加器不变，否则将 denom 的值附加到它。
• {|coin| coin%denom==0 } - 如果coin 可以被denom 整除而没有提醒，则传递给memo.any? 的块为真，即。模等于零

编辑： memo 是保存 #reduce 的当前结果并针对 Enumerable 实例的每个元素进行更新的累加器

例子：

denom_arr = [4,3,1]
coins[123]  # this invokes block passed to `Hash.new` to get default value
# denom_arr.reject { |coin| coin > key }.
# [4,3,1].reject { |coin| coin > 123 }
# => [4,3,1]
# .reduce([]) { |memo, denom| memo.any? {|coin| coin%denom==0 } ? memo : memo+[denom] }.
# initialization:  memo = [], denom = 4
# 1st pass : memo.any? evaluates to false as memo is "empty"
#   memo = memo + [4] ie. memo == [4] now
# 2nd pass : memo == [4], denom = 3
#   memo.any? evaluates to false as 4 % 3 != 0
#   memo = [4] + [3]  => [4, 3]
# 3rd pass : memo == [4,3], denom = 1
#   memo.any? evaluates to true as 4 % 1 == 0
#   memo = memo  => [4, 3]

希望现在更清楚