나는 그 숫자를 기억할 수 없다. 메모리 규칙이 필요합니다.

2,147,483,647입니다. 그것을 암기하는 가장 쉬운 방법은 문신을 통하는 것입니다.

내가 생각할 수있는 가장 정답은입니다 Int32.MaxValue.

10 진수에서 기억하기 어려운 값이라고 생각되면 2 단계를 시도하십시오. 1111111111111111111111111111111

전체 Pi 번호를 기억할 수있는 경우 찾고있는 숫자는 Pi 10 진수의 1,867,996,689에서 1,867,996,680까지입니다.

숫자 문자열 2147483647은 Pi의 1,867,996,680 10 진수에 나타납니다. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

출처 : http://www.subidiom.com/pi/

10 자리 숫자이므로 전화 번호 인 것처럼 가장합니다 (미국에 거주한다고 가정). 214-748-3647. 전화하지 않는 것이 좋습니다.

그것을 하나의 큰 숫자로 생각하기보다는 그것을 세분화하고 관련된 아이디어를 찾아보십시오.

• 최대 스누커 브레이크 2 회 (최대 브레이크는 147 회)
• 4 년 (48 개월)
• 3 년 (36 개월)
• 4 년 (48 개월)

위의 가장 큰 음수에 적용됩니다. 긍정적 인 것은 그 빼기 1입니다.

어쩌면 위의 고장은 더 이상 기억에 남지 않을 것입니다 (매우 흥미롭지는 않습니다!).하지만 희망이있는 아이디어를 얻을 수 있기를 바랍니다!

최대 음수 (32 비트) 값 : -2147483648
(1 << 31)

최대 양수 (32 비트) 값 : 2147483647
~ (1 << 31)

니모닉 : "술에 취한 AKA 흥분"

drunk ========= Drinking age is 21
AK ============ AK 47
A ============= 4 (A and 4 look the same)
horny ========= internet rule 34 (if it exists, there's 18+ material of it) 

21 47 4(years) 3(years) 4(years)
21 47 48       36       48

어쨌든이 정규 표현식을 사용하십시오 (문자열에 Int32.MaxValue보다 크지 않은 10 진수 형식의 음이 아닌 정수가 포함되어 있는지 확인)

[0-9]{1,9}|[0-1][0-9]{1,8}|20[0-9]{1,8}|21[0-3][0-9]{1,7}|214[0-6][0-9]{1,7}|2147[0-3][0-9]{1,6}|21474[0-7][0-9]{1,5}|214748[0-2][0-9]{1,4}|2147483[0-5][0-9]{1,3}|21474836[0-3][0-9]{1,2}|214748364[0-7]

아마 기억하는 데 도움이 될 것입니다.

그게 내가 기억하는 방법입니다 2147483647.

• 214-2.14는 대략 pi-1이므로
• 48 = 6 * 8
• 64 = 8 * 8

이것을 수평으로 작성하십시오.

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

이제 2147483647이 있습니다.

이것이 조금 도움이되기를 바랍니다.

2^(x+y) = 2^x * 2^y

2^10 ~ 1,000
2^20 ~ 1,000,000
2^30 ~ 1,000,000,000
2^40 ~ 1,000,000,000,000
(etc.)

2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64
2^7 = 128
2^8 = 256
2^9 = 512

따라서 2 ^ 31 (int int max)은 2 ^ 30 (약 10 억) 곱하기 2 ^ 1 (2), 즉 약 20 억입니다. 그리고 2 ^ 32는 2 ^ 30 * 2 ^ 2 또는 약 40 억입니다. 이 근사 방법은 약 2 ^ 64 (오류가 약 15 %로 증가)까지도 정확합니다.

정확한 답이 필요한 경우 계산기를 가져와야합니다.

편리한 단어 정렬 용량 근사치 :

• 2 ^ 16 ~ = 64 천 // uint16
• 2 ^ 32 ~ = 40 억 // uint32, IPv4, 유닉스 타임
• 2 ^ 64 ~ = 16 개의 quintillion (일명 160 억 또는 1600 만 조) // uint64, "bigint"
• 2 ^ 128 ~ = 256 quintillion quintillion (일명 256 조 조) // IPv6, GUID

괜찮은 계산기를 가지고 16 진수 모드에서 "7FFFFFFF"를 입력 한 다음 십진수로 전환하십시오.

2147483647.

에 관한 것 2.1 * 10^9입니다. 정확한 것을 알 필요가 없습니다 2^{31} - 1 = 2,147,483,647.

씨

C에서 다음과 같이 찾을 수 있습니다.

#include <stdio.h>
#include <limits.h>

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

제공 (잘없이 ,)

max int:          2,147,483,647
max unsigned int: 4,294,967,295

C ++ 11

std::cout << std::numeric_limits<int>::max() << "\n";
std::cout << std::numeric_limits<unsigned int>::max() << "\n";

자바

Java로도 얻을 수 있습니다.

System.out.println(Integer.MAX_VALUE);

그러나 Java 정수는 항상 서명됩니다.

파이썬 2

파이썬에는 임의의 정밀 정수가 있습니다. 그러나 Python 2에서는 C 정수에 매핑됩니다. 그래서 당신은 이것을 할 수 있습니다 :

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

그래서 파이썬 long은 정수가 커질 때로 전환합니다.2^31 -1

다음은 2 ** 31을 기억하기위한 니모닉입니다. 1을 빼면 최대 정수 값을 얻습니다.

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

Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide
2    1   4    7  4    8        3    6      4     8

나는 그것들을 기억하기에 충분할 정도로 종종 최대 18의 2의 힘을 사용했지만 심지어 2 ** 31을 암기하는 것을 귀찮게하지 않았습니다. 필요에 따라 계산하거나 상수를 사용하거나 2G로 추정하기가 너무 쉽습니다.

32 비트, 부호 용, 31 비트 정보 :

2^31 - 1 = 2147483647

왜 -1입니까?
첫 번째는 0이므로 최대 값은 1을 뺀 것 입니다.

cantfindaname88에 대한 편집

카운트는 2 ^ 31이지만 가장 큰 값은 2147483648 (2 ^ 31) 일 수 없습니다. 1이 아니라 0부터 계산하기 때문입니다.

Rank   1 2 3 4 5 6 ... 2147483648
Number 0 1 2 3 4 5 ... 2147483647

3 비트 만있는 또 다른 설명 : 1은 부호, 2는 정보

2^2 - 1 = 3

3 비트로 가능한 모든 값 아래 : (2 ^ 3 = 8 개 값)

1: 100 ==> -4
2: 101 ==> -3
3: 110 ==> -2
4: 111 ==> -1
5: 000 ==>  0
6: 001 ==>  1
7: 010 ==>  2
8: 011 ==>  3

글쎄, 그것은 32 비트를 가지고 2 ^ 32 다른 값을 저장할 수 있습니다. 그 중 절반은 부정적입니다.

해결책은 2,147,483,647입니다

가장 낮은 값은 −2,147,483,648입니다.

(음수 값이 하나 더 있음에 유의하십시오.)

글쎄, 농담 외에도 유용한 메모리 규칙을 찾고 있다면 항상 큰 숫자를 기억하는 데 사용하는 규칙이 있습니다.

3-4 자리 숫자로 숫자를 세분화하고 휴대폰 키보드의 투영을 사용하여 시각적으로 기억해야합니다. 사진에 표시하는 것이 더 쉽습니다.

보시다시피, 지금부터 3 가지 모양 만 기억하면됩니다. 그 중 2 개는 Tetris L처럼 보이고 1 개는 진드기처럼 보입니다 . 10 자리 숫자를 암기하는 것보다 훨씬 쉽습니다.

숫자를 기억해야 할 경우 도형을 기억하기 만하면 전화 키보드를 상상하고보고 도형을 투영합니다. 어쩌면 처음에는 키보드를 봐야하지만 약간의 연습 후에 숫자가 왼쪽 상단에서 오른쪽 하단으로 가고 있다는 것을 기억할 것이므로 머리에 간단히 상상할 수 있습니다.

모양의 방향과 각 모양의 자릿수를 기억해야합니다 (예를 들어, 2147483647의 예에서는 4 자리 Tetris L과 3 자리 L이 있습니다).

이 기술을 사용하여 중요한 숫자를 쉽게 기억할 수 있습니다 (예 : 16 자리 신용 카드 번호 등을 기억했습니다).

정수에 가장 쉬운 방법은 Int.maxInt ()와 같은 것이 없다면 16 진수를 사용하는 것입니다. 그 이유는 다음과 같습니다.

부호없는 최대 값

8-bit 0xFF
16-bit 0xFFFF
32-bit 0xFFFFFFFF
64-bit 0xFFFFFFFFFFFFFFFF
128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

7F를 최대 부호 값으로 사용하는 부호있는 값

8-bit 0x7F
16-bit 0x7FFF
32-bit 0x7FFFFFFF
64-bit 0x7FFFFFFFFFFFFFFF

최대 부호 값으로 80을 사용하는 부호 값

8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000

이것은 어떻게 작동합니까? 이것은 이진 전술과 매우 유사하며 각 16 진수는 정확히 4 비트입니다. 또한 많은 컴파일러가 바이너리를 지원하는 것보다 16 진수를 훨씬 잘 지원합니다.

F hex to binary: 1111
8 hex to binary: 1000
7 hex to binary: 0111
0 hex to binary: 0000

따라서 7F는 01111111 / 7FFF는 0111111111111111과 같습니다. 또한 "정상적으로 높은 상수"에 이것을 사용하는 경우 7F ...는 안전한 16 진수이지만 7F와 80을 시험해보고 인쇄하기는 쉽습니다. 화면을보고 어떤 화면인지 확인하십시오.

0x7FFF + 0x0001 = 0x8000, 따라서 손실은 하나의 숫자이므로 0x7F를 사용하면 더 안정적인 코드, 특히 32 비트 이상을 사용하기 시작하면 일반적으로 나쁜 트레이드 오프가 아닙니다

먼저 47을 두 번 쓰고 ( 에이전트 47 을 좋아합니까?) 표시된대로 공백을 유지하십시오 (각 대시는 한 자리의 슬롯입니다. 처음 2 개의 슬롯, 4).

--47----47

당신이 12손에 있다고 생각하십시오 (12 = 12이기 때문에). 4요원 47 번호의 첫 번째 자리 에을 곱한 후 47이미 가지고있는 첫 번째 페어의 오른쪽에 결과를 배치하십시오.

12 * 4 = 48
--4748--47 <-- after placing 48 to the right of first 47

그런 다음 곱셈 12에 의해 3(이다 에이전트 47의 수의 두 번째 숫자 있도록하기 위해 7당신이 필요를, 7 - 4 = 3첫 번째 이쌍 오른쪽 마지막 쌍의 슬롯에 결과를 넣어)

12 * 3 = 36
--47483647 <-- after placing 36 to the right of first two pairs

마지막으로 가장 오른쪽 자리 (이 경우 2)부터 시작하여 손에서 하나씩 숫자를 끌어서 첫 번째 빈 슬롯에 놓습니다.

2-47483647 <-- after placing 2
2147483647 <-- after placing 1

거기 있어요! 음수 제한의 경우 1에서 더 생각할 수 있습니다. 경우 양수 한계보다 절대 값 이 .

몇 번 연습하면 교수형에 처할 수 있습니다!

2GB

(답변에 대한 최소 길이가 있습니까?)

.NET 가정-

Console.WriteLine(Int32.MaxValue);

ASCII 테이블 을 아는 것으로 마음에 들지 않으면 MaxInt:
!GH6G = 21 47 48 36 47

기억하는 가장 좋은 규칙은 다음과 같습니다 :
21 (매직 넘버!)
47 (그냥 기억)
48 (순차!)
36 (21 + 15, 두 매직!)
47 다시

또한 10 자리보다 5 쌍을 기억하는 것이 더 쉽습니다.

기억하는 가장 쉬운 방법은 std::numeric_limits< int >::max()

예를 들어 ( MSDN에서 )

// numeric_limits_max.cpp

#include <iostream>
#include <limits>

using namespace std;

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

흥미롭게도 Int32.MaxValue는 2,147,486,647보다 많은 문자를 가지고 있습니다.

하지만 다시 코드를 완성했습니다.

우리가 정말로 외워야 할 것은 Int3<period>M<enter> 비주얼 스튜디오에서 입력 할 수있는 6 자에 불과합니다.

최신 정보 어떤 이유로 나는 downvoted했다. 내가 생각할 수있는 유일한 이유는 그들이 내 첫 진술을 이해하지 못했기 때문입니다.

"Int32.MaxValue"는 최대 14자를 입력합니다. 쉼표를 넣는 지 여부에 따라 2,147,486,647은 10 자 또는 13자를 입력합니다.

2 ^ (10 * x)는 대략 10 ^ (3 * x)입니다. 이미 킬로바이트 / 키비 바이트 등으로 이미 익숙한 상태 일 것입니다.

2^10 = 1024                ~= one thousand
2^20 = 1024^2 = 1048576    ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion

int는 31 비트 (부호는 + ~ 1 비트)를 사용하므로 2 ^ 30을 두 배로 늘리면 약 20 억이됩니다. 32 비트를 사용하는 부호없는 int의 경우 40 억으로 다시 두 배가됩니다. 물론 오차 계수는 커질수록 높아지지만 정확한 값을 기억할 필요는 없습니다 (필요한 경우 미리 정의 된 상수를 사용해야합니다). 근사값은 무언가가 넘쳐 넘칠 위험이있을 때 알기에 충분합니다.

이것이 내가 2,147,483,647을 기억하기 위해하는 방법입니다

먼 사바나 분기 옵티머스 트리오 사십 구십 구로

2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary

무슨 소리 야? 그것이 2 ^ 32라는 것을 기억하기에 충분히 쉬워야합니다. 규칙이 해당 숫자의 값을 기억하도록하려면 일반적으로 이진수와 십진수를 변환하는 편리한 규칙이 있습니다.

2 ^ 10 ~ 1000

이것은 2 ^ 20 ~ 1,000,000을 의미합니다

2 ^ 30 ~ 1,000,000,000

두 배 (2 ^ 31)는 20 억이고 두 배 (2 ^ 32)는 40 억입니다.

이진 숫자의 대략적인 추정치를 얻는 쉬운 방법입니다. 이진수 10은 10 진수로 3이됩니다.

Objective-C (iOS 및 OSX)에서 다음 매크로 만 기억하십시오.

#define INT8_MAX         127
#define INT16_MAX        32767
#define INT32_MAX        2147483647
#define INT64_MAX        9223372036854775807LL

#define UINT8_MAX         255
#define UINT16_MAX        65535
#define UINT32_MAX        4294967295U
#define UINT64_MAX        18446744073709551615ULL

Int32는 숫자를 저장할 수있는 32 비트가 있음을 의미합니다. 최상위 비트는 부호 비트이며 숫자가 양수인지 음수인지를 나타냅니다. 따라서 양수와 음수에 2 ^ 31 비트가 있습니다.

0이 양수이면 논리 범위 (앞서 언급)를 얻습니다.

+2147483647에서 -2147483648

그것이 작다고 생각되면 Int64를 사용하십시오.

+9223372036854775807 ~ -9223372036854775808

그리고 왜이 숫자를 기억하고 싶어? 코드에서 사용하려면? Int32.MaxValue 또는 Int32.MinValue는 항상 .net 코어 내에서 정적 값이므로 코드로 새 int를 만드는 것보다 사용 속도가 빠르므로 항상 코드에서 Int32.MaxValue 또는 Int32.MinValue를 사용해야합니다.

내 진술 :이 숫자를 기억으로 알고 있다면 .. 과시하고 있습니다!

이것을 기억하십시오 : 21 IQ ITEM 47

전화 패드로 인코딩을 해제하거나 종이에 직접 적을 수 있습니다.

"21 IQ ITEM 47"을 기억하기 위해, "Hitman : Codename 47에는 21 개의 미션이 있으며, 이는 각각 IQ ITEM 자체입니다".

또는 "IQ가 높고 입안의 물건을 좋아하지 않기 때문에 매일 21:47에 치아를 청소합니다."