Je ne me souviens jamais du numéro. 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 peux penser est Int32.MaxValue.

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

si vous vous souvenez du nombre entier de Pi, alors 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 au chiffre décimal de 1 867 996 680 de Pi. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

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

Il s'agit de 10 chiffres, alors faites comme s'il s'agissait d'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 le considérer comme un grand nombre, essayez de le décomposer et de rechercher des idées associées, par exemple:

• 2 pauses maximum de 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.

Peut-être que la ventilation ci-dessus ne sera plus mémorable pour vous (ce n'est guère excitant, n'est-ce pas!), Mais j'espère que vous pourrez trouver des idées qui le sont!

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

Plus grande valeur positive (32 bits): 2147483647
~ (1 << 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, prenez cette expression régulière (elle détermine si la chaîne contient un entier non négatif sous forme décimale qui n'est pas non plus 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.

Voilà comment je me suis souvenu 2147483647:

• 214 - parce que 2,14 est approximativement pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Écrivez-les 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

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 soit environ 4 milliards. Cette méthode d'approximation est suffisamment précise, même jusqu'à environ 2 ^ 64 (où l'erreur atteint environ 15%).

Si vous avez besoin d'une réponse exacte, vous devez alors ouvrir une calculatrice.

Approximations pratiques de la capacité d'alignement 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 quintillion (alias 256 trillions trillions de trillions) // IPv6, GUID

Prenez simplement une calculatrice décente et tapez "7FFFFFFF" en mode hexadécimal, puis passez en décimal.

2147483647.

C'est à peu près 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 arbitraires. Mais en Python 2, ils sont mappés sur des entiers C. Vous pouvez donc faire ceci:

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

Donc, Python passe longlorsque l'entier devient plus grand que2^31 -1

Voici un mnémonique pour se 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 pouvoirs de deux jusqu'à 18 assez souvent pour m'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 d'estimer comme 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 nombre 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é d'entre eux sont négatifs.

La solution est de 2147483647

Et le plus bas est −2 147 483 648.

(Notez qu'il existe une autre valeur négative.)

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 me souvenir des grands nombres.

Vous devez décomposer votre numéro en parties de 3 à 4 chiffres et les mémoriser visuellement en utilisant la projection sur le clavier de votre téléphone portable. Il est plus facile de montrer sur une photo:

Comme vous pouvez le voir, il ne vous reste plus qu'à vous souvenir de 3 formes, dont 2 ressemblent à un Tetris L et une ressemble à une tique . Ce qui est certainement beaucoup plus facile que de mémoriser un nombre à 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. Peut-être qu'au début, vous devrez regarder le clavier, mais après un peu de pratique, vous vous souviendrez que les nombres vont de haut en bas à droite, vous pourrez donc l'imaginer simplement dans votre tête.

Assurez-vous simplement de vous souvenir de la direction des formes et du nombre de chiffres dans 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 mémoriser facilement tous les 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 le faire pour les entiers est d'utiliser 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 signée maximale

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 cela marche-t-il? C'est très similaire à la tactique binaire, et chaque chiffre hexadécimal fait exactement 4 bits. De plus, de nombreux compilateurs prennent en charge l'hex beaucoup mieux que le 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 à 0111111111111111. De plus, si vous l'utilisez pour une "constante incroyablement élevée", 7F ... est un hex sûr, mais il est assez facile d'essayer 7F et 80 et de simplement les imprimer à votre écran pour voir lequel c'est.

0x7FFF + 0x0001 = 0x8000, donc votre perte n'est qu'un nombre, donc l'utilisation de 0x7F ... n'est généralement pas un mauvais compromis pour un code plus fiable, surtout une fois que vous commencez à utiliser 32 bits ou plus

Commencez par écrire 47 deux fois (vous aimez l' agent 47 , n'est-ce pas?), En gardant les espaces comme indiqué (chaque tiret est un emplacement pour un seul chiffre. 2 premiers emplacements, puis 4)

--47----47

Pensez que vous avez 12en main (car 12 = une douzaine). Multipliez-le par le 4premier chiffre du numéro de l'agent 47 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

Ensuite, multipliez 12par 3(afin de créer le deuxième chiffre du numéro de l'agent 47, qui est 7, vous avez besoin 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 par un depuis votre main à partir 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 plusieurs fois et vous aurez le coup!

2 Go

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

En supposant que .NET -

Console.WriteLine(Int32.MaxValue);

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

La meilleure règle pour la mémoriser est:
21 (nombre magique!)
47 (rappelez-vous juste)
48 (séquentiel!)
36 (21 + 15, les deux magies!)
47 à nouveau

Il est également plus facile de mémoriser 5 paires que 10 chiffres.

La façon la plus simple de se souvenir 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;
}

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

Mais là encore, nous avons l'achèvement du code,

Donc je suppose que tout ce que nous avons vraiment à mémoriser Int3<period>M<enter>, c'est seulement 6 caractères à taper dans Visual Studio.

MISE À JOUR Pour une raison quelconque, j'ai été rétrogradé. 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 à taper. 2.147.486.647 prend 10 ou 13 caractères à taper selon que vous insérez ou non les virgules.

N'oubliez pas que 2 ^ (10 * x) est environ 10 ^ (3 * x) - vous êtes probablement déjà habitué à cela avec des kilo-octets / kibio, 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 à nouveau pour 4 milliards. Le facteur d'erreur augmente plus vous augmentez bien sûr, mais vous n'avez pas besoin que la valeur exacte soit mémorisée (si vous en avez besoin, vous devez de toute façon utiliser une constante prédéfinie). La valeur approximative est suffisamment bonne pour remarquer quand quelque chose pourrait être dangereusement proche d'un débordement.

voici comment je me souviens de 2147483647

Dans un quartier de savane éloignée, le trio Optimus hexa 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 souhaitez qu'une règle mémorise la valeur de ce nombre, une règle pratique est pour la conversion entre binaire 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) équivaut à environ 2 milliards, et le double (2 ^ 32) à 4 milliards.

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

Dans Objective-C (iOS & 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 disposez de 32 bits 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ée précédemment)

+2147483647 à -2147483648

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

+9223372036854775807 à -9223372036854775808

Et pourquoi diable vous voulez vous souvenir de ce numéro? À utiliser dans votre code? Vous devez toujours utiliser Int32.MaxValue ou Int32.MinValue dans votre code car ce sont des 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 par la mémoire .. vous venez de montrer!

Rappelez-vous ceci: 21 IQ ITEM 47

Il peut être décodé avec n'importe quel clavier téléphonique, ou vous pouvez simplement en écrire un vous-même sur un papier.

Pour me souvenir de "21 IQ ITEM 47", je choisirais "Hitman: Codename 47 avait 21 missions, qui étaient chacune des IQ ITEM".

Ou "Je nettoie les dents à 21h47 tous les jours, car j'ai un QI élevé et je n'aime pas les articles dans ma bouche".