Question

以下是我的提示：

Catsylvanian的钱很奇怪：他们每个人都有一枚硬币面额（包括零！）。一个不稳定的变革机器 Catsylvania带任何价值N的硬币并返回3个新硬币，价值为N / 2，N / 3和N / 4（四舍五入）。

编写方法wonky_coins(n)，返回您的硬币数量如果您拿走所有非零硬币并继续喂它们，我们会留下它们回到机器，直到你只剩下零值硬币。

难度：3/5

describe "#wonky_coins" do
  it "handles a simple case" do
    wonky_coins(1).should == 3
  end

  it "handles a larger case" do
wonky_coins(5).should == 11
# 11
# => [2, 1, 1]
# => [[1, 0, 0], [0, 0, 0], [0, 0, 0]]
# => [[[0, 0, 0], 0, 0], [0, 0, 0], [0, 0, 0]]
  end

  it "handles being given the zero coin" do
    wonky_coins(0).should == 1
  end

end

也许是因为给出了涉及阵列的测试，但我无法理解他们的想法！所以到目前为止我的解决方案如下：

def wonky_coins(n)
    arr = []
    arr << n/2 << n/3 << n/4
    #base case?
    if arr.all?{|coin| coin == 0}
        return arr.flatten.length
        else
        arr.map{|x| wonky_coins(x)}
    end
end

p wonky_coins(5)

除非我将[[3,3,3]，3,3]作为输出，否则我将其映射。它实际上并没有反复发生，但即使在此之前，它也给出了一个奇怪的输出，我不能理解为什么输出是这样的！

我知道这是因为我使用的是map方法，是因为我在通过wonky_coins再次迭代它时我会改变它，我可以获得这个奇怪的输出＃＆＃m; 39;解释？

我看过这个解决方案并意识到数组使它变得不必要复杂，但我仍然想知道这里发生了什么？

Answer 1

以下是Seeing is Believing在代码运行时显示的内容：

def wonky_coins(n)
    arr = []                         # => [], [], [], [], [], [], []
    arr << n/2 << n/3 << n/4         # => [2, 1, 1], [1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]
    #base case?
    if arr.all?{|coin| coin == 0}    # => false, false, true, true, true, true, true
        return arr.flatten.length    # => 3, 3, 3, 3, 3
        else
        arr.map{|x| wonky_coins(x)}  # => [3, 3, 3], [[3, 3, 3], 3, 3]
    end
end

p wonky_coins(5)  # => [[3, 3, 3], 3, 3]

# >> [[3, 3, 3], 3, 3]

Seeing is Believing是一个很棒的工具，可以帮助挖掘代码中的怪异。

涉及Wonky硬币数组的递归

1 个答案: