Summieren Sie eine Zahl, bis sie 1-stellig JS wird

Sie können einige Dienstprogrammmethoden mit Rekursion kombinieren und dies in zwei Zeilen tun, die noch gut lesbar sind:

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

Hier ist eine rekursive Lösung ohne Verwendung einer Bibliothek!

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));

Sie können auch die forEach - Schleife und eine while - Bedingung verwenden, um die Stringify-Zahl zu durchlaufen und die Summe zu erhalten, bis die Länge 1 beträgt.

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();
}

Bitte schön

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);

Diese Codezeile macht das.

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

Wenn Sie das Modulo einer Zahl mit 9 nehmen, wird es eine 1 kleiner als 9. Wenn Sie also 10% 9 haben, erhalten Sie 1, was 1 + 0 entspricht.

In ähnlicher Weise ist 123% 9 = 6.

Warum (n-1)% 9 und 1 hinzugefügt: Wenn Sie 9 eingeben, wird es 0, sodass die Eingabe ungültig wird.

Für n = 9 gibt diese Methode (9-1)% 9 = 8 und 8 + 1 = 9 zurück.

Es bricht also nicht.

Sie können auch schreiben

return n%9 || 9

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"));

Für eine kompakte Methode können Sie einen iterativen und rekursiven Ansatz verwenden.

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

console.log(d(5678));

Sie müssen überprüfen, ob die Länge des Werts (nach der Konvertierung von sum in String) 1 beträgt oder nicht.

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]));

Demo

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]));

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);
}

Sie können das obige Snippet verwenden.

Ich habe es so gemacht:

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    
 }

Hinweis: Der Trick hier besteht darin, mod9 zu verwenden, da das Modulo 9 einer beliebigen mehrstelligen Zahl die Gesamtsumme ist, bis es zu einer einstelligen Zahl wird.

Dies ist meine Lösung für das gleiche Problem bei 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;
}

Sie können dies mithilfe der Rekursion tun. Hier ein Beispiel:

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)));