Das Finden der Länge einer ganzen Zahl in C

Question

Ich würde gerne wissen, wie ich die Länge einer ganzen Zahl in C finden kann.

Zum Beispiel:

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

und so weiter.

Wie kann ich dies tun in C?

Answer 1

C:

Warum nicht nur die Basis-10 Protokoll des Absolutwertes der Zahl, es abrunden, und eines hinzufügen? Dies funktioniert für positive und negative Zahlen, die nicht 0 sind, und vermeidet jede Zeichenfolge Konvertierungsfunktionen verwenden.

Die log10, abs und floor Funktionen werden von math.h zur Verfügung gestellt. Zum Beispiel:

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

Sie sollten in einer Klausel wickeln dies, dass the_integer != 0 gewährleistet, da log10(0) kehrt -HUGE_VAL nach man 3 log.

Darüber hinaus möchten Sie vielleicht ein auf das Endergebnis addieren, wenn der Eingang negativ ist, wenn Sie in der Länge der Zahl einschließlich ihrer negativen Vorzeichen interessiert sind.

Java:

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

---

N. B. Die Gleitkommazahlen Natur der in diesem Verfahren beteiligten Berechnungen kann es dazu führen, langsamer zu sein als ein direkterer Ansatz. Siehe die Kommentare für Kangkan Antwort für einige Diskussion der Effizienz.

Answer 2

Wenn Sie Interesse an einem schnell und sehr einfach Lösung, die folgenden möglicherweise schnellste (dies hängt von der Wahrscheinlichkeitsverteilung der Zahlen in Frage):

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);
}

Es ist zwar nicht die Preise für die genialste Lösung gewinnen könnte, es trivial ist, zu verstehen und auch trivial auszuführen -. So dass es schnell ist

Auf einem Q6600 MSC mich mit gebenchmarkt dies mit der folgenden Schleife:

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

Diese Lösung nimmt 0.062s, die zweitschnellste Lösung von Pete Kirkham einen Smart-Logarithmus-Ansatz nimmt 0.115s - fast doppelt so lang. Doch für die Zahlen rund 10000 und unten, das Smart-Protokoll ist schneller.

Auf Kosten der Klarheit, können Sie zuverlässiger schlagen Smart-Protokoll (zumindest auf einem 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;
        }
    }
}

Diese Lösung ist 0.062s noch auf eine große Zahl, und degradiert auf rund 0.09s für kleinere Zahlen - schneller in beiden Fällen als mit dem smart-log-Ansatz. (Gcc macht schnellen Code; 0,052 für diese Lösung und 0.09s für den smart-log-Ansatz).

Answer 3

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

und zweite wird für negative Zahlen arbeiten zu:

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

Answer 4

Sie können eine Funktion wie diese schreiben:

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

Answer 5

Länge von n:

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

Answer 6

Die Anzahl der Stellen eines ganzzahligen x gleich 1 + log10(x). So können Sie dies tun:

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

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

Sie können auch eine Schleife laufen die Ziffern selbst zu zählen: do Integer-Division durch 10, bis die Nummer ist 0:

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

Sie haben ein bisschen vorsichtig sein 1 zurückzukehren, wenn die ganze Zahl 0 in der ersten Lösung ist, und Sie möchten vielleicht auch zu behandeln negativen ganzen Zahlen (Arbeit mit -x wenn x < 0).

Answer 7

Der effizienteste Weg, könnte möglicherweise einen schnellen Logarithmus basierenden Ansatz, ähnlich denen zu benutzen, um das höchste Bit gesetzt in einer ganzen Zahl zu bestimmen.

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;
}

Diese (möglicherweise verfrüht) Optimierung nimmt 0.65s für 20 Millionen Anrufe auf meinem Netbook; iterative Division wie zed_0xff nimmt 1.8s 1,6s, rekursive Teilung wie Kangkan annimmt und unter Verwendung Gleitpunktfunktionen (Jordan Lewis-Code) hat eine satte 6.6S hat. snprintf Mit nimmt 11.5s, sondern geben Sie die Größe, dass snprintf für jedes Format erfordert, nicht nur ganze Zahlen. Jordan berichtet, dass die Reihenfolge der Zeitpunkt nicht auf dem Prozessor gehalten werden, den Punkt schneller als meins nicht schwimmen.

Am einfachsten ist es wahrscheinlich snprintf für die gedruckte Länge zu fragen:

#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

Ja, mit sprintf.

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

Alternativ können Sie dies mathematisch die log10 Funktion.

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

Answer 9

Eine korrekte snprintf Implementierung:

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

Sie können dieses verwenden -

(data_type) log10 (variable_name) + 1

ex:

  

len = (int) log10 (Anzahl) +1;

Answer 13

Ganz einfach

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

hält durch zehn dividiert, bis Null bekommen, dann Ausgabe nur die Anzahl der Teilungen.

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

Answer 15

Meiner Meinung nach der kürzeste und einfachste Lösung wäre:

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

Mein Weg:

Teile solange Zahl ist nicht mehr durch 10 teilbar:

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

    return i;
}

Ich weiß nicht, wie schnell ist es in Vergleich zu anderen Sätzen ..

Answer 17

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

Answer 18

Eine ausführlichere Weg wäre, diese Funktion zu nutzen.

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

Dies gilt sowohl für negative als auch positive intigers

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

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

        return  log10(n) + 1;
    }

Die gleiche Logik gilt für die Schleife

  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;
}

ich denke, dieses Verfahren gut für diese Aufgabe geeignet ist:

Wert und Antworten:

• -50 -> 3 // es zählt - als ein Zeichen als auch, wenn Sie nicht wollen, zählen                minus dann Zähler entfernen ++ von 5. Zeile.

• 566666 -> 6

• 0 -> 1

• 505 -> 3

Answer 21

Ich glaube, ich habe die effizienteste Weg, um die Länge einer ganzen Zahl zu finden Es ist eine sehr einfache und elegante Art und Weise hier ist sie:

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, size = 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

Bitte meine Antwort zu finden ist es in einer Zeile Code:

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

, die einfach und intelligent ist! Upvote, wenn Sie so!