I can never remember the number. I need a memory rule.
This question is related to
integer
The answer is
That's how I remembered 2147483647:
- 214 - because 2.14 is approximately pi-1
- 48 = 6*8
- 64 = 8*8
Write these horizontally:
214_48_64_
and insert:
^ ^ ^
7 3 7 - which is Boeing's airliner jet (thanks, sgorozco)
Now you've got 2147483647.
Hope this helps at least a bit.
Assuming .NET -
Console.WriteLine(Int32.MaxValue);
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
8-bit 0xFF
16-bit 0xFFFF
32-bit 0xFFFFFFFF
64-bit 0xFFFFFFFFFFFFFFFF
128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Signed values, using 7F as the max signed value
8-bit 0x7F
16-bit 0x7FFF
32-bit 0x7FFFFFFF
64-bit 0x7FFFFFFFFFFFFFFF
Signed values, using 80 as the max signed value
8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000
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.
F hex to binary: 1111
8 hex to binary: 1000
7 hex to binary: 0111
0 hex to binary: 0000
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
this is how i do it to remember 2,147,483,647
To a far savannah quarter optimus trio hexed forty septenary
2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary
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.)
The easiest way to remember is to look at std::numeric_limits< int >::max()
For example (from 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;
}
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.
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
The numeric string 2147483647 appears at the 1,867,996,680 decimal digit of Pi. 3.14......86181221809936452346214748364710527835665425671614...
source: http://www.subidiom.com/pi/
Just remember that 2^(10*x) is approximately 10^(3*x) - you're probably already used to this with kilobytes/kibibytes etc. That is:
2^10 = 1024 ~= one thousand
2^20 = 1024^2 = 1048576 ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion
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.
First write out 47 twice, (you like Agent 47, right?), keeping spaces as shown (each dash is a slot for a single digit. First 2 slots, then 4)
--47----47
Think you have 12 in hand (because 12 = a dozen). Multiply it by 4, first digit of Agent 47's number, i.e. 47, and place the result to the right of first pair you already have
12 * 4 = 48
--4748--47 <-- after placing 48 to the right of first 47
Then multiply 12 by 3 (in order to make second digit of Agent 47's number, which is 7, you need 7 - 4 = 3) and put the result to the right of the first 2 pairs, the last pair-slot
12 * 3 = 36
--47483647 <-- after placing 36 to the right of first two pairs
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
2-47483647 <-- after placing 2
2147483647 <-- after placing 1
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!
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.)
With Groovy on the path:
groovy -e " println Integer.MAX_VALUE "
(Groovy is extremely useful for quick reference, within a Java context.)
It's 231 − 1 (32 bits, one is used for sign).
If you want an approximate value, use 210 = 1024 ≈ 103, so 231 ≈ 2*109. If you want to compute an exact value by hand, use exponentiation by squaring to get to 232 = 2(25) and divide by two. You only need to square five times to get 232:
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
dividing this by two and subtracting one gives you 2,147,483,647. If you don't need all digits, but only want say, the first three significant digits, the computations on each squaring step are very easy.
Rather than think of it as one big number, try breaking it down and looking for associated ideas eg:
- 2 maximum snooker breaks (a maximum break is 147)
- 4 years (48 months)
- 3 years (36 months)
- 4 years (48 months)
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!
The most correct answer I can think of is Int32.MaxValue.
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
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:
- 2^16 ~= 64 thousand // uint16
- 2^32 ~= 4 billion // uint32, IPv4, unixtime
- 2^64 ~= 16 quintillion (aka 16 billion billions or 16 million trillions) // uint64, "bigint"
- 2^128 ~= 256 quintillion quintillion (aka 256 trillion trillion trillions) // IPv6, GUID
Using Java 9's REPL, jshell:
$ jshell
| Welcome to JShell -- Version 9-Debian
jshell> System.out.println(Integer.MAX_VALUE)
2147483647
32 bits, one for the sign, 31 bits of information:
2^31 - 1 = 2147483647
Why -1?
Because the first is zero, so the greatest is the count minus one.
EDIT for cantfindaname88
The count is 2^31 but the greatest can't be 2147483648 (2^31) because we count from 0, not 1.
Rank 1 2 3 4 5 6 ... 2147483648
Number 0 1 2 3 4 5 ... 2147483647
Another explanation with only 3 bits : 1 for the sign, 2 for the information
2^2 - 1 = 3
Below all the possible values with 3 bits: (2^3 = 8 values)
1: 100 ==> -4
2: 101 ==> -3
3: 110 ==> -2
4: 111 ==> -1
5: 000 ==> 0
6: 001 ==> 1
7: 010 ==> 2
8: 011 ==> 3
It's about 2.1 * 10^9. No need to know the exact 2^{31} - 1 = 2,147,483,647.
C
You can find it in C like that:
#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);
}
gives (well, without the ,)
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
You can get this with Java, too:
System.out.println(Integer.MAX_VALUE);
But keep in mind that Java integers are always signed.
Python 2
Python has arbitrary precision integers. But in Python 2, they are mapped to C integers. So you can do this:
import sys
sys.maxint
>>> 2147483647
sys.maxint + 1
>>> 2147483648L
So Python switches to long when the integer gets bigger than 2^31 -1
It is very easy to remember. In hexadecimal one digit is 4 bits. So for unsigned int write 0x and 8 fs (0xffffffff) 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 0x7fffffff into a Python or Ruby shell. You could also write 0x100000000 - 1 and 0x80000000 - 1, if that is more easy to you to remember.
Largest negative (32bit) value : -2147483648
(1 << 31)
Largest positive (32bit) value : 2147483647
~(1 << 31)
Mnemonic: "drunk AKA horny"
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
2GB
(is there a minimum length for answers?)
I made a couple genius methods in C# that you can take advantage of in your production environment:
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;
}
Using Java 9's REPL, jshell:
$ jshell
| Welcome to JShell -- Version 9-Debian
jshell> System.out.println(Integer.MAX_VALUE)
2147483647
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:
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.).
If you happen to know your ASCII table off by heart and not MaxInt :
!GH6G = 21 47 48 36 47
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.
Try in Python:
>>> int('1' * 31, base=2)
2147483647
I made a couple genius methods in C# that you can take advantage of in your production environment:
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;
}
Assuming .NET -
Console.WriteLine(Int32.MaxValue);
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.
If you think the value is too hard to remember in base 10, try base 2: 1111111111111111111111111111111
This is how I remember...
In hex, a digit represents four bits, so 4 * 8 = 32, so the max signed 32 bit int is:
0xFFFFFFFF >> 1 # => 2147483647
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
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)
[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]
Maybe it would help you to remember.
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.
If you happen to know your ASCII table off by heart and not MaxInt :
!GH6G = 21 47 48 36 47
First write out 47 twice, (you like Agent 47, right?), keeping spaces as shown (each dash is a slot for a single digit. First 2 slots, then 4)
--47----47
Think you have 12 in hand (because 12 = a dozen). Multiply it by 4, first digit of Agent 47's number, i.e. 47, and place the result to the right of first pair you already have
12 * 4 = 48
--4748--47 <-- after placing 48 to the right of first 47
Then multiply 12 by 3 (in order to make second digit of Agent 47's number, which is 7, you need 7 - 4 = 3) and put the result to the right of the first 2 pairs, the last pair-slot
12 * 3 = 36
--47483647 <-- after placing 36 to the right of first two pairs
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
2-47483647 <-- after placing 2
2147483647 <-- after placing 1
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!
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".
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
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:
- 2^16 ~= 64 thousand // uint16
- 2^32 ~= 4 billion // uint32, IPv4, unixtime
- 2^64 ~= 16 quintillion (aka 16 billion billions or 16 million trillions) // uint64, "bigint"
- 2^128 ~= 256 quintillion quintillion (aka 256 trillion trillion trillions) // IPv6, GUID
Just take any decent calculator and type in "7FFFFFFF" in hex mode, then switch to decimal.
2147483647.
In C use INT32_MAX after #include <stdint.h>.
In C++ use INT32_MAX after #include <cstdint>.
Or INT_MAX for platform-specific size or UINT32_MAX or UINT_MAX for unsigned int. See http://www.cplusplus.com/reference/cstdint/ and http://www.cplusplus.com/reference/climits/.
Or sizeof(int).
Just take any decent calculator and type in "7FFFFFFF" in hex mode, then switch to decimal.
2147483647.
Assuming .NET -
Console.WriteLine(Int32.MaxValue);
With Groovy on the path:
groovy -e " println Integer.MAX_VALUE "
(Groovy is extremely useful for quick reference, within a Java context.)
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).
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 Int3<period>M<enter>, 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.
It's 231 − 1 (32 bits, one is used for sign).
If you want an approximate value, use 210 = 1024 ≈ 103, so 231 ≈ 2*109. If you want to compute an exact value by hand, use exponentiation by squaring to get to 232 = 2(25) and divide by two. You only need to square five times to get 232:
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
dividing this by two and subtracting one gives you 2,147,483,647. If you don't need all digits, but only want say, the first three significant digits, the computations on each squaring step are very easy.
max_signed_32_bit_num = 1 << 31 - 1; // alternatively ~(1 << 31)
A compiler should optimize it anyway.
I prefer 1 << 31 - 1 over
0x7fffffff because you don't need count fs
unsigned( pow( 2, 31 ) ) - 1 because you don't need <math.h>
Assuming .NET -
Console.WriteLine(Int32.MaxValue);
2GB
(is there a minimum length for answers?)
In Objective-C (iOS & OSX), just remember these macros:
#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
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.
2GB
(is there a minimum length for answers?)
this is how i do it to remember 2,147,483,647
To a far savannah quarter optimus trio hexed forty septenary
2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary
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.)
Rather than think of it as one big number, try breaking it down and looking for associated ideas eg:
- 2 maximum snooker breaks (a maximum break is 147)
- 4 years (48 months)
- 3 years (36 months)
- 4 years (48 months)
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!
max_signed_32_bit_num = 1 << 31 - 1; // alternatively ~(1 << 31)
A compiler should optimize it anyway.
I prefer 1 << 31 - 1 over
0x7fffffff because you don't need count fs
unsigned( pow( 2, 31 ) ) - 1 because you don't need <math.h>
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".
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.
Rather than think of it as one big number, try breaking it down and looking for associated ideas eg:
- 2 maximum snooker breaks (a maximum break is 147)
- 4 years (48 months)
- 3 years (36 months)
- 4 years (48 months)
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!
Just remember that 2^(10*x) is approximately 10^(3*x) - you're probably already used to this with kilobytes/kibibytes etc. That is:
2^10 = 1024 ~= one thousand
2^20 = 1024^2 = 1048576 ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion
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.
32 bits, one for the sign, 31 bits of information:
2^31 - 1 = 2147483647
Why -1?
Because the first is zero, so the greatest is the count minus one.
EDIT for cantfindaname88
The count is 2^31 but the greatest can't be 2147483648 (2^31) because we count from 0, not 1.
Rank 1 2 3 4 5 6 ... 2147483648
Number 0 1 2 3 4 5 ... 2147483647
Another explanation with only 3 bits : 1 for the sign, 2 for the information
2^2 - 1 = 3
Below all the possible values with 3 bits: (2^3 = 8 values)
1: 100 ==> -4
2: 101 ==> -3
3: 110 ==> -2
4: 111 ==> -1
5: 000 ==> 0
6: 001 ==> 1
7: 010 ==> 2
8: 011 ==> 3
This is how I remember...
In hex, a digit represents four bits, so 4 * 8 = 32, so the max signed 32 bit int is:
0xFFFFFFFF >> 1 # => 2147483647
It is very easy to remember. In hexadecimal one digit is 4 bits. So for unsigned int write 0x and 8 fs (0xffffffff) 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 0x7fffffff into a Python or Ruby shell. You could also write 0x100000000 - 1 and 0x80000000 - 1, if that is more easy to you to remember.
2147483647
Here's what you need to remember:
- It's 2 billion.
- The next three triplets are increasing like so: 100s, 400s, 600s
- The first and the last triplet need 3 added to them so they get rounded up to 50 (eg 147 + 3 = 150 & 647 + 3 = 650)
- The second triplet needs 3 subtracted from it to round it down to 80 (eg 483 - 3 = 480)
Hence 2, 147, 483, 647
The most correct answer I can think of is Int32.MaxValue.
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
8-bit 0xFF
16-bit 0xFFFF
32-bit 0xFFFFFFFF
64-bit 0xFFFFFFFFFFFFFFFF
128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Signed values, using 7F as the max signed value
8-bit 0x7F
16-bit 0x7FFF
32-bit 0x7FFFFFFF
64-bit 0x7FFFFFFFFFFFFFFF
Signed values, using 80 as the max signed value
8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000
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.
F hex to binary: 1111
8 hex to binary: 1000
7 hex to binary: 0111
0 hex to binary: 0000
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
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:
The result would be 4294967295 in decimal:
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
2GB
(is there a minimum length for answers?)
Rather than think of it as one big number, try breaking it down and looking for associated ideas eg:
- 2 maximum snooker breaks (a maximum break is 147)
- 4 years (48 months)
- 3 years (36 months)
- 4 years (48 months)
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!
With Groovy on the path:
groovy -e " println Integer.MAX_VALUE "
(Groovy is extremely useful for quick reference, within a Java context.)
In Objective-C (iOS & OSX), just remember these macros:
#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
Just take any decent calculator and type in "7FFFFFFF" in hex mode, then switch to decimal.
2147483647.
Just remember that 2^(10*x) is approximately 10^(3*x) - you're probably already used to this with kilobytes/kibibytes etc. That is:
2^10 = 1024 ~= one thousand
2^20 = 1024^2 = 1048576 ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion
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.
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:
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.).
That's how I remembered 2147483647:
- 214 - because 2.14 is approximately pi-1
- 48 = 6*8
- 64 = 8*8
Write these horizontally:
214_48_64_
and insert:
^ ^ ^
7 3 7 - which is Boeing's airliner jet (thanks, sgorozco)
Now you've got 2147483647.
Hope this helps at least a bit.
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:
The result would be 4294967295 in decimal:
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
Try in Python:
>>> int('1' * 31, base=2)
2147483647
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.)
It's about 2.1 * 10^9. No need to know the exact 2^{31} - 1 = 2,147,483,647.
C
You can find it in C like that:
#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);
}
gives (well, without the ,)
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
You can get this with Java, too:
System.out.println(Integer.MAX_VALUE);
But keep in mind that Java integers are always signed.
Python 2
Python has arbitrary precision integers. But in Python 2, they are mapped to C integers. So you can do this:
import sys
sys.maxint
>>> 2147483647
sys.maxint + 1
>>> 2147483648L
So Python switches to long when the integer gets bigger than 2^31 -1
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)
[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]
Maybe it would help you to remember.
In C use INT32_MAX after #include <stdint.h>.
In C++ use INT32_MAX after #include <cstdint>.
Or INT_MAX for platform-specific size or UINT32_MAX or UINT_MAX for unsigned int. See http://www.cplusplus.com/reference/cstdint/ and http://www.cplusplus.com/reference/climits/.
Or sizeof(int).
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).
The most correct answer I can think of is Int32.MaxValue.
"If a huge integer isn't recalled, you recall this mnemonic."
Now count the letters in each word.
2147483647
Here's what you need to remember:
- It's 2 billion.
- The next three triplets are increasing like so: 100s, 400s, 600s
- The first and the last triplet need 3 added to them so they get rounded up to 50 (eg 147 + 3 = 150 & 647 + 3 = 650)
- The second triplet needs 3 subtracted from it to round it down to 80 (eg 483 - 3 = 480)
Hence 2, 147, 483, 647
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
Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide
2 1 4 7 4 8 3 6 4 8
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.
Just take any decent calculator and type in "7FFFFFFF" in hex mode, then switch to decimal.
2147483647.
With Groovy on the path:
groovy -e " println Integer.MAX_VALUE "
(Groovy is extremely useful for quick reference, within a Java context.)
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:
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
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)
- a = 4
- b = 8
- ba/a
- ab-1
- ab
- ab-a-b
- ab-1
Python quickcheck
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'
Formula 2
- x = 48
- x/2-3
- x-1
- x
- x*3/4
- x-1
Python quickcheck
x = 48
'%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1)
# gives '2147483647'
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
The numeric string 2147483647 appears at the 1,867,996,680 decimal digit of Pi. 3.14......86181221809936452346214748364710527835665425671614...
source: http://www.subidiom.com/pi/
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!
The most correct answer I can think of is Int32.MaxValue.
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
Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide
2 1 4 7 4 8 3 6 4 8
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.
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:
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
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)
- a = 4
- b = 8
- ba/a
- ab-1
- ab
- ab-a-b
- ab-1
Python quickcheck
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'
Formula 2
- x = 48
- x/2-3
- x-1
- x
- x*3/4
- x-1
Python quickcheck
x = 48
'%d%d%d%d%d' % (x/2-3, x-1, x, x*3/4, x-1)
# gives '2147483647'
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!
Largest negative (32bit) value : -2147483648
(1 << 31)
Largest positive (32bit) value : 2147483647
~(1 << 31)
Mnemonic: "drunk AKA horny"
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
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
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
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:
- 2^16 ~= 64 thousand // uint16
- 2^32 ~= 4 billion // uint32, IPv4, unixtime
- 2^64 ~= 16 quintillion (aka 16 billion billions or 16 million trillions) // uint64, "bigint"
- 2^128 ~= 256 quintillion quintillion (aka 256 trillion trillion trillions) // IPv6, GUID
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.
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.
If you think the value is too hard to remember in base 10, try base 2: 1111111111111111111111111111111
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 Int3<period>M<enter>, 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.
The easiest way to remember is to look at std::numeric_limits< int >::max()
For example (from 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;
}
"If a huge integer isn't recalled, you recall this mnemonic."
Now count the letters in each word.
Source: Stackoverflow.com