什么是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要快。

我的声明:如果通过记忆知道这个数字,你只是炫耀!