Javascript 在每个递归中复制数组好吗？

我实际上在做

每日编码问题#2

我相信我已经得到了结果，并将其用于递归，但我想知道在每个递归中传递

arr

是否好？传递它会导致更多的内存或时间吗

编码问题是

给定一个整数数组，返回一个新数组，使新数组索引i处的每个元素都是原始数组中除i处的数字外的所有数字的乘积

例如，如果我们的输入是[1,2,3,4,5]，则为预期输出 将是[120,60,40,30,24]。如果我们的输入是[3,2,1]，那么 预期产出为[2,3,6]

我的代码看起来像

const multiply_without_index = (arr, index, result) => {
    result = result || [];
    index = index || 0;
    if(index === arr.length) return result;
    
    const copy_arr = [...arr];
    copy_arr.splice(index, 1);
    let total = 1;
    for(let n of copy_arr){
        total *= n;
    }
    result.push(total);
    index++;

    return multiply_without_index(arr, index, result);
}

---

提前感谢您的建议。

我相信有一种简单的数学方法可以解决这个问题，因为我已经解决了这个问题。说到您的问题，您不需要创建另一个数组，即

copy\u arr

，因为您已经通过了索引。您可以直接检查

循环的
中的
i
==
索引
，并跳过该迭代

const multiply_without_index = (arr, index, result) => {
    result = result || [];
    index = index || 0;
    if(index === arr.length) return result;
    
    let total = 1;
    for(let [i,n] of arr.entries()){
    if(i===index)
    continue;
        total *= n;
    }
    result.push(total);
    index++;

    return multiply_without_index(arr, index, result);
}

扰流板警报以下是我在解决同一问题时使用的第二种方法。
//log（a*b*c）=loga+logb+logc
设a=[1,2,3,4]
让prod=a.reduce（（acc，val）=>{return acc*val}，1）
让res=[]
a、 地图（（val）=>{
res.push（Math.floor（Math.exp（Math.log（prod）-Math.log（val）））
})
log（res）
我相信有一种简单的数学方法可以解决这个问题，因为我已经解决了这个问题。说到您的问题，您不需要创建另一个数组，即
copy\u arr
，因为您已经通过了索引。您可以直接检查
循环的
中的
i
==
索引
，并跳过该迭代

const multiply_without_index = (arr, index, result) => {
    result = result || [];
    index = index || 0;
    if(index === arr.length) return result;
    
    let total = 1;
    for(let [i,n] of arr.entries()){
    if(i===index)
    continue;
        total *= n;
    }
    result.push(total);
    index++;

    return multiply_without_index(arr, index, result);
}

扰流板警报以下是我在解决同一问题时使用的第二种方法。
//log（a*b*c）=loga+logb+logc
设a=[1,2,3,4]
让prod=a.reduce（（acc，val）=>{return acc*val}，1）
让res=[]
a、 地图（（val）=>{
res.push（Math.floor（Math.exp（Math.log（prod）-Math.log（val）））
})
log（res）
这里有一种方法可以使用几个较小的解决方案编写复杂的解决方案

这里是
mult
-


constmult=（[n=1，…更多]）=>
更长
? n*mult（更多）
：n
console.log（mult（[]）//1
console.log（mult（[5]）//5
log（mult（[5,4]）//20
log（mult（[5,4,3]）//60
这里有一种使用几个较小的解决方案编写复杂解决方案的方法

这里是
mult
-


constmult=（[n=1，…更多]）=>
更长
? n*mult（更多）
：n
console.log（mult（[]）//1
console.log（mult（[5]）//5
log（mult（[5,4]）//20
log（mult（[5,4,3]）//60
为了回答您的特定问题，在函数中添加数组作为参数应该不是什么大问题。JavaScript通过引用传递数组（即对象）参数，因此每次递归下降到另一个级别时，本质上就是向堆栈添加更多的内存字节（对应于引用值）

至于问题的解决方案，请注意，您应该能够在不使用递归的情况下以O（n）的复杂度完成此操作（正如kapil所建议的，当他说有一个简单的数学解决方案时）。
仅为了回答您的特定问题，在函数中添加数组作为参数应该不是什么大问题。JavaScript通过引用传递数组（即对象）参数，因此每次递归下降到另一个级别时，本质上就是向堆栈添加更多的内存字节（对应于引用值）

至于问题的解决方案，请注意，你应该能够做到这一点，而不需要递归，在O（n）复杂度下（正如kapil所建议的，他说有一个简单的数学解决方案）.
在递归函数中传递数组不应该是一个问题，因为每次只传递引用，分配的内存将是相同的。但您所做的拼接操作是另一个在内部完成的循环操作。您可以在不使用递归和拼接操作的情况下执行此操作

如果数组中的数字是非零的，我们可以用O（2n）复杂度来实现。选中getProductSeries功能

如果不是，请检查以O（n^2）复杂度编写的getProductSeries2函数（已注释）


设arr=[1,2,3,4,5]；
让getProductSeries=（arr）=>{
让multiplyTotal=arr.reduce（（总计，currentValue）=>total*currentValue）；
返回arr.map（（num）=>multiplyTotal/num）；
}
log（getProductSeries（arr））；
/*
让getProductSeries2=（arr）=>{
返回arr.map（（num，index）=>{
设total=1；
arr.forEach（（num，内部索引）=>{
if（内部索引！==索引）{
总计*=arr[内部指数]；
}
});
返回总数；
});
}
log（getProductSeries2（arr））；
*/
在递归函数中传递数组不应该是个问题，因为每次只传递引用，分配的内存相同。但您所做的拼接操作是另一个在内部完成的循环操作。您可以在不使用递归和拼接操作的情况下执行此操作

如果数组中的数字是非零的，我们可以用O（2n）复杂度来实现。选中getProductSeries功能

如果不是，请检查以O（n^2）复杂度编写的getProductSeries2函数（已注释）


设arr=[1,2,3,4,5]；
让getProductSeries=（arr）=>{
让multiplyTotal=arr.reduce（（总计，currentValue）=>total*currentValue）；
返回arr.map（（num）=>multiplyTotal/num）；
}
log（getProductSeries（arr））；
/*
让getProductSeries2=（arr）=>{
返回arr.map（（num，index）=>{
设total=1；
arr.forEach（（num，内部索引）=>{
if（内部索引！==索引）{
托特