Я никогда не могу вспомнить номер. Мне нужно правило памяти.

Это 2 147 483 647. Самый простой способ запомнить это с помощью татуировки.

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

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

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

Числовая строка 2147483647 указывается с десятичной цифрой Pi 1 867 996 680. 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)

Мнемоника: "Пьяная ака роговая"

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 примерно пи-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 тыс. // уинт16
• 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:

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 ** 31, вычтите единицу, чтобы получить максимальное целочисленное значение.

а = 1, B = 2, с = 3, d = 4, е = 5, F = 6, г = 7, ч = 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.

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

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

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

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

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

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 и мне не нравятся предметы во рту».