Ermitteln Sie die Anzahl der führenden Nullen in einer Gleitkommazahl

Question

Wie kann ich berechnen, wie viele Nullen nach dem Dezimalpunkt kommen, aber vor dem ersten von Null in einer Gleitkommazahl. Beispiele:

0 -> 0 
1 -> 0 
1.0 -> 0 
1.1 -> 0 
1.01 -> 1 
1.00003456 ->4 

Intuitiv nehme ich eine mathematische Funktion, die diese bietet, oder zumindest hat der Hauptteil. Aber ich kann mich weder erinnern noch herausfinden, welcher.

Ich weiß, dass es getan werden kann, indem man zuerst die Zahl in eine Zeichenkette umwandelt, solange die Zahl nicht in der wissenschaftlichen Notation ist, aber ich will eine reine mathematische Lösung.

In meinem Fall brauche ich nicht etwas, das für negative Zahlen funktioniert, wenn das eine Komplikation ist.

Ich würde gerne wissen, was die allgemeinen Möglichkeiten sind, es zu tun, unabhängig von der Sprache.

Aber wenn es eine hübsche Standard-Mathematik-Funktion dafür gibt, möchte ich auch wissen, ob JavaScript diese Funktion hat.

Als Nebenbemerkung frage ich mich, ob diese Berechnung mit der Methode zur Bestimmung, wie viele Ziffern für die dezimale Darstellung einer ganzen Zahl erforderlich sind, verwandt ist.

Answer 1

x eine nicht sein lassen ganze Zahl, die als n Ziffern des ganzen Teils geschrieben werden kann, dann der Dezimalpunkt, dann m Nullen, dann der Rest des Bruchteils.

x = [a 1 a 2 ... a n ] . [0 ...0 m] [b b ... b m ]

Dies bedeutet, dass der Bruchteil von x größer als oder gleich 10 ^-m und kleineren als 10 ^{-m + 1}. Der Dezimallogarithmus des Bruchteils von x ist größer oder gleich –m und kleiner als –m+1.

Dies wiederum bedeutet, dass der gesamte Teil des Dezimallogarithmus des Bruchteils von x–m entspricht.

function numZeroesAfterPoint(x) { 
 
    if (x % 1 == 0) { 
 
    return 0; 
 
    } else { 
 
    return -1 - Math.floor(Math.log10(x % 1)); 
 
    } 
 
} 
 

 
console.log(numZeroesAfterPoint(0)); 
 
console.log(numZeroesAfterPoint(1)); 
 
console.log(numZeroesAfterPoint(1.0)); 
 
console.log(numZeroesAfterPoint(1.1)); 
 
console.log(numZeroesAfterPoint(1.01)); 
 
console.log(numZeroesAfterPoint(1.00003456));

Als Nebenbemerkung, frage ich, ob diese Berechnung auf das Verfahren zur Bestimmung bezogen ist, wie viele Stellen für die dezimale Darstellung einer ganzen Zahl erforderlich.

In der gleichen Weise wird eine positive ganze Zahl x nimmt n Dezimalziffern es darzustellen, wenn und nur wenn n - 1 <= log10(x) < n.

Also die Anzahl der Ziffern in der Dezimal-Darstellung x ist floor(log10(x)) + 1.

Das gesagt, ich würde nicht empfehlen, diese Methode zur Bestimmung der Anzahl der Stellen in der Praxis zu verwenden. log10 gibt nicht garantiert den genauen Wert des Logarithmus (nicht einmal so genau wie IEEE 754 erlaubt), was in einigen Randfällen zu falschen Ergebnissen führen kann.

Answer 2

Sie können es mit Methode, aber es gibt nur einen Fehler in meinem Code, müssen Sie die Länge der Zahlen angeben, die nach dem Punkt . kommt Es liegt an der Art, wie die Methode verwendet wird.

HINWEIS:

Die maximale Länge für toFixed() Methode ist 20, so geben Sie nicht mehr als 20 Zahlen nach . wie die in the docs

var num = 12.0003400; 

var lengthAfterThePoint = 7; 
var l = num.toFixed(lengthAfterThePoint); 
var pointFound = false; 
var totalZeros = 0; 

for(var i = 0; i < l.length; i++){ 
    if(pointFound == false){ 
    if(l[i] == '.'){ 
     pointFound = true; 
    } 
    }else{ 
    if(l[i] != 0){ 
     break; 
    }else{ 
     totalZeros++; 
    } 
    } 
} 
console.log(totalZeros); 

Extra-Antwort

Dies ist meine zusätzliche Antwort, in dieser Funktion zählt das Programm alle Nullen bis zum letzten nicht null. Also ignoriert es am Ende alle Nullen.

var num = 12.034000005608000; 

var lengthAfterThePoint = 15; 
var l = num.toFixed(lengthAfterThePoint); 
var pointFound = false; 
var theArr = []; 

for(var i = 0; i < l.length; i++){ 
    if(pointFound == false){ 
    if(l[i] == '.'){ 
     pointFound = true; 
    } 
    }else{ 
    theArr.push(l[i]); 
    } 
} 


var firstNumFound = false; 
var totalZeros = 0; 

for(var j = 0; j < theArr.length; j++){ 
    if(firstNumFound == false){ 
    if(theArr[j] != 0){ 
     firstNumFound = true; 
     totalZeros = totalZeros + j; 
    } 
    }else{ 
    if(theArr[j] == 0){ 
     totalZeros++; 
    } 
    } 
} 


var totalZerosLeft = 0; 
for (var k = theArr.length; k > 0; k--) { 
    if(theArr[k -1] == 0){ 
    totalZerosLeft++; 
    }else{ 
    break; 
    } 
} 

console.log(totalZeros - totalZerosLeft); 

Answer 3

Sie können es mit einem einfachen while Schleife tun:

function CountZeros(Num) { 

    var Dec = Num % 1; 
    var Counter = -1; 

    while ((Dec < 1) && (Dec > 0)) { 
     Dec = Dec * 10; 
     Counter++; 
    } 
    Counter = Math.max(0, Counter); // In case there were no numbers at all after the decimal point. 

    console.log("There is: " + Counter + " zeros"); 
} 

Dann geben Sie einfach die Nummer, die Sie in die Funktion überprüfen möchten:

CountZeros(1.0034); 

Answer 4

Mein Ansatz wird mit einer while() Schleife, die den .floor(n) Wert mit dem n.toFixed(x) Wert vergleicht, während x Erhöhen, bis die beiden nicht gleich sind:

console.log(getZeros(0));   //0 
 
console.log(getZeros(1));   //0 
 
console.log(getZeros(1.0));   //0 
 
console.log(getZeros(1.1));   //0 
 
console.log(getZeros(1.01));  //1 
 
console.log(getZeros(1.00003456)); //4 
 

 
function getZeros(num) { 
 
    var x = 0; 
 
    if(num % 1 === 0) return x; 
 
    while(Math.floor(num)==num.toFixed(x)) {x++;} 
 
    return(x-1); 
 
}