Каково максимальное значение для int32?
https://stackoverflow.com/questions/94591
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Я никогда не могу запомнить этот номер.Мне нужно правило запоминания.
Решение
Это 2,147,483,647.Самый простой способ запомнить это - с помощью татуировки.
Другие советы
Самый правильный ответ, который я могу придумать, это Int32.MaxValue.
Если вы считаете, что значение слишком сложно запомнить в базе 10, попробуйте использовать базу 2:1111111111111111111111111111111
если вы можете запомнить все число Pi, то искомое число находится в позиции от 1,867,996,680 до 1,867,996,689 десятичных цифр числа Pi
Числовая строка 2147483647 состоит из 1,867,996,680 десятичной цифры числа Пи.3.14......86181221809936452346214748364710527835665425671614...
Источник: 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 (signed 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
Вы можете найти это в 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 ** 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?
Поскольку первое равно нулю, то самое большое - это отсчет минус один.
РЕДАКТИРОВАТЬ для кантфинданаме88
Количество равно 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.
(Обратите внимание, что есть еще одно отрицательное значение.)
В этот момент, я бы сказал, что самый простой мнемонический является тип "stackoverflow.com" ВКЛАДКА "максимальный int32" в Chrome.
Где-то там есть шутка с рекурсией -> переполнением стека.Просто я не настолько чокнутый.
Ну, помимо шуток, если вы действительно ищете полезное правило запоминания, есть одно, которое я всегда использую для запоминания больших чисел.
Вам нужно разбить свой номер на части из 3-4 цифр и запомнить их визуально, используя проекцию на клавиатуре вашего мобильного телефона.Это легче показать на картинке:
Как вы можете видеть, с этого момента вам просто нужно запомнить 3 фигуры, 2 из которых похожи на тетрис L, а одна похожа на галочку.Это определенно намного проще, чем запомнить 10-значное число.
Когда вам нужно будет вспомнить номер, просто вспомните фигуры, представьте / посмотрите на клавиатуру телефона и спроецируйте на нее фигуры.Возможно, сначала вам придется смотреть на клавиатуру, но после небольшой практики вы вспомните, что цифры идут сверху слева направо, так что вы сможете просто представить это у себя в голове.
Просто убедитесь, что вы запомнили направление фигур и количество цифр в каждой фигуре (например, в примере 2147483647 у нас есть 4-значный тетрис 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 равно 011111111111111111.Кроме того, если вы используете это для "безумно высокой константы", 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 ГБ
(существует ли минимальная длина ответов?)
Если вы случайно знаете своего Таблица ASCII выучил наизусть и не MaxInt :
!GH6G = 21 47 48 36 47
Лучшее правило для запоминания этого таково:
21 (волшебное число!)
47 (просто запомни это)
48 (последовательно!)
36 (21 + 15, обе магии!)
47 снова
Также легче запомнить 5 пар, чем 10 цифр.
Предполагая , что .NET -
Console.WriteLine(Int32.MaxValue);
Интересно, что Int32.MaxValue содержит больше символов, чем 2,147,486 647.
Но опять же, у нас есть завершение кода,
Так что, я думаю, все, что нам действительно нужно запомнить, это Int3<period>M<enter>, что составляет всего 6 символов для ввода в Visual Studio.
Обновить По какой-то причине я был отвергнут.Единственная причина, о которой я могу думать, - это то, что они не поняли моего первого заявления.
Для ввода "Int32.MaxValue" требуется не более 14 символов.Для ввода 2,147,486 647 требуется либо 10, либо 13 символов, в зависимости от того, ставите вы запятые или нет.
Самый простой способ запомнить - это посмотреть на 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
Поскольку 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 нулями в десятичной.
Как физик, я бы просто перешел к 2 миллиарда (полушутя).Легко запоминается!
В 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
