¿Cuál es el valor máximo para un int32?

Question

Nunca puedo recordar el número.Necesito una regla de memoria.

Answer 1

Son 2.147.483.647.La forma más sencilla de memorizarlo es mediante un tatuaje.

Answer 2

La respuesta más correcta que se me ocurre es Int32.MaxValue.

Answer 3

Si cree que el valor es demasiado difícil de recordar en base 10, pruebe con la base 2:1111111111111111111111111111111

Answer 4

Si puedes recordar el número Pi completo, entonces el número que estás buscando está en la posición 1.867.996.680 hasta 1.867.996.689 de los dígitos decimales de Pi.

La cadena numérica 2147483647 aparece en el dígito decimal 1.867.996.680 de Pi.3.14......86181221809936452346214748364710527835665425671614...

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

Answer 5

Son 10 dígitos, así que imagina que es un número de teléfono (suponiendo que estés en los EE. UU.).214-748-3647.No recomiendo llamarlo.

Answer 6

En lugar de pensar en ello como un número grande, intenta desglosarlo y buscar ideas asociadas, por ejemplo:

• 2 descansos máximos de billar (un descanso máximo es 147)
• 4 años (48 meses)
• 3 años (36 meses)
• 4 años (48 meses)

Lo anterior se aplica al mayor número negativo;Lo positivo es que menos uno.

Tal vez el desglose anterior ya no sea memorable para usted (¡no es nada emocionante, verdad!), pero espero que se le ocurran algunas ideas que sí lo sean.

Answer 7

Valor negativo más grande (32 bits):-2147483648
(1 << 31)

Valor positivo más grande (32 bits):2147483647
~(1 << 31)

Mnemotécnico:"borracho también conocido como cachondo"

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

Answer 8

De todos modos, tome esta expresión regular (determina si la cadena contiene un número entero no negativo en forma decimal que tampoco sea mayor 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]

Tal vez te ayude a recordar.

Answer 9

Así es como lo recordé 2147483647:

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

Escribe estos horizontalmente:

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

Ahora tienes 2147483647.

Espero que esto ayude al menos un poco.

Answer 10

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

Entonces, 2^31 (int max con signo) es 2^30 (aproximadamente mil millones) por 2^1 (2), o aproximadamente 2 mil millones.Y 2^32 es 2^30 * 2^2 o alrededor de 4 mil millones.Este método de aproximación es lo suficientemente preciso incluso hasta alrededor de 2^64 (donde el error crece hasta aproximadamente el 15%).

Si necesita una respuesta exacta, debe utilizar una calculadora.

Prácticas aproximaciones de capacidad alineadas con palabras:

• 2^16 ~= 64 mil // uint16
• 2^32 ~= 4 mil millones // uint32, IPv4, unixtime
• 2^64 ~= 16 quintillones (también conocido como 16 mil millones de billones o 16 millones de billones) // uint64, "bigint"
• 2^128 ~= 256 quintillones de quintillones (también conocidos como 256 billones de billones de billones) // IPv6, GUID

Answer 11

Simplemente tome cualquier calculadora decente y escriba "7FFFFFFF" en modo hexadecimal, luego cambie a decimal.

2147483647.

Answer 12

Se trata de 2.1 * 10^9.No es necesario saber exactamente 2^{31} - 1 = 2,147,483,647.

C

Puedes encontrarlo en C así:

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

da (bueno, sin el ,)

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

También puedes obtener esto con Java:

System.out.println(Integer.MAX_VALUE);

Pero tenga en cuenta que los enteros de Java siempre están firmados.

Pitón 2

Python tiene números enteros de precisión arbitraria.Pero en Python 2, se asignan a números enteros de C.Entonces puedes hacer esto:

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

Entonces Python cambia a long cuando el número entero es mayor que 2^31 -1

Answer 13

Aquí hay un mnemotécnico para recordar 2**31, resta uno para obtener el valor entero 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

He usado los poderes de dos hasta 18 con suficiente frecuencia como para recordarlos, pero ni siquiera yo me he molestado en memorizar 2**31.Es demasiado fácil calcular según sea necesario, utilizar una constante o estimar como 2G.

Answer 14

32 bits, uno para el signo, 31 bits de información:

2^31 - 1 = 2147483647

¿Por qué -1?
Como el primero es cero, el mayor es el contar menos uno.

EDITAR para cantfindaname88

El recuento es 2^31 pero el mayor no puede ser 2147483648 (2^31) porque contamos desde 0, no desde 1.

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

Otra explicación con sólo 3 bits:1 para la señal, 2 para la información

2^2 - 1 = 3

A continuación todos los valores posibles con 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

Answer 15

Bueno, tiene 32 bits y, por tanto, puede almacenar 2^32 valores diferentes.La mitad de ellos son negativos.

La solución es 2.147.483.647

Y el más bajo es −2.147.483.648.

(Observe que hay un valor negativo más).

Answer 16

En este punto, diría que la mnemónica más sencilla es escribir "stackoverflow.com". PESTAÑA "máximo int32" en Chrome.

Hay una recursión -> broma de desbordamiento de pila en alguna parte.Simplemente no soy tan geek.

Answer 17

Bueno, aparte de las bromas, si realmente buscas una regla de memoria útil, hay una que siempre uso para recordar números grandes.

Debe dividir su número en partes de 3 a 4 dígitos y recordarlos visualmente mediante la proyección en el teclado de su teléfono celular.Es más fácil mostrarlo en una imagen:

Como puedes ver, a partir de ahora solo tienes que recordar 3 formas, 2 de ellas parecen un Tetris L y una parece una garrapata.Definitivamente es mucho más fácil que memorizar un número de 10 dígitos.

Cuando necesite recordar el número, simplemente recuerde las formas, imagine/mire el teclado de un teléfono y proyecte las formas en él.Quizás inicialmente tengas que mirar el teclado, pero después de un poco de práctica, recordarás que los números van de arriba a la izquierda a abajo a la derecha, por lo que podrás simplemente imaginártelo en tu cabeza.

Solo asegúrate de recordar la dirección de las formas y el número de dígitos en cada forma (por ejemplo, en el ejemplo 2147483647 tenemos un Tetris L de 4 dígitos y un L de 3 dígitos).

Puede utilizar esta técnica para recordar fácilmente cualquier número importante (por ejemplo, recordé el número de mi tarjeta de crédito de 16 dígitos, etc.).

Answer 18

La forma más sencilla de hacer esto para números enteros es usar hexadecimal, siempre que no exista algo como Int.maxInt().La razón es esta:

Valores máximos sin signo

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

Valores con signo, utilizando 7F como valor máximo con signo

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

Valores con signo, utilizando 80 como valor máximo con signo

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

¿Cómo funciona esto?Esto es muy similar a la táctica binaria, y cada dígito hexadecimal tiene exactamente 4 bits.Además, muchos compiladores admiten hexadecimal mucho mejor que binario.

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

Entonces 7F es igual a 01111111 / 7FFF es igual a 0111111111111111.Además, si estás usando esto para una "constante increíblemente alta", 7F...es hexadecimal seguro, pero es bastante fácil probar 7F y 80 e imprimirlos en la pantalla para ver cuál es.

0x7FFF + 0x0001 = 0x8000, por lo que su pérdida es solo un número, por lo que usando 0x7F...Por lo general, no es una mala compensación por un código más confiable, especialmente una vez que comienzas a usar 32 bits o más.

Answer 19

Primero escribe 47 dos veces (te gusta Agente 47, ¿verdad?), manteniendo los espacios como se muestra (cada guión es un espacio para un solo dígito).Primeros 2 espacios, luego 4)

--47----47

creo que tienes 12 en mano (porque 12 = una docena).Multiplicalo por 4, primer dígito del número del Agente 47, es decir 47, y coloca el resultado a la derecha del primer par que ya tienes

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

Luego multiplica 12 por 3 (para hacer el segundo dígito del número del Agente 47, que es 7, necesitas 7 - 4 = 3) y coloque el resultado a la derecha de los primeros 2 pares, el último par-espacio

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

Finalmente, arrastre los dígitos uno por uno desde su mano comenzando desde el dígito más a la derecha (2 en este caso) y colóquelos en el primer espacio vacío que obtenga.

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

¡Ahí tienes!Para el límite negativo, puedes considerarlo como 1 más en valor absoluto que el límite positivo.

¡Practica unas cuantas veces y lo dominarás!

Answer 20

2GB

(¿Existe una longitud mínima para las respuestas?)

Answer 21

Si por casualidad conoces tu tabla ASCII de memoria y no MaxInt :
!GH6G = 21 47 48 36 47

Answer 22

La mejor regla para memorizarlo es:
21 (¡número mágico!)
47 (solo recuérdalo)
48 (¡secuencial!)
36 (21 + 15, ¡ambas magias!)
47 de nuevo

Además, es más fácil recordar 5 pares que 10 dígitos.

Answer 23

Suponiendo .NET -

Console.WriteLine(Int32.MaxValue);

Answer 24

Curiosamente, Int32.MaxValue tiene más caracteres que 2.147.486.647.

Pero, de nuevo, tenemos finalización de código,

Así que supongo que todo lo que realmente tenemos que memorizar es Int3<period>M<enter>, que son solo 6 caracteres para escribir en Visual Studio.

ACTUALIZARPor alguna razón me rechazaron.La única razón que se me ocurre es que no entendieron mi primera afirmación.

"Int32.MaxValue" requiere como máximo 14 caracteres para escribir.2,147,486,647 requiere 10 o 13 caracteres para escribir dependiendo de si colocas comas o no.

Answer 25

La forma más fácil de recordar es mirar std::numeric_limits< int >::max()

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

Answer 26

Solo recuerda que 2^(10*x) es aproximadamente 10^(3*x); probablemente ya estés acostumbrado a esto con kilobytes/kibibytes, etc.Eso es:

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

Dado que un int usa 31 bits (+ ~1 bit para el signo), simplemente duplique 2^30 para obtener aproximadamente 2 mil millones.Para un int sin signo que utiliza 32 bits, duplique nuevamente para obtener 4 mil millones.El factor de error aumenta a medida que aumenta, por supuesto, pero no necesita memorizar el valor exacto (si lo necesita, debe usar una constante predefinida de todos modos).El valor aproximado es lo suficientemente bueno para notar cuando algo podría estar peligrosamente cerca de desbordarse.

Answer 27

así lo hago para recordar 2,147,483,647

A un lejano barrio de la sabana, el trío optimus hechizado cuarenta septenario

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

Answer 28

¿Qué quieres decir?Debería ser bastante fácil recordar que es 2^32.Si desea una regla para memorizar el valor de ese número, una regla práctica es la de convertir entre binario y decimal en general:

2^10 ~ 1000

lo que significa 2^20 ~ 1.000.000

y 2^30 ~ 1.000.000.000

Duplicar eso (2^31) es aproximadamente 2 mil millones, y duplicarlo nuevamente (2^32) es 4 mil millones.

Es una forma sencilla de obtener una estimación aproximada de cualquier número binario.10 ceros en binario se convierten en 3 ceros en decimal.

Answer 29

Como físico, simplemente redondearía a 2 billones (semi-broma).¡Fácil de recordar!

Answer 30

En Objective-C (iOS y OSX), sólo recuerda 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