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

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

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

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

如果您能记住整个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/

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

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

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

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

也许上面的故障对您来说不再令人难忘了（这确实令人兴奋！），但希望您能提出一些想法！

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

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

希望这至少可以有所帮助。

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〜= 64000 // // uint16
• 2 ^ 32〜= 40亿// // uint32，IPv4，unixtime
• 2 ^ 64〜= 16兆（即160亿亿或1600亿亿）// uint64，“ bigint”
• 2 ^ 128〜= 256亿个quintillion（aka 256万亿兆兆），// IPv6，GUID

只需带上任何像样的计算器，然后在十六进制模式下键入“ 7FFFFFFF”，然后切换到十进制即可。

2147483647。

关于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整数始终是带符号的。

Python 2

Python具有任意精度的整数。但是在Python 2中，它们被映射为C整数。因此，您可以执行以下操作：

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

因此，long当整数大于2^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的幂来记住它们，但是即使我也没有打扰记住2 ** 31。根据需要进行计算或使用常数或将其估算为2G太容易了。

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

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

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

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

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

好吧，除了笑话，如果您真的在寻找有用的记忆法则，那么我经常会用它来记住大数。

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

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

当您需要调出数字时，只需调出形状，在电话键盘上想象/看一下并在其上投影形状即可。也许一开始您必须先看一下键盘，但经过一些练习，您会记住数字从左上到右下，因此您可以在脑海中简单地想象它。

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

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

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

首先两次写出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比正极限多1。

练习几次，您将掌握其中的窍门！

2GB

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

假设.NET-

Console.WriteLine(Int32.MaxValue);

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

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

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

记住的最简单方法是看 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.MaxValue的字符数超过2,147,486,647。

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

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

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

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

只需记住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亿。当然，误差因子越大，误差因子就越高，但是您不需要存储确切的值（如果需要，则无论如何都应使用预定义的常数）。近似值足够好，足以提醒您可能危险地接近溢出。

这就是我要记住2,147,483,647的方式

到远大草原季度擎天柱三重奏四十年代

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〜1,000,000

和2 ^ 30〜1,000,000,000

将（2 ^ 31）翻倍达到20亿，再翻一番（2 ^ 32）变为40亿。

这是对任何二进制数进行粗略估计的一种简便方法。二进制的10个零变为十进制的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

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

以零为正数，您将获得（前面提到的）的逻辑范围

+2147483647至-2147483648

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

+9223372036854775807至-9223372036854775808

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

我的说法：如果通过记忆知道这个数字，那么您就是在炫耀！

记住这一点：21 IQ项目47

可以使用任何电话键盘对其进行解码，或者您也可以自己将其写下来。

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

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