integer - int32 的最大值是多少？

Question

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

score 5064 · Accepted Answer

5064

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

于 2008-09-18T17:20:17.460 回答

score 493 · Accepted Answer

493

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

于 2008-09-18T17:23:34.537 回答

score 439 · Accepted Answer

如果您认为以 10 为基数很难记住该值，请尝试以 2 为基数：1111111111111111111111111111111

score 316 · Accepted Answer

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

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

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

score 290 · Accepted Answer

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

score 172 · Accepted Answer

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

最多 2 次斯诺克休息（最多 147 次）
4年（48个月）
3年（36个月）
4年（48个月）

以上适用于最大的负数；正是负一。

也许上面的分解对你来说不会再令人难忘了（这几乎不是令人兴奋的！），但希望你能想出一些想法！

score 144 · Accepted Answer

最大负（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

score 75 · Accepted Answer

无论如何，采用这个正则表达式（它确定字符串是否包含一个不大于 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]

也许它会帮助你记住。

score 61 · Accepted Answer

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

希望这至少有一点帮助。

score 55 · Accepted Answer

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%）。

如果你需要一个准确的答案，那么你应该拿出一个计算器。

方便的字对齐容量近似值：

2^16 ~= 64000 // uint16
2^32 ~= 40 亿 // uint32, IPv4, unixtime
2^64 ~= 16 quintillion（又名 160 亿或 1600 万万亿） // uint64, "bigint"
2^128 ~= 256 quintillion quintillion（又名 256 万亿万亿）// IPv6，GUID

score 46 · Accepted Answer

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

2147483647。

score 36 · Accepted Answer

它是关于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 来获得它：

System.out.println(Integer.MAX_VALUE);

但请记住，Java 整数始终是有符号的。

蟒蛇2

Python 具有任意精度的整数。但在 Python 2 中，它们被映射到 C 整数。所以你可以这样做：

import sys
sys.maxint
>>> 2147483647
sys.maxint + 1
>>> 2147483648L

所以 Python 切换到long当整数大于2^31 -1

score 35 · Accepted Answer

这里有一个记忆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 到 18 的幂来记住它们，但即使我也没有费心记住 2**31。太容易根据需要计算或使用常数，或估计为2G。

score 31 · Accepted Answer

32位，1位符号，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

score 30 · Accepted Answer

好吧，它有 32 位，因此可以存储 2^32 个不同的值。其中一半是负面的。

解是 2,147,483,647

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

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

score 28 · Accepted Answer

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

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

如您所见，从现在开始您只需要记住 3 个形状，其中 2 个看起来像俄罗斯方块 L，一个看起来像勾号。这绝对比记住一个 10 位数字要容易得多。

当您需要回忆数字时，只需回忆形状，想象/看一下手机键盘并将形状投影在上面。也许一开始你必须看一下键盘，但经过一些练习后，你会记得数字是从左上角到右下角的，所以你可以在脑海中简单地想象它。

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

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

score 21 · Accepted Answer

对整数执行此操作的最简单方法是使用十六进制，前提是没有像 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 等于 0111111111111111。此外，如果您将其用于“异常高的常数”，则 7F... 是安全的十六进制，但尝试 7F 和 80 并打印它们很容易到你的屏幕上看看它是哪一个。

0x7FFF + 0x0001 = 0x8000，所以你的损失只是一个数字，所以使用 0x7F... 通常对于更可靠的代码来说并不是一个糟糕的权衡，尤其是当你开始使用 32 位或更多位时

score 21 · Accepted Answer

首先写出 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 对的右侧，最后一个 pair-slot

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。

多练习几次，你就会掌握窍门！

score 20 · Accepted Answer

20

2GB

（答案是否有最小长度？）

于 2008-09-18T17:57:51.630 回答

score 15 · Accepted Answer

15

假设 .NET -

Console.WriteLine(Int32.MaxValue);

于 2008-09-18T17:23:31.040 回答

score 15 · Accepted Answer

15

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

于 2014-09-05T03:15:09.277 回答

score 15 · Accepted Answer

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

此外，记住 5 对比记住 10 个数字更容易。

score 14 · Accepted Answer

最容易记住的方法是看 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;
}

score 14 · Accepted Answer

有趣的是，Int32.MaxValue 的字符数超过了 2,147,486,647。

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

所以我想我们真正需要记住的是Int3<period>M<enter>，在 Visual Studio 中只需输入 6 个字符。

更新由于某种原因，我被否决了。我能想到的唯一原因是他们不理解我的第一句话。

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

score 10 · Accepted Answer

请记住 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 亿。当然，误差系数越大，你走的越大，但你不需要记住确切的值（如果你需要它，你应该为它使用一个预定义的常量）。近似值足以注意到某物何时可能危险地接近溢出。

score 9 · Accepted Answer

这就是我如何记住 2,147,483,647

到遥远的大草原四分之一擎天柱三重奏被诅咒四十

2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary

score 7 · Accepted Answer

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

2^10 ~ 1000

这意味着 2^20 ~ 1,000,000

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

加倍 (2^31) 大约是 20 亿，再加倍 (2^32) 是 40 亿。

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

score 6 · Accepted Answer

在 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

score 5 · Accepted Answer

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

零是一个正数，你得到（前面提到的）的逻辑范围

+2147483647 至 -2147483648

如果您认为它很小，请使用 Int64：

+9223372036854775807 至 -9223372036854775808

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

我的声明：如果凭记忆知道这个数字..你只是在炫耀！

score 5 · Accepted Answer

记住这一点：21 IQ 第 47 项

它可以用任何电话板进行解码，或者您可以自己在纸上写下一个。

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

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

score 4 · Accepted Answer

在路径上使用 Groovy：

groovy -e " println Integer.MAX_VALUE "

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

score 4 · Accepted Answer

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

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

根据评论请求编辑：

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 是素数，如上所述，这种形式的素数是梅森素数。我们可以通过简单地计算它们来证明它是其中的八个。有关更多详细信息，请询问欧拉，或者可能是伯努利（他写信给谁）。

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

score 4 · Accepted Answer

2147483647

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

是20亿。
接下来的三个三元组是这样增加的：100s、400s、600s
第一个和最后一个三元组需要加3，以便四舍五入到50（例如 147 + 3 = 150 & 647 + 3 = 650）
第二个三元组需要减去3以将其四舍五入为80（例如 483 - 3 = 480）

因此 2, 147, 483, 647

score 4 · Accepted Answer

我在 C# 中制作了几个天才方法，您可以在生产环境中利用它们：

public static int GetIntMaxValueGenius1()
{
    int n = 0;
    while (++n > 0) { }
    return --n;
}

public static int GetIntMaxValueGenius2()
{
    int n = 0;
    try
    {
        while (true)
            n = checked(n + 1);
    }
    catch { }
    return n;
}

score 2 · Accepted Answer

这就是我记得的方式......
在十六进制中，一个数字代表四位，所以 4 * 8 = 32，所以最大有符号的 32 位 int 是：

0xFFFFFFFF >> 1 # => 2147483647

score 2 · Accepted Answer

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

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

结果将是十进制的 4294967295：

但是，由于也有负数的表示，所以将 4294967295 除以 2 得到 2147483647。

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

score 1 · Accepted Answer

这很容易记住。在十六进制中，一位是 4 位。因此，对于 unsigned int 写入0x和 8 fs ( 0xffffffff) 到 Python 或 Ruby shell 以获取以 10 为底的值。如果您需要带符号的值，请记住最高位用作符号。所以你必须把它排除在外。您只需要记住低 3 位为 1，第 4 位为 0 的数字等于 7，因此写入0x7fffffffPython 或 Ruby shell。你也可以写0x100000000 - 1and 0x80000000 - 1，如果这样你更容易记住的话。

score 1 · Accepted Answer

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

score 1 · Accepted Answer

使用 Java 9 的 REPL，jshell：

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

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

score 1 · Accepted Answer

1

在 Python 中尝试：

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

于 2018-07-05T02:29:55.573 回答

score 0 · Accepted Answer

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

或INT_MAX用于特定于平台的大小或UINT32_MAX或UINT_MAX用于unsigned int. 请参阅http://www.cplusplus.com/reference/cstdint/和http://www.cplusplus.com/reference/climits/。

或sizeof(int)。

score 0 · Accepted Answer

一般来说，你可以做一个反映 Int32 本质的简单操作，用 1 填充所有可用位 - 这是你可以轻松记住的东西。它在大多数语言中的工作方式基本相同，但我以 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。

但是自从贴了一些更冒险的方法后，我开始想到公式，只是为了好玩……

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

a = 4
b = 8
BA/A
ab-1
抗体
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'

score 0 · Accepted Answer

“如果一个大整数没有被召回，你就召回这个助记符。”

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

score -1 · Accepted Answer

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

无论如何，编译器都应该优化它。

我更1 << 31 - 1喜欢

0x7fffffff因为你不需要 count fs

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

score -1 · Accepted Answer

它是 2 ³¹ - 1（32 位，1 用于符号）。

如果您想要一个近似值，请使用 2 ¹⁰ = 1024 ≈ 10 ³，因此 2 ³¹ ≈ 2*10 ⁹。如果您想手动计算一个精确值，请使用平方乘幂得到 2 ³² = 2 ^{(2 ⁵ )}并除以 2。您只需平方五次即可得到 2 ³²：

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 得到 2,147,483,647。如果您不需要所有数字，而只想说前三个有效数字，则每个平方步骤的计算都非常容易。

integer - int32 的最大值是多少？

45 回答 45

C

C++ 11

爪哇

蟒蛇2

到遥远的大草原四分之一擎天柱三重奏被诅咒四十

Related

Reference