Quelle est la valeur maximale pour un int32?

Je ne peux jamais me souvenir du numéro. J’ai besoin d’une règle de mémoire.

    C’est 2 147 483 647. La façon la plus simple de mémoriser est via un tatouage.

    La réponse la plus correcte que je puisse penser est Int32.MaxValue .

    Si vous pensez que la valeur est trop difficile à retenir dans la base 10, essayez la base 2: 1111111111111111111111111111111

    C’est 10 chiffres, alors prétendez que c’est un numéro de téléphone (en supposant que vous êtes aux États-Unis). 214-748-3647. Je ne recommande pas de l’appeler.

    si vous vous souvenez du numéro Pi dans son intégralité, le nombre que vous recherchez est à la position 1 867 996 680 et 1 867 996 689 des chiffres décimaux de Pi

    La chaîne numérique 2147483647 apparaît au chiffre décimal 1 867 996 680 de Pi. 3,14 …… 86181221809936452346 2147483647 10527835665425671614 …

    source: http://www.subidiom.com/pi/

    Plutôt que de le considérer comme un grand nombre, essayez de le décomposer et recherchez des idées associées, par exemple:

    • 2 pauses snooker maximum (une pause maximale est de 147)
    • 4 ans (48 mois)
    • 3 ans (36 mois)
    • 4 ans (48 mois)

    Ce qui précède s’applique au plus grand nombre négatif; positif est celui moins un.

    Peut-être que la panne ci-dessus ne sera pas plus mémorable pour vous (ce n’est guère excitant!), Mais nous espérons que vous pourrez trouver des idées!

    Plus grande valeur négative (32 bits): -2147483648
    (1 << 31)

    Plus grande valeur positive (32 bits): 2147483647
    ~ (1 << 31)

    Mnémonique: “AKA ivre excitée”

     drunk ========= Drinking age is 21 AK ============ AK 47 A ============= 4 (A and 4 look the same) horny ========= internet rule 34 (if it exists, there's 18+ material of it) 21 47 4(years) 3(years) 4(years) 21 47 48 36 48 

    Quoi qu’il en soit, prenez cette regex (elle détermine si la chaîne contient un nombre entier non négatif sous forme décimale qui n’est pas supérieur à Int32.MaxValue)

    [0-9]{1,9}|[0-1][0-9]{1,8}|20[0-9]{1,8}|21[0-3][0-9]{1,7}|214[0-6][0-9]{1,7}|2147[0-3][0-9]{1,6}|21474[0-7][0-9]{1,5}|214748[0-2][0-9]{1,4}|2147483[0-5][0-9]{1,3}|21474836[0-3][0-9]{1,2}|214748364[0-7]

    Peut-être que cela vous aiderait à vous souvenir.

    C’est comme ça que je me suis souvenu 2147483647 :

    • 214 – parce que 2.14 est approximativement pi-1
    • 48 = 6 * 8
    • 64 = 8 * 8

    Écrivez ces horizontalement:

     214_48_64_ and insert: ^ ^ ^ 7 3 7 - which is Boeing's airliner jet (thanks, sgorozco) 

    Maintenant, vous avez 2147483647.

    J’espère que cela aide au moins un peu.

     2^(x+y) = 2^x * 2^y 2^10 ~ 1,000 2^20 ~ 1,000,000 2^30 ~ 1,000,000,000 2^40 ~ 1,000,000,000,000 (etc.) 2^1 = 2 2^2 = 4 2^3 = 8 2^4 = 16 2^5 = 32 2^6 = 64 2^7 = 128 2^8 = 256 2^9 = 512 

    Donc, 2 ^ 31 (signé int max) est 2 ^ 30 (environ 1 milliard) fois 2 ^ 1 (2), soit environ 2 milliards. Et 2 ^ 32 est 2 ^ 30 * 2 ^ 2 ou environ 4 milliards. Cette méthode d’approximation est suffisamment précise, même autour de 2 ^ 64 (où l’erreur augmente jusqu’à environ 15%).

    Si vous avez besoin d’une réponse exacte, alors vous devriez trouver une calculasortingce.

    Approximations de capacités pratiques alignées sur des mots:

    • 2 ^ 16 ~ = 64 mille // uint16
    • 2 ^ 32 ~ = 4 milliards // uint32, IPv4, unixtime
    • 2 ^ 64 ~ = 16 quintillions (aka 16 milliards de milliards ou 16 millions de milliards) // uint64, “bigint”
    • 2 ^ 128 ~ = 256 quintillions de quintillion (soit 256 billions de sortingllions de sortingllions) // IPv6, GUID

    Prenez simplement n’importe quelle calculasortingce décente et tapez “7FFFFFFF” en mode hexadécimal, puis passez en décimal.

    2147483647.

    Voici un mnémonique pour vous souvenir de 2 ** 31, soustrayez-en un pour obtenir la valeur entière maximale.

    a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8, i = 9

     Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide 2 1 4 7 4 8 3 6 4 8 

    J’ai utilisé les puissances de deux jusqu’à 18 suffisamment souvent pour s’en souvenir, mais même je n’ai pas pris la peine de mémoriser 2 ** 31. Il est trop facile de calculer selon les besoins ou d’utiliser une constante ou une estimation en 2G.

    32 bits, un pour le signe, 31 bits d’information:

     2^31 - 1 = 2147483647 

    Pourquoi -1?
    Comme le premier est zéro, le plus grand nombre est le nombre moins un .

    MODIFIER pour cantfindaname88

    Le compte est 2 ^ 31 mais le plus grand ne peut pas être 2147483648 (2 ^ 31) car nous comptons à partir de 0, pas 1.

     Rank 1 2 3 4 5 6 ... 2147483648 Number 0 1 2 3 4 5 ... 2147483647 

    Une autre explication avec seulement 3 bits: 1 pour le signe, 2 pour l’information

     2^2 - 1 = 3 

    En dessous de toutes les valeurs possibles avec 3 bits: (2 ^ 3 = 8 valeurs)

     1: 100 ==> -4 2: 101 ==> -3 3: 110 ==> -2 4: 111 ==> -1 5: 000 ==> 0 6: 001 ==> 1 7: 010 ==> 2 8: 011 ==> 3 

    C’est environ 2.1 * 10^9 . Pas besoin de connaître exactement 2^{31} - 1 = 2,147,483,647 .

    C

    Vous pouvez le trouver en C comme ça:

     #include  #include  main() { printf("max int:\t\t%i\n", INT_MAX); printf("max unsigned int:\t%u\n", UINT_MAX); } 

    donne (enfin, sans le , )

     max int: 2,147,483,647 max unsigned int: 4,294,967,295 

    C ++ 11

     std::cout << std::numeric_limits::max() << "\n"; std::cout << std::numeric_limits::max() << "\n"; 

    Java

    Vous pouvez aussi obtenir ceci avec Java:

     System.out.println(Integer.MAX_VALUE); 

    Mais gardez à l'esprit que les entiers Java sont toujours signés.

    Python 2

    Python a des entiers de précision arbitraires. Mais dans Python 2, ils sont mappés sur des entiers en C. Vous pouvez donc faire ceci:

     import sys sys.maxint >>> 2147483647 sys.maxint + 1 >>> 2147483648L 

    Donc Python passe à long quand l'entier devient plus grand que 2^31 -1

    Eh bien, il a 32 bits et peut donc stocker 2 ^ 32 valeurs différentes. La moitié d’entre eux sont négatifs.

    La solution est 2 147 483 647

    Et le plus bas est −2,147,483,648.

    (Notez qu’il y a une autre valeur négative.)

    À ce stade, je dirais que le mnémonique le plus simple est de taper “stackoverflow.com” TAB “maximum int32” dans Chrome.

    Il y a une récursion -> blague de débordement de stack quelque part. Je ne suis pas si geek.

    Le moyen le plus simple de le faire pour les entiers consiste à utiliser l’hexadécimal, à condition qu’il n’y ait pas quelque chose comme Int.maxInt (). La raison en est la suivante:

    Max valeurs non signées

     8-bit 0xFF 16-bit 0xFFFF 32-bit 0xFFFFFFFF 64-bit 0xFFFFFFFFFFFFFFFF 128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 

    Valeurs signées, en utilisant 7F comme valeur maximale signée

     8-bit 0x7F 16-bit 0x7FFF 32-bit 0x7FFFFFFF 64-bit 0x7FFFFFFFFFFFFFFF 

    Valeurs signées, en utilisant 80 comme valeur maximale signée

     8-bit 0x80 16-bit 0x8000 32-bit 0x80000000 64-bit 0x8000000000000000 

    Comment cela marche-t-il? Ceci est très similaire à la tactique binary, et chaque chiffre hexadécimal est exactement 4 bits. De plus, beaucoup de compilateurs supportent beaucoup mieux l’hex que le binary.

     F hex to binary: 1111 8 hex to binary: 1000 7 hex to binary: 0111 0 hex to binary: 0000 

    Donc, 7F est égal à 01111111 / 7FFF est égal à 0111111111111111. De plus, si vous utilisez ceci pour “constante incroyablement élevée”, 7F … est un hexagone sûr, mais il est assez facile d’essayer 7F et 80 et de les imprimer à votre écran pour voir lequel il est.

    0x7FFF + 0x0001 = 0x8000, donc votre perte est seulement un nombre, donc en utilisant 0x7F … n’est généralement pas un compromis pour un code plus fiable, en particulier une fois que vous commencez à utiliser 32 bits ou plus

    D’abord, écrivez 47 fois (vous aimez l’ agent 47 , non?), En gardant les espaces comme indiqué (chaque tiret est un emplacement pour un seul chiffre. Premiers 2 emplacements, puis 4)

     --47----47 

    Pensez que vous avez 12 en main (parce que 12 = une douzaine). Multipliez-le par 4 , premier chiffre du numéro de l’agent 47, soit 47 , et placez le résultat à droite de la première paire que vous avez déjà.

     12 * 4 = 48 --4748--47 <-- after placing 48 to the right of first 47 

    Puis multipliez 12 par 3 (afin de faire le deuxième chiffre du numéro de l'agent 47, qui est 7 , vous avez besoin de 7 - 4 = 3 ) et placez le résultat à droite des 2 premières paires, le dernier intervalle de paires

     12 * 3 = 36 --47483647 <-- after placing 36 to the right of first two pairs 

    Enfin, faites glisser les chiffres un par un de votre main en partant du chiffre le plus à droite (2 dans ce cas) et placez-les dans le premier emplacement vide que vous obtenez.

     2-47483647 <-- after placing 2 2147483647 <-- after placing 1 

    Voilà! Pour la limite négative, vous pouvez considérer cela comme 1 de plus en valeur absolue que la limite positive.

    Pratiquez-vous à quelques resockets, et vous aurez tout compris!

    2 Go

    (Y a-t-il une longueur minimale pour les réponses?)

    Eh bien, à part les blagues, si vous cherchez vraiment une règle de mémoire utile, il y en a une que j’utilise toujours pour mémoriser les grands nombres.

    Vous devez diviser votre numéro en parties de 3 à 4 chiffres et vous en rappeler visuellement en utilisant la projection sur le clavier de votre téléphone portable. C’est plus facile à montrer sur une photo:

    entrer la description de l'image ici

    Comme vous pouvez le voir, il ne vous rest plus qu’à retenir 3 formes, 2 d’entre elles ressemblent à un Tesortings L et l’autre ressemble à une tique . Ce qui est beaucoup plus facile que de mémoriser un numéro à 10 chiffres.

    Lorsque vous devez rappeler le numéro, rappelez-vous simplement les formes, imaginez / regardez sur un clavier de téléphone et projetez les formes dessus. Au début, vous devrez peut-être regarder le clavier, mais après un peu de pratique, vous vous souviendrez que les chiffres vont du haut à gauche au bas à droite pour que vous puissiez tout simplement l’imaginer dans votre tête.

    Veillez simplement à vous souvenir de la direction des formes et du nombre de chiffres de chaque forme (par exemple, dans 2147483647, par exemple, nous avons un Tesortings L à 4 chiffres et un L à 3 chiffres).

    Vous pouvez utiliser cette technique pour mémoriser facilement des numéros importants (par exemple, je me suis souvenu de mon numéro de carte de crédit à 16 chiffres, etc.).

    En supposant que .NET –

     Console.WriteLine(Int32.MaxValue); 

    Si vous connaissez votre table ASCII par cœur et non MaxInt :
    !GH6G = 21 47 48 36 47

    La façon la plus simple de s’en souvenir est de regarder std::numeric_limits< int >::max()

    Par exemple (à partir de MSDN ),

     // numeric_limits_max.cpp #include  #include  using namespace std; int main() { cout << "The maximum value for type float is: " << numeric_limits::max( ) << endl; cout << "The maximum value for type double is: " << numeric_limits::max( ) << endl; cout << "The maximum value for type int is: " << numeric_limits::max( ) << endl; cout << "The maximum value for type short int is: " << numeric_limits::max( ) << endl; } 

    La meilleure règle pour la mémoriser est la suivante:
    21 (nombre magique!)
    47 (souvenez-vous juste de ça)
    48 (séquentiel!)
    36 (21 + 15, les deux magiques!)
    47 encore

    En outre, il est plus facile de mémoriser 5 paires que 10 chiffres.

    Rappelez-vous juste que 2 ^ (10 * x) est approximativement de 10 ^ (3 * x) – vous êtes probablement déjà habitué à cela avec des kilo-octets / kilo-octets, etc.

     2^10 = 1024 ~= one thousand 2^20 = 1024^2 = 1048576 ~= one million 2^30 = 1024^3 = 1073741824 ~= one billion 

    Puisqu’un int utilise 31 bits (+ ~ 1 bit pour le signe), doublez 2 ^ 30 pour obtenir environ 2 milliards. Pour un int non signé utilisant 32 bits, doublez encore pour 4 milliards. Plus le facteur d’erreur est élevé, plus la valeur est importante, mais vous n’avez pas besoin de la valeur exacte mémorisée (si vous en avez besoin, vous devez quand même utiliser une constante prédéfinie). La valeur approximative est assez bonne pour remarquer quand quelque chose peut être dangereusement proche de déborder.

    Fait intéressant, Int32.MaxValue a plus de caractères que 2.147.486.647.

    Mais encore une fois, nous avons terminé le code,

    Donc, tout ce que nous devons mémoriser, c’est Int3M , qui ne comporte que 6 caractères à saisir dans Visual Studio.

    MISE À JOUR Pour une raison quelconque, j’ai été abaissé. La seule raison pour laquelle je peux penser est qu’ils n’ont pas compris ma première déclaration.

    “Int32.MaxValue” nécessite au maximum 14 caractères à saisir. 2,147,486,647 prend 10 ou 13 caractères à taper, selon que vous mettez les virgules ou non.

    c’est comme ça que je le fais pour me souvenir 2 147 483 647

    Pour un sortingo optimus de savannah de quartier sortingplé quarante septénaire

     2 - To 1 - A 4 - Far 7 - Savannah 4 - Quarter 8 - Optimus 3 - Trio 6 - Hexed 4 - Forty 7 - Septenary 

    Que voulez-vous dire? Il devrait être assez facile de se rappeler que c’est 2 ^ 32. Si vous souhaitez qu’une règle mémorise la valeur de ce nombre, une règle pratique est de convertir entre binary et décimal en général:

    2 ^ 10 ~ 1000

    ce qui signifie 2 ^ 20 ~ 1,000,000

    et 2 ^ 30 ~ 1 000 000 000

    Le double (2 ^ 31) est de 2 milliards, et le double (2 ^ 32) est de 4 milliards.

    C’est un moyen facile d’obtenir une estimation approximative de tout nombre binary. 10 zéros en binary deviennent 3 zéros en décimal.

    En Objective-C (iOS et OSX), rappelez-vous simplement ces macros:

     #define INT8_MAX 127 #define INT16_MAX 32767 #define INT32_MAX 2147483647 #define INT64_MAX 9223372036854775807LL #define UINT8_MAX 255 #define UINT16_MAX 65535 #define UINT32_MAX 4294967295U #define UINT64_MAX 18446744073709551615ULL 

    Int32 signifie que vous avez 32 bits disponibles pour stocker votre numéro. Le bit le plus élevé est le bit de signe, cela indique si le nombre est positif ou négatif. Vous avez donc 2 ^ 31 bits pour les nombres positifs et négatifs.

    Avec zéro étant un nombre positif, vous obtenez la plage logique de (mentionné précédemment)

    +2147483647 à -2147483648

    Si vous pensez que c’est trop petit, utilisez Int64:

    +9223372036854775807 à -9223372036854775808

    Et pourquoi diable voulez-vous vous souvenir de ce nombre? Pour utiliser dans votre code? Vous devez toujours utiliser Int32.MaxValue ou Int32.MinValue dans votre code car ce sont des valeurs statiques (dans le kernel .net) et donc plus rapides à utiliser que de créer un nouvel int avec le code.

    Ma déclaration: si vous connaissez ce numéro par la mémoire .. vous ne faites que vous montrer!