Comment puis-je obtenir le nombre total de chiffres d’un nombre en C #? Par exemple, le numéro 887979789 comporte 9 chiffres.
Sans conversion en chaîne, vous pouvez essayer:
Math.Ceiling(Math.Log10(n));
Correction suite au commentaire de ysap:
Math.Floor(Math.Log10(n) + 1);
Essaye ça:
myint.ToSsortingng().Length
Est-ce que ça marche?
Pas directement C #, mais la formule est: n = floor(log10(x)+1)
Les réponses à ce problème fonctionnent déjà pour les entiers non signés, mais je n’ai pas trouvé de bonnes solutions pour obtenir le nombre de chiffres à partir des décimales et des doubles.
public static int Length(double number) { number = Math.Abs(number); int length = 1; while ((number /= 10) >= 1) length++; return length; } //number of digits in 0 = 1, //number of digits in 22.1 = 2, //number of digits in -23 = 2
Vous pouvez changer le type d’entrée de double
à decimal
si la précision est importante, mais la décimale a aussi une limite.
Utiliser la récursivité (parfois demandé lors des interviews)
public int CountDigits(int number) { // In case of negative numbers number = Math.Abs(number); if (number >= 10) return CountDigits(number / 10) + 1; return 1; }
static void Main(ssortingng[] args) { long blah = 20948230498204; Console.WriteLine(blah.ToSsortingng().Length); }
La réponse de Steve est correcte , mais elle ne fonctionne pas pour les entiers inférieurs à 1.
Voici une version mise à jour qui fonctionne pour les négatifs:
int digits = n == 0 ? 1 : Math.Floor(Math.Log10(Math.Abs(n)) + 1)
N’importe laquelle de ces extensions fera le travail:
public static class Int32Extensions { // THE MATHEMATICALLY FORMULATED ONE: public static int Digits1(this Int32 n) => n == 0 ? 1 : 1 + (int) Math.Log10(Math.Abs(n)); // TYPICAL PROGRAMMING APPROACH: public static int Digits2(this Int32 n) { int digits = 0; do { ++digits; n /= 10; } while (n != 0); return digits; } // THE UGLIEST POSSIBLE THING: public static int Digits3(this Int32 n) { n = Math.Abs(n); if (n < 10) return 1; if (n < 100) return 2; if (n < 1000) return 3; if (n < 10000) return 4; if (n < 100000) return 5; if (n < 1000000) return 6; if (n < 10000000) return 7; if (n < 100000000) return 8; if (n < 1000000000) return 9; return 10; } // THE LOCOMOTIVE PULLING CHARACTERS: public static int Digits4(this Int32 n) => n >= 0 ? n.ToSsortingng().Length : n.ToSsortingng().Length - 1; }
J’ai effectué des tests de performance sur ceux, dans 5 scénarios différents, 100 000 000 appels dans une boucle for, mesurée avec Stopwatch
.
ET LE GAGNANT EST …
-1000000000.Digits1() => 1806 ms -1000000000.Digits2() => 4114 ms -1000000000.Digits3() => 664 ms <<< -1000000000.Digits4() => 13600 ms -1000.Digits1() => 1839 ms -1000.Digits2() => 1163 ms -1000.Digits3() => 429 ms <<< -1000.Digits4() => 9959 ms 0.Digits1() => 166 ms <<< 0.Digits2() => 369 ms 0.Digits3() => 165 ms <<< 0.Digits4() => 7416 ms 1000.Digits1() => 1578 ms 1000.Digits2() => 1182 ms 1000.Digits3() => 328 ms <<< 1000.Digits4() => 9296 ms 1000000000.Digits1() => 1596 ms 1000000000.Digits2() => 4074 ms 1000000000.Digits3() => 581 ms <<< 1000000000.Digits4() => 13679 ms
La chose la plus facile possible!
en divisant un nombre par 10, vous obtiendrez le chiffre le plus à gauche, puis en modifiant le chiffre 10, vous obtiendrez le numéro sans le premier chiffre et vous répéterez cela jusqu’à ce que vous ayez tous les chiffres.
int i = 855865264; int NumLen = i.ToSsortingng().Length;
Cela dépend exactement de ce que vous voulez faire avec les digiths. Vous pouvez effectuer une itération par chiffres à partir de la dernière à la première:
int tmp=number; int lastDigith = 0; do { lastDigith = tmp/10; doSomethingWithDigith(lastDigith); tmp %= 10; }while(tmp!=0);
Si c’est seulement pour valider vous pouvez faire: 887979789 > 99999999
convertir en chaîne et puis vous pouvez compter tatal no de chiffre par la méthode .length. Comme:
Ssortingng numberSsortingng = "855865264".toSsortingng(); int NumLen = numberSsortingng .Length;
En supposant que votre question se référait à un int, les travaux suivants pour négatif / positif et zéro également:
Math.Floor((decimal) Math.Abs(n)).ToSsortingng().Length