Quelle est la valeur maximale pour un int32?
Je ne me souviens jamais du nombre. J'ai besoin d'une règle de mémoire.
C'est 2.147.483.647. Le moyen le plus simple de le mémoriser est via un tatouage.
La réponse la plus correcte à laquelle je puisse penser est Int32.MaxValue.
Si vous pensez que la valeur est trop difficile à retenir en base 10, essayez en base 2:
C'est 10 chiffres, alors supposez que c'est un numéro de téléphone (en supposant que vous soyez aux États-Unis) 214-748-3647. Je ne recommande pas de l'appeler.
si vous vous souvenez de tout le nombre de Pi, le nombre que vous cherchez se trouve à la position 1 867 996 680 jusqu'à 1 867 996 689 des chiffres décimaux de Pi
La chaîne numérique 2147483647 apparaît avec le chiffre décimal de 1 867 996 680 de Pi. 3.14 ...... 861812218099364523462147483647 10527835665425671614 ...
source: http://www.subidiom.com/pi/
Plutôt que de penser à un grand nombre, essayez de le décomposer et de rechercher les idées associées, par exemple:
- 2 pauses maximum au billard (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 que moins un.
La ventilation ci-dessus ne sera peut-être pas plus mémorable pour vous (ce n'est guère excitant, n'est-ce pas!), Mais j'espère que vous pourrez proposer quelques idées!
Plus grande valeur négative (32bit): -2147483648
(1 << 31)
Valeur positive maximale (32 bits): 2147483647
~ (1 << 31)
Mnémonique: "AKA saoul excité"
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 expression rationnelle (elle détermine si la chaîne contient un 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 de 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 équivaut à 2 ^ 30 * 2 ^ 2, soit environ 4 milliards. Cette méthode d’approximation est suffisamment précise même aux alentours de 2 ^ 64 (où l’erreur atteint environ 15%).
Si vous avez besoin d'une réponse exacte, vous devriez vous procurer une calculatrice.
Des approximations pratiques de la capacité alignées sur Word:
- 2 ^ 16 ~ = 64 000 // uint16
- 2 ^ 32 ~ = 4 milliards // uint32, IPv4, unixtime
- 2 ^ 64 ~ = 16 milliards (soit 16 milliards ou 16 millions de milliards) // uint64, "bigint"
- 2 ^ 128 ~ = 256 milliards de milliards (soit 256 milliards de milliards de milliards) // IPv6, GUID
Il suffit de prendre n’importe quelle calculatrice décente et de taper «7FFFFFFF» en mode hexadécimal, puis de passer en décimal.
2147483647.
C'est à propos de 2.1 * 10^9. Pas besoin de connaître le 2^{31} - 1 = 2,147,483,647 exact.
C
Vous pouvez le trouver en C comme ça:
#include <stdio.h>
#include <limits.h>
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<int>::max() << "\n";
std::cout << std::numeric_limits<unsigned int>::max() << "\n";
Java
Vous pouvez aussi l'obtenir 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 arbitraire. Mais dans Python 2, ils sont mappés sur des entiers C. Donc, vous pouvez faire ceci:
import sys
sys.maxint
>>> 2147483647
sys.maxint + 1
>>> 2147483648L
Donc, Python bascule vers long lorsque le nombre entier dépasse 2^31 -1
Voici un mnémonique pour mémoriser 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 pouvoirs de deux à 18 ans assez souvent pour m'en souvenir, mais je n'ai même pas pris la peine de mémoriser 2 ** 31. Il est trop facile de calculer au besoin ou d'utiliser une constante, ou d'estimer en 2G.
32 bits, un pour le signe, 31 bits d'information:
2^31 - 1 = 2147483647
Pourquoi -1?
Parce que le premier est zéro, le plus grand est donc le compte moins un.
EDIT 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
Ci-dessous 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
Eh bien, il a 32 bits et peut donc stocker 2 ^ 32 valeurs différentes. La moitié de ceux-ci sont négatifs.
La solution est 2 147 483 647
Et le plus bas est -2,147,483,648.
(Notez qu'il existe une autre valeur négative.)
À ce stade, je dirais que le code mnémonique le plus simple est de taper "stackoverflow.com" TAB "int32 maximum" dans Chrome.
Il y a une plaisanterie de récurrence de pile -> pile quelque part. Je ne suis pas aussi geek.
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 me souvenir de gros nombres.
Vous devez diviser votre numéro en parties de 3 à 4 chiffres et vous en souvenir visuellement à l'aide de la projection sur le clavier de votre téléphone portable. Il est plus facile de montrer sur une image:
Comme vous pouvez le constater, à partir de maintenant il ne vous reste plus qu’à mémoriser 3 formes, 2 d’entre elles ressemblant à un Tetris L et l’autre à une tique. Ce qui est certainement beaucoup plus facile que de mémoriser un numéro à 10 chiffres.
Lorsque vous devez rappeler le numéro, rappelez simplement les formes, imaginez/regardez sur le clavier d'un 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 de haut en gauche à en bas à droite, vous pourrez donc simplement l'imaginer dans votre tête.
Assurez-vous simplement de vous souvenir de la direction des formes et du nombre de chiffres de chaque forme (par exemple, dans l'exemple 2147483647, nous avons un Tetris L à 4 chiffres et un L à 3 chiffres).
Vous pouvez utiliser cette technique pour vous souvenir facilement des numéros importants (par exemple, je me suis souvenu de mon numéro de carte de crédit à 16 chiffres, etc.).
La façon la plus simple de procéder pour les entiers est d'utiliser hexadécimal, à condition qu'il n'y ait pas quelque chose comme Int.maxInt (). La raison 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 binaire, et chaque chiffre hexadécimal est exactement 4 bits. En outre, beaucoup de compilateurs supportent bien mieux l'hex que leur support binaire.
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 à 011111111111111111. En outre, si vous utilisez ceci pour "constante incroyablement élevée", 7F ... est un hex sûr, mais il est assez facile d'essayer 7F et 80 et de les imprimer sur votre écran pour voir lequel il s’agit.
0x7FFF + 0x0001 = 0x8000, votre perte n'est donc qu'un chiffre. L'utilisation de 0x7F ... n'est généralement pas un mauvais compromis pour un code plus fiable, en particulier lorsque vous commencez à utiliser 32 bits ou plus.
Tout d'abord, écrivez 47 deux fois (vous aimez Agent 47 , n'est-ce pas?), En gardant les espaces comme indiqué (chaque tiret est une fente pour un seul chiffre. Les 2 premières, puis 4)
--47----47
Pensez que vous avez 12 en main (car 12 = une douzaine). Multipliez-le par 4, premier chiffre du numéro de l'agent 47, c'est-à-dire 47, et placez le résultat à la 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 (pour obtenir 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 emplacement de paire.
12 * 3 = 36
--47483647 <-- after placing 36 to the right of first two pairs
Enfin, faites glisser les chiffres un à 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 plus en valeur absolue que la limite positive.
Entraînez-vous quelques fois et vous comprendrez!
2 Go
(Y a-t-il une longueur minimale pour les réponses?)
Si vous connaissez votre table ASCII off par coeur et non pas MaxInt:!GH6G = 21 47 48 36 47
La meilleure règle pour le mémoriser est:
21 (nombre magique!)
47 (souviens-toi-en)
48 (séquentiel!)
36 (21 + 15, les deux magies!)
47 encore
En outre, il est plus facile de retenir 5 paires que 10 chiffres.
En supposant que .NET -
Console.WriteLine(Int32.MaxValue);
Fait intéressant, Int32.MaxValue a plus de caractères que 2.147.486.647.
Mais là encore, nous avons l'achèvement du code,
Donc, je suppose que tout ce que nous devons vraiment mémoriser est Int3<period>M<enter>, qui ne comporte que 6 caractères à saisir dans Visual Studio.
UPDATE Pour une raison quelconque, mon vote a été négatif. La seule raison pour laquelle je peux penser, c'est qu'ils n'ont pas compris ma première déclaration.
"Int32.MaxValue" prend au plus 14 caractères pour taper . 2 147 486 647 nécessite 10 ou 13 caractères à taper selon que vous insérez ou non les virgules.
Le moyen le plus simple à retenir est de regarder std::numeric_limits< int >::max()
Par exemple ( de MSDN ),
// numeric_limits_max.cpp
#include <iostream>
#include <limits>
using namespace std;
int main() {
cout << "The maximum value for type float is: "
<< numeric_limits<float>::max( )
<< endl;
cout << "The maximum value for type double is: "
<< numeric_limits<double>::max( )
<< endl;
cout << "The maximum value for type int is: "
<< numeric_limits<int>::max( )
<< endl;
cout << "The maximum value for type short int is: "
<< numeric_limits<short int>::max( )
<< endl;
}
Rappelez-vous simplement que 2 ^ (10 * x) équivaut à environ 10 ^ (3 * x) - vous êtes probablement déjà habitué à cela avec des kilo-octets/kibibytes, etc. C'est-à-dire:
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), il suffit de doubler 2 ^ 30 pour obtenir environ 2 milliards. Pour un entier non signé utilisant 32 bits, doublez encore pour 4 milliards. Le facteur d'erreur augmente d'autant plus que vous grandissez, mais vous n'avez pas besoin de mémoriser la valeur exacte (si vous en avez besoin, vous devriez utiliser une constante prédéfinie pour cela de toute façon). La valeur approximative est assez bonne pour remarquer quand quelque chose pourrait être dangereusement proche du débordement.
voici comment je le fais pour me souvenir de 2 147 483 647
Pour un lointain quartier de la savane, le trio Optimus a été frappé par quarante septenaires
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 qu’il s’agit de 2 ^ 32 . Si vous voulez qu’une règle mémorise la valeur de ce nombre, une règle simple est de convertir en binaire ou 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) équivaut à 2 milliards, et le double (2 ^ 32) équivaut à 4 milliards.
C'est un moyen facile d'obtenir une estimation approximative de tout nombre binaire. 10 zéros en binaire devient 3 zéros en décimal.
Dans Objective-C (iOS & OSX), rappelez-vous 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
En tant que physicien, je voudrais juste arrondir à 2 milliards (semi-blague). Facile à retenir!
Int32 signifie que vous avez 32 bits disponibles pour stocker votre numéro. Le bit le plus élevé est le bit de signe, il 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ée auparavant)
+2147483647 à -2147483648
Si vous pensez que c'est trop petit, utilisez Int64:
+9223372036854775807 à -9223372036854775808
Et pourquoi diable voulez-vous vous rappeler ce numéro? A utiliser dans votre code? Vous devez toujours utiliser Int32.MaxValue ou Int32.MinValue dans votre code car il s'agit de valeurs statiques (dans le noyau .net) et donc plus rapides à utiliser que la création d'un nouvel int avec du code.
Ma déclaration: si vous connaissez ce numéro de mémoire, vous ne faites que montrer!
Rappelez-vous ceci: 21 QI ITEM 47
Il peut être décodé avec n’importe quel téléphone, ou vous pouvez simplement en écrire un vous-même sur un papier.
Pour me souvenir de "21 IQ ITEM 47", je choisirais "Hitman: Nom de code 47 avait 21 missions, chacune correspondant à un IQ ITEM".
Ou "je me lave les dents tous les jours à 21h47, parce que mon QI est élevé et que je n'aime pas les objets dans ma bouche".
Avec Groovy sur le chemin:
groovy -e " println Integer.MAX_VALUE "
(Groovy est extrêmement utile pour une référence rapide, dans un contexte Java.)
Pour ne jamais oublier la valeur maximale de tout type:
S'il a 32 bits, la plus grande valeur possible serait les 32 bits avec le nombre 1:
Le résultat serait 4294967295 en décimal:
Mais comme il y a aussi la représentation des nombres négatifs, divisez 4294967295 par 2 et obtenez 2147483647.
Par conséquent, un entier de 32 bits est capable de représenter -2147483647 à 2147483647
Voici comment je me souviens ...
En hex, un chiffre représente quatre bits, donc 4 * 8 = 32, donc le maximum signé 32 bits int est:
0xFFFFFFFF >> 1 # => 2147483647
Essayez en Python:
>>> int('1' * 31, base=2)
2147483647
C'est 2147483647, mais vous n'avez vraiment pas besoin de le mémoriser. Cela dépend du nombre de chiffres que votre numéro peut avoir. Parfois, vous pouvez utiliser short int à la place.
Si un débordement serait catastrophique pour votre programme, vous devrez peut-être utiliser une bibliothèque avec une taille illimitée (ce qui serait plus lent cependant).
J'ai créé quelques méthodes géniales en C # dont vous pouvez tirer parti dans votre environnement de production:
public static int GetIntMaxValueGenius1()
{
int n = 0;
while (++n > 0) { }
return --n;
}
public static int GetIntMaxValueGenius2()
{
int n = 0;
try
{
while (true)
n = checked(n + 1);
}
catch { }
return n;
}
2147483647
Voici ce dont vous devez vous rappeler:
- C'est 2 milliards .
- Les trois prochains triplés augmentent comme suit: 100, 400, 600
- Il faut ajouter 3 au premier et au dernier triplet pour qu’ils soient arrondis à 50 (par exemple, 147 + 3 = 150 & 647 + 3 = 650)
- Le deuxième triplet doit en soustraire 3 pour l’arrondir à 80 (par exemple, 483 - 3 = 480)
D'où 2 147, 483, 647
Une autre façon d'atteindre ce numéro:
- Jouez 2048 jusqu'à sa limite théorique maximale. Dans l'image: 15 déplacements avant USHRT_MAX.
- Place le résultat. À propos de UINT_MAX.
- Divisez par 2 et - 1 pour obtenir INT_MAX.
Utilisation de REPL, jshell : de Java 9
$ jshell
| Welcome to JShell -- Version 9-Debian
jshell> System.out.println(Integer.MAX_VALUE)
2147483647
Vous trouverez en binaire la valeur maximale d’un Int32 égale à 111111111111111111111111111111111
- Élever 31 générations de lapins.
- Faites un ragoût d'un lapin. *
- Comptez les lapins restants.
* Comment faites-vous un ragoût de lapin? Je ne sais pas, regarde sur internet.
max_signed_32_bit_num = 1 << 31 - 1; // alternatively ~(1 << 31)
Un compilateur devrait l’optimiser quand même.
Je préfère 1 << 31 - 1 à
0x7fffffff parce que vous n'avez pas besoin de compter fs
unsigned( pow( 2, 31 ) ) - 1 car vous n'avez pas besoin de <math.h>
C'est 2 ^ 31 - 1 (32 bits, un est utilisé pour le signe).
Si vous voulez une valeur approximative, utilisez 2 ^ 10 = 1024 ~ 10 ^ 3, donc 2 ^ 31 ~ 2 * 10 ^ 9. Si vous voulez calculer une valeur exacte à la main, utilisez l’exponentiation en carré pour obtenir 2 ^ 32 = 2 ^ (2 ^ 5) et divisez-la par deux. Il suffit de cadrer cinq fois pour obtenir 2 ^ 32:
2*2 = 4
4*4 = 16
16*16 = 256
256*256 = 25*25*100 + 2*250*6 + 36 = 62500 + 3000 + 36 = 65536
65536*65536 =65000*65000 + 2*65000*536 + 536*536 =
4225000000 + 130000*536 + (250000 + 3600 + 36*36) =
4225000000 + 69680000 + 250000 + 3600 + 1296 =
4294967296
2147483647 est divisé par deux et on en soustrait un. Si vous n'avez pas besoin de tous les chiffres, mais que vous voulez seulement dire, les trois premiers chiffres significatifs, les calculs sur chaque étape de la mise au carré sont très faciles.
Je cherche toujours dans la bibliothèque de Babel, une collection de tous les textes possibles avec l'alphabet anglais.
Un lien vers la page spécifique du livre spécifique sur un domaine spécifique dans une section spécifique est ici: https://libraryofbabel.info/bookmark.cgi?max_int32
En C, utilisez INT32_MAX après #include <stdint.h>. En C++, utilisez INT32_MAX après #include <cstdint>.
Ou INT_MAX pour la taille spécifique à la plate-forme ou UINT32_MAX ou UINT_MAX pour unsigned int. Voir http://www.cplusplus.com/reference/cstdint/ et http://www.cplusplus.com/reference/climits/ .
Ou sizeof(int).
En général, vous pouvez effectuer une opération simple qui reflète la nature même d’un Int32, en remplissant tous les bits disponibles par des 1 - c’est quelque chose que vous pouvez facilement garder en mémoire. Cela fonctionne fondamentalement de la même manière dans la plupart des langues, mais je vais utiliser Python pour l'exemple:
max = 0
bits = [1] * 31 # Generate a "bit array" filled with 1's
for bit in bits:
max = (max << 1) | bit
# max is now 2147483647
Pour les Int32 non signés, choisissez 32 au lieu de 31 1.
Mais depuis que quelques approches plus aventureuses ont été publiées, j'ai commencé à penser à des formules, juste pour le plaisir ...
Formule 1 (Les chiffres sont concaténés si aucun opérateur n'est donné)
- a = 4
- b = 8
- bêlement
- ab-1
- un B
- ab-a-b
- ab-1
Python quickcheck
a = 4
b = 8
ab = int('%d%d' % (a, b))
ba = int('%d%d' % (b, a))
'%d%d%d%d%d' % (ba/a, ab-1, ab, ab-a-b, ab-1)
# gives '2147483647'
Formule 2
- x = 48
- x/2-3
- x-1
- x
- x * 3/4
- x-1
Python quickcheck
x = 48
'%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1)
# gives '2147483647'
Utilise ton imagination!
Fermez les yeux et voyez le vieux fermier chinois unijambiste Wang qui, malgré son handicap, est devenu le berger le plus riche et le plus puissant de Chine (et donc du monde entier également). Sa famille est composée de lui-même, de sa femme, de leurs quatre fils et du chien de berger Alice. Un jour, il les rassembla tous sur le terrain de gazon recouvert de ses millions de moutons et dit:
Je suis vieux et fatigué. Alors j'ai décidé de partager ma richesse égale entre mes fils.
Il désigna tous les moutons:
Ceux-ci, mes enfants, sont tous à vous. Chacun de vous a 123456789 moutons blancs, 10101010 moutons noirs, 203040 moutons tachetés, 444888 agneaux et 12000 béliers. Le chien je vais garder pour moi. C'est ce que j'ai dit.
Il s'appuya sur l'épaule de sa femme et sourit.
Alors ... mon ami, imagine cette photo! Imaginez-le aussi vivant et réel que possible! Faites-le vivre devant vos yeux!
Puis agenouillez-vous ... et commencez à compter! Le nombre de jambes sur ce champ est la valeur maximale pour un int32.
Il existe cependant deux failles du procédé décrit:
- L'imagination de l'humain ne connaît pas de limites ... il est donc difficile de vous limiter et d'imaginer le nombre exact de moutons sur ce champ sans en créer davantage alors que vous comptez les jambes.
- Les humains sont paresseux ... alors beaucoup de gens essaient de compter les moutons et de se multiplier par quatre au lieu de compter les pattes mais ... devinez quoi - ils tombent un sommeil.
C'est très facile à retenir. En hexadécimal, un chiffre correspond à 4 bits. Donc, pour unsigned int, écrivez 0x et 8 fs (0xffffffff) dans un shell Python ou Ruby Shell pour obtenir la valeur en base 10. Si vous avez besoin de la valeur signée, rappelez-vous que le bit le plus élevé est utilisé comme signe. Donc, vous devez laisser cela de côté. Vous devez seulement vous rappeler que le nombre où les 3 bits inférieurs sont 1 et le 4ème bit est égal à 0 est égal à 7, écrivez donc 0x7fffffff dans un shell Python ou Ruby. Vous pouvez également écrire 0x100000000 - 1 et 0x80000000 - 1, si cela vous est plus facile à mémoriser.
"Si un nombre entier énorme n'est pas rappelé, rappelez-vous ce mnémonique."
Comptez maintenant les lettres dans chaque mot.