45 回答 45

This answer is useful

5064

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

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

This answer is useful

493

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

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

This answer is useful

439

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

于 2010-06-01T17:05:17.017 回答

This answer is useful

316

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

于 2015-10-26T22:19:25.220 回答

This answer is useful

290

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

于 2008-09-18T17:24:53.177 回答

This answer is useful

172

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

最多 2 次斯诺克休息（最多 147 次）

4年（48个月）

3年（36个月）

4年（48个月）

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

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

于 2008-09-18T17:27:42.717 回答

This answer is useful

144

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

于 2012-06-15T20:04:05.697 回答

This answer is useful

75

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

也许它会帮助你记住。

于 2010-06-01T16:44:09.660 回答

This answer is useful

61

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

希望这至少有一点帮助。

于 2013-07-05T11:11:48.123 回答

This answer is useful

55

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

于 2008-09-18T17:48:38.343 回答

This answer is useful

46

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

2147483647。

于 2008-09-18T17:47:13.653 回答

This answer is useful

36

它是关于2.1 * 10^9。不需要知道确切的2^{31} - 1 = 2,147,483,647。

C

你可以像这样在 C 中找到它：

#include

#include

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::max() << "\n";

std::cout << std::numeric_limits::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

于 2012-11-27T18:59:40.073 回答

This answer is useful

35

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

于 2013-05-08T19:31:23.547 回答

This answer is useful

31

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

于 2013-12-04T11:38:25.580 回答

This answer is useful

30

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

解是 2,147,483,647

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

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

于 2008-09-18T17:19:40.987 回答

This answer is useful

28

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

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

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

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

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

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

于 2017-07-15T09:44:00.173 回答

This answer is useful

21

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

于 2012-09-14T15:50:14.200 回答

This answer is useful

21

首先写出 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。

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

于 2015-03-24T19:09:00.573 回答

This answer is useful

20

2GB

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

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

This answer is useful

15

假设 .NET -

Console.WriteLine(Int32.MaxValue);

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

This answer is useful

15

如果您碰巧知道您的ASCII 表，而不是MaxInt：

!GH6G = 21 47 48 36 47

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

This answer is useful

15

记住它的最佳规则是：

21（魔术数字！）

47（记住它）

48（顺序！）

36（21 + 15，两个魔术！）

47再一次

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

于 2015-02-26T13:33:47.373 回答

This answer is useful

14

最容易记住的方法是看 std::numeric_limits< int >::max()

例如（来自 MSDN），

// numeric_limits_max.cpp

#include

#include

using namespace std;

int main() {

cout << "The maximum value for type float is: "

<< numeric_limits::max( )

<< endl;

cout << "The maximum value for type double is: "

<< numeric_limits::max( )

<< endl;

cout << "The maximum value for type int is: "

<< numeric_limits::max( )

<< endl;

cout << "The maximum value for type short int is: "

<< numeric_limits::max( )

<< endl;

}

于 2009-03-03T11:42:30.103 回答

This answer is useful

14

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

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

所以我想我们真正需要记住的是Int3M，在 Visual Studio 中只需输入 6 个字符。

更新

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

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

于 2010-06-01T16:50:14.433 回答

This answer is useful

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

于 2008-09-18T17:58:45.607 回答

This answer is useful

9

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

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

2 - To

1 - A

4 - Far

7 - Savannah

4 - Quarter

8 - Optimus

3 - Trio

6 - Hexed

4 - Forty

7 - Septenary

于 2015-08-05T05:15:07.617 回答

This answer is useful

7

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

2^10 ~ 1000

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

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

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

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

于 2009-03-03T11:18:59.647 回答

This answer is useful

6

在 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

于 2013-12-04T11:51:35.707 回答

This answer is useful

5

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

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

+2147483647 至 -2147483648

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

+9223372036854775807 至 -9223372036854775808

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

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

于 2009-06-17T09:16:25.397 回答

This answer is useful

5

记住这一点：21 IQ 第 47 项

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

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

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

于 2016-01-27T08:21:07.543 回答

This answer is useful

4

在路径上使用 Groovy：

groovy -e " println Integer.MAX_VALUE "

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

于 2008-09-18T18:09:49.870 回答

This answer is useful

4

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

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

根据评论请求编辑：

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

于 2017-06-20T15:07:24.943 回答

This answer is useful

4

2147483647

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

是20亿。

接下来的三个三元组是这样增加的：100s、400s、600s

第一个和最后一个三元组需要加3，以便四舍五入到50（例如 147 + 3 = 150 & 647 + 3 = 650）

第二个三元组需要减去3以将其四舍五入为80（例如 483 - 3 = 480）

因此 2, 147, 483, 647

于 2018-05-22T14:58:51.423 回答

This answer is useful

4

我在 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;

}

于 2018-11-15T22:32:30.363 回答

This answer is useful

2

这就是我记得的方式......

在十六进制中，一个数字代表四位，所以 4 * 8 = 32，所以最大有符号的 32 位 int 是：

0xFFFFFFFF >> 1 # => 2147483647

于 2011-11-30T18:53:10.663 回答

This answer is useful

2

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

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

结果将是十进制的 4294967295：

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

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

于 2017-04-22T21:27:11.040 回答

This answer is useful

1

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

于 2011-07-07T15:19:20.147 回答

This answer is useful

1

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

于 2014-01-18T03:13:13.827 回答

This answer is useful

1

使用 Java 9 的 REPL，jshell：

$ jshell

| Welcome to JShell -- Version 9-Debian

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

2147483647

于 2017-04-10T18:09:00.970 回答

This answer is useful

1

在 Python 中尝试：

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

2147483647

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

This answer is useful

0

在 CINT32_MAX之后使用#include . INT32_MAX在C++ 中使用#include .

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

或sizeof(int)。

于 2017-02-06T22:21:20.847 回答

This answer is useful

0

一般来说，你可以做一个反映 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'

于 2017-07-28T18:54:43.857 回答

This answer is useful

0

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

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

于 2019-07-09T18:33:39.913 回答

This answer is useful

-1

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

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

我更1 << 31 - 1喜欢

0x7fffffff因为你不需要 count fs

unsigned( pow( 2, 31 ) ) - 1因为你不需要

于 2016-06-26T22:18:01.353 回答

This answer is useful

-1

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

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

于 2016-10-26T14:53:27.487 回答