Question

在标记重复的注释之前，它不是。其他人并没有找到与我完全相同的东西。

在javascript中总结一个数字的最紧凑的可行方法是什么，直到只剩下一个数字。例如：您输入5678然后脚本将它们加在一起（5 + 6 + 7 + 8）并获得26，但由于它超过1位数，它再次添加它并获得2 + 6 = 8。

无论如何都有这么多的尺寸吗？脚本有多紧凑？

Answer 1

如果您正在寻找短片，那就很难被击败：

＆＃13;

var n = 5678;
sum  = n % 9 || 9;

console.log(sum)

＆＃13;

如果您对其运作方式感到好奇，请参阅：casting out nines.

Answer 2

你可以使用递归来做到这一点，这是一个例子：

function getOneDigit(nr){
    let asStr = nr.toString();
    let sum = asStr.split("").reduce((a, c) => {
         a+=parseInt(c);
         return a;
    }, 0);
    return sum >= 10 ? getOneDigit(sum) : sum;
}

[234235, 235346, 657234, 1, 2, 5423].forEach(nr => console.log(getOneDigit(nr)));

Answer 3

这行代码可以做到这一点。

function digital_root(n) {
    return (n - 1) % 9 + 1;
}

当您将数字与9取模时，它变成小于9的1。因此，当您有10％9时，您将得到1，等于1 + 0。

类似地，123％9 = 6。

为什么（n-1）％9并添加1：因为当您输入9时，它变为0，所以输入将无效。

对于n = 9，此方法将返回（9-1）％9 = 8和8 + 1 = 9。

所以它不会破裂。

您也可以写

return n%9 || 9

Answer 4

function fun(n) {
sum = 0;
while(n > 0 || sum > 9)
    {
        if(n == 0)
        {
            n = sum;
            sum = 0;
        }
        sum = sum+n % 10;
        n = Math.floor(n/10);
    }
    console.log(sum);
}

您可以使用上述代码段。

Answer 5

对于紧凑的方法，您可以使用迭代和递归方法。

const d = n => n > 9 ? d([...n.toString()].reduce((a, b) => +a + +b)) : n;

console.log(d(5678));

Answer 6

function createCheckDigit(membershipId) {
     var total = membershipId;
   while (total.length > 1) {
       t = 0;
       for (let i = 0; i < total.length; i++) {
               t = Number(t) + Number(total[i]);
       }
       total = t.toString(); 
   }
   return total;
  }
console.log(createCheckDigit("55555"));

Answer 7

您需要检查值的长度（将sum转换为String后）是否为1。

var fnSum = (arr) => arr.reduce((a, c) => a + (+c), 0); //function to get sum of values

var fnGetSingleDigit = (arr) => {
  while (arr.length != 1) {
    var sum = fnSum(arr);
    arr = String(sum).split("");
  }
  return arr[0];
};

console.log(fnGetSingleDigit([5, 6, 7, 8]));

console.log(fnGetSingleDigit([41,34,3,54,63,46]));

<强>演示

var fnSum = (arr) => arr.reduce((a, c) => a + (+c), 0); //function to get sum of values

var fnGetSingleDigit = (arr) => {
  while (arr.length != 1) {
    var sum = fnSum(arr);
    arr = String(sum).split("");
  }
  return arr[0];
};

console.log(fnGetSingleDigit([5, 6, 7, 8]));

console.log(fnGetSingleDigit([41,34,3,54,63,46]));

Answer 8

你去吧

var number = 56785;
var total = number + '';
    
while(total.length > 1) {
   var temp = 0;
   for(var i = 0; i < total.length; i++) {
       temp += +total[i];
   }
   total = temp + '';
}
    
console.log(total);

Answer 9

您还可以选择使用forEach循环和while条件循环stringify数字并获取总和，直到长度为1。

var num = 5678;
var strNum = num.toString().split('');
while(strNum.length !== 1){
  var strNum = calculateSum(strNum);
  strNum = strNum.split('');
}
var result = parseInt(strNum);
console.log(result);

function calculateSum(strNum){
  var sum = 0;
  strNum.forEach((digit)=>{
    sum += parseInt(digit);
  });
  return sum.toString();
}

Answer 10

这是我在CodeWars上遇到同样问题的解决方案

const sumup = (num) => {
   let a = String(num).split('').map((k) => {
     return Number(k);
   }).reduce((p, c) => {
     return p + c;
   }, 0);

   return a > 9 ? sumup(a) : a;
}

Answer 11

这是一个不使用任何库的递归解决方案！

＆＃13;

function getSumOfDigits(num){
  var result = 0;
  while(~~(num/10) > 0){
    result += (num % 10);
    num = ~~(num/10);
  }
  return result + num;
}

function getSingleDigit(num) {
  if(~~(num/10) === 0) {
    return num
  } else {
    num = getSumOfDigits(num);
    return getSingleDigit(num);
  }
}

console.log(getSingleDigit(393));

＆＃13;

Answer 12

您可以将一些实用程序方法与递归结合起来，并以两行仍然很容易理解的方式完成：

function sumDigits(digits) {
  let sum = Array.from(digits.toString()).map(Number).reduce((res, val) => res + val, 0);
  return sum < 10 ? sum : sumDigits(sum);
}

console.log(sumDigits(55555)) // 5+5+5+5+5 = 25 -> 2+5 = 7

Answer 13

function doSum(n){
	var temp = n, total= 0;
		for(var i = 0; i < n.toString().length; i++ ){
    		  total = total + (Math.floor(temp) % 10)
		  temp = (temp / 10)
		}
	if(total > 9 ) { return doSum(total) }
return total
}
doSum(999999)

Answer 14

我是这样做的：

function sumOfID(__id){
  var arr_str = Array.from(__id)
  var arr = arr_str.map((t)=>{return parseInt(t)})
  function digSum(__arr){
   return __arr.reduce((a,b)=>{return a + b})
  }
   return digSum(arr)%9 || 9    
 }

注意：这里的诀窍是使用mod9，因为任何多位数的模9都是其总和，直到成为单个数为止。

Answer 15

// recursive
    function digitSum(n) {
      return (n % 10 === n) ? n : (digitSum(n.toString().split('').reduce((acc, curr) => acc + parseInt(curr), 0)));
    }

    
        
   function digitSum(n) {
       while(!(n % 10 === n)) {
         n = n.toString().split('').reduce((acc, curr) => acc + parseInt(curr), 0);
       }
      
       return n;
    
    console.log(digitSum(467)); // -> 17 -> 8

基本上检查 nums 长度（数字计数长度）< 2（通过 n % 10 === n (9 % 10 === 9) 或 n.toString 实现） ().length < 2 如果不是，则使用计算出的数字总和再次调用该函数以467为例：

4 + 6 + 7 = 17（数字长度不是 1）用 17 调用
1 + 7 = 8（数字长度为 1）-> 返回。第二个版本与递归版本相同，希望对您有所帮助！

总结一个数字，直到它成为1位JS

15 个答案: