wie finden Sie die Höhe der Zeichen in unsigned long long

Hallo, ich habe 2 Frage die erste ist, die man in den Titel und der andere ist der hier:
hat unsigned long long ist die größte ganze Zahl (kann die größte Menge von Zeichen)?
verursachen, brauche ich einen int, der kann halt paar Millionen Zeichen (Ziffern) - ist das möglich? Ich bin Programmierung in C.
und dies verbindet mich zu der anderen Frage, wie kann ich die Anzeige der Höhe der Ziffern auf dem Bildschirm? ist es muss so sein?:

printf("%d", intName.length)

Dank jeder!!

unsigned long long mit range nur 0 zu 2^64 - 1. (18,446,744,073,709,551,615)
lange, lange ist nicht gonna schneiden Sie es. Sie müssen eine Bibliothek wie gmplib. en.wikipedia.org/wiki/GNU_Multiple_Precision_Arithmetic_Library
Warum müssen Sie zahlen, haben Millionen von Ziffern? Frage nur, da Sie "nicht verstehen" eine ziemlich gute Antwort, das lässt mich ratlos, was Sie versuchen könnten, das zu tun.
Wenn Sie eine Zahl wie 100 Ziffern könnten Sie zuweisen 100 bytes Arbeitsspeicher zum speichern von 1 Stelle als 1 byte. Würden Sie benötigen, um Ihre eigenen add/sub/div/mul... - Funktion Berechnungen. Wir waren etwas wie das zu tun in der uni in Pascal, wo wir zu treffen hatten, die Summe von 2 mega-langen floating-point-zahlen. War interessant zum üben und finden die beste Lösung.

InformationsquelleAutor NSH | 2013-12-30

c string-length unsigned-long-long-int

1

Ich gehe davon aus, dass, wenn Sie beziehen sich auf die Menge der Zeichen, die Sie bedeuten die Anzahl der Ziffern in der Nummer. Wenn ja, dann eine diese Frage hat alles, was Sie wissen müssen und code ähnlich wie diese
```
int numberOfDigits(unsigned long long n) 
{
    if (n == 0)
        return 0;
    return floor( log10( abs( n ) ) ) + 1;
}
```
als für die Abhaltung von ein paar Millionen zahlen werden Sie wahrscheinlich wollen, mit einer Bibliothek wie Die GNU Multiple Precision Arithmetic Library die auch die Funktion
```
size_t mpz_sizeinbase( const mpz_t op, int base )
```
die Ihnen sagen, wie viele Ziffern Ihre Nummer hat.

ja das was ich meine aber kannst du mir erklären, was ist der Sinn von diesem Stück code, denn wenn ich nur copy past es zu meinem Programm, ich habe nicht verstanden, nichts!!!
von innen heraus haben wir
[sorry EINGABETASTE drücken, indem Fehler und bekam cutoff oben] von innen heraus haben wir abs(n) dies wird sicherstellen, dass die log10-Funktion bekommt eine positive Zahl, log10(...) sagt uns, wie viele Potenzen von 10 sind, passen in unser Nummer... also wenn n war 100 dann log10(100) wäre 2, oder, wenn n 10000 dann log10(10000) 4 sein würde. Weiter ist floor(...) die einfach da sind, um sicherzustellen, dass das Ergebnis ein integer, da das Ergebnis von log10 war wohl nicht eine ganze Zahl ist. Schließlich fügen wir die + 1 zu berücksichtigen, für die Letzte Ziffer in der Zahl wie die 3 in die 13, da es nicht in unserer Anzahl der Zehnerpotenzen.
danke, aber es hat nicht funktioniert!
nicht kompilieren, nicht geben Sie das richtige Ergebnis, ???? Haben Sie enthalten math.h ?

InformationsquelleAutor norlesh
0
```
printf("%llu", xxxxxxxxx);

 the ll (el-el) long-long modifier with the u (unsigned) conversion
```
können Sie auch
```
 uint64_t a;
 uint32_t b;
```
Aber müssen Sie include inttypes.h-Bibliothek, die Ihnen Typen wie int32_t, int64_t, uint64_t.

können Sie bitte genauer erklären, weil ich bin irgendwie neu auf C

InformationsquelleAutor Tharanga Abeyseela
0

C99 bietet vom Typ intmax_t (und uintmax_t), wird der größte unterstützt integer-Typ (typischerweise 64 bit).

Vorausgesetzt, Sie haben eine konforme C99 snprintf dann können Sie die Anzahl der Ziffern mit:
```
length = snprintf(NULL, 0, "%llu", value);
```
für einen unsigned long long-Wert (und %ju für uintmax_t.)

Sonst werden Sie haben, um einen Puffer im (igitt) oder etwas tut, was manuell wie:
```
length = value < 10 ? 1 :
         value < 100 ? 2 :
         ...
```
auch yuk!

Aber das ist alles ziemlich irrelevant, wenn Sie wirklich wollen Millionen-stellige ganze zahlen, in welchem Fall Sie brauchen, um eine Bibliothek wie gmp-arbeiten mit so großen zahlen.

danke Frank, aber ich Verstand nicht, nichts!!!
Ich bin neu in C also kann mir jemand erklären, es in basic, C-Sprache?
Ich schlage vor, Sie bekommen mehr Komfort mit den Grundlagen der C-übungen, dann haben Sie die Lösung Ihres Problems mit Hilfe der GMP-Bibliothek.
Ich weiß schon, die Grundlagen und die Millionen-stellige Zahl, ist nicht das Problem, was ich brauchen, ist die "wie-viele-zahlen" zeigen auf den Bildschirm mit einer einfachen printf(); commend. kann es sein?

InformationsquelleAutor Frank

Die maximale Länge dezimal unsigned integer einer bestimmten Art der bit-Länge bitlen ist gegeben durch 1 + floor(log10(2^bitlen-1)) (mathematisch, ohne überläufe Rundungsfehler berücksichtigt). Die Annäherung 1/log2(10) ~ 4004.0/13301 (die mit kettenbrüche, siehe http://en.wikipedia.org/wiki/Continued_fraction) führt zu der Formel 1 + bitlen * 4004 /13301 (rechnerisch, D. H. die division rundet ab). Die mathematischen details sind in den Kommentaren von dem snippet unten.

#include <limits.h>
#include <stdio.h>

/**
 * Maximal number of digits in the decimal representation of an unsigned type.
 *
 * floor( log2(2^bitlen - 1) /log2(10) ) == floor( bitlen /log2(10) )
 * otherwise an integer n would exist with
 *     log2(2^bitlen - 1) /log2(10) < n < bitlen /log2(10)
 *     log2(2^bitlen - 1) < n * log2(10) < bitlen
 *     2^bitlen - 1 < 2^(n * log2(10)) < 2^bitlen
 *     2^bitlen - 1 < (2^log2(10))^n < 2^bitlen
 *     2^bitlen - 1 < 10^n < 2^bitlen
 *     which is impossible
 *
 * 1 /log2(10) ~ 0.301029995663981
 * 4004 /13301 ~ 0.30102999774453
 *
 *     1 + floor( log10(2^bitlen - 1) )
 *  == 1 + floor( log2(2^bitlen - 1) /log2(10) )
 *  == 1 + floor( bitlen /log2(10) )
 *  <= 1 + floor( bitlen * 4004.0 /13301 )
 *  == 1 + bitlen * 4004 /13301
 * with equality for bitlen <= 13300 == 8 * 1662.5
 */
#define DECLEN(unsigned_t) (1 + CHAR_BIT*sizeof(unsigned_t) * 4004 / 13301)

int main(int argc, char *argv[]) {
    printf("unsigned char      : %zu\n", DECLEN(unsigned char));
    printf("short unsigned     : %zu\n", DECLEN(short unsigned));
    printf("unsigned           : %zu\n", DECLEN(unsigned));
    printf("long unsigned      : %zu\n", DECLEN(long unsigned));
    printf("long long unsigned : %zu\n", DECLEN(long long unsigned));
    return 0;
}

InformationsquelleAutor Loic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.