самый правильный ответ, который я могу думать, это Int32.MaxValue.

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

это 10 цифр, так что представьте, что это номер телефона (предполагая, что вы находитесь в США). 214-748-3647. Я не рекомендую звонить ему.

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

числовая строка 2147483647 появляется в 1,867,996,680 десятичной цифры Пи. 3.14......86181221809936452346214748364710527835665425671614...

источник: http://www.subidiom.com/pi/

вместо того, чтобы думать об этом как об одном большом числе, попробуйте разбить его и искать связанные с ним идеи, например:

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

вышесказанное относится к большим отрицательным; положительным является то, что минус один.

может быть, выше разбивка не будет более запоминающимся для вас (это вряд ли интересно так и есть!), но, надеюсь, вы можете придумать некоторые идеи!

самое большое отрицательное (32bit) значение : -2147483648
(1

самое большое положительное (32bit) значение : 2147483647
~(1

Мнемоника: "пьяный АКА роговой"

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.Максвеллову)

[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**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

речь идет о 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, они сопоставляются с числами. Так что вы можете сделать это:

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

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

Ну, он имеет длину 32 бита и, следовательно, может хранить 2^32 различных значений. Половина из них отрицательные.

решение составляет 2 147 483 647

и самый низкий -2,147,483,648.

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

на данный момент я бы сказал, что самая простая мнемоника-это набирать "stackoverflow.com" TAB "максимальный int32" в Chrome.

есть рекурсия --> переполнение стека шутка. Я просто не настолько чокнутая.

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

Max unsigned values

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

So 7F равно 01111111 / 7FFF равно 0111111111111111. Кроме того, если вы используете это для "безумно высокой константы", 7F... это безопасный hex, но достаточно легко попробовать 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 by 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

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

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

нужно разбить число на части из 3-4 цифр и запомнить их визуально с помощью проекции на клавиатуре сотового телефона. Это легче показать на картинке:

Как видите, теперь вы просто должны помнить 3 фигуры, 2 из них выглядит так Тетрис L и один выглядит как клещ. Что, безусловно, намного проще, чем запоминание 10-значного числа.

когда вам нужно вспомнить номер просто вспомнить формы, представьте / посмотрите на клавиатуре телефона и проецировать формы на нем. Возможно, сначала вам придется смотреть на клавиатуру, но после небольшой практики вы вспомните, что цифры идут сверху слева вниз справа, поэтому вы сможете просто представить себе это в своей голове.

просто убедитесь, вы помните направление фигур и количество цифр в каждой фигуре (например, в Примере 2147483647 у нас есть 4-значный Тетрис L и 3-значный L).

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

предполагая .NET -

Console.WriteLine(Int32.MaxValue);

Если вы не знаете свой таблица ASCII наизусть, а не MaxInt:
!GH6G = 21 47 48 36 47

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

лучшее правило для запоминания это:
21 (магическое число!)
47 (только это помню)
48 (последовательного!)
36 (21 + 15, как магия!)
47 снова

также легче запомнить 5 пар, чем 10 цифр.

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

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

поэтому я думаю, что все, что нам действительно нужно запомнить, это Int3<period>M<enter>, что составляет всего 6 символов для ввода в visual studio.

обновление По какой-то причине я был понижен. Единственная причина, о которой я могу думать, это то, что они не поняли моего первого заявления.

"типа 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 миллиарда. Для unsigned 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 to -9223372036854775808

и какого черта ты хочешь запомнить этот номер? Использовать в вашем коде? Вы всегда должны использовать Int32.MaxValue или Int32.MinValue в вашем коде, так как это статические значения (в пределах .net core) и, следовательно, быстрее в использовании, чем создание нового int с кодом.

мое утверждение: если знать это число по памяти.. ты просто выпендриваешься!