Я никогда не помню номер. Мне нужно правило памяти.
Какое максимальное значение для int32?
Ответ 1
Это 2 147 483 647. Самый простой способ запомнить это с помощью татуировки.
Ответ 2
Самый правильный ответ, о котором я могу думать, - Int32.MaxValue.
Ответ 3
Если вы считаете, что значение слишком сложно запомнить в базе 10, попробуйте базу 2: 1111111111111111111111111111111
Ответ 4
если вы можете вспомнить все число 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/
Ответ 5
Это 10 цифр, поэтому притворите номер телефона (если вы в США). 214-748-3647. Я не рекомендую называть его.
Ответ 6
Вместо того, чтобы думать о нем как о большом количестве, попробуйте разбить его и найти связанные идеи, например:
- 2 максимальных снукерных разрыва (максимальный разрыв 147)
- 4 года (48 месяцев)
- 3 года (36 месяцев)
- 4 года (48 месяцев)
Вышеупомянутое относится к самому большому отрицательному числу; положительным является то, что минус один.
Возможно, вышеуказанная разбивка будет не более запоминающейся для вас (это вряд ли интересно!), но, надеюсь, вы сможете придумать какие-то идеи!
Ответ 7
Наибольшее отрицательное (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 18+ material of it)
21 47 4(years) 3(years) 4(years)
21 47 48 36 48
Ответ 8
В любом случае, возьмите это регулярное выражение (он определяет, содержит ли строка неотрицательный целочисленный символ в десятичной форме, который также не больше 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]
Возможно, это поможет вам запомнить.
Ответ 9
Вот как я вспомнил 2147483647:
- 214 - потому что 2.14 приблизительно pi-1
- 48 = 6 * 8
- 64 = 8 * 8
Назовите их по горизонтали:
214_48_64_
and insert:
^ ^ ^
7 3 7 - which is Boeing airliner jet (thanks, sgorozco)
Теперь у вас есть 2147483647.
Надеюсь, что это поможет хотя бы немного.
Ответ 10
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 тыс. //uint 16
- 2 ^ 32 ~ = 4 миллиарда //uint 32, IPv4, unixtime
- 2 ^ 64 ~ = 16 квинтиллионов (или 16 миллиардов миллиардов или 16 миллионов триллионов)//uint64, "bigint"
- 2 ^ 128 ~ = 256 quintillion quintillion (ака 256 триллионов триллионов триллионов)//IPv6, GUID
Ответ 11
Просто возьмите любой достойный калькулятор и введите "7FFFFFFF" в шестнадцатеричном режиме, затем переключитесь на десятичный.
2147483647.
Ответ 12
Это около 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
Ответ 13
Здесь мнемоника для запоминания 2 ** 31 вычитает один, чтобы получить максимальное целочисленное значение.
а = 1, B = 2, с = 3, d = 4, е = 5, F = 6, г = 7, ч = 8, г = 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.
Ответ 14
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
Другое объяснение с тремя битами: 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
Ответ 15
Ну, он имеет 32 бита и, следовательно, может хранить 2 ^ 32 разных значения. Половина из них отрицательная.
Решение равно 2 147 483 647
И самое низкое -2,147,483,648.
(Обратите внимание, что есть еще одно отрицательное значение.)
Ответ 16
В этот момент я бы сказал, что самой простой мнемонической версией является запись "stackoverflow.com" TAB "максимум int32" в Chrome.
Существует где-то шутка рекурсии → . Я просто не так уродлив.
Ответ 17
Ну, кроме анекдотов, если вы действительно ищете полезное правило памяти, есть тот, который я всегда использую для запоминания больших чисел.
Вам нужно разбить свой номер на части с 3-4 цифр и запомнить их визуально, используя проекцию на клавиатуре вашего мобильного телефона. Это проще показать на картинке:
Как вы можете видеть, теперь вам нужно запомнить 3 формы, 2 из них выглядят как Tetris L, и один выглядит как галочка. Это определенно намного проще, чем запоминание 10-значного числа.
Когда вам нужно вспомнить номер, просто вспомните фигуры, представьте/посмотрите на клавиатуру телефона и спроектируйте фигуры на нем. Возможно, изначально вам придется смотреть на клавиатуру, но после небольшой практики вы запомните, что цифры идут сверху-вниз вправо, так что вы сможете просто представить это в своей голове.
Просто убедитесь, что вы помните направление фигур и количество цифр в каждой форме (например, в примере 2147483647 у нас есть четырехзначный тетрис L и 3-значный символ L).
Вы можете использовать эту технику, чтобы легко запомнить любые важные номера (например, я вспомнил свой 16-значный номер кредитной карты и т.д.).
Ответ 18
Самый простой способ сделать это для целых чисел - использовать шестнадцатеричный, при условии, что нет такого типа, как 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-битные или более
Ответ 19
Сначала запишите 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 больше по абсолютной величине, чем положительный предел.
Потренируйтесь несколько раз, и вы освоите это!
Ответ 20
2 Гб
(существует ли минимальная длина ответов?)
Ответ 21
Предполагая, что .NET -
Console.WriteLine(Int32.MaxValue);
Ответ 22
Интересно, что Int32.MaxValue имеет больше символов, чем 2,147,486,647.
Но опять же, у нас есть завершение кода,
Итак, я думаю, что все, что нам действительно нужно запомнить, - это Int3<period>M<enter>, который набирает всего 6 символов в визуальной студии.
UPDATE По какой-то причине я был остановлен. Единственная причина, по которой я могу думать, это то, что они не понимали моего первого заявления.
"Int32.MaxValue" занимает не более 14 символов. 2 147 486 647 занимает 10 или 13 символов для ввода в зависимости от того, вставляете ли вы запятые или нет.
Ответ 23
Если вы случайно узнали свою таблицу ASCII, а не MaxInt: !GH6G = 21 47 48 36 47
Ответ 24
Лучшее правило для запоминания:
21 (магическое число!)
47 (просто запомните это)
48 (последовательно!)
36 (21 + 15, оба волшебства!)
47 снова
Также легче запомнить 5 пар, чем 10 цифр.
Ответ 25
Самый простой способ запомнить - посмотреть 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;
}
Ответ 26
Просто помните, что 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 миллиарда. Коэффициент ошибок становится выше, чем больше вы, но вам не нужно точно запоминать значение (если вам это нужно, в любом случае вы должны использовать заранее определенную константу). Приблизительное значение достаточно хорошее, чтобы заметить, когда что-то может быть опасно близко к переполнению.
Ответ 27
вот как я это делаю, чтобы помнить 2,147,483,647
В отдаленную саванну четверть оптимизма трио шестидесяти сорок семеричных
2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary
Ответ 28
Что ты имеешь в виду? Достаточно легко запомнить, что это 2 ^ 32. Если вы хотите, чтобы правило запоминало значение этого числа, удобное правило для преобразования между двоичным и десятичным в целом:
2 ^ 10 ~ 1000
что означает 2 ^ 20 ~ 1 000 000
и 2 ^ 30 ~ 1,000,000,000
Двойной, что (2 ^ 31) составляет 2 миллиарда, и удваивает, что снова (2 ^ 32) составляет 4 миллиарда.
Это простой способ получить приблизительную оценку любого двоичного числа. 10 нулей в двоичном порядке становятся 3 нулями в десятичной форме.
Ответ 29
В 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
Ответ 30
Int32 означает, что у вас есть 32 бита для хранения вашего номера. Самый старший бит - знаковый бит, это указывает, является ли число положительным или отрицательным. Таким образом, у вас есть 2 ^ 31 бит для положительных и отрицательных чисел.
С нулем, являющимся положительным числом, вы получаете логический диапазон (упомянутый выше)
+2147483647 до -2147483648
Если вы считаете, что это мало, используйте Int64:
+9223372036854775807 - -9223372036854775808
И почему, черт возьми, вы хотите запомнить этот номер? Использовать в своем коде? Вы всегда должны использовать Int32.MaxValue или Int32.MinValue в своем коде, так как это статические значения (в ядре .net) и, следовательно, быстрее используются, чем создание нового int с кодом.
Мое утверждение: если вы знаете это число по памяти, вы просто хвастаетесь!