web-dev-qa-db-fra.com

Comment puis-je compter le nombre total de chiffres d'un numéro?

Comment puis-je compter le nombre total de chiffres d'un nombre en C #? Par exemple, le numéro 887979789 a 9 chiffres.

c#mathnumbers
90
Arash

Sans convertir en chaîne, vous pouvez essayer:

Math.Ceiling(Math.Log10(n));

Correction suivant le commentaire de ysap:

Math.Floor(Math.Log10(n) + 1);
143
Steve

Essaye ça:

myint.ToString().Length

Ça marche?

71
Andiih

Chacune 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.ToString().Length : n.ToString().Length - 1;
}

J'ai effectué des tests de performance sur ceux-ci, dans 5 scénarios différents, 100 000 000 d'appels dans une boucle for, mesurée avec Stopwatch.

ET LE GAGNANT IS ...

-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 lourde possible!

24
sɐunıɔןɐqɐp

Pas directement C #, mais la formule est la suivante: n = floor(log10(x)+1)

13
ysap

Les réponses déjà utilisées fonctionnent pour les entiers non signés, mais je n’ai pas trouvé les bonnes solutions pour obtenir le nombre de chiffres à partir de décimales et de 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 en decimal si la précision compte, mais le nombre décimal a également une limite.

8
nawfal

Utilisation de la récursion (parfois posée lors d'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;
 }
5
user2673195

La réponse de Steve est correct , mais cela 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)
5
Patrick Hofman
static void Main(string[] args)
{
    long blah = 20948230498204;
    Console.WriteLine(blah.ToString().Length);
}
4
weloytty

diviser un nombre par 10 vous donnera le chiffre le plus à gauche puis faire un mod 10 sur le nombre donne le nombre sans le premier chiffre et répétez-le jusqu'à ce que vous ayez tous les chiffres

1
romejoe
int i = 855865264;
int NumLen = i.ToString().Length;
0
Javed Akram