int32的最大值是多少？

Question

我永远记不住这个号码了。我需要一个记忆规则。

Answer 1

这是2,147,483,647。记忆它的最简单方法是通过纹身。

Answer 2

我能想到的最正确的答案是Int32.MaxValue。

Answer 3

如果您认为基数10中的值太难记住，请尝试基数2： 1111111111111111111111111111111

Answer 4

如果您能记住整个Pi编号，那么您要查找的编号位于1,867,996,680位，直到Pi的十进制数字为1,867,996,689

  

数字字符串2147483647出现在Pi的1,867,996,680十进制数字处。 3.14 ...... 86181221809936452346的 2147483647 10527835665425671614 ...

来源：http://www.subidiom.com/pi/

Answer 5

这是10位数，所以假装它是一个电话号码（假设你在美国）。 214-748-3647。我不建议打电话给它。

Answer 6

不要将其视为一个大数字，而是尝试将其分解并寻找相关的想法，例如：

• 2个最大斯诺克台球休息时间（最大休息时间为147）
• 4年（48个月）
• 3年（36个月）
• 4年（48个月）

以上适用于最大负数;积极的是减一。

也许上面的细分对你来说不再令人难忘（这简直令人兴奋！），但希望你能提出一些想法！

Answer 7

最大负值（32位）值：-2147483648
（1 <＆lt; 31）

最大正（32位）值：2147483647
〜（1 <＆lt; 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's 18+ material of it) 

21 47 4(years) 3(years) 4(years)
21 47 48       36       48

Answer 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]

也许这会帮助你记住。

Answer 9

这就是我记得的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。

希望这有助于至少一点。

Answer 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（signed 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~ = 16 quintillion（又名160亿或1600万万）// uint64，“bigint”
• 2 ^ 128~ = 256 quintillion quintillion（又名256万亿亿亿）// IPv6，GUID

Answer 11

只需使用任何不错的计算器并在十六进制模式下键入“7FFFFFFF”，然后切换到十进制。

2147483647。

Answer 12

关于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

当整数大于long

时，Python会切换到2^31 -1

Answer 13

这是记忆2 ** 31的助记符，减去1以获得最大整数值。

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到18的力量来记住它们，但即使我没有记住2 ** 31。根据需要计算太容易或使用常数，或估计为2G。

Answer 14

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

Answer 15

嗯，它有32位，因此可以存储2 ^ 32个不同的值。其中一半是消极的。

解决方案是2,147,483,647

最低的是-2,147,483,648。

（请注意，还有一个负值。）

Answer 16

此时，我说最简单的助记符是键入＆＃34; stackoverflow.com＆＃34; TAB ＆＃34;最大值为int32＆＃34;进入Chrome。

有一个递归 - ＆gt;堆栈溢出的笑话在某处。我不是那么讨厌。

Answer 17

嗯，除了笑话，如果你真的在寻找一个有用的记忆规则，我总会用它来记住大数字。

您需要将您的号码分成3-4位数的部分，并使用手机键盘上的投影直观地记住它们。它更容易在图片上显示：

正如你所看到的，从现在开始你只需要记住3个形状，其中2个看起来像是俄罗斯方块L，而其中一个看起来像是嘀嗒。这绝对比记忆10位数字容易得多。

当您需要回忆这个数字时，只需回忆一下形状，想象/看一下手机键盘并在其上投影形状。也许最初你必须要看键盘，但经过一些练习之后，你会记住这些数字是从左上角到右下角所以你可以简单地想象它在你的头。

请确保记住形状的方向和每个形状中的位数（例如，在2147483647中，我们有一个4位数的俄罗斯方块L和一个3位数的L）。

您可以使用此技术轻松记住任何重要数字（例如，我记得我的16位信用卡号等）。

Answer 18

首先写出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比正限制更多。

练习几次，你就会掌握它！

Answer 19

对整数执行此操作的最简单方法是使用十六进制，前提是不存在类似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位或更多

Answer 20

2GB

（答案的最小长度是多少？）

Answer 21

如果你碰巧知道你的ASCII table而不是MaxInt：
!GH6G = 21 47 48 36 47

Answer 22

记住它的最佳规则是：
21 （幻数！）
47 （只记得它）
48 （顺序！）
36 （21 + 15，两个魔法！）
47 再次

此外，记住5对比10位更容易。

Answer 23

有趣的是，Int32.MaxValue的字符数多于2,147,486,647。

但话说回来，我们确实有代码完成，

所以我想我们真正需要记住的是Int3<period>M<enter>，在视觉工作室中输入只有6个字符。

<强>更新 出于某种原因，我被投票了。我能想到的唯一原因是他们不理解我的第一个陈述。

“Int32.MaxValue”最多需要输入14个字符。 2,147,486,647需要输入10或13个字符，具体取决于您是否输入逗号。

Answer 24

假设.NET -

Console.WriteLine(Int32.MaxValue);

Answer 25

最简单的方法是查看std::numeric_limits< int >::max()

例如（from 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;
}

Answer 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即可获得大约20亿。对于使用32位的unsigned int，再次加倍为40亿。当然，误差因子越大，但你不需要记忆的确切值（如果你需要它，你应该使用预定义的常量）。大概的值足以让人注意到什么东西可能危险地接近溢出。

Answer 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

Answer 28

作为一名物理学家，我只会走向<强> 20亿（半开玩笑）。容易记住！

Answer 29

你是什​​么意思？应该很容易记住它是2 ^ 32。 如果你想要一个规则来记住那个数字的值，一个方便的经验法则是在二进制和十进制之间进行转换：

2 ^ 10~1000

表示2 ^ 20~1,000,000

和2 ^ 30~1,000,000,000

加倍（2 ^ 31）至20亿，再加倍（2 ^ 32）为40亿。

这是一种简单的方法来粗略估计任何二进制数。二进制中的10个零成为十进制的3个零。

Answer 30

在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

Answer 31

记住这个： 21 IQ ITEM 47

可以使用任何手机垫对其进行解码，也可以在纸上自行编写一个。

为了记住“21 IQ ITEM 47”，我会选择“Hitman：Codename 47有21个任务，这些任务都是IQ ITEM的。”

或者“我每天21:47清洁牙齿，因为我的智商高，不喜欢嘴里的东西”。

Answer 32

2147483647

以下是您需要记住的内容：

• 20亿。
• 接下来的三个三胞胎正如此增加： 100s，400s，600s
• 第一个和最后一个三元组需要 3 ，因此它们会向上舍入到 50 （例如147 + 3 = 150＆647; 3 = 650）
• 第二个三元组需要从 3 中减去 80 （例如483 - 3 = 480）

因此2,147,483,647

Answer 33

在路径上使用Groovy：

groovy -e " println Integer.MAX_VALUE "

（在Java上下文中，Groovy对于快速引用非常有用。）

Answer 34

Int32表示您有32位可用于存储您的号码。最高位是符号位，这表示该数​​字是正数还是负数。所以你有2 ^ 31位的正数和负数。

如果为正数，则得到（之前提到的）

的逻辑范围

+2147483647至-2147483648

如果您认为这是小的，请使用Int64：

+9223372036854775807 to -9223372036854775808

为什么你想要记住这个数字呢？要在你的代码中使用？您应该始终在代码中使用Int32.MaxValue或Int32.MinValue，因为这些是静态值（在.net内核中），因此比使用代码创建新int更快。

我的陈述：如果通过记忆知道这个数字......你只是炫耀！

Answer 35

我在C＃中创建了一些天才方法，您可以在生产环境中利用这些方法：

22

Answer 36

尝试使用Python：

>>> int('1' * 31, base=2)
2147483647

Answer 37

达到此数字的另一种方法：

1. 播放2048直到其最大理论极限。图中：USHRT_MAX之前的15次移动。
2. 将结果平方。关于UINT_MAX。
3. 除以2和-1得到INT_MAX。

Answer 38

这是2147483647，但你真的不需要记住它。这取决于您的号码可以有多少位数。有时您可以使用short int。

如果溢出对你的程序来说是灾难性的，你可能需要使用一个无限大小的库（虽然会慢一些）。

Answer 39

请记住，这是梅森的第八个素数。

如果这太难了，它也只是四个已知的双梅森素数中的第三个。

根据评论请求进行修改：

Euclid-Euler定理指出每个偶数完全数具有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是素数并且如上所述，这种形式的素数是梅森素数。我们可以通过计算它们来证明它是八个。有关详细信息，请咨询Euler，或者也许是Bernoulli（他向他们写过这些文章）。

请参阅：https://books.google.ie/books?id=x7p4tCPPuXoC&printsec=frontcover&dq=9780883853283&hl=en&sa=X&ved=0ahUKEwilzbORuJLdAhUOiaYKHcsZD-EQ6AEIKTAA#v=onepage&q=9780883853283&f=false

Answer 40

永远不要忘记任何类型的最大值：

如果它有32位，则最大可能值为32位，数字为1：

结果是小数为4294967295：

但是，由于还有负数的表示，将4294967295除以2得到2147483647.

因此，32位整数能够表示-2147483647到2147483647

Answer 41

这是我记得的...... 在十六进制中，数字表示四位，因此4 * 8 = 32，因此最大符号32位int为：

0xFFFFFFFF >> 1 # => 2147483647

Answer 42

使用Java 9的REPL，jshell：

$ jshell
|  Welcome to JShell -- Version 9-Debian

jshell> System.out.println(Integer.MAX_VALUE)
2147483647

Answer 43

一般来说，你可以做一个简单的操作，它反映了Int32的本质，用1＆＃39; s填充所有可用的位 - 这是你可以轻松掌握在你的记忆中的东西。它在大多数语言中的工作方式基本相同，但我会以Python为例：

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＆＃39。

但是，由于发布了一些更冒险的方法，我开始考虑公式，只是为了它的乐趣......

公式1 （如果没有给出运算符，则连接数字）

• a = 4
• b = 8
• BA / A
• AB-1
• AB
• AB-AB
• AB-1

Python快速检查

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快速检查

x = 48
'%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1) 
# gives '2147483647'

Answer 44

你会发现二进制Int32的最大值是1111111111111111111111111111111 但在十个基础上你会发现它是2147483647或2 ^ 31-1或Int32.MaxValue

Answer 45

我总是只在Babel图书馆中查找，该图书馆包含所有可能的英文字母文本。

此处是指向特定部分中特定书架上特定书籍的特定页面的链接：https://libraryofbabel.info/bookmark.cgi?max_int32

Answer 46

发挥您的想象力！

  

闭上眼睛，看看老一脚的中国农民王先生，尽管他有残障，但他已经成为中国最有钱有势的牧羊人（因此也是全世界）。他的家人由他本人，他的妻子，他们的四个儿子和爱丽丝牧羊犬组成。有一天，他把所有的人聚集在覆盖着数百万只羊的无尽草地上，说道：

     

    

我又老又累。因此，我决定将自己的财富平均分配给儿子们。

  

     

他指着所有的绵羊：

     

    

这些，我的孩子们，都是你的。你们每个人都会得到123456789只白羊，10101010只黑羊，203040只斑点羊，444888只羔羊和12000只公羊。我会自己养的狗。我就是这么说的。

  

     

他靠在妻子的肩膀上，微笑。

所以...我的朋友，想象一下这张照片！尽可能生动，真实地成像它！让它生活在您的眼前！

然后跪下……开始计数！该字段上的分支数是int32的最大值。

所描述的方法有两个已知的缺陷：

1. 人类的想像力是无限的...所以很难束缚自己并想像出那个领域的绵羊的确切数目，而又不会在盘腿时再造出更多的绵羊。
2. 人类很懒...所以很多人试图只数绵羊并乘以四，而不是数腿，但是...猜怎么着-他们入睡了。

Answer 47

在C INT32_MAX之后使用#include <stdint.h>。 在C ++中INT32_MAX之后使用#include <cstdint>。

或INT_MAX表示特定于平台的尺寸，或UINT32_MAX或UINT_MAX表示unsigned int。请参阅http://www.cplusplus.com/reference/cstdint/和http://www.cplusplus.com/reference/climits/。

或sizeof(int)。

Answer 48

它是2 ^ 31 - 1（32位，一个用于符号）。

如果你想要一个近似值，使用2 ^ 10 = 1024~10 ^ 3，所以2 ^ 31~2 * 10 ^ 9。如果要手动计算精确值，请使用取幂，通过平方得到2 ^ 32 = 2 ^（2 ^ 5）并除以2。你只需要平方五次得到2 ^ 32：

2*2 = 4
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.如果您不需要所有数字，但只想说出前三个有效数字，则每个平方步骤的计算都非常简单。

Answer 49

max_signed_32_bit_num = 1 << 31 - 1;  // alternatively ~(1 << 31)

编译器应该优化它。

我更喜欢1 << 31 - 1而不是

0x7fffffff，因为您不需要计算f s

unsigned( pow( 2, 31 ) ) - 1，因为您不需要<math.h>

Answer 50

很容易记住。在十六进制中，一位是4位。因此，对于unsigned int，将0x和8 f s（0xffffffff）写入Python或Ruby shell以获取基数为10的值。如果需要有符号值，请记住最高位用作符号。所以你必须把它留下来。您只需记住低3位为1且第4位为0的数字等于7，因此将0x7fffffff写入Python或Ruby shell。如果您更容易记住，也可以写0x100000000 - 1和0x80000000 - 1。

Answer 51

“如果不调用大整数，您将调用此助记符。”

现在计算每个单词中的字母。