Nigdy nie pamiętam numeru. Potrzebuję reguły pamięci.

Ma 2 147 483 647. Najłatwiejszym sposobem na zapamiętanie tego jest tatuaż.

Najbardziej poprawną odpowiedzią, jaką mogę wymyślić, jest Int32.MaxValue.

Jeśli uważasz, że wartość jest zbyt trudna do zapamiętania w bazie 10, wypróbuj bazę 2: 1111111111111111111111111111111

jeśli pamiętasz cały numer Pi, to liczba, której szukasz, znajduje się w pozycji 1 867 996 680 do 1 867 996 689 cyfr dziesiętnych Pi

Ciąg liczbowy 2147483647 pojawia się na 1 867 996 680 cyfrach dziesiętnych liczby Pi. 3,14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

źródło: http://www.subidiom.com/pi/

To 10 cyfr, więc udawaj, że to numer telefonu (zakładając, że jesteś w USA). 214–748–3647. Nie polecam tego nazywać.

Zamiast myśleć o tym jak o jednej dużej liczbie, spróbuj go rozbić i poszukaj powiązanych pomysłów, np .:

• 2 maksymalne przerwy w snookerze (maksymalna przerwa to 147)
• 4 lata (48 miesięcy)
• 3 lata (36 miesięcy)
• 4 lata (48 miesięcy)

Powyższe dotyczy największej liczby ujemnej; pozytywne jest to, że minus jeden.

Być może powyższy podział nie będzie już dla ciebie niezapomniany (to nie jest ekscytujące!), Ale mam nadzieję, że uda Ci się wymyślić kilka pomysłów, które są!

Największa wartość ujemna (32 bity): -2147483648
(1 << 31)

Największa wartość dodatnia (32 bity): 2147483647
~ (1 << 31)

Mnemonik: „pijany AKA napalony”

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

W każdym razie weź to wyrażenie regularne (określa, czy ciąg zawiera nieujemną liczbę całkowitą w postaci dziesiętnej, która również nie jest większa niż 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]

Może pomoże ci to zapamiętać.

Tak zapamiętałem 2147483647:

• 214 - ponieważ 2,14 to w przybliżeniu pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Napisz je poziomo:

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

Teraz masz 2147483647.

Mam nadzieję, że to pomoże choć trochę.

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

Zatem 2 ^ 31 (podpisane int max) to 2 ^ 30 (około 1 miliard) razy 2 ^ 1 (2) lub około 2 miliardów. A 2 ^ 32 to 2 ^ 30 * 2 ^ 2 lub około 4 miliardów. Ta metoda aproksymacji jest wystarczająco dokładna nawet do około 2 ^ 64 (gdzie błąd rośnie do około 15%).

Jeśli potrzebujesz dokładnej odpowiedzi, powinieneś pobrać kalkulator.

Przydatne przybliżone pojemności dostosowane do słów:

• 2 ^ 16 ~ = 64 tysiące // uint16
• 2 ^ 32 ~ = 4 miliardy // uint32, IPv4, unixtime
• 2 ^ 64 ~ = 16 kwintylionów (czyli 16 miliardów lub 16 milionów bilionów) // uint64, „bigint”
• 2 ^ 128 ~ = 256 kwintillionów kwintillionów (czyli 256 trylionów bilionów bilionów) // IPv6, GUID

Wystarczy wziąć dowolny kalkulator i wpisać „7FFFFFFF” w trybie szesnastkowym, a następnie przełączyć na tryb dziesiętny.

2147483647.

Chodzi o to 2.1 * 10^9. Nie musisz dokładnie znać2^{31} - 1 = 2,147,483,647 .

do

Możesz go znaleźć w C w ten sposób:

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

daje (no bez ,)

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

Jawa

Możesz to również uzyskać w Javie:

System.out.println(Integer.MAX_VALUE);

Pamiętaj jednak, że liczby całkowite Java są zawsze podpisane.

Python 2

Python ma dowolne liczby całkowite precyzji. Ale w Pythonie 2 są one mapowane na liczby całkowite C. Możesz to zrobić:

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

Python przełącza się longwtedy, gdy liczba całkowita staje się większa niż2^31 -1

Oto mnemonik do zapamiętywania 2 ** 31, odejmij jeden, aby uzyskać maksymalną wartość całkowitą.

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

Używałem mocy dwóch do 18 osób wystarczająco często, aby je zapamiętać, ale nawet nie zawracałem sobie głowy zapamiętywaniem 2 ** 31. Zbyt łatwo jest obliczyć w razie potrzeby lub użyć stałej lub oszacować jako 2G.

32 bity, jeden na znak, 31 bitów informacji:

2^31 - 1 = 2147483647

Dlaczego -1?
Ponieważ pierwszy wynosi zero, więc największa jest liczba minus jeden .

EDYCJA dla cantfindaname88

Liczba wynosi 2 ^ 31, ale największa nie może być 2147483648 (2 ^ 31), ponieważ liczymy od 0, a nie 1.

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

Kolejne wyjaśnienie zawierające tylko 3 bity: 1 dla znaku, 2 dla informacji

2^2 - 1 = 3

Poniżej wszystkich możliwych wartości z 3 bitami: (2 ^ 3 = 8 wartości)

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

Cóż, ma 32 bity, a zatem może przechowywać 2 ^ 32 różnych wartości. Połowa z nich jest negatywna.

Rozwiązaniem jest 2 147 483 647

A najniższy to -2 147 147 483 648.

(Zauważ, że jest jeszcze jedna wartość ujemna).

Cóż, oprócz żartów, jeśli naprawdę szukasz użytecznej reguły pamięci, jest taka, której zawsze używam do zapamiętywania dużych liczb.

Musisz podzielić swój numer na części z 3-4 cyfr i zapamiętać je wizualnie za pomocą projekcji na klawiaturze telefonu komórkowego. Łatwiej jest pokazać na zdjęciu:

Jak widać, odtąd musisz pamiętać tylko 3 kształty, 2 z nich wyglądają jak Tetris L, a jeden przypomina tyknięcie . Co jest zdecydowanie łatwiejsze niż zapamiętanie 10-cyfrowej liczby.

Kiedy potrzebujesz przywołać liczbę, po prostu przywołaj kształty, wyobraź sobie / spójrz na klawiaturę telefonu i wyświetl kształty na niej. Być może początkowo będziesz musiał spojrzeć na klawiaturę, ale po odrobinie praktyki pamiętasz, że liczby zmieniają się od lewej do prawej, a więc od prawej do prawej, więc będziesz mógł sobie to wyobrazić.

Upewnij się tylko, że pamiętasz kierunek kształtów i liczbę cyfr w każdym kształcie (na przykład w przykładzie 2147483647 mamy 4-cyfrowy Tetris L i 3-cyfrowy L).

Możesz użyć tej techniki do łatwego zapamiętania ważnych liczb (na przykład zapamiętałem mój 16-cyfrowy numer karty kredytowej itp.).

Najłatwiejszym sposobem na zrobienie tego dla liczb całkowitych jest użycie wartości szesnastkowej, pod warunkiem, że nie ma czegoś takiego jak Int.maxInt (). Powód jest następujący:

Maksymalna wartość bez znaku

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

Podpisane wartości, używając 7F jako maksymalnej wartości podpisanej

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

Podpisane wartości, przy użyciu 80 jako maksymalnej podpisanej wartości

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

Jak to działa? Jest to bardzo podobne do taktyki binarnej, a każda cyfra szesnastkowa ma dokładnie 4 bity. Ponadto wiele kompilatorów obsługuje hex znacznie lepiej niż obsługuje pliki binarne.

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

Więc 7F jest równy 01111111 / 7FFF jest równy 0111111111111111. Ponadto, jeśli używasz tego dla „niesamowicie wysokiej stałej”, 7F ... jest bezpiecznym hexem, ale łatwo wypróbować 7F i 80 i po prostu je wydrukować na ekranie, aby zobaczyć, który to jest.

0x7FFF + 0x0001 = 0x8000, więc twoja strata to tylko jedna liczba, więc użycie 0x7F ... zwykle nie jest złym kompromisem dla bardziej niezawodnego kodu, szczególnie gdy zaczniesz używać 32-bitów lub więcej

Najpierw napisz 47 dwukrotnie (lubisz Agenta 47 , prawda?), Zachowując spacje jak pokazano (każda kreska to miejsce na jedną cyfrę. Najpierw 2 miejsca, potem 4)

--47----47

Myślę, że masz 12pod ręką (bo 12 = tuzin). Pomnóż go przez 4pierwszą cyfrę numeru Agenta 47, tj. 47I umieść wynik po prawej stronie pierwszej pary, którą już masz

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

Następnie pomnóż 12przez 3(aby utworzyć drugą cyfrę numeru Agenta 47, czyli 7potrzebujesz 7 - 4 = 3) i umieść wynik na prawo od pierwszych 2 par, ostatniego miejsca na parę

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

Na koniec przeciągnij cyfry jeden po drugim, zaczynając od cyfry najbardziej po prawej (w tym przypadku 2) i umieść je w pierwszym pustym polu, który otrzymasz

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

Masz to! W przypadku limitu ujemnego można uznać to za 1 wartość bezwzględną więcej niż limit dodatni.

Poćwicz kilka razy, a zrozumiesz!

2 GB

(czy istnieje minimalna długość odpowiedzi?)

Zakładając .NET -

Console.WriteLine(Int32.MaxValue);

Jeśli zdarzy ci się, że znasz tablicę ASCII na pamięć, a nie MaxInt:
!GH6G = 21 47 48 36 47

Najlepszą zasadą do zapamiętania jest:
21 (magiczna liczba!)
47 (pamiętaj tylko)
48 (sekwencyjne!)
36 (21 + 15, obie magie!)
47 ponownie

Łatwiej jest również zapamiętać 5 par niż 10 cyfr.

Najłatwiejszym sposobem na zapamiętanie jest spojrzenie std::numeric_limits< int >::max()

Na przykład ( z 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;
}

Co ciekawe, Int32.MaxValue ma więcej znaków niż 2 147 486 647.

Ale z drugiej strony mamy uzupełnianie kodu,

Więc chyba wszystko, co naprawdę musimy zapamiętać, to Int3<period>M<enter> , to tylko 6 znaków do wpisania w studio wizualnym.

AKTUALIZACJA Z jakiegoś powodu zostałem odrzucony. Jedynym powodem, dla którego mogę wymyślić, jest to, że nie zrozumieli mojego pierwszego stwierdzenia.

„Int32.MaxValue” wymaga co najwyżej 14 znaków. 2 147 486 647 wymaga wpisania 10 lub 13 znaków, w zależności od tego, czy wstawisz przecinki, czy nie.

Pamiętaj tylko, że 2 ^ (10 * x) to około 10 ^ (3 * x) - prawdopodobnie już jesteś przyzwyczajony do tego z kilobajtami / kibibajtami itp. To znaczy:

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

Ponieważ int używa 31 bitów (+ ~ 1 bit na znak), wystarczy podwoić 2 ^ 30, aby uzyskać około 2 miliardów. W przypadku znaku bez znaku używającego 32 bitów ponownie dwukrotnie dla 4 miliardów. Współczynnik błędu rośnie wraz ze wzrostem, oczywiście, ale nie potrzebujesz zapamiętanej dokładnej wartości (jeśli jej potrzebujesz, i tak powinieneś użyć wcześniej zdefiniowanej stałej). Przybliżona wartość jest wystarczająca do zauważenia, kiedy coś może być niebezpiecznie bliskie przepełnienia.

tak właśnie robię, aby zapamiętać 2 147 483 647

Do odległego trio sawanny ćwierćwiecznika trio przeklęło czterdzieści Sepptenary

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

Co masz na myśli? Należy pamiętać, że jest to 2 ^ 32. Jeśli chcesz, aby reguła zapamiętywała wartość tej liczby, przydatna jest praktyczna reguła do konwersji między cyframi binarnymi i dziesiętnymi:

2 ^ 10 ~ 1000

co oznacza 2 ^ 20 ~ 1 000 000

oraz 2 ^ 30 ~ 1 000 000 000

Dwukrotność tego (2 ^ 31) to mniej więcej 2 miliardy, a podwojenie tego (2 ^ 32) to 4 miliardy.

To łatwy sposób, aby uzyskać przybliżone oszacowanie dowolnej liczby binarnej. 10 zer w formacie binarnym staje się 3 zerami w systemie dziesiętnym.

W Objective-C (iOS i OSX) pamiętaj tylko te makra:

#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 oznacza, że ​​masz 32 bity dostępne do przechowywania swojego numeru. Najwyższy bit to bit znaku, który wskazuje, czy liczba jest dodatnia czy ujemna. Masz więc 2 ^ 31 bitów na liczby dodatnie i ujemne.

Gdy zero jest liczbą dodatnią, otrzymujesz logiczny zakres (wspomniany wcześniej)

+2147483647 do -2147483648

Jeśli uważasz, że to za małe, użyj Int64:

+9223372036854775807 do -9223372036854775808

I dlaczego, do diabła, chcesz zapamiętać ten numer? Do wykorzystania w kodzie? Zawsze powinieneś używać Int32.MaxValue lub Int32.MinValue w swoim kodzie, ponieważ są to wartości statyczne (w rdzeniu .net) i dlatego są szybsze w użyciu niż tworzenie nowej int z kodem.

Moje oświadczenie: jeśli znasz ten numer z pamięci ... po prostu się popisujesz!

Pamiętaj o tym: 21 IQ POZYCJA 47

Można go odkodować za pomocą dowolnej podkładki telefonicznej lub możesz po prostu zapisać sobie na papierze.

Aby zapamiętać „21 IQ ITEM 47”, wybrałbym „Hitman: Codename 47 miał 21 misji, z których każda była IEM ITEM”.

Lub „Czyszczę zęby codziennie o 21:47, ponieważ mam wysokie IQ i nie lubię przedmiotów w ustach”.