blocks|key|3841743|text|是2147,483,647.记住它最简单的方法就是纹身。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3841744|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It's 2,147,483,647. Easiest way to memorize it is via a tattoo.

blocks|key|3841837|text|我能想到的最正确的答案是Int32.MaxValue。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3841838|entityMap^0|C|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

The most correct answer I can think of is <code>Int32.MaxValue</code>.

blocks|key|755527|text|如果您认为基数10中的值太难记住，请尝试基数2:+111111111111111111111111111111111|type|unstyled|depth|inlineStyleRanges|entityRanges|data|755528|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you think the value is too hard to remember in base 10, try base 2:
1111111111111111111111111111111

blocks|key|5254440|text|如果您能记住整个Pi数字，那么您要查找的数字位于Pi的小数位数的1,867,996,680到1,867,996,689之间|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5254441|5254442|数字串2147483647出现在Pi的1,867,996,680位十进制数。3.14......86181221809936452346214748364710527835665425671614...|blockquote|offset|length|style|BOLD|5254443|5254444|5254445|来源：http://www.subidiom.com/pi/|5254446|entityMap|0|LINK|mutability|MUTABLE|url|http://www.subidiom.com/pi/^0|0|0|1W|A|0|0|0|3|R|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@$F|Y|G|Z|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@$F|13|G|14|1|15]]|A|$]]|$1|N|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

if you can remember the entire Pi number, then the number you are looking for is at the position 1,867,996,680 till 1,867,996,689 of the decimal digits of Pi 

<blockquote>
 The numeric string 2147483647 appears at the 1,867,996,680 decimal digit of Pi. 3.14......86181221809936452346214748364710527835665425671614...
</blockquote>

source: <a href="http://www.subidiom.com/pi/">http://www.subidiom.com/pi/</a>

blocks|key|3841894|text|它是10位数字，所以假设它是一个电话号码(假设你在美国)。214-748-3647我不建议你这么叫它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3841895|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It's 10 digits, so pretend it's a phone number (assuming you're in the US). 214-748-3647. I don't recommend calling it.

blocks|key|2997688|text|与其认为它是一个很大的数字，不如试着分解它，寻找相关的想法，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2997689|2997690|2最大斯诺克破发率(最大破发率为147)|unordered-list-item|2997691|4年(48个月)|2997692|3年(36个月)|2997693|2997694|2997695|上面的情况适用于最大的负数；正数是负1。|2997696|也许上面的分解对你来说不再令人难忘(这很难令人兴奋！)，但希望你能想出一些想法！|2997697|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|V|8|@]|9|@]|A|$]]|$1|J|3|G|5|E|7|W|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Y|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Z|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|Q|$]]

Rather than think of it as one big number, try breaking it down and looking for associated ideas eg:

<ul>
<li>2 maximum snooker breaks (a maximum break is 147)</li>
<li>4 years (48 months)</li>
<li>3 years (36 months)</li>
<li>4 years (48 months)</li>
</ul>

The above applies to the biggest negative number; positive is that minus one.

Maybe the above breakdown will be no more memorable for you (it's hardly exciting is it!), but hopefully you can come up with some ideas that are!

blocks|key|3843054|text|最大负值(32位)：-2147483648|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3843055|(1+<<+31)|3843056|最大正(32位)值:+2147483647|3843057|~(1+<<+31)|3843058|助记符：“醉酒又名角质”|3843059|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%2B+material+of+it)+

21+47+4(years)+3(years)+4(years)
21+47+48+++++++36+++++++48|code-block|syntax|javascript|3843060|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Largest negative (32bit) value : -2147483648 
(1 &lt;&lt; 31) 

Largest positive (32bit) value : 2147483647 
~(1 &lt;&lt; 31) 

Mnemonic: "drunk AKA horny" 

<pre><code>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
</code></pre>

blocks|key|755475|text|无论如何，使用这个正则表达式(它确定字符串是否包含也不大于Int32.MaxValue的十进制形式的非负整数)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|755476|[0-9]{1,9}%7C[0-1][0-9]{1,8}%7C20[0-9]{1,8}%7C21[0-3][0-9]{1,7}%7C214[0-6][0-9]{1,7}%7C2147[0-3][0-9]{1,6}%7C21474[0-7][0-9]{1,5}%7C214748[0-2][0-9]{1,4}%7C2147483[0-5][0-9]{1,3}%7C21474836[0-3][0-9]{1,2}%7C214748364[0-7]|offset|length|style|CODE|755477|也许这能帮你记起来。|755478|entityMap^0|0|0|5L|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Anyway, take this regex (it determines if the string contains a non-negative Integer in decimal form that is also not greater than Int32.MaxValue) 

<code>[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]</code>

Maybe it would help you to remember.

blocks|key|3843357|text|这就是我对2147483647的记忆|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3843358|3843359|214+-因为2.14近似为pi-1|unordered-list-item|3843360|48+=+6*8|3843361|64+=+8*8|3843362|3843363|水平地写下这些：|3843364|214_48_64_
and+insert:
+++%5E++%5E++%5E
+++7++3++7+-+which+is+Boeing's+airliner+jet+(thanks,+sgorozco)|code-block|syntax|javascript|3843365|现在你有2147483647个了。|3843366|希望这至少能有一点帮助。|3843367|entityMap^0|5|A|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|I|7|16|8|@]|D|@]|E|$]]|$1|L|3|M|5|I|7|17|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|19|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1A|8|@]|D|@]|E|$T|U]]|$1|V|3|W|5|6|7|1B|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1C|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|10|$]]

That's how I remembered <code>2147483647</code>:

<ul>
<li>214 - because 2.14 is approximately pi-1</li>
<li>48 = 6*8</li>
<li>64 = 8*8</li>
</ul>

Write these horizontally:

<pre><code>214_48_64_
and insert:
 ^ ^ ^
 7 3 7 - which is Boeing's airliner jet (thanks, sgorozco)
</code></pre>

Now you've got 2147483647.

Hope this helps at least a bit.

blocks|key|5252748|text|2%5E(x%2By)+=+2%5Ex+*+2%5Ey

2%5E10+~+1,000
2%5E20+~+1,000,000
2%5E30+~+1,000,000,000
2%5E40+~+1,000,000,000,000
(etc.)

2%5E1+=+2
2%5E2+=+4
2%5E3+=+8
2%5E4+=+16
2%5E5+=+32
2%5E6+=+64
2%5E7+=+128
2%5E8+=+256
2%5E9+=+512|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5252749|因此，2%5E31+(带符号的int+max)等于2%5E30+(约10亿)乘以2%5E1+(2)，或约20亿。2%5E32等于2%5E30+*+2%5E2，约为40亿。这种近似方法即使在2%5E64左右(误差增长到15%25左右)也足够精确。|unstyled|5252750|如果你需要一个确切的答案，那么你应该打开一个计算器。|5252751|方便的单词对齐容量近似：|5252752|5252753|2%5E16+~=+64千兆//+uint16|unordered-list-item|5252754|2%5E32+~=+40亿//+uint32，IPv4，unixtime|5252755|2%5E64+~=+16万亿(又称160亿或1600万万亿)+//+uint64，"bigint"|5252756|2%5E128+~=+256万亿万亿(又称256万亿)+//+IPv6，GUID|5252757|5252758|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|10|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|N|7|13|8|@]|9|@]|A|$]]|$1|Q|3|R|5|N|7|14|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|15|8|@]|9|@]|A|$]]|$1|U|3|-4|5|F|7|16|8|@]|9|@]|A|$]]|$1|V|3|-4|5|F|7|17|8|@]|9|@]|A|$]]]|W|$]]

<pre><code>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
</code></pre>

So, 2^31 (signed int max) is 2^30 (about 1 billion) times 2^1 (2), or about 2 billion. And 2^32 is 2^30 * 2^2 or about 4 billion. This method of approximation is accurate enough even out to around 2^64 (where the error grows to about 15%).

If you need an exact answer then you should pull up a calculator.

Handy word-aligned capacity approximations:

<ul>
<li>2^16 ~= 64 thousand // uint16</li>
<li>2^32 ~= 4 billion // uint32, IPv4, unixtime</li>
<li>2^64 ~= 16 quintillion (aka 16 billion billions or 16 million trillions) // uint64, "bigint"</li>
<li>2^128 ~= 256 quintillion quintillion (aka 256 trillion trillion trillions) // IPv6, GUID</li>
</ul>

blocks|key|5252666|text|只需使用任何合适的计算器，在十六进制模式下键入"7FFFFFFF“，然后切换为十进制。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5252667|2147483647。|5252668|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Just take any decent calculator and type in "7FFFFFFF" in hex mode, then switch to decimal.

2147483647.

blocks|key|2998938|text|是关于2.1+*+10%5E9的。不需要知道确切的2%5E{31}+-+1+=+2,147,483,647。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2998939|C|2998940|您可以在C中找到它，如下所示：|2998941|#include+<stdio.h>
#include+<limits.h>

main()+{
++++printf("max+int:\t\t%25i\n",+INT_MAX);
++++printf("max+unsigned+int:\t%25u\n",+UINT_MAX);
}|code-block|syntax|javascript|2998942|给出(好吧，没有,)|2998943|max+int:++++++++++2,147,483,647
max+unsigned+int:+4,294,967,295|2998944|C%2B%2B+11|2998945|std::cout+<<+std::numeric_limits<int>::max()+<<+"\n";
std::cout+<<+std::numeric_limits<unsigned+int>::max()+<<+"\n";|2998946|Java|2998947|你也可以用Java实现这个功能：|2998948|System.out.println(Integer.MAX_VALUE);|2998949|但请记住，Java整数始终是有符号的。|2998950|Python+2|2998951|Python有任意精度的整数。但在Python+2中，它们被映射到C整数。所以你可以这样做：|2998952|import+sys
sys.maxint
>>>+2147483647
sys.maxint+%2B+1
>>>+2147483648L|2998953|因此，当整数大于2%5E31+-1时，Python会切换到long|2998954|entityMap^0|3|A|N|Q|0|0|0|0|8|1|0|0|0|0|0|0|0|0|0|0|0|8|7|R|4|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1J|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1K|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1L|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1P|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|1R|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1S|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1T|8|@]|D|@]|E|$]]|$1|10|3|11|5|L|7|1U|8|@]|D|@]|E|$M|N]]|$1|12|3|13|5|6|7|1V|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|1W|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|1X|8|@]|D|@]|E|$]]|$1|18|3|19|5|L|7|1Y|8|@]|D|@]|E|$M|N]]|$1|1A|3|1B|5|6|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|24|8|@]|D|@]|E|$]]]|1D|$]]

It's about <code>2.1 * 10^9</code>. No need to know the exact <code>2^{31} - 1 = 2,147,483,647</code>.

<h1>C</h1>

You can find it in C like that:

<pre class="lang-c prettyprint-override"><code>#include &lt;stdio.h&gt;
#include &lt;limits.h&gt;

main() {
 printf("max int:\t\t%i\n", INT_MAX);
 printf("max unsigned int:\t%u\n", UINT_MAX);
}
</code></pre>

gives (well, without the <code>,</code>)

<pre><code>max int: 2,147,483,647
max unsigned int: 4,294,967,295
</code></pre>

<h1>C++ 11</h1>

<pre class="lang-cpp11 prettyprint-override"><code>std::cout &lt;&lt; std::numeric_limits&lt;int&gt;::max() &lt;&lt; "\n";
std::cout &lt;&lt; std::numeric_limits&lt;unsigned int&gt;::max() &lt;&lt; "\n";
</code></pre>

<h1>Java</h1>

You can get this with Java, too:

<pre class="lang-java prettyprint-override"><code>System.out.println(Integer.MAX_VALUE);
</code></pre>

But keep in mind that Java integers are always signed.

<h1>Python 2</h1>

Python has arbitrary precision integers. But in Python 2, they are mapped to C integers. So you can do this:

<pre class="lang-py prettyprint-override"><code>import sys
sys.maxint
&gt;&gt;&gt; 2147483647
sys.maxint + 1
&gt;&gt;&gt; 2147483648L
</code></pre>

So Python switches to <code>long</code> when the integer gets bigger than <code>2^31 -1</code>

blocks|key|755773|text|这是一个记忆2**31的助记符，减去1得到最大整数值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|755774|a=1、b=2、c=3、d=4、e=5、f=6、g=7、h=8、i=9|755775|Boys+And+Dogs+Go+Duck+Hunting,+Come+Friday+Ducks+Hide
2++++1+++4++++7++4++++8++++++++3++++6++++++4+++++8|code-block|syntax|javascript|755776|我经常使用2到18的能力来记住它们，但即使是我也没有费心去记住2**31。根据需要计算或使用常量，或估计为2G太容易了。|755777|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a mnemonic for remembering 2**31, subtract one to get the maximum integer value.

a=1,b=2,c=3,d=4,e=5,f=6,g=7,h=8,i=9

<pre><code>Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide
2 1 4 7 4 8 3 6 4 8
</code></pre>

I've used the powers of two up to 18 often enough to remember them, but even I haven't bothered memorizing 2**31. It's too easy to calculate as needed or use a constant, or estimate as 2G.

blocks|key|2999208|text|32位，一个用于符号，31位信息：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2999209|2%5E31+-+1+=+2147483647|code-block|syntax|javascript|2999210|为什么是-1？|2999211|因为第一个是0，所以最大的是计数减去1。|offset|length|style|BOLD|2999212|针对+的编辑|2999213|计数是2%5E31，但最大的不能是2147483648+(2%5E31)，因为我们从0开始计数，而不是从1开始计数。|2999214|Rank+++1+2+3+4+5+6+...+2147483648
Number+0+1+2+3+4+5+...+2147483647|2999215|另一种只有3位的解释:1表示符号，2表示信息|2999216|2%5E2+-+1+=+3|2999217|所有可能的值下面有3位：(2%5E3+=8个值)|2999218|1:+100+==>+-4
2:+101+==>+-3
3:+110+==>+-2
4:+111+==>+-1
5:+000+==>++0
6:+001+==>++1
7:+010+==>++2
8:+011+==>++3|2999219|entityMap^0|0|0|0|E|5|0|4|2|0|0|1I|0|0|0|M|0|0|0|M|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|17|8|@$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$K|1B|L|1C|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@$K|1E|L|1F|M|N]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1H|8|@$K|1I|L|1J|M|N]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1L|8|@$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|10|3|11|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|13|$]]

32 bits, one for the sign, 31 bits of information:

<pre><code>2^31 - 1 = 2147483647
</code></pre>

Why -1? 
Because the first is zero, so the greatest is the count minus one.

EDIT for <a href="https://stackoverflow.com/users/695655/cantfindaname88">cantfindaname88</a>

The count is 2^31 but the greatest can't be 2147483648 (2^31) because we count from 0, not 1.

<pre><code>Rank 1 2 3 4 5 6 ... 2147483648
Number 0 1 2 3 4 5 ... 2147483647
</code></pre>

Another explanation with only 3 bits : 1 for the sign, 2 for the information

<pre><code>2^2 - 1 = 3
</code></pre>

Below all the possible values with 3 bits: (2^3 = 8 values)

<pre><code>1: 100 ==&gt; -4
2: 101 ==&gt; -3
3: 110 ==&gt; -2
4: 111 ==&gt; -1
5: 000 ==&gt; 0
6: 001 ==&gt; 1
7: 010 ==&gt; 2
8: 011 ==&gt; 3
</code></pre>

blocks|key|2997457|text|嗯，它有32位，因此可以存储2%5E32个不同的值。其中一半是阴性的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2997458|解决方案是2,147,483,647|2997459|最低的是−2,147,483,648。|2997460|(请注意，还有一个负值。)|2997461|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Well, it has 32 bits and hence can store 2^32 different values. Half of those are negative.

The solution is 2,147,483,647

And the lowest is −2,147,483,648.

(Notice that there is one more negative value.)

blocks|key|3000439|text|嗯，除了笑话之外，如果你真的在寻找有用的记忆规则，有一个我总是用来记忆大数的规则。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3000440|你需要将你的号码分成3-4位数字，并使用手机键盘上的投影来直观地记住它们。它更容易在图片上显示：|3000441|​|3000442|📷|atomic|3000443|3000444|正如你所看到的，从现在开始你只需要记住三个形状，其中两个看起来像俄罗斯方块L，一个看起来像tick。这绝对比记住一个10位数的数字容易得多。|3000445|当你需要回忆数字时，只需回忆形状，想象/看手机键盘上的形状，并将形状投影在上面。也许一开始你必须看着键盘，但经过一点练习，你就会记住数字是从左上角到右下角的，所以你可以在脑海中简单地想象它。|3000446|只需确保你记住了形状的方向和每个形状的位数(例如，在2147483647的例子中，我们有一个4位的俄罗斯方块L和一个3位的L)。|3000447|您可以使用此技术轻松地记住任何重要的数字(例如，我记住了我的16位信用卡号码等)。|3000448|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/c0f39bfa16481bbb6d5a780efdeb4605.png|imageAlt^0|0|15|0|0|0|0|1|0|0|0|D|10|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|M|3|I|5|6|7|1D|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1H|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1I|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1J|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|W|$X|$5|Y|Z|10|E|$11|12|13|-4]]]]

Well, aside from jokes, if you're really looking for a useful memory rule, there is one that I always use for remembering big numbers.

You need to break down your number into parts from 3-4 digits and remember them visually using projection on your cell phone keyboard. It's easier to show on a picture:

<a href="https://i.stack.imgur.com/rCL8f.png" rel="noreferrer"><img src="https://i.stack.imgur.com/rCL8f.png" alt="enter image description here"></a>

As you can see, from now on you just have to remember 3 shapes, 2 of them looks like a Tetris L and one looks like a tick. Which is definitely much easier than memorizing a 10-digit number.

When you need to recall the number just recall the shapes, imagine/look on a phone keyboard and project the shapes on it. Perhaps initially you'll have to look at the keyboard but after just a bit of practice, you'll remember that numbers are going from top-left to bottom-right so you will be able to simply imagine it in your head.

Just make sure you remember the direction of shapes and the number of digits in each shape (for instance, in 2147483647 example we have a 4-digit Tetris L and a 3-digit L).

You can use this technique to easily remember any important numbers (for instance, I remembered my 16-digit credit card number etc.).

blocks|key|5253596|text|对于整数，最简单的方法是使用十六进制，前提是没有类似Int.maxInt()的东西。原因是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5253597|最大无符号值|5253598|8-bit+0xFF
16-bit+0xFFFF
32-bit+0xFFFFFFFF
64-bit+0xFFFFFFFFFFFFFFFF
128-bit+0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF|code-block|syntax|javascript|5253599|有符号值，使用7F作为最大有符号值|5253600|8-bit+0x7F
16-bit+0x7FFF
32-bit+0x7FFFFFFF
64-bit+0x7FFFFFFFFFFFFFFF|5253601|有符号值，使用80作为最大有符号值|5253602|8-bit+0x80
16-bit+0x8000
32-bit+0x80000000
64-bit+0x8000000000000000|5253603|这是怎么回事？这与二进制策略非常相似，每个十六进制数字恰好是4位。此外，许多编译器对十六进制的支持比它们对二进制的支持要好得多。|5253604|F+hex+to+binary:+1111
8+hex+to+binary:+1000
7+hex+to+binary:+0111
0+hex+to+binary:+0000|5253605|所以7F等于01111111+/+7FFF等于0111111111111111。另外，如果你使用这个“疯狂的高常数”，7F…是安全的十六进制，但它是足够容易的尝试7F和80，并只需将它们打印到您的屏幕上，看看是哪一个。|5253606|0x7FFF+%2B+0x0001+=+0x8000，所以您的损失只有一个数字，所以使用0x7F...通常对于更可靠的代码来说，这是一个不错的折衷方案，尤其是当您开始使用32位或更多的代码时|5253607|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

The easiest way to do this for integers is to use hexadecimal, provided that there isn't something like Int.maxInt(). The reason is this:

Max unsigned values

<pre><code>8-bit 0xFF
16-bit 0xFFFF
32-bit 0xFFFFFFFF
64-bit 0xFFFFFFFFFFFFFFFF
128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
</code></pre>

Signed values, using 7F as the max signed value

<pre><code>8-bit 0x7F
16-bit 0x7FFF
32-bit 0x7FFFFFFF
64-bit 0x7FFFFFFFFFFFFFFF
</code></pre>

Signed values, using 80 as the max signed value

<pre><code>8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000
</code></pre>

How does this work? This is very similar to the binary tactic, and each hex digit is exactly 4 bits. Also, a lot of compilers support hex a lot better than they support binary. 

<pre><code>F hex to binary: 1111
8 hex to binary: 1000
7 hex to binary: 0111
0 hex to binary: 0000
</code></pre>

So 7F is equal to 01111111 / 7FFF is equal to 0111111111111111. Also, if you are using this for "insanely-high constant", 7F... is safe hex, but it's easy enough to try out 7F and 80 and just print them to your screen to see which one it is.

0x7FFF + 0x0001 = 0x8000, so your loss is only one number, so using 0x7F... usually isn't a bad tradeoff for more reliable code, especially once you start using 32-bits or more

blocks|key|756011|text|首先将47写两遍(您喜欢Agent+47，对吧？)，如图所示保留空格(每个破折号都是一个表示单个数字的槽)。前2个插槽，然后是4个)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|756012|--47----47|code-block|syntax|javascript|756013|认为您已经掌握了12+(因为12+=12)。将其乘以4，即代理47的编号的第一位数，即47，并将结果放在已有的第一对的右边|style|CODE|756014|12+*+4+=+48
--4748--47+<--+after+placing+48+to+the+right+of+first+47|756015|然后将12乘以3+(为了得到代理47编号的第二位数，即7，您需要7+-+4+=+3)，并将结果放在前2对的右侧，即最后一对槽|756016|12+*+3+=+36
--47483647+<--+after+placing+36+to+the+right+of+first+two+pairs|756017|最后，从最右边的数字(本例中为2)开始，从手中逐个拖动数字，并将它们放入您得到的第一个空位中|756018|2-47483647+<--+after+placing+2
2147483647+<--+after+placing+1|756019|这就对了！对于负极限，你可以认为它的绝对值比正极限多1。|756020|练习几次，你就会掌握它的诀窍！|756021|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Hitman:_Agent_47^0|C|8|0|0|0|8|2|Q|1|17|2|0|0|3|2|7|1|R|1|W|9|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1D|8|@$A|1E|B|1F|K|L]|$A|1G|B|1H|K|L]|$A|1I|B|1J|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|1K|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|1L|8|@$A|1M|B|1N|K|L]|$A|1O|B|1P|K|L]|$A|1Q|B|1R|K|L]|$A|1S|B|1T|K|L]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1U|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1V|8|@]|9|@]|C|$]]|$1|U|3|V|5|F|7|1W|8|@]|9|@]|C|$G|H]]|$1|W|3|X|5|6|7|1X|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|1Z|8|@]|9|@]|C|$]]]|11|$12|$5|13|14|15|C|$16|17]]]]

First write out 47 twice, (you like <a href="http://en.wikipedia.org/wiki/Hitman:_Agent_47" rel="noreferrer">Agent 47</a>, right?), keeping spaces as shown (each dash is a slot for a single digit. First 2 slots, then 4)

<pre><code>--47----47
</code></pre>

Think you have <code>12</code> in hand (because 12 = a dozen). Multiply it by <code>4</code>, first digit of Agent 47's number, i.e. <code>47</code>, and place the result to the right of first pair you already have

<pre><code>12 * 4 = 48
--4748--47 &lt;-- after placing 48 to the right of first 47
</code></pre>

Then multiply <code>12</code> by <code>3</code> (in order to make second digit of Agent 47's number, which is <code>7</code>, you need <code>7 - 4 = 3</code>) and put the result to the right of the first 2 pairs, the last pair-slot

<pre><code>12 * 3 = 36
--47483647 &lt;-- after placing 36 to the right of first two pairs
</code></pre>

Finally drag digits one by one from your hand starting from right-most digit (2 in this case) and place them in the first empty slot you get

<pre><code>2-47483647 &lt;-- after placing 2
2147483647 &lt;-- after placing 1
</code></pre>

There you have it! For negative limit, you can think of that as 1 more in absolute value than the positive limit.

Practise a few times, and you will get the hang of it!

blocks|key|5252922|text|2+2GB|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5252923|(答案是否有最小长度？)|5252924|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

2GB

(is there a minimum length for answers?)

blocks|key|755027|text|假设.NET+-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|755028|Console.WriteLine(Int32.MaxValue);|code-block|syntax|javascript|755029|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Assuming .NET -

<pre><code>Console.WriteLine(Int32.MaxValue);
</code></pre>

blocks|key|5254043|text|如果你碰巧知道你的ASCII+table+off，而不是MaxInt：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5254044|!GH6G+=+21+47+48+36+47|5254045|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/ASCII#ASCII_printable_code_chart^0|S|6|9|B|0|0|0|M|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

If you happen to know your <a href="https://en.wikipedia.org/wiki/ASCII#ASCII_printable_code_chart">ASCII table</a> off by heart and not <code>MaxInt</code> : 
<code>!GH6G = 21 47 48 36 47</code>

blocks|key|752740|text|记住它的最佳规则是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|752741|21+(魔术数字！)|752742|47+(只需记住)|752743|48+(顺序！)|752744|36+(21+%2B+15，两个魔术！)|752745|47再一次|752746|此外，5对数字比10个数字更容易记忆。|752747|entityMap^0|0|A|0|0|2|0|0|2|0|0|2|0|0|2|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1B|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|S|$]]

The best rule to memorize it is: 
21 (magic number!) 
47 (just remember it) 
48 (sequential!) 
36 (21 + 15, both magics!) 
47 again

Also it is easier to remember 5 pairs than 10 digits.

blocks|key|752316|text|最容易记住的方法是查看std::numeric_limits<+int+>::max()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|752317|例如(from+MSDN)，|752318|//+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;
}|code-block|syntax|javascript|752319|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/s086ab1z%2528v=vs.80%2529.aspx^0|B|X|0|3|9|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

The easiest way to remember is to look at <code>std::numeric_limits&lt; int &gt;::max()</code>

For example (<a href="http://msdn.microsoft.com/en-us/library/s086ab1z%28v=vs.80%29.aspx" rel="noreferrer">from MSDN</a>),

<pre><code>// numeric_limits_max.cpp

#include &lt;iostream&gt;
#include &lt;limits&gt;

using namespace std;

int main() {
 cout &lt;&lt; "The maximum value for type float is: "
 &lt;&lt; numeric_limits&lt;float&gt;::max( )
 &lt;&lt; endl;
 cout &lt;&lt; "The maximum value for type double is: "
 &lt;&lt; numeric_limits&lt;double&gt;::max( )
 &lt;&lt; endl;
 cout &lt;&lt; "The maximum value for type int is: "
 &lt;&lt; numeric_limits&lt;int&gt;::max( )
 &lt;&lt; endl;
 cout &lt;&lt; "The maximum value for type short int is: "
 &lt;&lt; numeric_limits&lt;short int&gt;::max( )
 &lt;&lt; endl;
}
</code></pre>

blocks|key|2998626|text|有趣的是，Int32.MaxValue有超过2,147,486,647个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2998627|但话又说回来，我们确实有代码完成，|2998628|所以我猜我们真正需要记住的就是Int3<period>M<enter>，它在visual+studio中只需要输入6个字符。|offset|length|style|CODE|2998629|更新由于某种原因我被否决了。我能想到的唯一原因是他们不理解我的第一句话。|BOLD|2998630|"Int32.MaxValue“最多只能输入14个字符。2,147,486,647可以输入10个或13个字符，具体取决于是否输入逗号。|2998631|entityMap^0|0|0|F|K|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|V|8|@$F|W|G|X|H|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Y|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|P|$]]

Interestingly, Int32.MaxValue has more characters than 2,147,486,647.

But then again, we do have code completion,

So I guess all we really have to memorize is <code>Int3&lt;period&gt;M&lt;enter&gt;</code>, which is only 6 characters to type in visual studio.

UPDATE
For some reason I was downvoted. The only reason I can think of is that they didn't understand my first statement.

"Int32.MaxValue" takes at most 14 characters to type.
2,147,486,647 takes either 10 or 13 characters to type depending on if you put the commas in or not.

blocks|key|3842568|text|只需记住，2%5E(10*x)大约是10%5E(3*x)+-您可能已经习惯了千字节/千比字节等等。也就是说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3842569|2%5E10+=+1024++++++++++++++++~=+one+thousand
2%5E20+=+1024%5E2+=+1048576++++~=+one+million
2%5E30+=+1024%5E3+=+1073741824+~=+one+billion|code-block|syntax|javascript|3842570|由于int使用31位(符号为%2B+~1位)，因此只需将2%5E30加倍即可获得约20亿。对于使用32位的无符号整数，再加倍以换取40亿。当然，误差因子会变得越大，但你不需要记住确切的值(如果你需要的话，无论如何你应该对它使用一个预定义的常量)。近似值足够好，可以注意到什么时候可能有危险的接近溢出。|3842571|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Just remember that 2^(10*x) is approximately 10^(3*x) - you're probably already used to this with kilobytes/kibibytes etc. That is:

<pre><code>2^10 = 1024 ~= one thousand
2^20 = 1024^2 = 1048576 ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion
</code></pre>

Since an int uses 31 bits (+ ~1 bit for the sign), just double 2^30 to get approximately 2 billion. For an unsigned int using 32 bits, double again for 4 billion. The error factor gets higher the larger you go of course, but you don't need the exact value memorised (If you need it, you should be using a pre-defined constant for it anyway). The approximate value is good enough for noticing when something might be a dangerously close to overflowing.

blocks|key|5254215|text|这就是我记忆2,147,483,647的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5254216|到了遥远的大草原四分之一擎天柱三重奏四十个七进制|5254217|2+-+To
1+-+A
4+-+Far
7+-+Savannah
4+-+Quarter
8+-+Optimus
3+-+Trio
6+-+Hexed
4+-+Forty
7+-+Septenary|code-block|syntax|javascript|5254218|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

this is how i do it to remember 2,147,483,647

<h2>To a far savannah quarter optimus trio hexed forty septenary</h2>

<pre><code>2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary
</code></pre>

blocks|key|755403|text|你是什么意思？应该很容易记住它是2%5E32。如果您想要一个规则来记住该数字的值，通常一个方便的经验法则是用于在二进制和十进制之间进行转换：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|755404|2%5E10+~+1000|755405|这意味着2%5E20+~+1,000,000|755406|和2%5E30+~+1,000,000,000|755407|这两倍(2%5E31)大约是20亿，再翻一番(2%5E32)是40亿。|755408|这是获得任何二进制数的粗略估计的一种简单方法。二进制中的10个零变成了十进制中的3个零。|755409|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

What do you mean? It should be easy enough to remember that it is 2^32.
If you want a rule to memorize the value of that number, a handy rule of thumb is for converting between binary and decimal in general:

2^10 ~ 1000

which means 2^20 ~ 1,000,000

and 2^30 ~ 1,000,000,000

Double that (2^31) is rounghly 2 billion, and doubling that again (2^32) is 4 billion.

It's an easy way to get a rough estimate of any binary number. 10 zeroes in binary becomes 3 zeroes in decimal.

blocks|key|5253922|text|在Objective-C+(iOS+&+OSX)中，只需记住这些宏：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5253923|#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|code-block|syntax|javascript|5253924|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In Objective-C (iOS &amp; OSX), just remember these macros:

<pre class="lang-c prettyprint-override"><code>#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
</code></pre>

blocks|key|3842843|text|Int32表示您有32位可用来存储您的号码。最高的位是符号位，这表示数字是正数还是负数。所以你有2%5E31位的正数和负数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3842844|0是一个正数，你得到的逻辑范围是(前面提到的)|3842845|%2B2147483647至-2147483648|3842846|如果您认为这太小了，可以使用Int64：|3842847|%2B9223372036854775807至-9223372036854775808|3842848|为什么你要记住这个该死的数字？在你的代码中使用？您应该始终在代码中使用Int32.MaxValue或Int32.MinValue，因为它们是静态值(在.net核心中)，因此使用起来比使用代码创建新的int更快。|3842849|我的陈述:如果通过记忆知道这个数字..你只是在炫耀！|3842850|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Int32 means you have 32 bits available to store your number. The highest bit is the sign-bit, this indicates if the number is positive or negative. So you have 2^31 bits for positive and negative numbers. 

With zero being a positive number you get the logical range of (mentioned before)

+2147483647 to -2147483648

If you think that is to small, use Int64:

+9223372036854775807 to -9223372036854775808

And why the hell you want to remember this number? To use in your code? You should always use Int32.MaxValue or Int32.MinValue in your code since these are static values (within the .net core) and thus faster in use than creating a new int with code.

My statement: if know this number by memory.. you're just showing off!

blocks|key|756162|text|记住这个:+21智商47|type|unstyled|depth|inlineStyleRanges|entityRanges|data|756163|它可以用任何电话本解密，或者你也可以自己在纸上写下来。|756164|为了记住"21智商项目47"，我会选择“刺客:代号47有21个任务，这是每个智商项目本身”。|756165|或者“我每天21:47刷牙，因为我的智商很高，不喜欢嘴里的东西”。|756166|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Remember this:
21 IQ ITEM 47

It can be de-encoded with any phone pad, or you can just write one down yourself on a paper.

In order to remember "21 IQ ITEM 47", I would go with "Hitman:Codename 47 had 21 missions, which were each IQ ITEM's by themselves".

Or "I clean teeth at 21:47 every day, because I have high IQ and don't like items in my mouth".

blocks|key|755368|text|在使用Groovy的情况下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|755369|groovy+-e+"+println+Integer.MAX_VALUE+"|code-block|syntax|javascript|755370|(Groovy对于Java上下文中的快速引用非常有用。)|755371|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

With Groovy on the path:

<pre><code>groovy -e " println Integer.MAX_VALUE "
</code></pre>

(Groovy is extremely useful for quick reference, within a Java context.)

blocks|key|753169|text|只要记住这是第八个梅森素数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|753170|如果这太难了，这也是已知的仅有的四个双梅森素数中的第三个。|753171|每个评论请求的编辑：|offset|length|style|BOLD|753172|欧几里德-欧拉定理指出，每个偶数都有形式2%5E(n−1)+(2%5En−1)，其中2%5En−1是素数。形式为2%5En的−1的素数称为梅森素数，并且要求n本身是素数。|753173|我们知道INT32的长度当然是32位。根据人们普遍接受的对2补码的理解，带符号的INT32是32位-1位。|753174|为了找出具有给定位数的二进制数的大小，我们通常将2乘以n的幂，减1，其中n等于位数。|753175|因此，数量级计算为2%5E(32+-+1)+-+1+=+2%5E31+-1。31是素数，如上所述，这种形式的素数是梅森素数。我们可以通过简单地计算它们来证明它是其中的8个。有关更多细节，请询问Euler，或者Bernoulli+(他给他写了关于他们的文章)。|753176|请参阅：https://books.google.ie/books?id=x7p4tCPPuXoC&printsec=frontcover&dq=9780883853283&hl=en&sa=X&ved=0ahUKEwilzbORuJLdAhUOiaYKHcsZD-EQ6AEIKTAA#v=onepage&q=9780883853283&f=false|753177|entityMap|0|LINK|mutability|MUTABLE|url|https://books.google.ie/books?id=x7p4tCPPuXoC&printsec=frontcover&dq=9780883853283&hl=en&sa=X&ved=0ahUKEwilzbORuJLdAhUOiaYKHcsZD-EQ6AEIKTAA#v=onepage&q=9780883853283&f=false^0|0|0|7|3|0|0|0|0|0|4|4T|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@$F|14|G|15|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1A|8|@]|9|@$F|1B|G|1C|1|1D]]|A|$]]|$1|T|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Just remember that it's the eighth Mersenne prime.

If that's too hard, it's also the third of only four known double Mersenne primes.

Edit per comment request:

The Euclid-Euler theorem states that every even perfect number has the form 2^(n − 1) (2^n − 1), where 2^n − 1 is a prime number. The prime numbers of the form 2^n − 1 are known as Mersenne primes, and require n itself to be prime.

We know that the length of an INT32 is of course 32 bits. Given the generally accepted understanding of 2's complement, a signed INT32 is 32 bits - 1 bit. 

To find the magnitude of a binary number with a given number of bits we generally raise 2 to the power n, minus 1, where n is equal to the number of bits.

Thus the magnitude calculation is 2^(32 - 1) - 1 = 2^31 - 1. 31 is prime and as outlined above, prime numbers of this form are Mersenne primes. We can prove it is the eight of such simply by counting them. For further details, please ask Euler, or maybe Bernoulli (to whom he wrote about them).

See: <a href="https://books.google.ie/books?id=x7p4tCPPuXoC&amp;printsec=frontcover&amp;dq=9780883853283&amp;hl=en&amp;sa=X&amp;ved=0ahUKEwilzbORuJLdAhUOiaYKHcsZD-EQ6AEIKTAA#v=onepage&amp;q=9780883853283&amp;f=false" rel="nofollow noreferrer">https://books.google.ie/books?id=x7p4tCPPuXoC&amp;printsec=frontcover&amp;dq=9780883853283&amp;hl=en&amp;sa=X&amp;ved=0ahUKEwilzbORuJLdAhUOiaYKHcsZD-EQ6AEIKTAA#v=onepage&amp;q=9780883853283&amp;f=false</a>

blocks|key|3000741|text|2147483647|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3000742|以下是你需要记住的：|3000743|第一个和最后一个三元组需要加上3才能向上舍入到50+(例如147+%2B3=+150+&+647+%2B3=650)<>H115第二个三元组需要<>E1163将其向下舍入为80+(例如483+-3=+480)|offset|length|style|BOLD|3000744|因此2,147,483,647|3000745|entityMap^0|0|0|F|1|N|2|1J|19|0|0|F|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]|$F|S|G|T|H|I]|$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|M|$]]

2147483647

Here's what you need to remember:

<ul>
<li>It's 2 billion.</li>
<li>The next three triplets are increasing like so: 100s, 400s, 600s</li>
<li>The first and the last triplet need 3 added to them so they get rounded up to 50 (eg 147 + 3 = 150 &amp; 647 + 3 = 650)</li>
<li>The second triplet needs 3 subtracted from it to round it down to 80 (eg 483 - 3 = 480)</li>
</ul>

Hence 2, 147, 483, 647

blocks|key|5255768|text|我用C#做了几个天才的方法，你可以在你的生产环境中利用它们：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5255769|public+static+int+GetIntMaxValueGenius1()
{
++++int+n+=+0;
++++while+(%2B%2Bn+>+0)+{+}
++++return+--n;
}

public+static+int+GetIntMaxValueGenius2()
{
++++int+n+=+0;
++++try
++++{
++++++++while+(true)
++++++++++++n+=+checked(n+%2B+1);
++++}
++++catch+{+}
++++return+n;
}|code-block|syntax|javascript|5255770|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I made a couple genius methods in C# that you can take advantage of in your production environment:

<pre><code>public static int GetIntMaxValueGenius1()
{
 int n = 0;
 while (++n &gt; 0) { }
 return --n;
}

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

blocks|key|752465|text|这就是我记得的..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|752466|在十六进制中，一个数字表示四位，因此4*8=+32，因此最大有符号32位int为：|752467|0xFFFFFFFF+>>+1+#+=>+2147483647|code-block|syntax|javascript|752468|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is how I remember... 
In hex, a digit represents four bits, so 4 * 8 = 32, so the max signed 32 bit int is:

<pre><code>0xFFFFFFFF &gt;&gt; 1 # =&gt; 2147483647
</code></pre>

blocks|key|756328|text|永远不会忘记任何类型的最大值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|756329|如果它有32位，则可能的最大值是数字为1的32位：|756330|​|756331|📷|atomic|offset|length|756332|756333|结果将是以十进制表示的4294967295：|756334|756335|756336|756337|但是，因为还有负数的表示，所以将4294967295除以2得到2147483647。|756338|因此，32位整数能够表示-2147483647到2147483647|756339|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/1d319b806e11e4de72bce99d8ba936db.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/6aac1d1d9543b9c290661ef7b9f52297.png^0|0|0|0|0|1|0|0|0|0|0|0|1|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|18|8|@]|9|@$I|19|J|1A|1|1B]]|A|$]]|$1|K|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1D|8|@]|9|@]|A|$]]|$1|N|3|E|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|G|5|H|7|1F|8|@]|9|@$I|1G|J|1H|1|1I]]|A|$]]|$1|P|3|E|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1L|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11|12|-4]]|13|$5|X|Y|Z|A|$10|14|12|-4]]]]

To never forget the maximum value of any type:

If it has 32 bits, the largest possible value would be the 32 bits with the number 1:

<a href="https://i.stack.imgur.com/A3fj7.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/A3fj7.png" alt="enter image description here"></a>

The result would be 4294967295 in decimal:

<a href="https://i.stack.imgur.com/ZQscf.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/ZQscf.png" alt="enter image description here"></a>

But, as there is also the representation of negative numbers, divide 4294967295 by 2 and get 2147483647.

Therefore, a 32-bit integer is capable of representing -2147483647 to 2147483647

blocks|key|5253468|text|这很容易记住。在十六进制中，一个数字是4位。因此，对于无符号整数，将0x和8+fs+(0xffffffff)写入Python或Ruby+shell，以获得以10为基数的值。如果需要有符号的值，只需记住最高位用作符号。所以你必须省略这一点。您只需记住低3位为1，第4位为0的数字等于7，因此将0x7fffffff写入Python或Ruby+shell。您还可以编写0x100000000+-+1和0x80000000+-+1，如果这对您更容易记住的话。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5253469|entityMap^0|Y|2|13|1|17|A|41|A|51|F|5H|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|G|$]]

It is very easy to remember. In hexadecimal one digit is 4 bits. So for unsigned int write <code>0x</code> and 8 <code>f</code>s (<code>0xffffffff</code>) into a Python or Ruby shell to get the value in base 10. If you need the signed value, just remember that the highest bit is used as the sign. So you have to leave that out. You only need to remember that the number where the lower 3 bits are 1 and the 4th bit is 0 equals 7, so write <code>0x7fffffff</code> into a Python or Ruby shell. You could also write <code>0x100000000 - 1</code> and <code>0x80000000 - 1</code>, if that is more easy to you to remember.

blocks|key|3843540|text|您会发现Int32的最大值是1111111111111111111111111111111111111111111111111111111111111，但以十为基数，您会发现它是2147483647、2%5E31-1或Int32.MaxValue|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3843541|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You will find in binary the maximum value of an Int32 is 1111111111111111111111111111111
but in ten based you will find it is 2147483647 or 2^31-1 or Int32.MaxValue

blocks|key|3844229|text|使用Java9的REPL、jshell|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3844230|$+jshell
%7C++Welcome+to+JShell+--+Version+9-Debian

jshell>+System.out.println(Integer.MAX_VALUE)
2147483647|code-block|syntax|javascript|3844231|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/JShell^0|D|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Using Java 9's REPL, <a href="https://en.wikipedia.org/wiki/JShell" rel="nofollow noreferrer">jshell</a>:

<pre><code>$ jshell
| Welcome to JShell -- Version 9-Debian

jshell&gt; System.out.println(Integer.MAX_VALUE)
2147483647
</code></pre>

blocks|key|3000772|text|在Python中尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3000773|>>>+int('1'+*+31,+base=2)
2147483647|code-block|syntax|javascript|3000774|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try in Python:

<pre><code>&gt;&gt;&gt; int('1' * 31, base=2)
2147483647
</code></pre>

blocks|key|5254976|text|在C中，在#include+<stdint.h>之后使用INT32_MAX。在C%2B%2B中，在#include+<cstdint>之后使用INT32_MAX。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5254977|或用于特定于平台的大小的INT_MAX，或用于unsigned+int的UINT32_MAX或UINT_MAX。参见http://www.cplusplus.com/reference/cstdint/和http://www.cplusplus.com/reference/climits/。|5254978|或者sizeof(int)。|5254979|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/cstdint/|1|http://www.cplusplus.com/reference/climits/^0|5|J|S|9|19|I|1V|9|0|C|7|N|C|10|A|1B|8|1M|17|0|2U|17|1|0|2|B|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|H|3|I|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

In C use <code>INT32_MAX</code> after <code>#include &lt;stdint.h&gt;</code>.
In C++ use <code>INT32_MAX</code> after <code>#include &lt;cstdint&gt;</code>.

Or <code>INT_MAX</code> for platform-specific size or <code>UINT32_MAX</code> or <code>UINT_MAX</code> for <code>unsigned int</code>. See <a href="http://www.cplusplus.com/reference/cstdint/" rel="nofollow noreferrer">http://www.cplusplus.com/reference/cstdint/</a> and <a href="http://www.cplusplus.com/reference/climits/" rel="nofollow noreferrer">http://www.cplusplus.com/reference/climits/</a>.

Or <code>sizeof(int)</code>.

blocks|key|3000528|text|一般来说，你可以做一个简单的操作来反映Int32的本质，用1填充所有可用的位--这是你可以很容易地保存在内存中的东西。它在大多数语言中的工作方式基本相同，但我将使用Python作为示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3000529|max+=+0
bits+=+[1]+*+31+#+Generate+a+"bit+array"+filled+with+1's
for+bit+in+bits:
++++max+=+(max+<<+1)+%7C+bit
#+max+is+now+2147483647|code-block|syntax|javascript|3000530|对于无符号Int32，将其设置为32而不是31+1。|3000531|但由于有一些更冒险的方法，我开始考虑公式，只是为了好玩……|3000532|公式1+(如果未给定运算符，则连接数字)|offset|length|style|BOLD|3000533|3000534|a+=+4|unordered-list-item|3000535|b+=+8|3000536|ba/a|3000537|ab-1|3000538|ab|3000539|ab-a-b|3000540|3000541|3000542|Python快速检查|3000543|a+=+4
b+=+8
ab+=+int('%25d%25d'+%25+(a,+b))
ba+=+int('%25d%25d'+%25+(b,+a))
'%25d%25d%25d%25d%25d'+%25+(ba/a,+ab-1,+ab,+ab-a-b,+ab-1)
#+gives+'2147483647'|3000544|公式2|3000545|3000546|x+=+48|3000547|x/2-3|3000548|x-1|3000549|x|3000550|x*3/4|3000551|3000552|3000553|3000554|x+=+48
'%25d%25d%25d%25d%25d'+%25+(x/2-3,+x-1,+x,+x*3/4,+x-1)+
#+gives+'2147483647'|3000555|entityMap^0|0|0|0|0|0|3|0|0|0|0|0|0|0|0|0|0|0|0|0|3|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1Y|8|@$M|1Z|N|20|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|22|8|@]|9|@]|A|$]]|$1|U|3|V|5|T|7|23|8|@]|9|@]|A|$]]|$1|W|3|X|5|T|7|24|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|T|7|25|8|@]|9|@]|A|$]]|$1|10|3|11|5|T|7|26|8|@]|9|@]|A|$]]|$1|12|3|13|5|T|7|27|8|@]|9|@]|A|$]]|$1|14|3|Z|5|T|7|28|8|@]|9|@]|A|$]]|$1|15|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2A|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|2B|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|2C|8|@$M|2D|N|2E|O|P]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|T|7|2G|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|T|7|2H|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|T|7|2I|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|T|7|2J|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|T|7|2K|8|@]|9|@]|A|$]]|$1|1N|3|1I|5|T|7|2L|8|@]|9|@]|A|$]]|$1|1O|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1P|3|17|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|D|7|2O|8|@]|9|@]|A|$E|F]]|$1|1S|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]]|1T|$]]

In general you could do a simple operation which reflects the very nature of a Int32, fill all the available bits with 1's - That is something which you can hold easily in your memory. It works basically the same way in most languages, but i'm going with Python for the example:

<pre><code>max = 0
bits = [1] * 31 # Generate a "bit array" filled with 1's
for bit in bits:
 max = (max &lt;&lt; 1) | bit
# max is now 2147483647
</code></pre>

For unsigned Int32's, make it 32 instead of 31 1's.

But since there are posted a few more adventurous approaches, i began to think of formulas, just for the fun of it...

Formula 1 (Numbers are concatenated if no operator is given)

<ul>
<li>a = 4</li>
<li>b = 8</li>
<li>ba/a</li>
<li>ab-1</li>
<li>ab</li>
<li>ab-a-b</li>
<li>ab-1</li>
</ul>

Python quickcheck

<pre><code>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'
</code></pre>

Formula 2

<ul>
<li>x = 48</li>
<li>x/2-3</li>
<li>x-1</li>
<li>x</li>
<li>x*3/4</li>
<li>x-1</li>
</ul>

Python quickcheck

<pre><code>x = 48
'%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1) 
# gives '2147483647'
</code></pre>

blocks|key|756573|text|如果没有召回一个大整数，您将召回此助记符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|756574|现在数一下每个单词中的字母。|756575|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

"If a huge integer isn't recalled, you recall this mnemonic."

Now count the letters in each word.

blocks|key|756235|text|max_signed_32_bit_num+=+1+<<+31+-+1;++//+alternatively+~(1+<<+31)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|756236|编译器无论如何都应该对其进行优化。|unstyled|756237|比起1+<<+31+-+1，我更喜欢1+<<+31+-+1|offset|length|style|CODE|756238|0x7fffffff，因为您不需要count+f%25s|756239|因为您不需要<math.h>，所以使用unsigned(+pow(+2,+31+)+)+-+1|756240|entityMap^0|0|0|2|B|I|B|0|0|A|N|1|0|6|8|J|S|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|Z|8|@$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@$I|15|J|16|K|L]|$I|17|J|18|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|19|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>max_signed_32_bit_num = 1 &lt;&lt; 31 - 1; // alternatively ~(1 &lt;&lt; 31)
</code></pre>

A compiler should optimize it anyway.

I prefer <code>1 &lt;&lt; 31 - 1</code> over 

<code>0x7fffffff</code> because you don't need count <code>f</code>s

<code>unsigned( pow( 2, 31 ) ) - 1</code> because you don't need <code>&lt;math.h&gt;</code>

I can never remember the number. I need a memory rule.

What is the maximum value for an int32?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

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

问int32的最大值是多少？
EN

回答 44

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问int32的最大值是多少？EN

回答 44

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问int32的最大值是多少？
EN