Bevor Sie eine doppelte Notiz markieren, beachten Sie, dass dies nicht der Fall ist. Andere suchten nicht genau das Gleiche wie ich.
Was ist der kompakteste Weg, um eine Zahl in Javascript zusammenzufassen, bis nur noch eine Ziffer übrig ist? Beispiel: Sie geben 5678 ein, dann addiert das Skript es (5 + 6 + 7 + 8) und erhält 26, aber da es mehr als eine Ziffer ist, fügt es es erneut hinzu und erhält 2 + 6 = 8.
Gibt es überhaupt eine Möglichkeit, dies mit einer Nummer beliebiger Größe zu tun? Und wie kompakt kann das Skript werden?
14 Antworten
Wenn Sie kurz suchen, ist es schwer zu schlagen:
var n = 5678;
sum = n % 9 || 9;
console.log(sum)
Wenn Sie neugierig sind, wie das funktioniert, lesen Sie: Neun austreiben.
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.
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)
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)));