什么是最大的价值int32?

StackOverflow https://stackoverflow.com/questions/94591

  •  01-07-2019
  •  | 
  •  

题

我永远都不可能还记得号码。我需要一个记忆的规则。

有帮助吗？

解决方案

这是2、147、483和647。最简单的方法记住它是通过一个纹身。

其他提示

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

如果你认为值是太难记在基10，尝试基2:1111111111111111111111111111111

如果你能记住整个Pi数字，然后你正在寻找是在位置1,867,996,680到1,867,996,689的小数位数字Pi

这数字串2147483647出现在1,867,996,680小数字Pi.3.14......86181221809936452346214748364710527835665425671614...

资料来源： 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)

记忆:"喝醉了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

无论如何，采取这regex(它决定如果串包含一个不负整数小数形式，这也是不大于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(约1亿美元)次2^1(2)，或大约2亿美元。2^32 2^30*2^2或大约4亿美元。这个方法近似是不够准确，甚至出约2^64(其中的错误长到约15%)。

如果你需要一个确切的答案那么你应该拉一个计算器。

方便的字盟能力近似值:

  • 2^16~=64千//uint16
  • 2^32~=4亿//uint32、IPv4,unixtime
  • 2^64~=16三次方(又名16亿数十亿或16亿万亿美元)//uint64,"bigint"
  • 2^128~=256百万的三次方百万的三次方(又名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整数总是签署。

蟒蛇2

蟒蛇具有任意的精确度整数。但在蟒蛇2,它们是映射C整数。所以你可以这样做：

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

所以Python开关 long 当整数得到更大比 2^31 -1

这是一个记忆记忆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

我已经使用的权力的两起至18往往不够记住它们，但是，即使我没有打扰记忆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.

(请注意，还有一个负数值。)

在这一点上，我想说的最简单的记忆是型"stackoverflow.com" 卡 "最大int32"成。

有一个递归-->堆溢玩笑在那里的某个地方。我只是不是令人讨厌。

除了笑话，如果你真的在寻找一个有用的存储器的规则，有一个我总是用于记住的大数字。

你需要打破你的数成部分3-4个数字和记住他们在视觉上使用投影，你的手机上的键盘上。这是更容易表现出对一个画面：

enter image description here

正如你可以看到，从现在起 你只要记住3的形状，2他们看起来像一个俄罗斯方块L和一个看起来像一个勾.这绝对是很容易于记忆一个10分位数字。

当你需要回想一下的数字只是回顾一下形状、想象/看看在手机上的键盘和项目的形状。也许一开始你就必须要看的键盘，但后一位的做法，你会记得的数字是从左上到右所以，你将能够简单地想象在你的头上。

只是确保你记住方向的形状和数量的数字在每个形状(例如，在2147483647的例子，我们有4位数的俄罗斯方块L和一个3位数L)。

你可以使用这种技术很容易记住的任何重要的数字(例如，我记得我的16位数字的信用卡号码等等)。

最简单的方法来做到这对于整数是使用进制，前提是不存在的东西喜欢Int。maxInt().原因是这样的：

Max unsigned值

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...是安全的hex，但它很容易试试7F和80和只是打印到你的屏幕上看到哪个是的。

0x7FFF+0x0001=0x8000，所以你的损失仅仅是一个数字，所以使用0x7F...通常是个不错的折衷于更多的可靠的代码，尤其是一旦你开始使用的32位或更多

第一个写信了47次，(你喜欢 探员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 绝对价值 于正的限制。

练习几次，你将得到它！

2GB

(是否有一个最长为答案？)

如果你碰巧知道你的 ASCII表 通过心脏，而不 MaxInt :
!GH6G = 21 47 48 36 47

最好的规则的记忆是：
21 (神奇的号码!)
47 (只要记住它)
48 (顺序!)
36 (21+15，这两个魔法!)
47 再一次

也很容易记住，5对于10个数字。

假设。净

Console.WriteLine(Int32.MaxValue);

有趣的是，Int32。MaxValue有更多的人物，比2,147,486,647.

但随后再次，我们没有代码完成

所以我猜我们真的必须记住的是 Int3<period>M<enter>, ，其中只有6人物在visual studio.

更新 由于某些原因我downvoted.唯一的理由我可以认为是他们不了解我的第一次发言。

"Int32。MaxValue"需要在最多14个字符的类型。2,147,486,647需要10个或13个字的类型取决于如果你把逗号或没有。

最简单的方式来记住的是看看 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;
}

只要记住，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获得约2亿美元。为unsigned int使用32位，双再次为4亿美元。错误的因素获得更高的较大你去当然，但你不需要的确切价值的记忆(如果你需要它，你应该用一个预先定义的不断为它无论如何)。近似值得注意的东西时可能是一个危险地接近溢出。

这是我这样做，要记住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)rounghly2亿美元，并增加一倍，再次(2^32)为4亿美元。

这是一个简单的方法来获得一个粗略的估计的任的二进制数字。10零二元变为零3小数。

作为一个物理学家我只是轮到 2亿 (半开玩笑).容易记得！

在目标-C(iOS和OS x)，只记得这些宏：

#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
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top