Die Länge einer Ganzzahl in C ermitteln

Wenn Sie an einer fast und very simple -Lösung interessiert sind, kann Folgendes am schnellsten sein (dies hängt von der Wahrscheinlichkeitsverteilung der betreffenden Zahlen ab):

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

Zwar gewinnt die genialste Lösung möglicherweise keine Preise, aber es ist trivial zu verstehen und auch trivial auszuführen - also schnell.

Bei einem Q6600 mit MSC habe ich dies mit der folgenden Schleife verglichen:

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

Diese Lösung dauert 0,062 Sekunden, die zweitschnellste Lösung von Pete Kirkham mit einem intelligenten Logarithmus-Ansatz dauert 0,115 Sekunden - fast doppelt so lang. Bei Zahlen um 10000 und darunter ist das Smart-Log jedoch schneller.

Auf Kosten der Klarheit können Sie Smart-Log (zumindest bei einem Q6600) zuverlässiger schlagen:

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 bei großen Zahlen immer noch 0,062 Sekunden und bei kleineren Zahlen auf 0,09 Sekunden herabgesetzt - in beiden Fällen schneller als beim Smart-Log-Ansatz. (gcc macht schnelleren Code; 0,052 für diese Lösung und 0,09 Sekunden für den Smart-Log-Ansatz).

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

und der zweite wird auch für negative Zahlen funktionieren:

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

Sie können eine Funktion wie folgt schreiben:

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

länge von n:

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

Die Anzahl der Stellen einer ganzen Zahl x ist gleich 1 + log10(x). So kannst du das machen:

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

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

Oder Sie können eine Schleife ausführen, um die Ziffern selbst zu zählen: Machen Sie eine Ganzzahldivision durch 10, bis die Zahl 0 ist:

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

Sie müssen etwas aufpassen, um 1 zurückzugeben, wenn die Ganzzahl in der ersten Lösung 0 ist, und Sie möchten möglicherweise auch negative Ganzzahlen behandeln (arbeiten Sie mit -x, wenn x < 0).

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 mit der Funktion log10 tun.

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

Der effizienteste Weg könnte möglicherweise die Verwendung eines auf einem schnellen Logarithmus basierenden Ansatzes sein, ähnlich demjenigen, der zur Bestimmung des höchsten Bits einer ganzen Zahl verwendet wird.

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ühte) Optimierung erfordert 0,65 Sekunden für 20 Millionen Anrufe auf meinem Netbook. Die iterative Division wie zed_0xff dauert 1,6 Sekunden, die rekursive Division wie Kangkan 1,8 Sekunden und die Verwendung von Gleitkommafunktionen (Code von Jordan Lewis) macht satte 6,6 Sekunden. Die Verwendung von snprintf dauert 11,5 Sekunden, gibt Ihnen jedoch die Größe, die für snprintf für jedes Format und nicht nur für ganze Zahlen erforderlich ist. Jordan berichtet, dass die Reihenfolge der Timings auf seinem Prozessor nicht beibehalten wird, was Fließkomma schneller macht als meiner.

Am einfachsten ist es wahrscheinlich, snprintf nach der gedruckten 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;
}

Eine korrekte snprintf-Implementierung:

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

int digits=1;

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

Sie können dies verwenden -

(Datentyp) log10 (Variablenname) +1

ex: 

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

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

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

teilen Sie den Wert durch zehn, bis Sie Null erhalten, und geben Sie dann einfach die Anzahl der Unterteilungen aus.

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

Auf meine Art:

Teilen Sie, solange die Anzahl nicht mehr durch 10 teilbar ist:

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

    return i;
}

Ich weiß nicht, wie schnell es mit anderen Sätzen ist.

Dies gilt sowohl für negative als auch für positive ganze Zahlen

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

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, dass diese Methode für diese Aufgabe gut geeignet ist:

wert und Antworten:

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

• 566666 -> 6

• 0 -> 1

• 505 → 3

Eine ausführlichere Methode wäre die Verwendung dieser Funktion.

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

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

Bitte finden Sie meine Antwort in einem Code:

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

das ist einfach und schlau! Wenn es Ihnen gefällt, positiv bewertet!

Die kürzeste und einfachste Lösung wäre meiner Meinung nach:

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