valor maximo integer

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



int32 max value (30)

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

¿Qué quieres decir? Debe ser fácil recordar que es 2 ^ 32. Si desea que una regla memorice el valor de ese número, una regla práctica es la conversión entre binario y decimal en general:

2 ^ 10 ~ 1000

lo que significa 2 ^ 20 ~ 1,000,000

y 2 ^ 30 ~ 1,000,000,000

El doble de eso (2 ^ 31) es apenas 2 billones, y duplicarlo nuevamente (2 ^ 32) es de 4 billones.

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

2GB

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

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

2^31 - 1 = 2147483647

¿Por qué -1?
Porque el primero es cero, entonces el mayor es el conteo menos uno .

EDITAR para cantfindaname88

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

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

Otra explicación con solo 3 bits: 1 para el signo, 2 para la información.

2^2 - 1 = 3

Debajo de 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

Aquí hay un mnemónico para recordar 2 ** 31, reste 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 la frecuencia suficiente para recordarlos, pero incluso no me he molestado en memorizar 2 ** 31. Es demasiado fácil calcular según sea necesario o usar una constante, o estimar como 2G.

Así es como lo hago para recordar 2.147.483.647.

A un cuarto de la sabana lejana, el trío del optimus hexágono cuarenta septenarios

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

Así es como me acordé de 2147483647 :

  • 214 - porque 2.14 es aproximadamente pi-1
  • 48 = 6 * 8
  • 64 = 8 * 8

Escribe esto 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.

Asumiendo .NET -

Console.WriteLine(Int32.MaxValue);

Bueno, tiene 32 bits y por lo 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.

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

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 solo tiene 6 caracteres para escribir en Visual Studio.

ACTUALIZACIÓN Por alguna razón fui votado. La única razón por la que puedo pensar es que no entendieron mi primera afirmación.

"Int32.MaxValue" toma como máximo 14 caracteres para escribir. 2.147.486.647 toma 10 o 13 caracteres para escribir, dependiendo de si colocas las comas o no.

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

En este punto, diría que el mnemotécnico más sencillo es escribir ".com" TAB "maximum int32" en Chrome.

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

En lugar de considerarlo como un gran número, intente descomponerlo y buscar ideas asociadas, por ejemplo:

  • 2 descansos máximos para snooker (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; positivo es que menos uno.

Tal vez el desglose anterior no sea más memorable para usted (¡no es emocionante!), ¡Pero espero que pueda aportar algunas ideas que sean!

Es 2,147,483,647. La forma más fácil de memorizarlo es a través de un tatuaje.

Int32 significa que tiene 32 bits disponibles para almacenar su número. El bit más alto es el bit de signo, esto indica si el número es positivo o negativo. Entonces tienes 2 ^ 31 bits para números positivos y negativos.

Con cero siendo un número positivo, obtienes el rango lógico de (mencionado anteriormente)

+2147483647 a -2147483648

Si crees que es demasiado pequeño, usa Int64:

+9223372036854775807 a -9223372036854775808

¿Y por qué demonios quieres recordar este número? ¿Para usar en tu código? Siempre debe usar Int32.MaxValue o Int32.MinValue en su código, ya que estos son valores estáticos (dentro del núcleo .net) y, por lo tanto, de uso más rápido que la creación de un nuevo int con código.

Mi declaración: si conoces este número de memoria ... ¡solo estás alardeando!

La forma más fácil de hacer esto para los enteros es usar hexadecimal, siempre que no haya algo como Int.maxInt (). La razón es esta:

Valores máximos sin firmar

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

Valores firmados, usando 7F como el valor máximo firmado

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

Valores firmados, usando 80 como el valor máximo firmado

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

¿Como funciona esto? Esto es muy similar a la táctica binaria, y cada dígito hexadecimal es exactamente 4 bits. Además, muchos compiladores soportan mucho mejor el hexágono que el binario.

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

Por lo tanto, 7F es igual a 01111111 / 7FFF es igual a 0111111111111111. Además, si está usando esto para "constante extremadamente alta", 7F ... es un hexágono seguro, pero es bastante fácil probar 7F y 80 y simplemente imprimirlos A tu pantalla para ver cuál es.

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

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

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

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

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

Mnemónico: "borracho, también córneo"

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

Primero escribe 47 dos veces (te gusta el Agente 47 , ¿no?), Manteniendo los espacios como se muestra (cada guión es una ranura para un solo dígito. Primero 2 ranuras, luego 4)

--47----47

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

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 coloca el resultado a la derecha de los primeros 2 pares, el último par de casillas

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

Finalmente, arrastre los dígitos uno a uno desde su mano comenzando desde el dígito que se encuentra más a la derecha (2 en este caso) y colóquelos en la primera ranura vacía que obtiene

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

¡Ahí tienes! Para el límite negativo, puede pensar que hay 1 más en valor absoluto que el límite positivo.

¡Practica unas cuantas veces, y te dominarás!

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

do

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.

Python 2

Python tiene enteros de precisión arbitraria. Pero en Python 2, se asignan a C enteros. Así que puedes hacer esto:

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

Entonces, Python cambia a long cuando el número entero crece más que 2^31 -1

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

Si por casualidad usted sabe de memoria su tabla ASCII y no MaxInt :
!GH6G = 21 47 48 36 47

Si puede recordar el número completo de Pi, entonces el número que está 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 ...... 86181221809936452346 2147483647 10527835665425671614 ...

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

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

2147483647.

Solo recuerde que 2 ^ (10 * x) es aproximadamente 10 ^ (3 * x) - probablemente ya esté 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

Como un int usa 31 bits (+ ~ 1 bit para el signo), solo duplica 2 ^ 30 para obtener aproximadamente 2 mil millones. Para un int sin signo que usa 32 bits, doble nuevamente para 4 billones. Por supuesto, el factor de error aumenta cuanto mayor sea, pero no necesita memorizar el valor exacto (si lo necesita, debería utilizar una constante predefinida para ello de todos modos). El valor aproximado es lo suficientemente bueno para darse cuenta de que algo podría estar peligrosamente cerca de desbordarse.

Tiene 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.

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

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

Como puedes ver, de ahora en adelante solo debes recordar 3 formas, 2 de ellas parecen un Tetris L y una parece una garrapata . Lo que 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 en el teclado de un teléfono y proyecte las formas en él. Tal vez al principio tengas que mirar el teclado, pero después de un poco de práctica, recordarás que los números van de arriba a abajo a la derecha, por lo que simplemente podrás imaginarlo en tu cabeza.

Solo asegúrese 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 usar 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.).

En Objective-C (iOS y OSX), recuerde 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

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

También es más fácil recordar 5 pares que 10 dígitos.

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 (con signo int max) es 2 ^ 30 (aproximadamente 1 billón) por 2 ^ 1 (2), o aproximadamente 2 billón. Y 2 ^ 32 es 2 ^ 30 * 2 ^ 2 o unos 4 billones. Este método de aproximación es lo suficientemente exacto hasta aproximadamente 2 ^ 64 (donde el error aumenta hasta aproximadamente el 15%).

Si necesita una respuesta exacta, debe sacar 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 (alias 16 billones o 16 millones de billones) // uint64, "bigint"
  • 2 ^ 128 ~ = 256 quintillones de quintillones (alias 256 trillones de billones de billones) // IPv6, GUID