Non riesco mai a ricordare il numero. Ho bisogno di una regola di memoria.

Sono 2.147.483.647. Il modo più semplice per memorizzarlo è tramite un tatuaggio.

La risposta più corretta che mi viene in mente è Int32.MaxValue.

Se ritieni che il valore sia troppo difficile da ricordare nella base 10, prova la base 2: 1111111111111111111111111111111

se riesci a ricordare l'intero numero Pi, il numero che stai cercando è nella posizione 1.867.996.680 fino a 1.867.996.689 delle cifre decimali di Pi

La stringa numerica 2147483647 appare alla cifra decimale di 1.867.996.680. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

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

Sono 10 cifre, quindi fai finta che sia un numero di telefono (supponendo che tu sia negli Stati Uniti). 214-748-3647. Non consiglio di chiamarlo.

Invece di pensarlo come un unico numero, prova a scomporlo e cercare idee associate, ad esempio:

• 2 pause massimo per snooker (una pausa massima è 147)
• 4 anni (48 mesi)
• 3 anni (36 mesi)
• 4 anni (48 mesi)

Quanto sopra si applica al maggior numero negativo; positivo è quello meno.

Forse la ripartizione di cui sopra non sarà più memorabile per te (non è affatto eccitante!), Ma spero che tu possa trovare alcune idee che lo siano!

Valore negativo (32 bit) più grande: -2147483648
(1 << 31)

Valore positivo (32 bit) più grande: 2147483647
~ (1 << 31)

Mnemonico: "ubriaco AKA cornea"

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

Ad ogni modo, prendi questa regex (determina se la stringa contiene un numero intero non negativo in forma decimale che non è anche maggiore di 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]

Forse ti aiuterebbe a ricordare.

È così che mi sono ricordato 2147483647:

• 214 - perché 2.14 è approssimativamente pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Scrivi questi in orizzontale:

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

Ora hai 2147483647.

Spero che questo aiuti almeno un po '.

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

Quindi, 2 ^ 31 (int int max) è 2 ^ 30 (circa 1 miliardo) volte 2 ^ 1 (2), o circa 2 miliardi. E 2 ^ 32 è 2 ^ 30 * 2 ^ 2 o circa 4 miliardi. Questo metodo di approssimazione è abbastanza accurato fino a circa 2 ^ 64 (dove l'errore aumenta a circa il 15%).

Se hai bisogno di una risposta esatta, dovresti prendere una calcolatrice.

Pratiche approssimazioni di capacità allineate a parole:

• 2 ^ 16 ~ = 64 mila // uint16
• 2 ^ 32 ~ = 4 miliardi // uint32, IPv4, unixtime
• 2 ^ 64 ~ = 16 quintilioni (ovvero 16 miliardi di miliardi o 16 milioni di trilioni) // uint64, "bigint"
• 2 ^ 128 ~ = 256 quintilioni di quintilioni (ovvero 256 trilioni di trilioni di miliardi) // IPv6, GUID

Basta prendere una calcolatrice decente e digitare "7FFFFFFF" in modalità esadecimale, quindi passare al decimale.

2147483647.

Si tratta 2.1 * 10^9. Non c'è bisogno di sapere l'esatto 2^{31} - 1 = 2,147,483,647.

C

Puoi trovarlo in C in quel modo:

#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à (beh, senza il ,)

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

Giava

Puoi ottenerlo anche con Java:

System.out.println(Integer.MAX_VALUE);

Ma tieni presente che gli interi Java sono sempre firmati.

Python 2

Python ha numeri interi di precisione arbitraria. Ma in Python 2, sono mappati su numeri interi C. Quindi puoi farlo:

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

Quindi Python passa a longquando l'intero diventa più grande di2^31 -1

Ecco un mnemonico per ricordare 2 ** 31, sottrarre uno per ottenere il valore intero massimo.

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

Ho usato i poteri da due a 18 abbastanza spesso per ricordarli, ma anche non mi sono preoccupato di memorizzare 2 ** 31. È troppo facile calcolare secondo necessità o usare una costante o stimare come 2G.

32 bit, uno per il segno, 31 bit di informazioni:

2^31 - 1 = 2147483647

Perché -1?
Perché il primo è zero, quindi il più grande è il conteggio meno uno .

EDIT per cantfindaname88

Il conteggio è 2 ^ 31 ma il massimo non può essere 2147483648 (2 ^ 31) perché contiamo da 0, non 1.

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

Un'altra spiegazione con solo 3 bit: 1 per il segno, 2 per l'informazione

2^2 - 1 = 3

Di seguito tutti i possibili valori con 3 bit: (2 ^ 3 = 8 valori)

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

Bene, ha 32 bit e quindi può memorizzare 2 ^ 32 valori diversi. La metà di questi sono negativi.

La soluzione è 2.147.483.647

E il più basso è -2,147,483,648.

(Si noti che esiste un altro valore negativo.)

Bene, a parte le battute, se stai davvero cercando un'utile regola di memoria, ce n'è una che uso sempre per ricordare grandi numeri.

Devi scomporre il tuo numero in parti di 3-4 cifre e ricordarle visivamente usando la proiezione sulla tastiera del tuo cellulare. È più facile mostrare su un'immagine:

Come puoi vedere, d'ora in poi devi solo ricordare 3 forme, 2 di loro sembrano un Tetris L e uno sembra un segno di spunta . Che è sicuramente molto più facile che memorizzare un numero di 10 cifre.

Quando è necessario richiamare il numero, basta richiamare le forme, immaginare / guardare sulla tastiera di un telefono e proiettare le forme su di esso. Forse inizialmente dovrai guardare la tastiera, ma dopo solo un po 'di pratica, ricorderai che i numeri vanno da in alto a sinistra a in basso a destra in modo da poterlo semplicemente immaginare nella tua testa.

Assicurati solo di ricordare la direzione delle forme e il numero di cifre in ciascuna forma (ad esempio, nell'esempio 2147483647 abbiamo un Tetris L a 4 cifre e una L a 3 cifre).

Puoi usare questa tecnica per ricordare facilmente qualsiasi numero importante (ad esempio, ho ricordato il mio numero di carta di credito a 16 cifre ecc.).

Il modo più semplice per eseguire questa operazione per gli interi è utilizzare esadecimali, a condizione che non esista Int.maxInt (). Il motivo è questo:

Valori massimi non firmati

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

Valori firmati, utilizzando 7F come valore massimo firmato

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

Valori firmati, usando 80 come valore massimo firmato

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

Come funziona? Questo è molto simile alla tattica binaria e ogni cifra esadecimale è esattamente 4 bit. Inoltre, molti compilatori supportano hex molto meglio di quanto supportino binario.

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

Quindi 7F è uguale a 01111111 / 7FFF è uguale a 0111111111111111. Inoltre, se lo stai usando per "costante follemente alta", 7F ... è esadecimale sicuro, ma è abbastanza facile provare 7F e 80 e semplicemente stamparli sullo schermo per vedere quale è.

0x7FFF + 0x0001 = 0x8000, quindi la tua perdita è solo un numero, quindi usando 0x7F ... di solito non è un cattivo compromesso per un codice più affidabile, specialmente quando inizi a usare 32 bit o più

Prima scrivi 47 due volte (ti piace l' Agente 47 , giusto?), Mantenendo gli spazi come mostrato (ogni trattino è uno slot per una singola cifra. Prima 2 slot, quindi 4)

--47----47

Pensi di avere 12in mano (perché 12 = una dozzina). Moltiplicalo per 4, prima cifra del numero dell'Agente 47, cioè 47e posiziona il risultato a destra della prima coppia che hai già

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

Quindi moltiplica 12per 3(per creare la seconda cifra del numero dell'Agente 47, che è 7, è necessario 7 - 4 = 3) e metti il ​​risultato a destra delle prime 2 coppie, l'ultima coppia di slot

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

Infine trascina le cifre una ad una dalla tua mano iniziando dalla cifra più a destra (2 in questo caso) e posizionale nel primo slot vuoto che ottieni

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

Ecco qui! Per limite negativo, puoi considerarlo come 1 in più in valore assoluto rispetto al limite positivo.

Esercitati un paio di volte e te ne renderai conto!

2GB

(esiste una lunghezza minima per le risposte?)

Supponendo .NET -

Console.WriteLine(Int32.MaxValue);

Se ti capita di conoscere a memoria la tua tabella ASCII e non MaxInt:
!GH6G = 21 47 48 36 47

La migliore regola per memorizzarla è:
21 (numero magico!)
47 (ricordalo)
48 (sequenziale!)
36 (21 + 15, entrambi magici!)
47 di nuovo

Inoltre è più facile ricordare 5 coppie di 10 cifre.

Il modo più semplice da ricordare è guardare std::numeric_limits< int >::max()

Ad esempio ( da 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;
}

È interessante notare che Int32.MaxValue ha più caratteri di 2.147.486.647.

Ma poi di nuovo, abbiamo il completamento del codice,

Quindi suppongo che tutto ciò che dobbiamo davvero memorizzare è Int3<period>M<enter>, che è solo 6 personaggi da scrivere in Visual Studio.

AGGIORNAMENTO Per qualche motivo sono stato sottoposto a downgrade. L'unica ragione a cui riesco a pensare è che non hanno capito la mia prima affermazione.

"Int32.MaxValue" richiede al massimo 14 caratteri per digitare. 2.147.486.647 richiedono 10 o 13 caratteri per digitare a seconda che si inseriscano le virgole o meno.

Ricorda solo che 2 ^ (10 * x) è circa 10 ^ (3 * x) - probabilmente ti sei già abituato con kilobyte / kibibyte ecc. Cioè:

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

Poiché un int utilizza 31 bit (+ ~ 1 bit per il segno), basta raddoppiare 2 ^ 30 per ottenere circa 2 miliardi. Per un int senza segno che utilizza 32 bit, raddoppiare nuovamente per 4 miliardi. Il fattore di errore aumenta con il passare del tempo, ovviamente, ma non è necessario memorizzare il valore esatto (se ne hai bisogno, dovresti comunque utilizzare una costante predefinita). Il valore approssimativo è abbastanza buono da notare quando qualcosa potrebbe essere pericolosamente vicino allo straripamento.

questo è come lo faccio per ricordare 2.147.483.647

In un quarto di savana lontana, un trio di ottimus ha troncato quaranta settenari

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

Cosa intendi? Dovrebbe essere abbastanza facile ricordare che è 2 ^ 32. Se vuoi che una regola memorizzi il valore di quel numero, una pratica regola empirica è per la conversione tra binario e decimale in generale:

2 ^ 10 ~ 1000

il che significa 2 ^ 20 ~ 1.000.000

e 2 ^ 30 ~ 1.000.000.000

Raddoppia che (2 ^ 31) è approssimativamente 2 miliardi, e raddoppiando di nuovo (2 ^ 32) è 4 miliardi.

È un modo semplice per ottenere una stima approssimativa di qualsiasi numero binario. 10 zeri in binario diventano 3 zeri in decimale.

In Objective-C (iOS e OSX), ricorda solo queste macro:

#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 che hai 32 bit disponibili per memorizzare il tuo numero. Il bit più alto è il bit di segno, questo indica se il numero è positivo o negativo. Quindi hai 2 ^ 31 bit per i numeri positivi e negativi.

Con zero che è un numero positivo si ottiene l'intervallo logico di (menzionato prima)

Da +2147483647 a -2147483648

Se pensi che sia troppo piccolo, usa Int64:

Da +9223372036854775807 a -9223372036854775808

E perché diavolo vuoi ricordare questo numero? Da usare nel tuo codice? Dovresti sempre usare Int32.MaxValue o Int32.MinValue nel tuo codice poiché questi sono valori statici (all'interno del core .net) e quindi più veloci nell'uso rispetto alla creazione di un nuovo int con codice.

La mia affermazione: se conosci questo numero dalla memoria .. ti stai solo mettendo in mostra!

Ricorda questo: 21 IQ ITEM 47

Può essere decodificato con qualsiasi pad del telefono, oppure puoi semplicemente scriverne uno da solo su un foglio.

Per ricordare "21 IQ ITEM 47", andrei con "Hitman: il nome in codice 47 aveva 21 missioni, che erano ciascuna delle voci del QI da sole".

Oppure "Pulisco i denti ogni giorno alle 21:47, perché ho un QI elevato e non mi piacciono gli oggetti in bocca".