Trouver la longueur d'un nombre entier en C

Question

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

Par exemple:

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

et ainsi de suite.

Comment puis-je faire en C?

Answer 1

C:

Pourquoi ne pas simplement prendre la base 10 log de la valeur absolue du nombre, arrondissez vers le bas, et en ajouter une? Cela fonctionne pour des nombres positifs et négatifs qui ne sont pas 0, et évite d'avoir à utiliser toutes les fonctions de conversion de chaîne.

Les log10, abs et les fonctions de floor sont fournis par math.h. Par exemple:

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

Vous devriez envelopper cela dans une clause assurant que the_integer != 0, puisque les rendements de log10(0) -HUGE_VAL selon man 3 log.

En outre, 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, y compris 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 amener à être plus lente qu'une approche plus directe. Voir les commentaires pour la réponse de Kangkan pour une discussion sur l'efficacité.

Answer 2

Si vous êtes intéressé par une rapide et très simple solution, ce qui suit pourrait être plus rapide (cela dépend de la distribution de probabilité des numéros 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);
}

Alors qu'il pourrait ne pas gagner des prix pour la solution la plus ingénieuse, il est trivial de comprendre et aussi trivial à exécuter -. Il est donc rapide

Sur un Q6600 à l'aide MSC I étalonnée ceci avec la boucle suivante:

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

Cette solution prend 0.062s, la solution la plus rapide du second par Pete Kirkham en utilisant une approche intelligente logarithme prend 0.115s - presque deux fois plus longtemps. Cependant, pour les numéros environ 10000 et au-dessous, la smart-log est plus rapide.

Au détriment d'une certaine clarté, vous pouvez plus fiable battre smart-log (au 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 0.062s encore sur un grand nombre, et se dégrade à environ 0.09s pour un plus petit nombre - plus rapide dans les deux cas que l'approche intelligente journal. (Gcc rend le code plus rapide; 0,052 pour cette solution et 0.09s pour l'approche intelligente log).

Answer 3

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

et deuxième travailleront pour les nombres négatifs aussi:

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 ceci:

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;

Answer 6

Le nombre de chiffres d'un x entier est égal à 1 + log10(x). Ainsi, vous pouvez faire ceci:

#include <math.h>
#include <stdio.h>

int main()
{
    int x;
    scanf("%d", &x);
    printf("x has %d digits\n", 1 + (int)log10(x));
}

Ou vous pouvez exécuter une boucle pour compter les chiffres vous: faites entier division par 10 jusqu'à ce que le nombre est 0:

int numDigits = 0;
do
{
    ++numDigits;
    x = x / 10;
} while ( x );

Vous devez être un peu prudent de revenir 1 si l'entier est 0 dans la première solution et vous pouvez également traiter des entiers négatifs (travail avec -x si x < 0).

Answer 7

La façon la plus efficace pourrait être d'utiliser une approche basée logarithme rapide, similaire à celles utilisées pour déterminer le bit le plus élevé dans un entier.

size_t printed_length ( int32_t x )
{
    size_t count = x < 0 ? 2 : 1;

    if ( x < 0 ) x = -x;

    if ( x >= 100000000 ) {
        count += 8;
        x /= 100000000;
    }

    if ( x >= 10000 ) {
        count += 4;
        x /= 10000;
    }

    if ( x >= 100 ) {
        count += 2;
        x /= 100;
    }

    if ( x >= 10 )
        ++count;

    return count;
}

(peut-être prématurée) l'optimisation prend 0.65s pour 20 millions d'appels sur mon netbook; division itérative comme zed_0xff a prend 1,6 s, division récursive comme Kangkan prend 1,8s, et en utilisant des fonctions en virgule flottante (le code de Jordan Lewis) prend un énorme 6.6s. L'utilisation snprintf prend 11.5s, mais vous donnera la taille que snprintf a besoin pour tout format, non seulement des nombres entiers. La Jordanie signale que l'ordre des timings ne sont pas entretenus sur son processeur, ce qui ne virgule flottante plus rapide que le mien.

Le plus simple est sans doute de demander snprintf pour la longueur imprimée:

#include <stdio.h>

size_t printed_length ( int x )
{
    return snprintf ( NULL, 0, "%d", x );
}

int main ()
{
    int x[] = { 1, 25, 12512, 0, -15 };

    for ( int i = 0; i < sizeof ( x ) / sizeof ( x[0] ); ++i )
        printf ( "%d -> %d\n", x[i], printed_length ( x[i] ) );

    return 0;
}

Answer 8

Oui, en utilisant sprintf.

int num;
scanf("%d",&num);
char testing[100];
sprintf(testing,"%d",num);
int length = strlen(testing);

Vous pouvez le faire en utilisant mathématiquement la fonction log10.

int num;
scanf("%d",&num);
int length;
if (num == 0) {
  length = 1;
} else {    
  length = log10(fabs(num)) + 1;
  if (num < 0) length++;
}

Answer 9

Une implémentation snprintf correcte:

int count = snprintf(NULL, 0, "%i", x);

Answer 10

int digits=1;

while (x>=10){
    x/=10;
    digits++;
}
return digits;

Answer 11

sprintf(s, "%d", n);
length_of_int = strlen(s);

Answer 12

Vous pouvez utiliser ce -

(data_type) log10 (variable_name) 1

ex:

  

len = (int) log10 (nombre) 1;

Answer 13

Assez simple

int main() {
    int num = 123;
    char buf[50];

    // convert 123 to string [buf]
    itoa(num, buf, 10);

    // print our string
    printf("%s\n", strlen (buf));

    return 0;
}

Answer 14

divisant par dix continuer jusqu'à ce que vous obtenez zéro, alors que la sortie le nombre de divisions.

int intLen(int x)
{
  if(!x) return 1;
  int i;
  for(i=0; x!=0; ++i)
  {
    x /= 10;
  }
  return i;
}

Answer 15

A mon avis, la plus courte et la solution la plus simple serait:

int length , n;

printf("Enter a number: ");

scanf("%d", &n);

length = 0;

while (n > 0) {
   n = n / 10;
   length++;
}

printf("Length of the number: %d", length);

Answer 16

Ma façon:

Diviser tant que le nombre est plus divisible par 10:

u8 NumberOfDigits(u32 number)
{
    u8 i = 1;
    while (number /= 10) i++;

    return i;
}

Je ne sais pas comment il est rapide par rapport à d'autres propositions ..

Answer 17

int intlen(int integer){
    int a;
    for(a = 1; integer /= 10; a++);
    return a;
}

Answer 18

Un plus bavard moyen serait d'utiliser cette fonction.

int length(int n)
{
    bool stop;
    int nDigits = 0;
    int dividend = 1;
    do
    {
        stop = false;
        if (n > dividend)
        {
            nDigits = nDigits + 1;
            dividend = dividend * 10;
        }
        else {
            stop = true;
        }


    }
    while (stop == false);
    return nDigits;
}

Answer 19

Cela vaut pour les deux négatifs et positifs intigers

    int get_len(int n)
    {
        if(n == 0)
        return 1;

        if(n < 0)    
        {
           n = n * (-1); // if negative
        }

        return  log10(n) + 1;
    }

logique même chose pour la boucle

  int get_len(int n)
  {
       if(n == 0)
       return 1;

       int len = 0;
       if(n < 0)
       n = n * (-1);

       while(n > 1)
       {
          n /= 10;
          len++;
       }

       return len;
  }

Answer 20

int returnIntLength(int value){
    int counter = 0;
    if(value < 0)
    {
        counter++;
        value = -value;
    }
    else if(value == 0)
        return 1;

    while(value > 0){
        value /= 10;
        counter++;
    }

    return counter;
}

Je pense que cette méthode est bien adaptée à cette tâche:

valeur et réponses:

• -50 -> 3 // il comptera - comme un caractère aussi bien si vous ne voulez pas compter                moins puis retirez contre ++ de la ligne 5.

• 566666 -> 6

• 0 -> 1

• 505 -> 3

Answer 21

Je pense que je suis la façon la plus efficace de trouver la longueur d'un entier sa façon très simple et élégante ici il est:

int PEMath::LengthOfNum(int Num)
{
int count = 1;  //count starts at one because its the minumum amount of digits posible
if (Num < 0)
{
    Num *= (-1);
}

for(int i = 10; i <= Num; i*=10)
{
     count++;
}      
return count;
                // this loop will loop until the number "i" is bigger then "Num"
                // if "i" is less then "Num" multiply "i" by 10 and increase count
                // when the loop ends the number of count is the length of "Num".
}

Answer 22

int main (void) {     unsigned int n, taille = 0;

printf("get the int:");
scanf("%u",&n);

/*the magic*/
for(int i = 1; n >= i; i*=10){
    size++;
}

printf("the value is: %u \n", n);
printf("the size is: %u \n", size);

return 0;

}

Answer 23

Veuillez trouver ma réponse, il est dans un code de ligne:

#include <stdio.h> int main(void){ int c = 12388884; printf("length of integer is: %d",printf("%d",c)); return 0; }

qui est simple et intelligent! Upvote si vous aimez ça!