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

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

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

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

si puede recordar todo el número 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/

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.

En lugar de pensarlo como un gran número, intente 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; positivo es eso menos uno.

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

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

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

Mnemónico: "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

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 ayudaría a recordar.

Así recordaba 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.

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

Si necesita una respuesta exacta, debe extraer 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 conocidos como 16 billones de billones o 16 millones de billones) // uint64, "bigint"
• 2 ^ 128 ~ = 256 quintillion quintillion (también conocido como 256 billones de billones de billones) // IPv6, GUID

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

2147483647.

Se trata 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 puede obtener esto con Java:

System.out.println(Integer.MAX_VALUE);

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

Python 2

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

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

Entonces Python cambia a longcuando el número entero se hace más grande que2^31 -1

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 la suficiente frecuencia como para recordarlos, pero ni siquiera me he molestado en memorizar 2 ** 31. Es demasiado fácil calcular según sea necesario o usar una constante, o estimar como 2G.

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 recuento 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 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

Bueno, tiene 32 bits y, por lo tanto, puede almacenar 2 ^ 32 valores diferentes. La mitad de esos 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).

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

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

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

Cuando necesite recuperar el número, solo recuerde las formas, imagine / mire en el teclado de un teléfono y proyecte las formas en él. Quizás inicialmente tenga que mirar el teclado, pero después de un poco de práctica, recordará que los números van de arriba a la izquierda a abajo a la derecha, por lo que simplemente podrá imaginarlo en su 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é mi número de tarjeta de crédito de 16 dígitos, etc.).

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:

Max valores sin signo

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

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

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

Valores firmados, utilizando 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 tiene exactamente 4 bits. Además, muchos compiladores admiten hexadecimal mucho mejor de lo que admiten binarios.

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á usando esto para "constante increíblemente alta", 7F ... es un hexadecimal seguro, pero es bastante fácil probar 7F y 80 e 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 ... generalmente no es una mala compensación para un código más confiable, especialmente una vez que comience a usar 32 bits o más

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

--47----47

Piensa que tienes 12en la mano (porque 12 = una docena). Multiplique por el 4primer 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 multiplique 12por 3(para hacer el segundo dígito del número del Agente 47, que es 7, usted necesita 7 - 4 = 3) y coloque el resultado a la derecha de los primeros 2 pares, el último par de ranuras

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, puede pensar en eso como 1 más en valor absoluto que el límite positivo.

Practica algunas veces, ¡y te acostumbrarás!

2GB

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

Suponiendo .NET -

Console.WriteLine(Int32.MaxValue);

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

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

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

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

Curiosamente, Int32.MaxValue tiene más caracteres que 2,147,486,647.

Pero, de nuevo, tenemos la finalización del 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.

ACTUALIZACIÓN Por alguna razón fui rechazado. La única razón por la que puedo pensar es que no entendieron mi primera declaració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 pone las comas o no.

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 firmar con 32 bits, doble nuevamente por 4 mil millones. El factor de error aumenta cuanto más grande va, por supuesto, pero no necesita memorizar el valor exacto (si lo necesita, debería estar utilizando una constante predefinida para ello de todos modos). El valor aproximado es lo suficientemente bueno como para notar cuándo algo podría estar peligrosamente cerca de desbordarse.

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

A un cuarto de la sabana lejana, Optimus Trio hechizó cuarenta septenarios

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

¿Qué quieres decir? Debería ser bastante fácil recordar que es 2 ^ 32. Si desea que una regla memorice el valor de ese número, una práctica regla práctica es 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 duplicar eso nuevamente (2 ^ 32) es 4 mil millones.

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

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

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 su 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, su uso es más rápido que la creación de un nuevo int con código.

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

Recuerda esto: 21 IQ ITEM 47

Se puede descodificar con cualquier teclado telefónico, o simplemente puede escribir uno usted mismo en un papel.

Para recordar "21 IQ ITEM 47", iría con "Hitman: Codename 47 tenía 21 misiones, que eran cada IQ ITEM por sí mismas".

O "me lavo los dientes a las 21:47 todos los días, porque tengo un coeficiente intelectual alto y no me gustan los artículos en la boca".