Я ніколи не можу згадати число. Мені потрібно правило пам'яті.

Це 2,147,483,647. Найпростіший спосіб запам'ятати це за допомогою татуювання.

Найправильніша відповідь, яку я можу придумати, - це Int32.MaxValue.

Якщо ви вважаєте, що значення занадто важко запам'ятати в базі 10, спробуйте базу 2: 111111111111111111111111111111111

якщо ви можете запам’ятати все число Pi, то число, яке ви шукаєте, знаходиться в положенні 1,867,996,680 до 1,867,996,689 десяткових цифр Pi

Числовий рядок 2147483647 відображається в 1,867,996,680 десяткових цифр Pi. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

джерело: http://www.subidiom.com/pi/

Це 10 цифр, тому зробіть вигляд, що це номер телефону (якщо ви знаходитесь в США). 214-748-3647. Не рекомендую телефонувати.

Замість того, щоб вважати це одним великим числом, спробуйте розбити його та шукати пов'язані ідеї, наприклад:

• 2 максимальних перерви на снукері (максимальна перерва - 147)
• 4 роки (48 місяців)
• 3 роки (36 місяців)
• 4 роки (48 місяців)

Сказане стосується найбільшої від’ємної кількості; Позитивним є той мінус один.

Можливо, вищевказана розбивка для вас буде не запам'ятовується (це навряд чи захоплююче!), Але, сподіваємось, ви зможете придумати кілька ідей, які є!

Найбільше негативне (32 біт) значення: -2147483648
(1 << 31)

Найбільше позитивне (32 біт) значення: 2147483647
~ (1 << 31)

Мнемонічний: "п'яний AKA роговий"

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

У будь-якому випадку візьміть цей регулярний вираз (він визначає, чи містить рядок невід'ємний цілий число в десятковій формі, що також не перевищує 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]

Можливо, це допоможе вам згадати.

Ось як я згадав 2147483647:

• 214 - тому що 2.14 - це приблизно pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Запишіть їх по горизонталі:

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

Тепер у вас 2147483647.

Сподіваюсь, це допоможе хоч трохи.

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

Отже, 2 ^ 31 (підписаний int max) дорівнює 2 ^ 30 (приблизно 1 мільярд) разів 2 ^ 1 (2), або приблизно 2 мільярди. І 2 ^ 32 - це 2 ^ 30 * 2 ^ 2 або близько 4 мільярдів. Цей метод наближення досить точний навіть приблизно до 2 ^ 64 (де похибка зростає приблизно до 15%).

Якщо вам потрібна точна відповідь, тоді вам слід підняти калькулятор.

Зручні наближення ємності для вирівнювання за словом:

• 2 ^ 16 ~ = 64 тис. // uint16
• 2 ^ 32 ~ = 4 мільярди // uint32, IPv4, unixtime
• 2 ^ 64 ~ = 16 квінтільйона (він же 16 мільярдів мільярдів або 16 мільйонів трильйонів) // uint64, "bigint"
• 2 ^ 128 ~ = 256 квінтільйонних квінтільйон (він же 256 трлн трильйонів) // IPv6, GUID

Просто візьміть будь-який гідний калькулятор і введіть "7FFFFFFF" у шестигранному режимі, а потім перейдіть до десяткового.

2147483647.

Йдеться про те 2.1 * 10^9. Не потрібно точно знати 2^{31} - 1 = 2,147,483,647.

С

Ви можете знайти його на C так:

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

дає (ну, без ,)

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

Ви також можете отримати це за допомогою Java:

System.out.println(Integer.MAX_VALUE);

Але майте на увазі, що цілі Java завжди підписані.

Пітон 2

Python має довільні точні цілі числа. Але в Python 2 вони відображаються на цілі числа C. Тож ви можете зробити це:

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

Тож Python перемикається, longколи ціле число стає більшим за2^31 -1

Ось мнемоніка для запам'ятовування 2 ** 31, відніміть одну, щоб отримати максимальне ціле значення.

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

Я використовував повноваження від двох до 18 досить часто, щоб їх запам'ятати, але навіть я не намагався запам'ятати 2 ** 31. Занадто просто обчислити за потребою або використовувати константу або оцінити як 2G.

32 біта, один для знака, 31 біт інформації:

2^31 - 1 = 2147483647

Чому -1?
Тому що перший дорівнює нулю, тому найбільшим вважається підрахунок мінус один .

EDIT для cantfindaname88

Підрахунок становить 2 ^ 31, але найбільший не може бути 2147483648 (2 ^ 31), оскільки ми рахуємо від 0, а не 1.

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

Ще одне пояснення лише з 3 бітами: 1 для знака, 2 для інформації

2^2 - 1 = 3

Нижче всіх можливих значень з 3 бітами: (2 ^ 3 = 8 значень)

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

Ну, він має 32 біти, а значить, може зберігати 2 ^ 32 різних значення. Половина таких негативних.

Розчин 2,147,483,647

А найнижчий - -2,147,483,648.

(Зауважте, що є ще одне негативне значення.)

Ну, окрім жартів, якщо ти справді шукаєш корисного правила пам’яті, є одне, яке я завжди використовую для запам'ятовування великих чисел.

Вам потрібно розбити свій номер на частини з 3-4 цифр і запам'ятати їх візуально, використовуючи проекцію на клавіатурі вашого мобільного телефону. Простіше показати на малюнку:

Як бачите, відтепер ви просто повинні запам'ятати 3 фігури, 2 з них схожі на тетріс L, а одна схожа на кліща . Що, безумовно, набагато простіше, ніж запам'ятовування 10-значного числа.

Коли вам потрібно згадати число, просто згадайте фігури, уявіть / подивіться на клавіатуру телефону та спроектуйте фігури на ньому. Можливо, спочатку вам доведеться поглянути на клавіатуру, але після трохи практики ви згадаєте, що цифри йдуть зліва-вліво-вправо, тому ви зможете просто уявити це в голові.

Просто переконайтеся, що ви пам’ятаєте напрямок фігур та кількість цифр у кожній фігурі (наприклад, у прикладі 2147483647 у нас є 4-значний Tetris L та 3-значний L).

Ви можете використовувати цю техніку, щоб легко запам'ятовувати будь-які важливі номери (наприклад, я запам'ятав свій 16-значний номер кредитної картки тощо).

Найпростіший спосіб зробити це для цілих чисел - це використовувати шістнадцятковий за умови, що не існує щось на зразок Int.maxInt (). Причина така:

Максимально не підписані значення

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

Підписані значення, використовуючи 7F як максимальне підписане значення

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

Підписані значення, використовуючи 80 як максимальне підписане значення

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

Як це працює? Це дуже схоже на двійкову тактику, і кожна шістнадцятка цифр рівно 4 біт. Крім того, багато компіляторів підтримують шістнадцятковий розмір набагато краще, ніж вони підтримують двійкові.

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

Отже, 7F дорівнює 01111111 / 7FFF дорівнює 0111111111111111. Також, якщо ви використовуєте це для "шалено-високої постійної", 7F ... це безпечний шістнадцятковий, але досить просто спробувати 7F і 80 та просто надрукувати їх на ваш екран, щоб побачити, який це.

0x7FFF + 0x0001 = 0x8000, тож ваша втрата становить лише одне число, тому використання 0x7F ... зазвичай не є поганим компромісом для більш надійного коду, особливо коли ви починаєте використовувати 32-бітні або більше

Спочатку випишіть 47 двічі (вам подобається агент 47 , правда?), Зберігаючи пробіли, як показано (кожен тире - це слот для однієї цифри. Перші два слоти, потім 4)

--47----47

Подумайте, у вас є 12в руці (адже 12 = десяток). Помножте його на 4першу цифру числа агента 47, тобто 47поставте результат праворуч від першої пари, у вас вже є

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

Потім помножте 12на 3(для того, щоб скласти другу цифру числа агента 47, тобто 7вам потрібно 7 - 4 = 3) і поставте результат праворуч від перших 2 пар, останнього парного слота

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

Нарешті перетягніть цифри одну за одною з руки, починаючи з найбільш правої цифри (2 у цьому випадку) і помістіть їх у перший порожній слот, який ви отримаєте

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

Там у вас є! Для від'ємної межі ви можете вважати це як 1 більше в абсолютній величині, ніж позитивний межа.

Попрактикуйтесь кілька разів, і ви отримаєте повісити його!

2 Гб

(чи є мінімальна довжина відповідей?)

Припустимо. NET -

Console.WriteLine(Int32.MaxValue);

Якщо ви випадково знаєте свій стіл ASCII напам'ять, а не MaxInt:
!GH6G = 21 47 48 36 47

Найкраще правило для запам'ятовування це:
21 (магічне число!)
47 (просто запам'ятайте це)
48 (послідовне!)
36 (21 + 15, обидва маги!)
47 знову

Також простіше запам'ятати 5 пар, ніж 10 цифр.

Найпростіший спосіб запам'ятати - це подивитися std::numeric_limits< int >::max()

Наприклад ( від 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;
}

Цікаво, що Int32.MaxValue має більше символів, ніж 2,147,486,647.

Але знову ж таки, у нас є завершення коду,

Тож я думаю, що насправді нам потрібно запам’ятати - Int3<period>M<enter>це лише 6 символів, які слід набрати у візуальній студії.

ОНОВЛЕННЯ Чомусь мене зняли з посади. Єдина причина, про яку я можу подумати - це те, що вони не зрозуміли мого першого твердження.

"Int32.MaxValue" набирає не більше 14 символів. 2,147,486,647 набирає або 10 символів, або 13 символів, залежно від того, вставляєте ви коми чи ні.

Пам'ятайте лише, що 2 ^ (10 * x) приблизно 10 ^ (3 * x) - ви, мабуть, вже звикли до цього з кілобайт / кібібайт тощо. Це:

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

Оскільки int використовує 31 біт (+ ~ 1 біт для знаку), просто подвійно 2 ^ 30, щоб отримати приблизно 2 мільярди. Для безпідписаного int, що використовує 32 біти, знову подвійно на 4 мільярди. Коефіцієнт помилки стає вище, чим більше ви хочете, звичайно, але вам не потрібно точно запам'ятовувати значення (Якщо воно вам потрібно, ви все одно повинні використовувати попередньо визначену константу). Орієнтовне значення досить добре, щоб помітити, коли щось може бути небезпечно близьким до переповнення.

ось як я це роблю, щоб згадати 2,147,483,647

До далекої чверті савани оптимістичне тріо приєднало сорок септенарі

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

Що ви маєте на увазі? Потрібно досить легко пам’ятати, що це 2 ^ 32. Якщо ви хочете, щоб правило запам'ятовувало значення цього числа, зручне правило великого пальця призначене для перетворення між двійковим і десятковим в цілому:

2 ^ 10 ~ 1000

що означає 2 ^ 20 ~ 1 000 000

і 2 ^ 30 ~ 1 000 000 000

Подвійне, що (2 ^ 31), становить приблизно 2 мільярди, а подвоєння (2 ^ 32) - 4 мільярди.

Це простий спосіб отримати приблизну оцінку будь-якого двійкового числа. 10 нулів у двійкових стає 3 нулями в десяткових.

У Objective-C (iOS та OSX) пам’ятайте лише про ці макроси:

#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 означає, що у вас є 32 біти для зберігання вашого номера. Найвищий біт - це бітовий знак, це вказує, чи є число позитивним чи негативним. Отже, у вас є 2 ^ 31 біт для додатних і від’ємних чисел.

Якщо нуль є позитивним числом, ви отримуєте логічний діапазон (згаданий раніше)

+2147483647 до -2147483648

Якщо ви вважаєте, що це мало, використовуйте Int64:

+9223372036854775807 до -9223372036854775808

І чому, до біса, ти хочеш запам'ятати це число? Щоб використовувати у своєму коді? Ви завжди повинні використовувати Int32.MaxValue або Int32.MinValue у своєму коді, оскільки це статичні значення (в ядрі .net) і, таким чином, швидше у використанні, ніж створення нового int з кодом.

Мій вислів: якщо знати це число по пам’яті .. ти просто показуєшся!

Пам'ятайте це: 21 IQ ITEM 47

Його можна розкодувати за допомогою будь-якої телефонної колодки, а можна просто записати її на папері.

Для того, щоб запам’ятати «21 IQ ITEM 47», я б пішов із «Hitman: Codename 47 мав 21 місію, які кожен IQ ITEM був самостійно».

Або "Я чищу зуби о 21:47 щодня, тому що у мене високий IQ і не люблю предмети в роті".