Ermitteln der Länge einer Ganzzahl in C

Ich würde gerne wissen, wie ich finden kann, die Länge eines integer in C.

Zum Beispiel:

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

und so weiter.

Wie kann ich dies in C?

InformationsquelleAutor der Frage marabunta2048 | 2010-06-18

  1. 86

    C:

    Warum nicht einfach den Basis-10-Protokoll der absolute Wert der Zahl, Runden Sie ab, und fügen Sie ein? Das funktioniert für positive und negative zahlen, die nicht 0 sind, und vermieden, dass jede beliebige Zeichenfolge verwenden, die Konvertierung Funktionen.

    Den log10absund floor Funktionen werden angeboten durch die math.h. Zum Beispiel:

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

    Sollten Sie wickeln Sie diese in eine Klausel sicherzustellen, dass the_integer != 0da log10(0) zurück -HUGE_VAL nach man 3 log.

    Darüber hinaus können Sie auf hinzufügen, um das endgültige Ergebnis, wenn die Eingabe negativ ist, wenn Sie interessiert sind, in der Länge der Zahl einschließlich Ihrer negativen Vorzeichen.

    Java:

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

    N. B. Die floating-point-Natur die Berechnungen einbezogen, die in dieser Methode möglicherweise langsamer als ein direkter Ansatz. Siehe die Kommentare für Kangkan Antwort für einige Diskussion von Effizienz.

    InformationsquelleAutor der Antwort Jordan Lewis

  2. 42

    Wenn Sie interessiert sind, in einem schnell und sehr einfach Lösung, die folgende vielleicht am schnellsten sein (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);
}

    Während es möglicherweise nicht gewinnen Preise für die genialste Lösung, es ist trivial zu verstehen und auch leicht zu führen - so geht es schnell.

    Auf einem Q6600 mit MSC habe ich zudem diese mit der folgenden Schleife:

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

    Diese Lösung nimmt 0.062 s, die zweitbeste Lösung von Pete Kirkham mit einem smart-Logarithmus-Ansatz nimmt 0.115 s - fast doppelt so lange. Doch für zahlen um 10000 und unterhalb der smart-log ist schneller.

    Auf Kosten der Klarheit, Sie können mehr zuverlässig schlagen smart-log (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 immer noch 0.062 s in großer Zahl, und verschlechtert sich auf rund 0.09 s für kleinere zahlen schneller in beiden Fällen als das smart-log-Ansatz. (gcc schneller macht-code; 0.052 für diese Lösung und 0,09 s für den smart-log-Ansatz).

    InformationsquelleAutor der Antwort Eamon Nerbonne

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

    und das zweite funktioniert für negative zahlen zu:

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

    InformationsquelleAutor der Antwort zed_0xff

  4. 17

    Schreiben Sie eine Funktion wie diese:

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

    InformationsquelleAutor der Antwort Kangkan

  5. 9

    Länge n:

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

    InformationsquelleAutor der Antwort Fritz G. Mehner

  6. 7

    Ja, die Nutzung von sprintf.

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

    Alternativ kann man diese mathematisch mit Hilfe der log10 Funktion.

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

    InformationsquelleAutor der Antwort Jamie Wong

  7. 6

    Die Anzahl der Ziffern einer ganzen Zahl x gleich 1 + log10(x). Damit Sie dies tun können:

    #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 führen eine Schleife zum zählen der Ziffern sich: integer-division durch 10 bis die Zahl 0 ist:

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

    Müssen Sie ein bisschen vorsichtig zurück 1 wenn die ganze Zahl ist 0 in die erste Lösung und vielleicht wollen Sie auch zur Behandlung von negativen ganzen zahlen (die Arbeit mit -x wenn x < 0).

    InformationsquelleAutor der Antwort IVlad

  8. 6

    Der effizienteste Weg sein könnte, mit einem schnellen Logarithmus basierenden Ansatz, ähnlich denen, die verwendet werden, um zu bestimmen, das höchste bit in einem integer.

    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 (ggf. vorzeitige) Optimierung dauert 0.65 s für 20 Millionen Anrufe auf meinem netbook; iterative division wie zed_0xff hat nimmt, 1.6 s, rekursive Aufteilung wie Kangkan nimmt, 1.8 s, und Verwendung von floating-point-Funktionen (Jordan Lewis' code) nimmt eine satte 6.6 en. Mit snprintf nimmt 11.5 s, aber geben Sie die Größe, die Funktionen snprintf erfordert für jedes format, nicht nur Ganzzahlen. Jordan berichtet, dass die Bestellung des timings sind nicht gepflegt, seinen Prozessor, die keine floating-point-schneller als meine.

    Das einfachste ist wohl zu Fragen, snprintf für die gedruckte Länge:

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

    InformationsquelleAutor der Antwort Pete Kirkham

  9. 4

    Einen richtigen snprintf Umsetzung:

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

    InformationsquelleAutor der Antwort sam hocevar

  10. 4
    int digits=1;

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

    InformationsquelleAutor der Antwort Pasi

  11. 2

    Können Sie diese -

    (data_type)log10(variable_name)+1

    ex:

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

    InformationsquelleAutor der Antwort Ashraful

  12. 1

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

    InformationsquelleAutor der Antwort Mauro

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

    InformationsquelleAutor der Antwort OK_or_CANCEL

  14. 0

    halten die Teilung von zehn bis null, dann wird nur die Ausgabe der Anzahl der Divisionen.

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

    InformationsquelleAutor der Antwort Graphics Noob

  15. 0

    Ich glaub ich hab den effizientesten Weg zu finden, der die Länge einer ganzen Zahl
    es ist eine sehr einfache und elegante Weise
    hier ist es:

    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".
}

    InformationsquelleAutor der Antwort shiups

  16. 0

    Meiner Meinung nach die 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);

    InformationsquelleAutor der Antwort Flo

  17. 0

    Mein Weg:

    Teilen, solange Zahl 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 im Vergleich mit anderen Aussagen..

    InformationsquelleAutor der Antwort tBlabs

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

    InformationsquelleAutor der Antwort Ruza

Schreibe einen Kommentar