it-swarm.com.de

Die Länge einer Ganzzahl in C ermitteln

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

Zum Beispiel:

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

und so weiter.

Wie kann ich das in C machen?

53
marabunta2048

C:

Warum nicht einfach das Basis-10-Protokoll des absoluten Werts der Zahl nehmen, abrunden und eins hinzufügen? Dies funktioniert für positive und negative Zahlen, die nicht 0 sind, und vermeidet die Verwendung von String-Konvertierungsfunktionen.

Die Funktionen log10, abs und floor werden von math.h bereitgestellt. Zum Beispiel:

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

Sie sollten dies in eine Klausel einschließen, die sicherstellt, dass the_integer != 0, da log10(0)-HUGE_VAL gemäß man 3 log zurückgibt.

Darüber hinaus möchten Sie möglicherweise zum Endergebnis eine hinzufügen, wenn die Eingabe negativ ist, wenn Sie an der Länge der Zahl einschließlich des negativen Vorzeichens interessiert sind.

Java:

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

N.B. Der Gleitkomma-Charakter der an dieser Methode beteiligten Berechnungen kann dazu führen, dass sie langsamer ist als ein direkter Ansatz. In den Kommentaren zu Kangkans Antwort finden Sie einige Diskussionen zur Effizienz.

91
Jordan Lewis

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

44
Eamon Nerbonne
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;
}
24
zed_0xff

Sie können eine Funktion wie folgt schreiben:

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

länge von n:

length =  ( i==0 ) ? 1 : (int)log10(n)+1;
10
Fritz G. Mehner

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

7
IVlad

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++;
}
7
Jamie Wong

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;
}
6
Pete Kirkham

Eine korrekte snprintf-Implementierung:

int count = snprintf(NULL, 0, "%i", x);
5
sam hocevar
int digits=1;

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

Sie können dies verwenden -

(Datentyp) log10 (Variablenname) +1

ex: 

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

2
Ashraful
sprintf(s, "%d", n);
length_of_int = strlen(s);
1
OK_or_CANCEL

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

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;
}
0
Graphics Noob

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.

0
tBlabs

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

0
Sa'gear Giree

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;
}
0
Chirag M
int intlen(int integer){
    int a;
    for(a = 1; integer /= 10; a++);
    return a;
}
0
Ruza

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!

0
Nasir Shah

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