What is the maximum value for an int32?
我永远记不起号码了。我需要一个记忆规则。
号码是2147483647。最简单的记忆方法是纹身。
我能想到的最正确的答案是
如果您认为该值太难在基数10中记住，请尝试基数2：1111111111111111111111111111111111111
如果你能记住整个圆周率，那么你要找的数字就是圆周率小数位数的1867996680到1867996689的位置。
The numeric string 2147483647 appears at the 1,867,996,680 decimal digit of Pi. 3.14......86181221809936452346214748364710527835665425671614...
资料来源：http://www.subadilam.com/pi/
它是10位数，所以假设它是一个电话号码(假设你在美国)。214-783636.我不建议叫它。
与其把它看成一个大数字，不如试着把它分解并寻找相关的想法，例如：
- 斯诺克最多休息2次(最多休息147次)
- 4年(48个月)
- 3年(36个月)
- 4年(48个月)
上面适用于最大的负数；正数是负数。
也许上面的故障对你来说不会再令人难忘了(这很难让人兴奋！)但希望你能想出一些想法！
最大负值(32位)：-2147483648
(1＜31)< BR>
最大正(32位)值：2147483647
~(1＜31)< BR>
助记词："醉酒又叫好色"
1 2 3 4 5 6 7 | 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 |
无论如何，使用这个regex(它确定字符串是否包含十进制形式的非负整数，该整数也不大于Int32.MaxValue)
也许它能帮助你记住。
这就是我记得
- 214-因为2.14大约是π-1
- 48＝6×8
- 64＝8×8
水平书写：
1 2 3 4 | 214_48_64_ and insert: ^ ^ ^ 7 3 7 - which is Boeing's airliner jet (thanks, sgorozco) |
现在你有2147483647。
希望这至少有点帮助。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | 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(约10亿)乘以2^1(2)，或约20亿。2^32是2^30*2^2或大约40亿。这种近似方法精确到2^64左右(误差增长到15%左右)。
如果你需要一个准确的答案，那么你应该拿出一个计算器。
方便的单词对齐容量近似值：
- 2^16~=64千//uint16
- 2^32~=40亿//uint32，ipv4，unixtime
- 2^64~=1600万(亦称160亿或1600万万亿)//uint64，"bigint"
- 2^128~=256万亿次(亦称256万亿万亿万亿次)//ipv6，guid
只要拿一个像样的计算器，在十六进制模式下输入"7fffffff"，然后切换到十进制。
2147483647。
是关于
你可以在C中这样找到它：
1 2 3 4 5 6 7 8 9 | #include <stdio.h> #include <limits.h> main() { printf("max int:\t\t%i ", INT_MAX); printf("max unsigned int:\t%u ", UINT_MAX); } |
给出(没有
1 2 | max int: 2,147,483,647 max unsigned int: 4,294,967,295 |
C++ 11
1 2 3 4 | std::cout << std::numeric_limits<int>::max() <<" "; std::cout << std::numeric_limits<unsigned int>::max() <<" "; |
爪哇
你也可以用Java得到这个：
1 | System.out.println(Integer.MAX_VALUE); |
但是请记住，Java整数总是签名的。
Python2python具有任意精度整数。但在Python2中，它们被映射到C整数。所以你可以这样做：
1 2 3 4 5 | import sys sys.maxint >>> 2147483647 sys.maxint + 1 >>> 2147483648L |
所以当整数大于
这是一个记忆法，用来记住2*31，减去1得到最大整数值。
A=1，B=2，C=3，D=4，E=5，F=6，G=7，H=8，I=9
1 2 | Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide 2 1 4 7 4 8 3 6 4 8 |
我经常使用2到18的力量来记住它们，但即使是我也没有费心去记住2*31。根据需要计算或使用常量，或估计为2g太容易了。
32位，一个用于符号，31位信息：
1 | 2^31 - 1 = 2147483647 |
为什么？1？< BR>因为第一个是零，所以最大的是计数减去一。
为Cantfindaname88编辑
计数是2^31，但最大值不能是2147483648(2^31)，因为我们从0开始计数，而不是1。
1 2 | Rank 1 2 3 4 5 6 ... 2147483648 Number 0 1 2 3 4 5 ... 2147483647 |
另一个只有3位的解释：1代表符号，2代表信息
1 | 2^2 - 1 = 3 |
在所有可能的3位值下面：(2^3=8个值)
1 2 3 4 5 6 7 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个不同的值。其中一半是阴性的。
解决方案是2147483647
最低的是？2147483648。
(注意还有一个负值。)
在这一点上，我想说最简单的记忆方法是在chrome中键入"stackoverflow.com"t"maximum int32"。
这里有一个递归——>堆栈溢出的笑话。我只是没那么古怪而已。
好吧，除了开玩笑，如果你真的在寻找一个有用的记忆规则，我总是用它来记住大数字。
你需要把你的号码分成3-4位数字的部分，然后用手机键盘上的投影来直观地记住它们。在图片上更容易显示：
正如你所看到的，从现在开始你只需要记住3个形状，其中2个看起来像俄罗斯方块，1个看起来像个勾号。这绝对比记住10位数要容易得多。
当您需要回忆数字时，只需回忆形状，想象/看手机键盘，然后将形状投射到键盘上。也许刚开始你需要看键盘，但是经过一点练习，你会记住数字是从左上到右下的，所以你可以简单地想象它在你的头脑中。
只需确保记住形状的方向和每个形状中的数字(例如，在2147483647示例中，我们有一个4位数的俄罗斯方块L和一个3位数的L)。
您可以使用此技术轻松记住任何重要号码(例如，我记得我的16位信用卡号码等)。
先写47两次，(你喜欢47号探员，对吧？)，如图所示保留空格(每个破折号都是一个数字槽。前2个插槽，然后4个)
1 | --47----47 |
你认为你手头有一本书(因为12本=一打)。乘以
1 2 | 12 * 4 = 48 --4748--47 <-- after placing 48 to the right of first 47 |
然后用
1 2 | 12 * 3 = 36 --47483647 <-- after placing 36 to the right of first two pairs |
最后，从最右边的数字(在本例中是2)开始一个接一个地从手上拖动数字，并将它们放在您得到的第一个空槽中。
1 2 | 2-47483647 <-- after placing 2 2147483647 <-- after placing 1 |
给你！对于负极限，可以将其视为绝对值比正极限多1个。
练习几次，你就会掌握窍门的！
对整数执行此操作的最简单方法是使用十六进制，前提是不存在类似int.maxint()的内容。原因是：
最大无符号值
1 2 3 4 5 | 8-bit 0xFF 16-bit 0xFFFF 32-bit 0xFFFFFFFF 64-bit 0xFFFFFFFFFFFFFFFF 128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
有符号值，使用7f作为最大有符号值
1 2 3 4 | 8-bit 0x7F 16-bit 0x7FFF 32-bit 0x7FFFFFFF 64-bit 0x7FFFFFFFFFFFFFFF |
有符号值，使用80作为最大有符号值
4这是怎么工作的？这与二进制策略非常相似，每个十六进制数字正好是4位。而且，许多编译器支持十六进制比支持二进制要好得多。
1 2 3 4 | F hex to binary: 1111 8 hex to binary: 1000 7 hex to binary: 0111 0 hex to binary: 0000 |
所以7f等于0111111/7fff等于011111111111。另外，如果你用这个来表示"非常高的常数"，7f…是安全的十六进制，但它很容易试用7F和80，只需打印到您的屏幕上，看看是哪一个。
0x7fff+0x001=0x8000，所以你的损失只是一个数字，所以用0x7f…对于更可靠的代码来说，通常是一个不错的折衷，尤其是当您开始使用32位或更多的代码时。
2GB
(答案是否有最短长度？)
最好的记忆规则是：21(神奇数字！)47(记住)48(顺序！)36(21+15，两个魔术师！)47又
另外，5对比10位数更容易记住。
如果您不知道
假设.NET
1 | Console.WriteLine(Int32.MaxValue); |
有趣的是，Int32.MaxValue的字符数超过了2147486647。
但是，我们还有代码完成，
所以我想我们真正需要记住的是
更新出于某种原因，我被否决了。我能想到的唯一原因是他们不理解我的第一句话。
"Int32.MaxValue"最多需要14个字符才能键入。2147486647需要10或13个字符来输入，这取决于是否输入逗号。
最容易记住的方法是看
例如(来自msdn)
4请记住，2^(10*x)大约是10^(3*x)-您可能已经习惯了使用千字节/千字节等，即：
1 2 3 | 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亿。当然，误差系数越大，但不需要记忆精确的值(如果需要的话，应该使用预先定义的常量)。这个近似值足以让人注意到什么时候可能会有危险地接近溢出。
我这样做是为了记住2147483647
到一个遥远的萨凡纳四分之一的擎天柱，三人组已于九月四十日结束。1 2 3 4 5 6 7 8 9 10 | 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~1000000
和2^30~100000000
两倍(2^31)是20亿卢布，再翻一倍(2^32)是40亿卢布。
这是一个简单的方法来得到任何二进制数的粗略估计。二进制中的10个零变为十进制中的3个零。
作为一个物理学家，我只需要20亿(半开玩笑)。很容易记住！
在Objective-C(iOS&osx)中，只需记住以下宏：
4有了groovy：
1 | groovy -e" println Integer.MAX_VALUE" |
(Groovy对于Java上下文中的快速引用非常有用。)
Int32表示您有32位可用于存储您的号码。最高的位是符号位，这表示数字是正的还是负的。所以正负数有2^31位。
当零是正数时，您得到的逻辑范围是(前面提到的)
+2147483647至-2147483648
如果您认为这很小，请使用Int64：
+9223372036854775807至-9223372036854775808
你为什么要记住这个号码？在代码中使用？在代码中应该始终使用Int32.MaxValue或Int32.MinValue，因为它们是静态值(在.NET核心中)，因此使用起来比用代码创建新的int快。
我的陈述是：如果通过记忆知道这个数字……你只是在炫耀！
二十一亿四千七百四十八万三千六百四十七
你需要记住的是：
- 它是20亿。
- 接下来的三个三胞胎是这样增长的：100秒，400秒，600秒。
- 第一个和最后一个三联体需要加3个，这样它们才能四舍五入到50(例如147+3=150&647+3=650)
- 第二个三元组需要从它中减去3才能四舍五入到80(例如483-3=480)
因此，2147483647
记住这一点：21智商项目47
它可以用任何电话簿进行编码，也可以直接写在纸上。
为了记住"21智商项目47"，我会说"杀手：代号47有21个任务，每个智商项目都是自己完成的"。
或者"我每天21:47刷牙，因为我智商高，不喜欢吃东西"。
我在C中做了几个天才的方法，你可以在你的生产环境中利用它们：
4到达这个号码的另一种方法：
记住这是第八个梅森素数。
如果这太难，它也是已知的四个梅森双素数中的第三个。
按注释编辑请求：
欧几里得-欧拉定理指出，每一个偶数的形式都是2^(n？1)(2 ^ n)？1)，哪里2^n？1是质数。形式2^n的质数？1被称为梅森素数，它要求n本身是素数。
我们知道Int32的长度当然是32位。考虑到对2的补码的普遍理解，有符号Int32是32位-1位。
为了找到具有给定位数的二进制数的大小，我们通常将2提高到幂N减去1，其中n等于位数。
因此，震级计算为2^(32-1)-1=2^31-1。31是素数，如上所述，这种形式的素数是梅森素数。我们只要数一数就可以证明这是其中的八个。欲了解更多详情，请咨询欧拉，或者可能是伯努利(他写给谁)。
参见：https://books.google.ie/books？ID=x7p4tcppuxoc&printsec=封面&dq=9780883853283&hl=en&sa=x&ved=0ahukewilzborjldahuoyayhcszd-eq6aeiktaa v=onepage&q=9780883853283&f=false
尝试在Python：
1 2 | >>> int('1' * 31, base=2) 2147483647 |
它是2147483647，但是你真的不需要记住这个。这取决于你的号码可以有多少个数字。有时你可以用短int代替。
但是，如果溢出对程序来说是灾难性的，那么您可能需要使用一个不受限制大小的库(但速度会慢一些)。
永远不要忘记任何类型的最大值：
如果它有32位，最大的可能值将是数字为1的32位：
结果将是4294967295，十进制：
但是，由于也有负数的表示，将4294967295除以2，得到2147483647。
因此，32位整数可以表示-2147483647到2147483647
我就是这样记得的…
在十六进制中，一个数字代表四位，所以4*8=32，所以最大有符号32位int是：
1 | 0xFFFFFFFF >> 1 # => 2147483647 |
使用Java 9的RePL，JSeB:
1 2 3 4 5 | $ jshell | Welcome to JShell -- Version 9-Debian jshell> System.out.println(Integer.MAX_VALUE) 2147483647 |
一般来说，你可以做一个简单的操作，它反映了Int32的本质，用1填充所有可用的位——这是你可以在记忆中轻松保存的东西。它在大多数语言中的工作方式基本相同，但我将以Python为例：
1 2 3 4 5 | max = 0 bits = [1] * 31 # Generate a"bit array" filled with 1's for bit in bits: max = (max << 1) | bit # max is now 2147483647 |
对于无符号Int32，将其设为32而不是31 1。
但由于有更多的冒险方法，我开始考虑公式，只是为了好玩…
公式1(如果没有给出运算符，则将数字连接起来)
- A＝4
- B＝8
- BA/A
- AB-1
- 抗体
- AB-A B
- AB-1
python快速检查
1 2 3 4 5 6 | a = 4 b = 8 ab = int('%d%d' % (a, b)) ba = int('%d%d' % (b, a)) '%d%d%d%d%d' % (ba/a, ab-1, ab, ab-a-b, ab-1) # gives '2147483647' |
公式2
- x＝48
- x/2-3
- X-1
- X
- x* 3/4
- X-1
python快速检查
1 2 3 | x = 48 '%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1) # gives '2147483647' |
发挥你的想象力！
Close your eyes and see the old one-legged Chinese farmer Wang who despite his handicap has became the most rich and powerful shepherd in China (hence in the whole world too). His family consists from himself, his wife, their four sons and the sheep dog Alice. One day he gathered all of them on the endless grass field covered with his millions of sheep and said:
I'm old and tired. So I decided to divide my wealth equal between my sons.
他指着所有的羊：
These, my children, are all yours. Each one of you gets 123456789 white sheep, 10101010 black sheep, 203040 spotted sheep, 444888 lambs and 12000 rams. The dog I'll keep for myself. That is what I said.
他靠在妻子的肩上笑了。
< /块引用>所以…我的朋友，想象这张照片！把它想象得栩栩如生，真实如你所能！让它活在你眼前！
然后跪下…开始数数！该字段上的支腿数是Int32的最大值。
但是，所述方法有两个已知缺陷：
人类的想象力没有极限…所以很难限制你自己，想象在计算腿数的时候，在没有创造更多羊的情况下，在那块地上绵羊的确切数量。 人类是懒惰的…所以很多人试着把羊数出来，然后乘以四，而不是数腿，但是…猜猜看-他们睡着了。 您将在二进制文件中找到Int32的最大值是1111111111111111111111111111111。但从10个角度看，你会发现它是2147483647或2^31-1或Int32.MaxValue
我总是在巴别塔图书馆里查阅，这是一个包含所有可能的英文字母表文本的集合。
链接到特定章节中特定书架上特定书籍的特定页面：https://libraryofbabel.info/bookmark.cgi？马克斯国际32
它是2^31-1(32位，一个用于符号)。
如果需要一个近似值，请使用2^10=1024~10^3，因此2^31~2*10^9。如果要手工计算精确值，请使用平方求幂得到2^32=2^(2^5)，然后除以2。你只需要五次平方就可以得到2^32：
2
3
4
5
6
7
8
4*4 = 16
16*16 = 256
256*256 = 25*25*100 + 2*250*6 + 36 = 62500 + 3000 + 36 = 65536
65536*65536 =65000*65000 + 2*65000*536 + 536*536 =
4225000000 + 130000*536 + (250000 + 3600 + 36*36) =
4225000000 + 69680000 + 250000 + 3600 + 1296 =
4294967296除以2再减去1，得到2147483647。如果您不需要所有的数字，但只想说，前三个有效数字，每个平方步的计算是非常容易的。
在c中，在
#include 之后使用INT32_MAX 。在C++中，使用EDOCX1，0，EDCX1，3。或平台特定尺寸的
INT_MAX 或UINT32_MAX 或UINT_MAX 用于unsigned int 。请参阅http://www.cplusplus.com/reference/cstint/和http://www.cplusplus.com/reference/climits/。或
sizeof(int) 。
无论如何，编译器应该优化它。
我更喜欢
1 << 31 - 1 而不是因为你不需要计算
f s因为你不需要
这很容易记住。在十六进制中，一个数字是4位。因此，对于unsigned int，将
0x 和8f s(0xffffffff )写入python或ruby shell中，得到以10为基的值。如果您需要有符号的值，请记住最高的位用作符号。所以你必须把这个忘了。您只需要记住下面3位为1，第4位为0的数字等于7，所以将0x7fffffff 写入python或ruby shell。如果你更容易记住的话，你也可以写0x100000000 - 1 和0x80000000 - 1 。