Qual é o valor máximo para um int32?
https://stackoverflow.com/questions/94591
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu nunca consigo lembrar o número. Eu preciso de uma regra de memória.
Solução
É 2,147,483,647. maneira mais fácil de memorizar, é através de uma tatuagem.
Outras dicas
A resposta mais correta que eu posso pensar é Int32.MaxValue.
Se você acha que o valor é muito difícil para se lembrar de base 10, base try 2: 1111111111111111111111111111111
Se você pode se lembrar de todo o número Pi, então o número que você está procurando está na posição 1867996680 até 1867996689 dos dígitos decimais de Pi
Os seqüência numérica 2147483647 aparece no dígitos 1867996680 decimal de Pi. 3,14 ...... 86181221809936452346 2147483647 10527835665425671614 ...
Fonte: http://www.subidiom.com/pi/
É 10 dígitos, por isso, fingir que é um número de telefone (supondo que você está nos EUA). 214-748-3647. Eu não recomendo chamá-lo.
Ao invés de pensar nisso como um número grande, tente dividi-lo e à procura de ideias associadas por exemplo:
- 2 quebras máximos snooker (uma quebra máxima é 147)
- 4 anos (48 meses)
- 3 anos (36 meses)
- 4 anos (48 meses)
O acima aplica-se ao maior número negativo; positivo é que menos um.
Talvez a repartição acima haverá mais memorável para você (é dificilmente emocionante é que é!), Mas espero que você pode vir acima com algumas idéias que são!
Maior negativo (32 bits) Valor: -2147483648
(1 << 31)
Maior (32 bits) valor positivo: 2147483647
~ (1 << 31)
Mnemonic: "bêbado AKA 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, levar este regex (que determina se a cadeia contém um não negativo inteiro 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 fosse ajudá-lo a se lembrar.
É assim que eu me lembrava 2147483647:
- 214 - porque 2,14 é de aproximadamente pi-1
- 48 = 6 * 8
- 64 = 8 * 8
Escreva estes 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
Assim, 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. Este método de aproximação é suficiente preciso, mesmo para cerca de 2 ^ 64 (onde o erro cresce para cerca de 15%).
Se você precisar de uma resposta exata, então você deve puxar para cima uma calculadora.
Handy alinhados palavra-aproximações capacidade:
- 2 ^ 16 ~ = 64000 // uint16
- 2 ^ 32 ~ = 4 bilhões // uint32, IPv4, unixtime
- 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
Apenas tomar qualquer calculadora decente e digite "7FFFFFFF" no modo hexadecimal, então mudar para decimal.
2147483647.
É sobre 2.1 * 10^9. Não há necessidade de conhecer a 2^{31} - 1 = 2,147,483,647 exato.
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 a ,)
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ê pode obter isso com Java, demasiado:
System.out.println(Integer.MAX_VALUE);
Mas tenha em mente que inteiros Java são sempre assinados.
Python 2
Python tem inteiros de precisão arbitrária. Mas em Python 2, eles são mapeados para inteiros C. Então você pode fazer isso:
import sys
sys.maxint
>>> 2147483647
sys.maxint + 1
>>> 2147483648L
Assim Python muda para long quando o inteiro se torna maior do que 2^31 -1
Aqui está um mnemônico para lembrar 2 ** 31, subtrair um para obter o valor máximo inteiro.
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 as potências de dois até 18 vezes o suficiente para se lembrar deles, mas mesmo eu não ter incomodado memorizar 2 ** 31. É muito fácil de calcular como necessário ou usar uma constante, ou estimativa a 2G.
32 bits, um para o sinal, 31 bits de informação:
2^31 - 1 = 2147483647
Por -1?
Porque o primeiro é zero, de modo que o maior é o contar menos um .
Editar para cantfindaname88
A contagem é 2 ^ 31, mas a maior não pode ser 2147483648 (2 ^ 31) porque nós contar 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
A seguir 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, tem 32 bits e, portanto, pode armazenar 2 ^ 32 valores diferentes. Metade das pessoas são negativos.
A solução é 2,147,483,647
E o menor é 2,147,483,648.
(Observe que há um valor mais negativo.)
Neste ponto, eu diria que o mnemônico mais fácil é escrever "stackoverflow.com" TAB "int32 máxima" no Chrome.
Há uma recursão -> piada estouro de pilha em algum lugar. Eu não sou apenas que geeky.
Bem, além de piadas, se você está realmente procurando uma regra de memória útil, há um que eu sempre uso para lembrar grandes números.
Você precisa quebrar o seu número em partes de 3-4 dígitos e recordá-los visualmente utilizando projeção no teclado do telefone celular. É mais fácil mostrar em uma imagem:
Como você pode ver, a partir de agora você só tem que lembrar de 3 formas, 2 deles parece um Tetris L e parece um carrapato . Que é definitivamente muito mais fácil do que memorizar um número de 10 dígitos.
Quando você precisa para recuperar o número apenas recordar as formas, imagine / olhada em um teclado de telefone e projetar as formas nele. Talvez, inicialmente, você vai ter que olhar para o teclado, mas depois de um pouco de prática, você vai se lembrar que os números vão de canto superior esquerdo para canto inferior direito, assim você será capaz de simplesmente imaginar isso na sua cabeça.
Apenas certifique-se de lembrar a direção de formas e o número de dígitos em cada forma (por exemplo, em 2147483647 exemplo, temos um 4 dígitos Tetris L e uma de 3 dígitos L).
Você pode usar esta técnica para se lembrar com facilidade quaisquer números importantes (por exemplo, eu lembrei do meu cartão de crédito número de 16 dígitos etc.).
A maneira mais fácil de fazer isso para inteiros é usar hexadecimal, desde que não existe algo como Int.maxInt (). A razão é esta:
Os valores não assinados Max
8-bit 0xFF
16-bit 0xFFFF
32-bit 0xFFFFFFFF
64-bit 0xFFFFFFFFFFFFFFFF
128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Os valores assinado, usando 7F como o valor assinado max
8-bit 0x7F
16-bit 0x7FFF
32-bit 0x7FFFFFFF
64-bit 0x7FFFFFFFFFFFFFFF
Os valores assinado, usando 80 como o valor assinado max
8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000
Como isso funciona? Isto é muito semelhante à tática binário, e cada dígito hexadecimal é exatamente 4 bits. Além disso, um monte de compiladores apoiar hex muito melhor do que eles suportam binário.
F hex to binary: 1111
8 hex to binary: 1000
7 hex to binary: 0111
0 hex to binary: 0000
Assim 7F é igual a 01111111 / 7FFF é igual a 0111111111111111. Além disso, se você estiver usando este para "insanamente de alta constante", 7F ... é hex seguro, mas é fácil o suficiente para experimentar 7F e 80 e apenas imprimi-los à sua tela para ver qual deles é.
0x7FFF + 0x0001 = 0x8000, por isso a sua perda é apenas um número, portanto, usando 0x7F ... geralmente não é um mau compromisso para o código mais confiável, especialmente uma vez que você começar a usar 32-bits ou mais
Primeiro gravação fora 47 duas vezes, (você gosta Agente 47 , certo?), mantendo os espaços imediata (cada traço representa uma ranhura para um único dígito. Primeiro 2 ranhuras, em seguida, 4)
--47----47
Pense que você tem 12 na mão (porque 12 = uma dúzia). Multiplicá-lo por 4, primeiro dígito do número Agent 47 de, ou seja, 47, e colocar o resultado à direita do primeiro par você já
12 * 4 = 48
--4748--47 <-- after placing 48 to the right of first 47
12 Então multiplique por 3 (a fim de fazer segundo dígito do número Agente 47 do, que é 7, você precisa 7 - 4 = 3) e colocar o resultado à direita dos primeiros 2 pares, o último par-slot
12 * 3 = 36
--47483647 <-- after placing 36 to the right of first two pairs
Finalmente arraste dígitos um a um da sua mão a partir de dígito mais à direita (2 neste caso) e colocá-los no primeiro slot vazio você começa
2-47483647 <-- after placing 2
2147483647 <-- after placing 1
Lá você tem! Para limite negativo, você pode pensar que como um mais em valor absoluto do que o limite positivo.
Pratique algumas vezes, e você obterá o jeito dele!
2GB
(existe um comprimento mínimo para respostas?)
A melhor regra para memorizá-lo é:
21 (número mágico!)
47 (basta lembrar-lo)
48 (seqüencial!)
36 (21 + 15, ambas as magias!)
47 novamente
Também é mais fácil de lembrar 5 pares de 10 dígitos.
Assumindo .NET -
Console.WriteLine(Int32.MaxValue);
Curiosamente, Int32.MaxValue tem mais caracteres que 2147486647.
Mas, novamente, temos a conclusão do código,
Então eu acho que todos nós realmente tem que memorizar é Int3<period>M<enter>, que fica a apenas 6 caracteres para digitar no estúdio visual.
Atualizar Por alguma razão eu estava downvoted. A única razão que eu posso pensar é que eles não entenderam a minha primeira declaração.
"Int32.MaxValue" leva, no máximo, 14 caracteres com o tipo. 2147486647 leva 10 ou 13 caracteres para digitar dependendo se você colocar as vírgulas ou não.
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;
}
Basta lembrar que 2 ^ (10 * x) é de aproximadamente 10 ^ (3 * x) - você provavelmente já está acostumado a isso com kilobytes / kibibytes etc. Ou seja:
2^10 = 1024 ~= one thousand
2^20 = 1024^2 = 1048576 ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion
Uma vez que um int usa 31 bits (+ ~ 1 bit para o sinal), apenas double 2 ^ 30 para obter aproximadamente 2 bilhões. Para um int não assinado usando 32 bits, dobrar novamente para 4 bilhões. O fator de erro fica maior quanto maior você vai, naturalmente, mas você não precisa o valor exato memorizado (Se você precisar, você deve estar usando uma constante pré-definido para ele de qualquer maneira). O valor aproximado é bom o suficiente para perceber quando algo pode ser um perigosamente perto de transbordar.
isto é como eu fazê-lo a lembrar 2147483647
Para um muito savana trimestre optimus trio quarenta hexed septenary
2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary
O que quer dizer? Deve ser fácil o suficiente para lembrar que é 2 ^ 32. Se você quer uma regra para memorizar o valor desse número, uma regra prática de ouro é para converter entre binário e decimal em geral:
2 ^ 10 ~ 1000
o que significa 2 ^ 20 ~ 1.000.000
e 2 ^ 30 ~ 1000000000
Double que (2 ^ 31) é rounghly 2 bilhões, e duplicando isso de novo (2 ^ 32) é de 4 bilhões.
É uma maneira fácil de obter uma estimativa aproximada de qualquer número binário. 10 zeros em binário torna-se 3 zeros em decimal.
Como físico Gostaria apenas redonda para 2 bilhões (semi-piada). Fácil de lembrar!
Em Objective-C (iOS e OSX), basta lembrar estas 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
