递归：Sum位数的乘积

Question

我只是从递归开始的，所以我正在解决一个像这样的问题

创建一个将数字作为参数的函数，将它们加在一起，然后返回数字乘积，直到答案只有1个数字长为止。

sumDigProd(16, 28) ➞ 6
// 16 + 28 = 44
// 4 * 4 =  16
// 1 * 6 = 6

sumDigProd(0) ➞ 0

sumDigProd(1, 2, 3, 4, 5, 6) ➞ 2

所以我以递归方式完成了

function sumDigProd(...digits) {
  let ans = digits.reduce((a, b) => a + b, 0);
  console.log(ans);
  const result=calc(ans);
 function calc(ans) {
    ans = ans.toString();
    let pro = 1;
    for (let i = 0; i < ans.length; i++) {
      pro = pro * ans[i];
    }
    console.log(pro);
    while (pro > 10) {
      calc(pro);
    }
    return pro
   
  }
  return result
}
console.log(sumDigProd(16,28));

所以我正在无限循环中运行它

Answer 1

您没有分配递归调用的返回值。

此外，您正在将迭代解决方案（带有while）与递归解决方案混合在一起。您需要两者之一，而不是全部。

对于递归解决方案，您可以只使用if。在这种情况下，您甚至可以立即从递归调用中返回返回值。

此外，条件应为pro >= 10，因为10不能作为最终值：

function sumDigProd(...digits) {
  let ans = digits.reduce((a, b) => a + b, 0);
  console.log(ans);

  function calc(ans) {
    ans = ans.toString();
    let pro = 1;
    for (let i = 0; i < ans.length; i++) {
      pro = pro * ans[i];
    }
    console.log(pro);
    if (pro >= 10) {
      return calc(pro); // recursive case
    }
    return pro; // base case
  }

  return calc(ans);
}
console.log(sumDigProd(16,28));

只需很少更改即可实现迭代解决方案：

function sumDigProd(...digits) {
  let pro = digits.reduce((a, b) => a + b, 0);
  console.log(pro);

  while (pro >= 10) {
    ans = pro.toString();
    pro = 1;
    for (let i = 0; i < ans.length; i++) {
      pro = pro * ans[i];
    }
    console.log(pro);
  }

  return pro;
}
console.log(sumDigProd(16,28));

然后将代码压缩到较小的占用空间，它可能会变成：

function sumDigProd(...digits) {
  let pro = digits.reduce((a, b) => a + b, 0);
  while (pro >= 10) {
    pro = Array.from(pro.toString()).reduce((a, b) => a * b, 1);
  }
  return pro;
}
console.log(sumDigProd(16,28));

Answer 2

您可以返回调用calc以获得递归结果的结果。

function sumDigProd(...digits) {
    function calc(ans) {
        let pro = [...ans.toString()].reduce((a, b) => a * b);
        return pro > 9 
            ? calc(pro)
            : pro;
    }

    return calc(digits.reduce((a, b) => a + b, 0));
}

console.log(sumDigProd(16, 28)); // 6
console.log(sumDigProd(1, 2, 3, 4, 5, 6)); // 2

Answer 3

您只需要分配pro并将while更改为if：

function sumDigProd(...digits) {
  let ans = digits.reduce((a, b) => a + b, 0);
  console.log(ans);
  const result=calc(ans);
 function calc(ans) {
    ans = ans.toString();
    let pro = 1;
    for (let i = 0; i < ans.length; i++) {
      pro = pro * ans[i];
    }
    console.log(pro);
    if (pro >= 10) {
      pro = calc(pro);
    }
    return pro

  }
  return result
}
console.log(sumDigProd(16,28,12));

Answer 4

短一点的版本：

function sumDigProd(a, b){

  let rec = function(a) {
    if (String(a).length == 1) return a;
        return rec(String(a).split('').map(Number).reduce((a,b)=>a*b));
  }
   return rec(a+b);
}

Answer 5

编辑：我发现这里的一些答案很聪明，但是比较难理解，下面是另一个例子，将值相加，如果有多个，则将数字相乘

递归：Sum位数的乘积

const sumDigitProduct = (num,...rest)=>{

  if(rest.length)
    num = sumDigitProduct( rest.reduce((agg,cv)=>agg+parseFloat(cv), num) )
  
  const digits = (''+num).split('')
  if( digits.length > 1)
    num = sumDigitProduct( digits.reduce((agg,cv)=>agg*parseFloat(cv)) )
  
  return num;
};


// Tests
console.log('expect: 3; got:', sumDigitProduct(1,2))
console.log('expect: 5; got:', sumDigitProduct(15))
console.log('expect: 6; got:', sumDigitProduct(16,28))
console.log('expect: 0; got:', sumDigitProduct(0))
console.log('expect: 2; got:', sumDigitProduct(1,2,3,4,5,6))

递归遍历无限循环

5 个答案:

递归：Sum位数的乘积