什么是int32的最大值？
我永远不会记得这个号码。 我需要一个内存规则。
这是2,147,483,647 。 记住它最简单的方法是通过纹身。
我能想到的最正确的答案是Int32.MaxValue 。
如果你认为这个值在10进制中难以记忆，那么试试2：1111111111111111111111111111111
这是10位数，所以假装它是一个电话号码（假设你在美国）。 214-748-3647。 我不build议调用它。
如果你能记住整个Pi号码，那么你正在寻找的号码位于Pi的十进制数字的位置1,867,996,680直到1,867,996,689
数字string2147483647出现在Pi的1,867,996,680十进制数字处。 3.14 …… 86181221809936452346 2147483647 10527835665425671614 …
来源： http : //www.subidiom.com/pi/
不要把它看作是一个大数字，而是尝试分解并寻找相关的想法，例如：
- 2次最大斯诺克分数（最大分数是147）
- 4年（48个月）
- 3年（36个月）
- 4年（48个月）
以上适用于最大的负数; 积极的是减去一个。
也许上面的细节对你来说不会让人难忘（这不是令人兴奋的），但希望你能想出一些想法！
最大的负值（32位）值：-2147483648
（1 << 31）
最大正值（32位）值：2147483647
〜（1 << 31）
助记符：“醉AKAangular质”
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
无论如何，采取这个正则expression式（它确定如果string包含一个十进制forms的非负整数也不大于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大约是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。
希望这有助于至less一点。
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（约10亿）乘以2 ^ 1（2），即约20亿。 2 ^ 32是2 ^ 30 * 2 ^ 2或约40亿。 这种近似方法甚至可以达到2 ^ 64左右（误差增加到15％左右）。
如果你需要一个确切的答案，那么你应该拉起一个计算器。
方便的字alignment容量近似值：
- 2 ^ 16〜= 64000 // uint16
- 2 ^ 32〜= 40亿// uint32，IPv4，unixtime
- 2 ^ 64〜16十亿（也就是160亿亿或1600万亿）// uint64，“bigint”
- 2 ^ 128〜256 =百万分之一千万亿（也就是256万亿亿万亿次）// IPv6，GUID
只要拿一个像样的计算器，在hex模式下input“7FFFFFFF”，然后切换到十进制。
2147483647。
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 ** 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
我经常使用两到十八的能力来记住它们，但即使我没有背诵2 ** 31。 根据需要计算太容易，或者使用常数，或者估计为2G。
大约是2.1 * 10^9 。 不需要知道确切的2^{31} - 1 = 2,147,483,647 。
C
你可以像这样在C中find它：
#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
Python有任意的精度整数。 但在Python 2中，它们映射到C整数。 所以你可以这样做：
import sys sys.maxint >>> 2147483647 sys.maxint + 1 >>> 2147483648L
所以当整数大于2^31 -1时，Python会切换到long时间
那么，它有32位，因此可以存储2 ^ 32个不同的值。 其中一半是负面的。
解决scheme是2,147,483,647
最低的是-2,147,483,648。
（请注意，还有一个负值。）
在这一点上，我会说最简单的助记符是键入“stackoverflow.com”选项卡“最大int32”到Chrome。
在那里有一个recursion – >堆栈溢出笑话。 我只是不那么讨厌
对于整数来说，最简单的方法是使用hex，只要不存在像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
这个怎么用？ 这与二进制策略非常相似，每个hex数字正好是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 …是安全的hex，但是很容易尝试7F和80，只是打印它们到你的屏幕看看是哪一个。
0x7FFF + 0x0001 = 0x8000，所以你的损失是只有一个数字，所以使用0x7F …通常是不是一个更可靠的代码，尤其是一旦你开始使用32位或更多
2GB
（有答案的最小长度？）
首先写出47次（你喜欢Agent 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 倍多。
练习几次，你会得到它的窍门！
假设.NET –
Console.WriteLine(Int32.MaxValue);
最简单的方法是查看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; }
如果你碰巧知道你的ASCII表而不是MaxInt ：
!GH6G = 21 47 48 36 47
记住它的最好的规则是：
21 （魔术数字！）
47 （只记得它）
48 （顺序！）
36 （21 + 15，都是魔法！）
47再次
记住5对比10位更容易。
只要记住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就可以得到大约20亿个。 对于使用32位的无符号整数，再次翻倍为40亿。 误差因素越大，当然就越大，但是你不需要记住确切的值（如果你需要的话，你应该使用一个预先定义的常量）。 近似值足以发现什么时候某个东西可能会危险地接近溢出。
有趣的是，Int32.MaxValue的字符数多于2,147,486,647。
但是再次，我们有代码完成，
所以我想我们真正要记住的是Int3<period>M<enter> ，在Visual Studio中只能Int3<period>M<enter> 6个字符。
更新由于某种原因，我被低估了。 我能想到的唯一原因是他们不理解我的第一个陈述。
“Int32.MaxValue”最多需要14个字符才能input。 2,147,486,647可以input10或13个字符，具体取决于您是否input逗号。
你什么意思？ 应该很容易记住它是2 ^ 32。 如果你想要一个规则来记住这个数字的值，一个简便的规则就是在二进制和十进制之间进行转换：
2 ^ 10〜1000
这意味着2 ^ 20〜100万
和2 ^ 30〜10亿
双（2 ^ 31）是20亿，再加倍（2 ^ 32）是40亿。
这是一个简单的方法来粗略估计任何二进制数。 二进制中的十个零变成十进制的三个零。
那么，除了笑话，如果你真的在寻找一个有用的记忆规则，那么我总是使用它来记忆大数字。
您需要将您的号码分成3-4位数字，并使用手机键盘上的投影进行视觉记忆。 在照片上显示更容易：
正如你所看到的，从现在起， 你只需要记住3个形状，其中2个看起来像一个俄罗斯方块L，一个看起来像一个蜱 。 这绝对比记忆一个10位数字容易得多。
当你需要回忆这个数字时，只需回想一下这些形状，就可以在电话键盘上想象/看一下，然后投射这些形状。 也许最初你必须看看键盘，但经过一些练习之后，你会记得数字是从左上angular到右下angular的，所以你可以简单地想象一下。
只要确保你记得形状的方向和每个形状的数字的数量（例如，在2147483647的例子中，我们有一个4位的Tetris L和一个3位的L）。
您可以使用这种技术轻松记住任何重要的数字（例如，我记得我的16位信用卡号码等）。
在Objective-C（iOS和OSX）中，只记得这些macros：
#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
这是我如何去记住2,147,483,647
到一个遥远的热带稀树草原三分之一的四分之一七十七岁的美国人
2 - To 1 - A 4 - Far 7 - Savannah 4 - Quarter 8 - Optimus 3 - Trio 6 - Hexed 4 - Forty 7 - Septenary
Int32意味着你有32位可用来存储你的号码。 最高位是符号位，这表示数字是正数还是负数。 所以你有2 ^ 31位的正数和负数。
零是一个正数，你得到的逻辑范围（前面提到）
+2147483647至-2147483648
如果你认为这是小的，使用Int64：
+9223372036854775807至-9223372036854775808
为什么你要记住这个号码？ 在你的代码中使用？ 你应该总是在你的代码中使用Int32.MaxValue或者Int32.MinValue，因为它们是静态值（在.net内核中），因此比使用代码创build一个新的int要快。
我的声明：如果通过记忆知道这个数字，你只是炫耀！
