Comment augmenter la valeur d’un nombre au multiple suivant de 10, 100, 1000, 10 000 et ainsi de suite

Vous devrez pardonner le libellé de cette question, je suis sûr qu’il y a une meilleure façon, plus succincte de la poser, mais je ne le sais pas.

Disons que j’ai un graphique et que toutes les valeurs de l’axe des y sont

[0,4,5,3,2,5,6]

La valeur maximale est six. Je voudrais donc que l’échelle Y soit étiquetée de 0 à 10.

Compte tenu des valeurs suivantes

[33,26,54,23,86,23]

La valeur maximale est 86, donc je voudrais que l’échelle Y passe de 0 à 90.

Maintenant, disons que j’ai les valeurs suivantes

[98,253,87, 876,263]

Le maximum est 876, donc l’échelle Y devrait aller de 0 à 900

Maintenant, j’ai créé la fonction suivante qui devrait me donner toutes les valeurs d’échelle maximales dont j’ai besoin jusqu’à présent.

 function padMaxValue(value){ for(var i = 1; i < 1000000000000000000; i = i * 10){ var decimalValue = value / i; if(value === i){ return i; } if(decimalValue  0.09){ return i; } } } 

Cependant, compte tenu des valeurs suivantes

[99,123,82,189,45]

Ma fonction définirait l’échelle y max à 1000 . Mais le maximum devrait vraiment être 200. Je me rends compte que ce dont j’ai vraiment besoin est une manière plus intelligente d’augmenter la valeur de i au lieu de la multiplier par 10. Je dois pouvoir augmenter la valeur de i de 10, tout le long jusqu’à 100. Puis augmentez-le de 100, jusqu’à 1000. Puis augmentez-le de 1000, jusqu’à 10 000 et ainsi de suite.

J’ai l’impression qu’il devrait y avoir une manière mathématique nette et ordonnée de le faire. Et je pense aussi que le numéro 1000000000000000000 j’ai dans la boucle for trahit mon ignorance des mathématiques.

Anyhoot, c’est le problème. Des idées?

Il n’y a pas besoin d’aller au pays des cordes, ce qui pourrait être gênant si vous aviez déjà une valeur décimale.

 function RoundedMax(a) { var mx = Math.max.apply(Math, a); if (mx == 0) {return 0}; var size = Math.floor(Math.log(Math.abs(mx)) / Math.LN10); var magnitude = Math.pow(10, size); var yMax = Math.ceil(mx / magnitude) * magnitude; return yMax; } function RoundedMin(a) { var mn = Math.min.apply(Math, a); if (mn == 0) {return 0}; var size = Math.floor(Math.log(Math.abs(mn)) / Math.LN10); var magnitude = Math.pow(10, size); var yMin = Math.floor(mn / magnitude) * magnitude; return yMin; } var arr = [-9.9,-1.23,-8.2,-2.01,-4.5,0]; document.write(RoundedMax(arr) + " " + RoundedMin(arr)); 

Sorties: 0 -10 .

EDIT Mise à jour à la vue des commentaires. Fonctionne maintenant même dans IE8.

Je n’aime pas les maths, alors voici une solution assez simple / hilarante:

Trouvez la valeur maximale:

 var max = Math.max.apply(Math, [98,253,87, 876,263]); // 876 

Prenez son premier personnage

 var c = max.toSsortingng()[0] // "8" 

Faites-en un entier et ajoutez 1

 c = (c | 0) + 1 // 9 

Convertissez-le en chaîne de caractères:

 c = c.toSsortingng() // "9" 

Ajoutez N – 1 zéros, N étant la longueur de votre numéro d’origine:

 c += Array(max.toSsortingng().length).join("0") // "900" 

Convertissez-le en entier:

 c = (c | 0) // 900 

Terminé!


Sérieusement, utilisez les mathématiques .

Je crois que cela ferait le tour pour vous:

 var data = [98, 253, 87, 876, 263, -155]; var max = Math.max.apply(null, data); // var factor = Math.pow(10, Math.floor(Math.log(Math.abs(max)) / Math.LN10)); if (factor == 0) { factor = 1; } var magnitude = Math.ceil(max / (factor * 1.00)) * factor; 

En gros, ce qui se passe ci-dessus est le suivant:

  1. Trouver le maximum de l’échantillon
  2. Obtenez la longueur maximale des valeurs, puis élevez-la à une puissance de 10 soit 345, longueur = 3, le facteur est donc 100
  3. Assurez-vous de ne pas diviser par 0
  4. Divisez le nombre maximum par le facteur pour obtenir une décimale, et prenez le plafond de ce nombre, puis multipliez-le par le facteur pour obtenir le bon nombre de 0.

UPDATE: Si vous voulez trouver la valeur minimale (pour les valeurs négatives), retournez le Math.ceil à Math.floor . Vous devez également prendre la valeur absolue du minimum pour vous assurer de ne pas compter le caractère négatif dans la chaîne.

 var data = [98, 253, 87, 876, 263, -155]; var min = Math.min.apply(null, data); var factor = Math.pow(10, Math.floor(Math.log(Math.abs(max)) / Math.LN10)); if (factor == 0) { factor = 1; } var mag = Math.floor(min / (factor * 1.00)) * factor // mag = -200; 

MISE À JOUR 2: Comme beaucoup de personnes l’ont dit dans les commentaires, nous ne devrions pas utiliser la manipulation de chaînes. J’ai mis à jour le code pour utiliser des logarithmes à la place.

Je me suis retrouvé avec:

 function getGraphRange(data) { var max=Math.max.apply(null, data); var min=Math.min.apply(null, data); var maxDigits=max.toSsortingng().length; var minDigits=min.toSsortingng().length; var maxD=Math.pow(10,Math.max((maxDigits-1),1)); var minD=Math.pow(10,Math.max((minDigits-1),1)); var maxR=(Math.ceil(max/maxD)*maxD); var minR=(Math.floor(min/minD)*minD); return [minR,maxR]; } alert(getGraphRange([11, 20, 345, 99]).join(' - '));//10-400 alert(getGraphRange([0,4,5,3,2,5,6]).join(' - '));//0-10 alert(getGraphRange([98,253,87,876,263]).join(' - '));//80-900 

http://jsfiddle.net/p4xjs9na/

Il y a déjà de bonnes réponses ici. J’ai utilisé en boucle pour résoudre le problème. La fonction est très rapide et peut retourner une valeur en moins d’une seconde, même pour un très grand nombre.

 function padMaxValue(value) { var i = 10; var counter = 0; var roundMax = 10; var copyValue = value; //If the value is negative, convert copyValue to positive if(value < 0) copyValue *= -1; while(roundMax <= copyValue) { roundMax += i; counter++; if(counter == 9) { i *= 10; counter = 0; } } if(value < 0) roundMax *= -1; return roundMax; } document.write(padMaxValue(8) + "
"); document.write(padMaxValue(77) + "
"); document.write(padMaxValue(889.65) + "
"); document.write(padMaxValue(-880.65) + "
"); document.write(padMaxValue(-765889.65) + "
"); document.write(padMaxValue(7888.88) + "
"); document.write(padMaxValue(88999887788899.099887) + "
");

Sortie:

dix

80

900

-900

-800000

8000

90000000000000

Je ne suis pas beaucoup de personne mathématique mais je prends la programmation au sérieux! Je suis venu avec cette solution!

 function getMax(max){ var mCopy = max; var d=1;//Assuming everything is greater than 10, while(Math.floor(mCopy) > 10){//if the number is not one digited mCopy /= Math.pow(10,d); d++; } d--;//back one digit if(d<1) d++; if((Math.floor(max / Math.pow(10,d))*Math.pow(10,d))==max) return max; return Math.floor(max / Math.pow(10,d))*Math.pow(10,d) + Math.pow(10,d); } 

J'espère que cela t'aides

À mon avis, les réponses données sont trop compliquées. Voici une fonction anonyme qui peut être utilisée dans MATLAB:

 next = @(x,n) ceil(x/n)*n; >> next(11,10) ans = 20 %# 20 is the next "10" after "11") >> next(110,100) ans = 200 %# 200 is the next "100" after "110" >> next([98,253,87, 876,263],100) ans = 100 300 100 900 300 

x est le nombre à traiter et n est la taille de pas requirejse.

edit L’ automatisation de la détermination de l’ordre de grandeur suivant est également possible

 >> nextOrder = @(x) ceil(x/10.^ceil(log10(x))) * 10.^ceil(log10(x)); >> nextOrder([98,253,87,876,263]) ans = 100 1000 100 1000 1000