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

解是 2,147,483,647

最低值为-2,147,483,648。

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

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

假设 .NET -

Console.WriteLine(Int32.MaxValue);

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

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

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

• 斯诺克最大破发次数为2次（最大破发次数为147次）
• 4 年 （48 个月）
• 3 年 （36 个月）
• 4 年 （48 个月）

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

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

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

2147483647.

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 ~= 6.4万 // uint16
• 2^32 ~= 40 亿 // uint32、IPv4、unixtime
• 2^64 ~= 16 quintillion （又名 160 亿或 1600 万亿） // uint64， “bigint”
• 2^128 ~= 256 quintillion quintillion （aka 256 trillion trillion trillions） // IPv6， GUID

2GB的

（答案有最小长度吗？

请记住，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 位的无符号 int，再次加倍表示 40 亿。当然，误差因子越大，误差系数就越高，但你不需要记住确切的值（如果你需要它，无论如何你都应该为它使用预定义的常量）。近似值足以注意到某些东西何时可能危险地接近溢出。

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

2^10 ~ 1000

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

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

再加一倍（2^31）就是20亿，再加一倍（2^32）就是40亿。

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

最简单的记忆方法是查看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;
}

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

如果零是正数，则得到（前面提到的）的逻辑范围

+2147483647 至 -2147483648

如果您认为这太小了，请使用 Int64：

+9223372036854775807 至 -9223372036854775808

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

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

无论如何，采用此正则表达式（它确定字符串是否包含十进制形式的非负整数，该整数也不大于 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]

也许它会帮助你记住。

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

但话又说回来，我们确实有代码补全，

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

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

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

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

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

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

这是关于.无需确切知道.2.1 * 10^92^{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 整数始终是有符号的。

Python 2 中文文档

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

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

因此，当整数大于long2^31 -1

这里有一个记住 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

我经常使用两个到 18 的幂来记住它们，但即使我也没有费心记住 2**31。根据需要进行计算或使用常数，或估计为 2G，这太容易了。

我是这样想起来的：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。

希望这至少会有所帮助。

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

在 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

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

记住它的最佳规则是：
21（神奇的数字！
47 （记住它）
48 （连续！
36 （21 + 15，都是魔法！
47 再次

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

首先写出 47 两次，（你喜欢 Agent 47，对吧？），保留空格，如图所示（每个破折号是一个数字的插槽。前 2 个插槽，然后是 4 个插槽）

--47----47

认为你手里有（因为 12 = 一打）。将其乘以 ，即 47 号特工的第一个数字，然后将结果放在您已有的第一对的右侧12447

12 * 4 = 48
--4748--47 <-- after placing 48 to the right of first 47

然后乘以（为了使 Agent 47 的数字的第二个数字，即 ，你需要 ），并将结果放在前 2 对的右侧，即最后一个对槽12377 - 4 = 3

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。

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

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

到遥远的大草原区，擎天柱三人组六进制四十七月

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

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

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

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

记住这一点： 21 智商项目 47

它可以用任何手机板解码，或者你可以自己在纸上写下来。

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

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

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

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

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

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

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

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