Quelle est la valeur maximale pour un int32?
https://stackoverflow.com/questions/94591
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je ne me souviens jamais du nombre. J'ai besoin d'une règle de mémoire.
La solution
C'est 2 147 483 647. Le moyen le plus simple de le mémoriser consiste à utiliser un tatouage.
Autres conseils
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: 111111111111111111111111111111111
si vous vous souvenez de tout le nombre de Pi, le nombre que vous recherchez est à 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 ...... 86181221809936452346 2147483647 10527835665425671614 ...
source: http://www.subidiom.com/pi/
C'est 10 chiffres, donc 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.
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 snooker (la 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.
Peut-être que la ventilation ci-dessus ne sera pas plus mémorable pour vous (ce n’est guère excitant, n’est-ce pas!), mais espérons que vous pourrez trouver des idées qui le sont!
Valeur la plus négative (32 bits): -2147483648
(1 & Lt; & Lt; 31)
Valeur maximale positive (32 bits): 2147483647
~ (1 & Lt; & Lt; 31)
Mnémonique: & "; ivre AKA corné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, prenons 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]
Cela vous aiderait peut-être à vous souvenir.
C'est comme ça que je me suis souvenu 2147483647:
- 214 - car 2,14 correspond approximativement à pi-1
- 48 = 6 * 8
- 64 = 8 * 8
Ecrivez ces horizontalement:
214_48_64_
and insert:
^ ^ ^
7 3 7 - which is Boeing's airliner jet (thanks, sgorozco)
Vous avez maintenant 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
Ainsi, 2 ^ 31 (signé int max) correspond à 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ée sur les mots:
- 2 ^ 16 ~ = 64 000 // uint16
- 2 ^ 32 ~ = 4 milliards // uint32, IPv4, unixtime
- 2 ^ 64 ~ = 16 quintillions (soit 16 milliards ou 16 millions de milliards) // uint64, & "bigint &";
- 2 ^ 128 ~ = 256 quintillions (soit 256 milliards de milliards de milliards) // IPv6, GUID
Prenez juste une calculatrice décente et tapez & "; 7FFFFFFF &"; en mode hexadécimal, puis passez en mode décimal.
2147483647.
Il s’agit de 2.1 * 10^9. Pas besoin de connaître l'exact 2^{31} - 1 = 2,147,483,647.
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 également obtenir cela 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 sur long lorsque le nombre entier devient supérieur à 2^31 -1
Voici un mnémonique pour retenir 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 même moi, je n'ai 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 que 2G.
32 bits, un pour le signe, 31 bits d'information:
2^31 - 1 = 2147483647
Pourquoi -1?
Comme le premier est égal à zéro, le plus grand est le compte moins un .
ÉDITER pour cantfindaname88
Le nombre est 2 ^ 31 mais le plus grand ne peut pas être 2147483648 (2 ^ 31) car nous comptons à partir de 0 et non de 1.
Rank 1 2 3 4 5 6 ... 2147483648
Number 0 1 2 3 4 5 ... 2147483647
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é d'entre eux sont négatifs.
La solution est 2 147 483 647
Et le plus bas est & # 8722; 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 " maximum int32 & "; dans Chrome.
Il y a une récursivité - > pile blague débordement là quelque part. Je ne suis tout simplement pas si geek.
Eh bien, mis à part les blagues, si vous recherchez vraiment une règle de mémoire utile, il y en a une que j'utilise toujours pour me souvenir de gros chiffres.
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 photo:
Comme vous pouvez le constater, vous devez désormais mémoriser 3 formes. Deux d'entre elles ressemblent à un Tetris L et une à 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.).
Le moyen le 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:
Nombre maximal de 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 signée maximale
8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000
Comment ça marche? 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. De plus, si vous utilisez ceci pour & "Insanely-High Constant &"; assez pour essayer 7F et 80 et les imprimer à 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 donc 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 fentes, puis 4)
--47----47
Pensez que vous avez 12 en main (car 12 = une douzaine). Multipliez-le par 4, le 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 3 par 7 (pour obtenir le deuxième chiffre du numéro de l'agent 47, qui est 7 - 4 = 3, vous avez besoin de <=>) et placez le résultat à droite des 2 premières paires, le dernière paire-slot
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 fois plus dans la valeur absolue que la limite positive.
Entraînez-vous à quelques reprises et vous comprendrez!
2 Go
(y a-t-il une longueur minimale pour les réponses?)
S'il vous arrive de connaître votre table ASCII par cœur et non MaxInt:
!GH6G = 21 47 48 36 47
La meilleure règle à retenir est la suivante:
21 (nombre magique!)
47 (rappelez-vous-le simplement)
48 (séquentiel!)
36 (21 + 15, les deux magies!)
47 à nouveau
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 comporte plus de caractères que 2 147 486 647.
Mais là encore, nous avons l'achèvement du code,
Je suppose donc que tout ce que nous avons à mémoriser est Int3<period>M<enter>, ce qui ne représente que 6 caractères à saisir dans Visual Studio.
MISE À JOUR Pour une raison quelconque, j'ai été voté. La seule raison pour laquelle je peux penser est qu’ils n’ont pas compris ma première déclaration.
" Int32.MaxValue " prend au plus 14 caractères à taper. 2 147 486 647 nécessite 10 ou 13 caractères à saisir, selon que vous insériez ou non les virgules.
Le moyen le plus simple à retenir est de regarder std::numeric_limits< int >::max()
Par exemple ( à partir 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;
}
N'oubliez pas que 2 ^ (10 * x) équivaut à environ 10 ^ (3 * x) - vous y êtes probablement déjà habitué 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 que quelque chose pourrait être dangereusement proche du débordement.
voici comment je le fais pour me souvenir de 2 147 483 647
À un lointain quartier de la savane, le trio optimus a dominé 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 est 2 ^ 32. Si vous souhaitez 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 n’importe quel nombre binaire. 10 zéros en binaire devient 3 zéros en décimal.
Sous Objective-C (iOS & et 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
