为什么它有效？ “乘法（arr，n）==乘法（arr，n - 1）* arr [n - 1]”

Question

我只是无法理解 freeCodeCamp 的“使用递归替换循环”课程。 我将在下面引用该部分；

递归是一个函数可以用以下形式表达的概念 本身。为了帮助理解这一点，首先考虑以下问题 任务：将数组的前 n 个元素相乘以创建乘积 那些元素。使用 for 循环，您可以这样做：

  function multiply(arr, n) {
    var product = 1;
    for (var i = 0; i < n; i++) {
        product *= arr[i];
    }
    return product;
  }

但是，请注意 multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1] 。这意味着您可以根据自身重写乘法 并且永远不需要使用循环。

  function multiply(arr, n) {
    if (n <= 0) {
      return 1;
    } else {
      return multiply(arr, n - 1) * arr[n - 1];
    }
  }

尤其是这部分。 multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]

如果是这样的话我可以理解；

multiply(arr, n) == multiply(arr, n - 1) * arr[n]

那是因为如果 arr = [2,3,4,5,6,7,8,9],

乘法(arr, 5);等于 2*3*4*5*6*7

乘法(arr, 4);等于 2*3*4*5*6

乘法(arr, 4) * arr[5];等于 (2*3*4*5*6)*7

所以multiply(arr, n) 和multiply(arr, n - 1) * arr[n] 是相同的值”

但是，我不明白为什么 multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1] ？ 谁能告诉我这段代码发生了什么？为什么他们是平等的？

Answer 1

However, I can't understand why multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1] ? Can anyone please tell what’s happening in this code? Why they are equal?

给定的算法是将数组arr 的第一个n 元素相乘并返回答案。

现在，要与第一个 n 元素相乘，我们可以将第一个 (n-1) 元素相乘，然后将结果与数组的第 n 个元素相乘。

所以，multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]。

multiply(arr, n) 表示将数组arr 的第一个n 元素相乘。
multiply(arr, n - 1) 表示将数组arr 的第一个n-1 元素相乘。

Answer 2

我自己刚刚上完这一课，发现自己迷失了一段时间。我们的问题来自于没有意识到 arr 的第 n 项不等于 arr[n] 而是 arr[n-1]。

multiply(arr, 5); equals 2*3*4*5*6*7

在这种情况下，您将前 5 个术语相加 2*3*4*5*6

multiply(arr, 4); equals 2*3*4*5*6

在这种情况下，您将前 4 个术语相加 2*3*4*5

multiply(arr, 4) * arr[5]; equals (2*3*4*5*6)*7

由于术语编号和索引之间的差异（第一个术语在 [0]，第二个术语在 [1]，等等），multiply(arr, 4) * arr[5]; 实际上等于 (2*3*4*5)*7，因为 arr[5] 是数组的第 6 项而不是第 5 项。

Answer 3

所以我怀疑multiply(arr, n) and multiply(arr, n - 1) * arr[n] 会给出相同的值。 multiply(arr, n) 为您提供第一个 nth 项的结果。请参阅下面的证明：

注意：下面的代码是伪代码

//given the array below
var arr = [1,2,3,4]
// if n = 3
return multiply(arr, n); //output will be [1,2,3] = 1*2*3 = 6

//but
multiply(arr, n - 1) * arr[n]; //output will be [1,2]*4 => 1*2*4 = 8
//therefore 
multiply(arr, n) != multiply(arr, n - 1) * arr[n];

但是

//given the array below
var arr = [1,2,3,4]
// if n = 3
return multiply(arr, n); //output will be [1,2,3] = 1*2*3 = 6

//but
multiply(arr, n - 1) * arr[n - 1]; //output will be [1,2]*3 => 1*2*3 = 6
//therefore 
multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1];

希望对你有帮助

Answer 4

好的，我将尝试按照我想出的方式来解释它。我也遇到了这个问题。

这部分是这里的混淆：multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]

假设我们有一个数组： var arr = [1, 2, 3, 4, 5] 这里的n，指的是数组中元素的个数，是5，因为数组里面有5个元素。

现在在给出的第一个函数中：

函数乘法（arr，n）{

var product = 1;

for (var i = 0; i < n; i++) {

    product *= arr[i];

}

return product;

}

在这里我们可以找到我们混淆的左侧作为函数本身，即multiply(arr, n)。

这里乘积不断地与箭头的元素相乘，直到变量 i 变为 5 然后它停止，因为它不再小于 n 但等于 n 恰好是 5，元素本身的数量.

所以它是从 0 到 4，这些是恰好与乘积相乘的元素的索引号，即 1。

当索引为0时，则arr[0]为1

当索引为1时，则arr[1]为2

当索引为2时，则arr[2]为3

当索引为 3 时，则 arr[3] 为 4

当索引为4时，则arr[4]为5

它们都相乘，结果是 = 1 * 2 * 3 * 4 * 5 = 120。

所以我们左边的混淆值是 120

然后我们来到我们困惑的右侧。

乘法(arr, n - 1) * arr[n - 1]

这部分有两件事相乘

第一个是 multiply(arr, n - 1)，除了你只需要比上一次少一个元素外，它是一样的。想一想同样的函数，其中只有元素数量为 n，这次少了 1 个元素。所以现在 n 是 4。

所以现在是这样的：

当索引为0时，则arr[0]为1

当索引为1时，则arr[1]为2

当索引为2时，则arr[2]为3

当索引为 3 时，则 arr[3] 为 4

所以对于第一个 multiply(arr, n - 1) 部分，它们都相乘，结果是 = 1 * 2 * 3 * 4 = 24。

接下来是arr[n - 1]

在这里，我们只获得数组的第 n-1 个索引，我们知道 n 是 5，因此 n-1 将是 4。我们知道索引从零开始，所以第 4 个index 将是箭头中的第 5 项，即 5。

这意味着 arr[n - 1] 是 5。

现在，让我们将这两个部分相乘：

我们有：

乘法（arr，n - 1） = 24 和， arr[n - 1] = 5

5 * 24 = 120，与我们混淆左侧的结果相同。

希望这会有所帮助。

Answer 5

是的，据我所见（或注意到），这个概念不起作用，除非最后一个“n”值与索引值相同。 2x4x7x6=1680（n 然后是 2x4x7x"6"=1680..."6" 是另一个随机数...只是不是 3 vs n=(2x4x7x"3") 索引为@3（在 n-1 条件下），这会解决的。2x4x7=280...x"3"=840 where with n=2473.这正是我注意到的，所以是的，这个概念在一定程度上有效，除非...这个概念仅适用于与索引值相同的最后一个 n 数。 最终结果： n 是（2473=1680），并且 n-1 为 (247=280)x3=1680... 结果相同。

如果我错了，请帮忙，谢谢）