Saya tidak pernah bisa mengingat nomornya. Saya membutuhkan aturan memori.

Ini 2.147.483.647. Cara termudah untuk menghafalnya adalah melalui tato.

Jawaban paling benar yang bisa saya pikirkan adalah Int32.MaxValue.

Jika Anda berpikir nilainya terlalu sulit untuk diingat dalam basis 10, coba basis 2: 111111111111111111111111111111111

jika Anda dapat mengingat seluruh nomor Pi, maka angka yang Anda cari ada di posisi 1.867.996.680 hingga 1.867.996.689 dari angka desimal Pi

String numerik 2147483647 muncul pada angka desimal Pi 1,867.996.680. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

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

Ini 10 digit, jadi anggap itu nomor telepon (dengan asumsi Anda berada di AS). 214-748-3647. Saya tidak merekomendasikan untuk menyebutnya.

Daripada menganggapnya sebagai satu angka besar, cobalah memecahnya dan mencari ide-ide terkait misalnya:

• 2 istirahat snooker maksimum (istirahat maksimum adalah 147)
• 4 tahun (48 bulan)
• 3 tahun (36 bulan)
• 4 tahun (48 bulan)

Hal di atas berlaku untuk angka negatif terbesar; positif adalah minus satu itu.

Mungkin uraian di atas tidak akan lebih berkesan bagi Anda (rasanya tidak mengasyikkan!), Tapi mudah-mudahan Anda dapat menemukan beberapa ide yang ada!

Nilai negatif (32bit) terbesar: -2147483648
(1 << 31)

Nilai positif (32bit) terbesar: 2147483647
~ (1 << 31)

Mnemonic: "mabuk AKA horny"

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

Pokoknya, ambil regex ini (menentukan apakah string berisi Integer non-negatif dalam bentuk desimal yang juga tidak lebih besar dari 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]

Mungkin itu akan membantu Anda mengingat.

Itulah yang saya ingat 2147483647:

• 214 - karena 2,14 kira-kira pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Tulis ini secara horizontal:

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

Sekarang Anda punya 2147483647.

Semoga ini bisa membantu setidaknya sedikit.

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

Jadi, 2 ^ 31 (masuk int max) adalah 2 ^ 30 (sekitar 1 miliar) kali 2 ^ 1 (2), atau sekitar 2 miliar. Dan 2 ^ 32 adalah 2 ^ 30 * 2 ^ 2 atau sekitar 4 miliar. Metode pendekatan ini cukup akurat bahkan sekitar 2 ^ 64 (di mana kesalahan tumbuh sekitar 15%).

Jika Anda membutuhkan jawaban yang tepat maka Anda harus menarik kalkulator.

Perkiraan kapasitas rata-rata yang praktis:

• 2 ^ 16 ~ = 64 ribu // uint16
• 2 ^ 32 ~ = 4 miliar // uint32, IPv4, unixtime
• 2 ^ 64 ~ = 16 quintillion (alias 16 miliar miliar atau 16 juta trilyun) // uint64, "bigint"
• 2 ^ 128 ~ = 256 trilyun trilyun (alias 256 triliun triliun trilyun) // IPv6, GUID

Ambil saja kalkulator yang layak dan ketik "7FFFFFFF" dalam mode hex, kemudian beralih ke desimal.

2147483647

Ini tentang 2.1 * 10^9. Tidak perlu tahu persisnya 2^{31} - 1 = 2,147,483,647.

C

Anda dapat menemukannya di C seperti itu:

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

memberi (baik, tanpa ,)

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

Anda juga bisa mendapatkan ini dengan Java:

System.out.println(Integer.MAX_VALUE);

Tetapi perlu diingat bahwa Java integer selalu masuk.

Python 2

Python memiliki bilangan bulat presisi acak. Tetapi dalam Python 2, mereka dipetakan ke C integer. Jadi Anda bisa melakukan ini:

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

Jadi Python beralih ke longsaat bilangan bulat menjadi lebih besar dari2^31 -1

Ini adalah mnemonic untuk mengingat 2 ** 31, kurangi satu untuk mendapatkan nilai integer maksimum.

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

Saya telah menggunakan kekuatan dua hingga 18 cukup sering untuk mengingatnya, tetapi bahkan saya belum repot-repot mengingat 2 ** 31. Terlalu mudah untuk menghitung sesuai kebutuhan atau menggunakan konstanta, atau memperkirakan sebagai 2G.

32 bit, satu untuk tanda, 31 bit informasi:

2^31 - 1 = 2147483647

Kenapa -1?
Karena yang pertama adalah nol, jadi yang terbesar adalah hitungan minus .

EDIT untuk cantfindaname88

Hitungannya adalah 2 ^ 31 tetapi yang terbesar tidak mungkin 2147483648 (2 ^ 31) karena kita menghitung dari 0, bukan 1.

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

Penjelasan lain dengan hanya 3 bit: 1 untuk tanda, 2 untuk informasi

2^2 - 1 = 3

Di bawah semua nilai yang mungkin dengan 3 bit: (2 ^ 3 = 8 nilai)

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

Yah, ia memiliki 32 bit dan karenanya dapat menyimpan 2 ^ 32 nilai yang berbeda. Setengah dari mereka adalah negatif.

Solusinya adalah 2.147.483.647

Dan yang terendah adalah ,2.147.483.648.

(Perhatikan bahwa ada satu lagi nilai negatif.)

Nah, selain dari lelucon, jika Anda benar-benar mencari aturan memori yang berguna, ada satu yang selalu saya gunakan untuk mengingat angka besar.

Anda perlu memecah nomor Anda menjadi bagian-bagian dari 3-4 digit dan mengingatnya secara visual menggunakan proyeksi pada keyboard ponsel Anda. Lebih mudah ditampilkan pada gambar:

Seperti yang Anda lihat, mulai sekarang Anda hanya perlu mengingat 3 bentuk, 2 di antaranya tampak seperti Tetris L dan satu lagi terlihat seperti tanda centang . Yang pasti jauh lebih mudah daripada menghafal nomor 10 digit.

Ketika Anda perlu mengingat nomor hanya ingat bentuk, bayangkan / lihat pada keyboard ponsel dan proyeksikan bentuk di atasnya. Mungkin awalnya Anda harus melihat keyboard tetapi setelah sedikit latihan, Anda akan ingat bahwa angka-angka bergerak dari kiri atas ke kanan bawah sehingga Anda dapat membayangkannya di kepala Anda.

Pastikan Anda mengingat arah bentuk dan jumlah digit di setiap bentuk (misalnya, pada 2147483647 contoh, kami memiliki Tetris L 4 digit dan L 3 digit).

Anda dapat menggunakan teknik ini untuk dengan mudah mengingat angka penting (misalnya, saya ingat nomor kartu kredit 16 digit saya, dll.).

Cara termudah untuk melakukan ini untuk bilangan bulat adalah dengan menggunakan heksadesimal, asalkan tidak ada sesuatu seperti Int.maxInt (). Alasannya adalah ini:

Nilai maksimum unsigned

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

Nilai yang ditandatangani, menggunakan 7F sebagai nilai yang ditandatangani maks

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

Nilai yang ditandatangani, menggunakan 80 sebagai nilai yang ditandatangani maks

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

Bagaimana cara kerjanya? Ini sangat mirip dengan taktik biner, dan setiap digit hex tepat 4 bit. Juga, banyak kompiler mendukung hex jauh lebih baik daripada mereka mendukung biner.

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

Jadi 7F sama dengan 01111111 / 7FFF sama dengan 0111111111111111. Juga, jika Anda menggunakan ini untuk "konstanta gila-gilaan tinggi", 7F ... adalah hex aman, tetapi cukup mudah untuk mencoba 7F dan 80 dan hanya mencetaknya ke layar Anda untuk melihat yang mana itu.

0x7FFF + 0x0001 = 0x8000, jadi kerugian Anda hanya satu angka, jadi menggunakan 0x7F ... biasanya bukan tradeoff yang buruk untuk kode yang lebih andal, terutama sekali Anda mulai menggunakan 32-bit atau lebih

Pertama, tulis 47 dua kali, (Anda suka Agen 47 , kan?), Menjaga spasi seperti yang ditunjukkan (setiap tanda hubung adalah slot untuk satu digit. Pertama 2 slot, lalu 4)

--47----47

Pikirkan Anda ada 12di tangan (karena 12 = selusin). Lipat gandakan dengan 4, digit pertama nomor Agen 47, yaitu 47, dan tempatkan hasilnya di sebelah kanan pasangan pertama yang sudah Anda miliki

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

Kemudian kalikan 12dengan 3(untuk membuat digit kedua dari nomor Agen 47, yaitu 7, yang Anda butuhkan 7 - 4 = 3) dan letakkan hasilnya di sebelah kanan 2 pasangan pertama, slot pasangan terakhir

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

Terakhir, seret digit satu per satu dari tangan Anda mulai dari digit paling kanan (2 dalam hal ini) dan letakkan di slot kosong pertama yang Anda dapatkan

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

Itu dia! Untuk batas negatif, Anda dapat menganggapnya sebagai 1 lebih dalam nilai absolut daripada batas positif.

Berlatihlah beberapa kali, dan Anda akan terbiasa!

2GB

(apakah ada panjang minimum untuk jawaban?)

Dengan asumsi .NET -

Console.WriteLine(Int32.MaxValue);

Jika Anda mengetahui tabel ASCII dengan hati dan tidak MaxInt:
!GH6G = 21 47 48 36 47

Aturan terbaik untuk mengingatnya adalah:
21 (angka ajaib!)
47 (ingat saja)
48 (berurutan!)
36 (21 + 15, keduanya sihir!)
47 lagi

Juga lebih mudah untuk mengingat 5 pasang daripada 10 digit.

Cara termudah untuk diingat adalah dengan melihatnya std::numeric_limits< int >::max()

Misalnya ( dari 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;
}

Menariknya, Int32.MaxValue memiliki lebih banyak karakter daripada 2.147.486.647.

Tapi sekali lagi, kita memang memiliki penyelesaian kode,

Jadi saya kira yang harus kita hafal adalah Int3<period>M<enter>, yang hanya 6 karakter untuk mengetik di studio visual.

UPDATE Entah mengapa saya downvoted. Satu-satunya alasan yang dapat saya pikirkan adalah bahwa mereka tidak memahami pernyataan pertama saya.

"Int32.MaxValue" membutuhkan maksimal 14 karakter untuk mengetik. 2.147.486.647 membutuhkan 10 atau 13 karakter untuk diketik tergantung pada apakah Anda memasukkan koma atau tidak.

Ingatlah bahwa 2 ^ (10 * x) kira-kira 10 ^ (3 * x) - Anda mungkin sudah terbiasa dengan ini dengan kilobytes / kibibytes dll. Yaitu:

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

Karena int menggunakan 31 bit (+ ~ 1 bit untuk tanda), cukup gandakan 2 ^ 30 untuk mendapatkan sekitar 2 miliar. Untuk int unsigned menggunakan 32 bit, gandakan lagi untuk 4 miliar. Faktor kesalahan semakin tinggi semakin besar Anda pergi tentu saja, tetapi Anda tidak perlu nilai tepat dihafal (Jika Anda membutuhkannya, Anda harus menggunakan konstanta yang telah ditentukan sebelumnya untuk itu). Nilai perkiraannya cukup baik untuk diperhatikan ketika sesuatu mungkin hampir meluap.

ini adalah bagaimana saya melakukannya untuk mengingat 2.147.483.647

Untuk seperempat sabana jauh, optimus trio dipoles empat puluh september

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

Apa maksudmu? Seharusnya cukup mudah untuk mengingat bahwa itu adalah 2 ^ 32. Jika Anda ingin aturan untuk menghafal nilai angka itu, aturan praktis praktis adalah untuk mengkonversi antara biner dan desimal secara umum:

2 ^ 10 ~ 1000

yang berarti 2 ^ 20 ~ 1.000.000

dan 2 ^ 30 ~ 1.000.000.000

Dua kali lipat (2 ^ 31) adalah 2 miliar, dan dua kali lipat lagi (2 ^ 32) adalah 4 miliar.

Ini cara mudah untuk mendapatkan perkiraan kasar dari angka biner apa pun. 10 nol dalam biner menjadi 3 nol dalam desimal.

Di Objective-C (iOS & OSX), ingatlah makro ini:

#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 berarti Anda memiliki 32 bit yang tersedia untuk menyimpan nomor Anda. Bit tertinggi adalah bit tanda, ini menunjukkan jika angka tersebut positif atau negatif. Jadi, Anda memiliki 2 ^ 31 bit untuk angka positif dan negatif.

Dengan nol menjadi angka positif Anda mendapatkan rentang logis dari (disebutkan sebelumnya)

+2147483647 hingga -2147483648

Jika menurut Anda itu kecil, gunakan Int64:

+9223372036854775807 hingga -9223372036854775808

Dan mengapa Anda ingin mengingat nomor ini? Untuk digunakan dalam kode Anda? Anda harus selalu menggunakan Int32.MaxValue atau Int32.MinValue dalam kode Anda karena ini adalah nilai statis (dalam inti .net) dan karenanya lebih cepat digunakan daripada membuat int baru dengan kode.

Pernyataan saya: jika tahu nomor ini berdasarkan memori .. Anda hanya pamer!

Ingat ini: 21 IQ ITEM 47

Itu dapat di-encoded dengan pad ponsel apa pun, atau Anda bisa menuliskannya sendiri di atas kertas.

Untuk mengingat "21 IQ ITEM 47", saya akan pergi dengan "Hitman: Codename 47 memiliki 21 misi, yang masing-masing adalah ITEM IQ sendiri".

Atau "Saya membersihkan gigi pada 21:47 setiap hari, karena saya memiliki IQ tinggi dan tidak suka barang di mulut saya".