Trouver la longueur d'un entier en C

Question

Je voudrais savoir comment trouver la longueur d'un nombre entier en C.

Par exemple :

• 1 => 1
• 25 => 2
• 12512 => 5
• 0 => 1

et ainsi de suite.

Comment puis-je faire cela en C ?

Answer 1

C :

Pourquoi ne pas simplement prendre le logarithme en base 10 de la valeur absolue du nombre, l'arrondir au chiffre inférieur et ajouter un ? Cela fonctionne pour les nombres positifs et négatifs qui ne sont pas égaux à 0, et évite d'avoir à utiliser des fonctions de conversion de chaîne.

El log10 , abs y floor Les fonctions sont fournies par math.h . Par exemple :

int nDigits = floor(log10(abs(the_integer))) + 1;

Vous devez inclure cette clause dans une clause garantissant que the_integer != 0 puisque log10(0) renvoie à -HUGE_VAL en fonction de man 3 log .

De plus, vous pouvez ajouter un au résultat final si l'entrée est négative, si vous êtes intéressé par la longueur du nombre incluant son signe négatif.

Java :

int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;

---

N.B. La nature à virgule flottante des calculs impliqués dans cette méthode peut la rendre plus lente qu'une approche plus directe. Voir les commentaires de la réponse de Kangkan pour une discussion sur l'efficacité.

Answer 2

Si vous êtes intéressé par un rapide y très simple la solution suivante pourrait être la plus rapide (cela dépend de la distribution de probabilité des nombres en question) :

int lenHelper(unsigned x) {
    if (x >= 1000000000) return 10;
    if (x >= 100000000)  return 9;
    if (x >= 10000000)   return 8;
    if (x >= 1000000)    return 7;
    if (x >= 100000)     return 6;
    if (x >= 10000)      return 5;
    if (x >= 1000)       return 4;
    if (x >= 100)        return 3;
    if (x >= 10)         return 2;
    return 1;
}

int printLen(int x) {
    return x < 0 ? lenHelper(-x) + 1 : lenHelper(x);
}

Même si elle ne remporte pas de prix pour la solution la plus ingénieuse, elle est triviale à comprendre et triviale à exécuter, donc rapide.

Sur un Q6600 utilisant MSC, je l'ai testé avec la boucle suivante :

int res = 0;
for(int i = -2000000000; i < 2000000000; i += 200) res += printLen(i);

Cette solution prend 0,062s, la deuxième solution la plus rapide de Pete Kirkham utilisant une approche smart-logarithmique prend 0,115s - presque deux fois plus de temps. Cependant, pour les nombres autour de 10000 et en dessous, le smart-log est plus rapide.

Au prix d'une certaine clarté, vous pouvez battre smart-log de manière plus fiable (du moins, sur un Q6600) :

int lenHelper(unsigned x) { 
    // this is either a fun exercise in optimization 
    // or it's extremely premature optimization.
    if(x >= 100000) {
        if(x >= 10000000) {
            if(x >= 1000000000) return 10;
            if(x >= 100000000) return 9;
            return 8;
        }
        if(x >= 1000000) return 7;
        return 6;
    } else {
        if(x >= 1000) {
            if(x >= 10000) return 5;
            return 4;
        } else {
            if(x >= 100) return 3;
            if(x >= 10) return 2;
            return 1;
        }
    }
}

Cette solution est toujours de 0,062s pour les grands nombres, et se dégrade à environ 0,09s pour les petits nombres - plus rapide dans les deux cas que l'approche smart-log. (gcc fait un code plus rapide ; 0.052 pour cette solution et 0.09s pour l'approche smart-log).

Answer 3

int get_int_len (int value){
  int l=1;
  while(value>9){ l++; value/=10; }
  return l;
}

et la seconde fonctionnera aussi pour les nombres négatifs :

int get_int_len_with_negative_too (int value){
  int l=!value;
  while(value){ l++; value/=10; }
  return l;
}

Answer 4

Vous pouvez écrire une fonction comme celle-ci :

unsigned numDigits(const unsigned n) {
    if (n < 10) return 1;
    return 1 + numDigits(n / 10);
}

Answer 5

Longueur de n :

length =  ( i==0 ) ? 1 : (int)log10(n)+1;