Eu nunca consigo me lembrar do número. Eu preciso de uma regra de memória.

São 2.147.483.647. A maneira mais fácil de memorizar é através de uma tatuagem.

A resposta mais correta que consigo pensar é Int32.MaxValue.

Se você acha que o valor é muito difícil de lembrar na base 10, tente a base 2: 1111111111111111111111111111111

se você se lembra do número inteiro do Pi, o número que você está procurando está na posição 1.867.996.680 a 1.867.996.689 dos dígitos decimais de Pi

A sequência numérica 2147483647 aparece no dígito decimal 1.867.996.680 de Pi. 3,14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

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

São 10 dígitos, então finja que é um número de telefone (supondo que você esteja nos EUA). 214-748-3647. Eu não recomendo chamá-lo.

Em vez de pensar nele como um grande número, tente dividi-lo e procurar idéias associadas, por exemplo:

• 2 intervalos máximos de sinuca (um intervalo máximo é 147)
• 4 anos (48 meses)
• 3 anos (36 meses)
• 4 anos (48 meses)

O exposto acima se aplica ao maior número negativo; positivo é aquele menos um.

Talvez o colapso acima não seja mais memorável para você (dificilmente é emocionante!), Mas espero que você possa ter algumas idéias!

Maior valor negativo (32 bits): -2147483648
(1 << 31)

Maior valor positivo (32 bits): 2147483647
~ (1 << 31)

Mnemônico: "bêbado AKA com tesão"

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

De qualquer forma, considere esse regex (ele determina se a sequência contém um número inteiro não negativo na forma decimal que também não é maior que 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]

Talvez ajude você a se lembrar.

Foi assim que me lembrei 2147483647:

• 214 - porque 2,14 é aproximadamente pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Escreva-os horizontalmente:

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

Agora você tem 2147483647.

Espero que isso ajude pelo menos um pouco.

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

Portanto, 2 ^ 31 (assinado int max) é 2 ^ 30 (cerca de 1 bilhão) vezes 2 ^ 1 (2), ou cerca de 2 bilhões. E 2 ^ 32 é 2 ^ 30 * 2 ^ 2 ou cerca de 4 bilhões. Esse método de aproximação é preciso o suficiente, mesmo em torno de 2 ^ 64 (onde o erro cresce para cerca de 15%).

Se você precisar de uma resposta exata, deverá abrir uma calculadora.

Aproximações úteis de capacidade alinhada por palavras:

• 2 ^ 16 ~ = 64 mil // uint16
• 2 ^ 32 ~ = 4 bilhões // uint32, IPv4, tempo unix
• 2 ^ 64 ~ = 16 quintilhões (aka 16 bilhões de bilhões ou 16 milhões de trilhões) // uint64, "bigint"
• 2 ^ 128 ~ = 256 quintilhões de quintilhões (aka 256 trilhões de trilhões de trilhões) // IPv6, GUID

Basta pegar uma calculadora decente e digitar "7FFFFFFF" no modo hexadecimal e depois mudar para decimal.

2147483647.

É sobre 2.1 * 10^9. Não há necessidade de saber exatamente 2^{31} - 1 = 2,147,483,647.

C

Você pode encontrá-lo em C assim:

#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);
}

dá (bem, sem o ,)

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

Você também pode obter isso com Java:

System.out.println(Integer.MAX_VALUE);

Mas lembre-se de que números inteiros Java sempre são assinados.

Python 2

Python possui números inteiros de precisão arbitrários. Mas no Python 2, eles são mapeados para inteiros C. Então você pode fazer isso:

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

Então, Python muda para longquando o número inteiro fica maior que2^31 -1

Aqui está um mnemônico para lembrar 2 ** 31, subtraia um para obter o valor inteiro máximo.

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

Eu usei os poderes de dois até 18 com frequência suficiente para lembrá-los, mas mesmo assim eu não me incomodei em memorizar 2 ** 31. É muito fácil calcular conforme necessário ou usar uma constante ou estimar como 2G.

32 bits, um para o sinal, 31 bits de informação:

2^31 - 1 = 2147483647

Por que -1?
Como o primeiro é zero, o maior é a contagem menos um .

EDIT para cantfindaname88

A contagem é 2 ^ 31, mas a maior não pode ser 2147483648 (2 ^ 31) porque contamos de 0, não 1.

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

Outra explicação com apenas 3 bits: 1 para o sinal, 2 para a informação

2^2 - 1 = 3

Abaixo de todos os valores possíveis com 3 bits: (2 ^ 3 = 8 valores)

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

Bem, ele tem 32 bits e, portanto, pode armazenar 2 ^ 32 valores diferentes. Metade deles é negativa.

A solução é 2.147.483.647

E o mais baixo é -2.147.483.648.

(Observe que há mais um valor negativo.)

Bem, além das piadas, se você está realmente procurando uma regra de memória útil, há uma que eu sempre uso para lembrar grandes números.

Você precisa dividir seu número em partes de 3 a 4 dígitos e lembrá-los visualmente usando a projeção no teclado do telefone celular. É mais fácil mostrar na foto:

Como você pode ver, a partir de agora você só precisa se lembrar de três formas, duas delas parecem um Tetris L e uma parece um tiquetaque . Definitivamente, é muito mais fácil do que memorizar um número de 10 dígitos.

Quando você precisar recuperar o número, basta recuperar as formas, imagine / olhe no teclado do telefone e projete as formas nele. Talvez inicialmente você precise olhar para o teclado, mas depois de um pouco de prática, lembre-se de que os números estão indo do canto superior esquerdo para o canto inferior direito, para que você possa simplesmente imaginá-lo na sua cabeça.

Lembre-se de lembrar a direção das formas e o número de dígitos em cada forma (por exemplo, no exemplo 2147483647, temos um Tetris L de 4 dígitos e um L de 3 dígitos).

Você pode usar essa técnica para lembrar facilmente qualquer número importante (por exemplo, lembrei-me do número do meu cartão de crédito de 16 dígitos etc.).

A maneira mais fácil de fazer isso para números inteiros é usar hexadecimal, desde que não exista algo como Int.maxInt (). A razão é esta:

Valores máximos não assinados

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

Valores assinados, usando 7F como o valor máximo assinado

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

Valores assinados, usando 80 como o valor máximo assinado

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

Como é que isso funciona? Isso é muito semelhante à tática binária e cada dígito hexadecimal é exatamente de 4 bits. Além disso, muitos compiladores suportam hexadecimal muito melhor do que binários.

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

Portanto, 7F é igual a 01111111 / 7FFF é igual a 0111111111111111. Além disso, se você estiver usando isso para "constante incrivelmente alta", 7F ... é um hex seguro, mas é fácil o suficiente experimentar 7F e 80 e imprimi-los na sua tela para ver qual é.

0x7FFF + 0x0001 = 0x8000, portanto, sua perda é apenas um número, portanto, usar 0x7F ... geralmente não é uma desvantagem ruim para um código mais confiável, especialmente quando você começa a usar 32 bits ou mais

Primeiro, escreva 47 duas vezes (você gosta do Agente 47 , certo?), Mantendo os espaços mostrados (cada traço é um slot para um único dígito. Primeiros 2 slots e depois 4)

--47----47

Pense que você tem 12em mãos (porque 12 = uma dúzia). Multiplique pelo 4primeiro dígito do número do Agente 47, ou seja 47, e coloque o resultado à direita do primeiro par que você já possui

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

Multiplique 12por 3(para fazer o segundo dígito do número do Agente 47, ou seja 7, você precisa 7 - 4 = 3) e coloque o resultado à direita dos 2 primeiros pares, o último slot do par

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

Por fim, arraste os dígitos um a um da sua mão, começando no dígito mais à direita (2 neste caso) e coloque-os no primeiro slot vazio que você obtiver

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

Aí está! Para o limite negativo, você pode pensar nisso como mais 1 em valor absoluto do que o limite positivo.

Pratique algumas vezes e você entenderá!

2GB

(existe um tamanho mínimo para respostas?)

Assumindo .NET -

Console.WriteLine(Int32.MaxValue);

Se você conhece sua tabela ASCII de cor e não MaxInt:
!GH6G = 21 47 48 36 47

A melhor regra para memorizar é:
21 (número mágico!)
47 (lembre-se disso)
48 (sequencial!)
36 (21 + 15, ambas as mágicas!)
47 novamente

Também é mais fácil lembrar 5 pares do que 10 dígitos.

A maneira mais fácil de lembrar é olhar para std::numeric_limits< int >::max()

Por exemplo ( do 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;
}

Curiosamente, Int32.MaxValue tem mais caracteres que 2.147.486.647.

Mas, novamente, temos a conclusão de código,

Acho que tudo o que realmente precisamos memorizar é Int3<period>M<enter>que são apenas 6 caracteres para digitar no visual studio.

ATUALIZAÇÃO Por algum motivo, eu fui votada com baixa. A única razão pela qual consigo pensar é que eles não entenderam minha primeira afirmação.

"Int32.MaxValue" leva no máximo 14 caracteres para digitar. 2.147.486.647 leva 10 ou 13 caracteres para digitar, dependendo se você coloca as vírgulas ou não.

Lembre-se de que 2 ^ (10 * x) é aproximadamente 10 ^ (3 * x) - você provavelmente já está acostumado a isso com kilobytes / kibibytes etc. Isso é:

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

Como um int usa 31 bits (+ ~ 1 bit para o sinal), apenas dobre 2 ^ 30 para obter aproximadamente 2 bilhões. Para um int não assinado usando 32 bits, dobre novamente para 4 bilhões. O fator de erro aumenta, quanto maior você aumentar, é claro, mas você não precisa do valor exato memorizado (se precisar, deve usar uma constante predefinida para ele). O valor aproximado é bom o suficiente para perceber quando algo pode estar perigosamente próximo do transbordamento.

é assim que eu faço para lembrar 2.147.483.647

Para um bairro da savana distante, o trio optimus enfeitiçou quarenta setenários

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

O que você quer dizer? Deve ser fácil lembrar que é 2 ^ 32. Se você deseja que uma regra memorize o valor desse número, uma regra prática é a conversão entre binário e decimal em geral:

2 ^ 10 ~ 1000

o que significa 2 ^ 20 ~ 1.000.000

e 2 ^ 30 ~ 1.000.000.000

O dobro disso (2 ^ 31) é aproximadamente 2 bilhões, e dobrando novamente (2 ^ 32) é 4 bilhões.

É uma maneira fácil de obter uma estimativa aproximada de qualquer número binário. 10 zeros em binário se tornam 3 zeros em decimal.

No Objective-C (iOS e OSX), lembre-se destas 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 significa que você tem 32 bits disponíveis para armazenar seu número. O bit mais alto é o bit de sinal, isso indica se o número é positivo ou negativo. Então você tem 2 ^ 31 bits para números positivos e negativos.

Com zero sendo um número positivo, você obtém o intervalo lógico de (mencionado anteriormente)

+2147483647 a -2147483648

Se você acha que é muito pequeno, use Int64:

+9223372036854775807 a -9223372036854775808

E por que diabos você quer se lembrar desse número? Para usar no seu código? Você sempre deve usar Int32.MaxValue ou Int32.MinValue em seu código, pois esses são valores estáticos (dentro do núcleo .net) e, portanto, mais rápidos em uso do que a criação de um novo int com código.

Minha afirmação: se conhece esse número de memória .. você está apenas se exibindo!

Lembre-se disto: 21 IQ ITEM 47

Ele pode ser decodificado com qualquer teclado telefônico ou você mesmo pode escrever um em um papel.

Para lembrar "21 IQ ITEM 47", eu usaria "Hitman: Codename 47 tinha 21 missões, que eram cada IQ ITEM por si mesmas".

Ou "limpo os dentes às 21:47 todos os dias, porque tenho QI alto e não gosto de itens na boca".