Comment puis-je obtenir le nombre total de chiffres d’un nombre?

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