В 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

Запомните: 21 IQ ITEM 47

Его можно декодировать с любой телефонной панели, или вы можете просто записать его на бумаге.

Чтобы вспомнить «21 IQ ITEM 47», я бы сказал: «Hitman: Codename 47 имел 21 миссию, каждая из которых была IQ ITEM».

Или «Я чищу зубы каждый день в 21:47, потому что у меня высокий IQ и я не люблю предметы во рту».

С Groovy на пути:

groovy -e " println Integer.MAX_VALUE "

(Groovy чрезвычайно полезен для справочника в контексте Java.)

Чтобы никогда не забывать максимальное значение любого типа:

Если оно имеет 32 бита, наибольшим возможным значением будут 32 бита с номером 1:

Результат будет 4294967295 в десятичном виде:

Но, как есть также представление отрицательных чисел, разделите 4294967295 на 2 и получите 2147483647.

Следовательно, 32-разрядное целое число может представлять от -2147483647 до 2147483647.

Вы найдете в двоичном формате максимальное значение Int32 1111111111111111111111111111111, но в десяти основаниях вы найдете 2147483647 или 2 ^ 31-1 или Int32.MaxValue

Попробуйте на Python:

>>> int('1' * 31, base=2)
2147483647

В общем, вы могли бы выполнить простую операцию, которая отражает саму природу Int32, заполнить все доступные биты единицами - это то, что вы можете легко сохранить в своей памяти. Он работает в основном одинаково в большинстве языков, но я собираюсь использовать Python для примера:

max = 0
bits = [1] * 31 # Generate a "bit array" filled with 1's
for bit in bits:
    max = (max << 1) | bit
# max is now 2147483647

Для неподписанных Int32, сделайте его 32 вместо 31 1.

Но так как опубликовано еще несколько авантюрных подходов, я начал думать о формулах, просто для удовольствия ...

Формула 1 (Числа объединяются, если оператор не указан)

• a = 4
• b = 8
• ba / a
• ab-1
• ab
• ab-ab
• ab-1

Python quickcheck

a = 4
b = 8
ab = int('%d%d' % (a, b))
ba = int('%d%d' % (b, a))
'%d%d%d%d%d' % (ba/a, ab-1, ab, ab-a-b, ab-1)
# gives '2147483647'

Формула 2

• x = 48
• x / 2-3
• x- 1
• x
• x * 3/4 ​​
• x-1

Быстрый контроль Python

x = 48
'%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1) 
# gives '2147483647'

Самый простой способ запомнить это посмотреть на 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;
}

Просто помните, что 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

, Так как интервал использует 31 бит (+ ~1 бит для знака), просто удвойтесь 2^30 для получения приблизительно 2 миллиардов. Для неподписанного интервала с помощью 32 битов, дважды снова для 4 миллиардов. Ошибочный фактор становится выше большее, Вы идете, конечно, но Вам не нужно точное запоминаемое значение (При необходимости в нем необходимо использовать предопределенную константу для него так или иначе). Приближенное значение достаточно хорошо для того, чтобы замечать, когда что-то могло бы быть опасно близко к переполнению.

Самый корректный ответ, о котором я могу думать, Int32.MaxValue.

Это - 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

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 (подписанный интервал макс.) 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 ** 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?
Поскольку первый равен нулю, поэтому наибольшее значение составляет минус один .

РЕДАКТИРОВАТЬ для 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.

(Обратите внимание, что есть еще одно отрицательное значение.)

Самый простой способ сделать это для целых чисел - это использовать шестнадцатеричное при условии, что нет ничего похожего на 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 бита. Кроме того, многие компиляторы поддерживают hex намного лучше, чем двоичный.

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 , верно?), Оставляя пробелы, как показано (каждая черта - это слот для одной цифры. Сначала 2 слота, затем 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 больше в абсолютном значении , чем положительном пределе.

Попрактикуйтесь несколько раз, и вы освоите это!

2GB

(есть ли минимальная длина для ответов?)

Принятие.NET -

Console.WriteLine(Int32.MaxValue);

Если вам случится знать, что ваш ASCII-стол выключен наизусть, а не MaxInt:
!GH6G = 21 47 48 36 47

Это о 2.1 * 10^9. Не нужно точно знать 2^{31} - 1 = 2,147,483,647.

C

Вы можете найти его в 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 всегда подписаны.

Python 2

Python имеет произвольные целые числа точности. Но в Python 2 они отображаются на целые числа C. Итак, вы можете сделать это:

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

Итак, Python переключается на long, когда целое число становится больше, чем 2^31 -1

Что Вы имеете в виду? Должно быть достаточно легко помнить, что это 2^32. Если Вы хотите правило запомнить значение того числа, удобное эмпирическое правило для преобразования между двоичным файлом и десятичным числом в целом:

2^10 ~ 1000

, что означает 2^20 ~ 1,000,000

и 2^30 ~ 1,000,000,000

Двойной, что (2^31) rounghly 2 миллиарда и удвоение, которое снова (2^32) является 4 миллиардами.

Это - простой способ получить грубую оценку любого двоичного числа. 10 обнуляет в двоичном файле, становится 3, обнуляет в десятичном числе.

Int32 означает, что у вас есть 32 бита для хранения вашего номера. Самый старший бит - это бит знака, он указывает, положительное или отрицательное число. Итак, у вас есть 2 ^ 31 бит для положительных и отрицательных чисел.

Если ноль является положительным числом, вы получите логический диапазон (упомянутый ранее)

от +2147483647 до -2147483648

Если вы считаете, что это слишком мало, используйте Int64:

+9223372036854775807 до -9223372036854775808

И какого черта вы хотите запомнить это число? Для использования в вашем коде? Вы всегда должны использовать Int32.MaxValue или Int32.

Если вы думаете, что значение в базе 10 слишком сложно запомнить, попробуйте базу 2: 11111111111111111111111111111

В любом случае, возьмите это регулярное выражение (оно определяет, содержит ли строка неотрицательное целое число в десятичной форме, которое также не превышает 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]

Может быть, это поможет вам вспомнить.

Интересно, что Int32.MaxValue имеет больше символов, чем 2,147,486,647.

Но опять же, у нас есть автозавершение кода,

Так что я думаю, что все, что нам действительно нужно запомнить, это Int3M, который составляет всего 6 символов для ввода в Visual Studio.

ОБНОВЛЕНИЕ По какой-то причине я был отклонен. Единственная причина, о которой я могу думать, заключается в том, что они не поняли моего первого заявления.

Для ввода "Int32.MaxValue" требуется не более 14 символов. 2 147 486 647 требует 10 или 13 символов для ввода в зависимости от того, ставите ли вы запятые или нет.