Tôi không bao giờ có thể nhớ số. Tôi cần một quy tắc bộ nhớ.

Đó là 2.147.483.647. Cách dễ nhất để ghi nhớ nó là thông qua một hình xăm.

Câu trả lời đúng nhất tôi có thể nghĩ là Int32.MaxValue.

Nếu bạn nghĩ rằng giá trị quá khó nhớ trong cơ sở 10, hãy thử cơ sở 2: 11111111111111111111111111111111

nếu bạn có thể nhớ toàn bộ số Pi, thì số bạn đang tìm kiếm nằm ở vị trí 1.867.996.680 cho đến 1.867.996.689 của các chữ số thập phân của Pi

Chuỗi số 2147483647 xuất hiện ở 1.867.996.680 chữ số thập phân của Pi. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

nguồn: http://www.subidiom.com/pi/

Đó là 10 chữ số, vì vậy hãy giả vờ đó là số điện thoại (giả sử bạn đang ở Mỹ). 214-748-3647. Tôi không khuyên bạn nên gọi nó.

Thay vì nghĩ về nó như một con số lớn, hãy thử phá vỡ nó và tìm kiếm những ý tưởng liên quan, ví dụ:

• 2 lần nghỉ bi-a tối đa (thời gian nghỉ tối đa là 147)
• 4 năm (48 tháng)
• 3 năm (36 tháng)
• 4 năm (48 tháng)

Những điều trên áp dụng cho số âm lớn nhất; tích cực là trừ đi một.

Có thể sự cố ở trên sẽ không còn đáng nhớ đối với bạn nữa (hầu như không thú vị lắm!), Nhưng hy vọng bạn có thể đưa ra một số ý tưởng!

Giá trị âm lớn nhất (32 bit): -2147483648
(1 << 31)

Giá trị dương lớn nhất (32 bit): 2147483647
~ (1 << 31)

Mnemonic: "AKA say rượu"

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

Dù sao, hãy lấy regex này (nó xác định nếu chuỗi chứa Số nguyên không âm ở dạng thập phân cũng không lớn hơn 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]

Có lẽ nó sẽ giúp bạn nhớ.

Đó là cách tôi nhớ 2147483647:

• 214 - vì 2,14 xấp xỉ pi-1
• 48 = 6 * 8
• 64 = 8 * 8

Viết những thứ này theo chiều ngang:

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

Bây giờ bạn đã có 2147483647.

Hy vọng điều này sẽ giúp ít nhất một chút.

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

Vì vậy, 2 ^ 31 (đã ký int max) là 2 ^ 30 (khoảng 1 tỷ) lần 2 ^ 1 (2), tương đương khoảng 2 tỷ. Và 2 ^ 32 là 2 ^ 30 * 2 ^ 2 hoặc khoảng 4 tỷ đồng. Phương pháp gần đúng này đủ chính xác, thậm chí khoảng 2 ^ 64 (trong đó sai số tăng lên khoảng 15%).

Nếu bạn cần một câu trả lời chính xác thì bạn nên kéo lên một máy tính.

Các xấp xỉ công suất liên kết từ tiện dụng:

• 2 ^ 16 ~ = 64 nghìn // uint16
• 2 ^ 32 ~ = 4 tỷ // uint32, IPv4, unixtime
• 2 ^ 64 ~ = 16 triệu (còn gọi là 16 tỷ tỷ hoặc 16 triệu nghìn tỷ đồng) // uint64, "bigint"
• 2 ^ 128 ~ = 256 triệu triệu triệu (còn gọi là 256 nghìn tỷ nghìn tỷ đồng) // IPv6, GUID

Chỉ cần lấy bất kỳ máy tính tử tế nào và nhập "7FFFFFFF" ở chế độ hex, sau đó chuyển sang thập phân.

2147483647.

Đó là về 2.1 * 10^9. Không cần phải biết chính xác 2^{31} - 1 = 2,147,483,647.

C

Bạn có thể tìm thấy nó trong C như thế:

#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);
}

cho (tốt, không có ,)

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

Bạn cũng có thể có được điều này với Java:

System.out.println(Integer.MAX_VALUE);

Nhưng hãy nhớ rằng các số nguyên Java luôn được ký.

Con trăn 2

Python có số nguyên chính xác tùy ý. Nhưng trong Python 2, chúng được ánh xạ tới các số nguyên C. Vì vậy, bạn có thể làm điều này:

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

Vì vậy, Python chuyển sang longkhi số nguyên lớn hơn2^31 -1

Đây là một ghi nhớ để ghi nhớ 2 ** 31, trừ đi một để có giá trị nguyên tối đa.

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

Tôi đã sử dụng sức mạnh của hai đến 18 thường đủ để ghi nhớ chúng, nhưng thậm chí tôi không bận tâm đến việc ghi nhớ 2 ** 31. Thật quá dễ dàng để tính toán khi cần hoặc sử dụng hằng số, hoặc ước tính là 2G.

32 bit, một cho dấu hiệu, 31 bit thông tin:

2^31 - 1 = 2147483647

Tại sao -1?
Bởi vì đầu tiên là 0, nên lớn nhất là số trừ một .

EDIT cho cantfindaname88

Tổng số là 2 ^ 31 nhưng lớn nhất không thể là 2147483648 (2 ^ 31) vì chúng tôi đếm từ 0 chứ không phải 1.

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

Một lời giải thích khác chỉ có 3 bit: 1 cho dấu hiệu, 2 cho thông tin

2^2 - 1 = 3

Bên dưới tất cả các giá trị có thể có 3 bit: (2 ^ 3 = 8 giá trị)

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

Chà, nó có 32 bit và do đó có thể lưu trữ 2 ^ 32 giá trị khác nhau. Một nửa trong số đó là tiêu cực.

Giải pháp là 2.147.483.647

Và thấp nhất là −2,147,483,648.

(Lưu ý rằng có thêm một giá trị âm.)

Chà, ngoài những trò đùa, nếu bạn thực sự tìm kiếm một quy tắc bộ nhớ hữu ích, có một quy tắc mà tôi luôn sử dụng để ghi nhớ những con số lớn.

Bạn cần chia số của bạn thành các phần từ 3-4 chữ số và ghi nhớ chúng một cách trực quan bằng cách sử dụng phép chiếu trên bàn phím điện thoại di động của bạn. Dễ dàng hơn để hiển thị trên một hình ảnh:

Như bạn có thể thấy, từ bây giờ bạn chỉ cần nhớ 3 hình dạng, 2 trong số chúng trông giống như một Tetris L và một hình trông giống như một con bọ ve . Điều này chắc chắn dễ dàng hơn nhiều so với việc ghi nhớ một số gồm 10 chữ số.

Khi bạn cần nhớ lại số chỉ cần nhớ lại các hình dạng, hãy tưởng tượng / nhìn trên bàn phím điện thoại và chiếu các hình trên đó. Có lẽ ban đầu bạn sẽ phải nhìn vào bàn phím nhưng chỉ sau một chút luyện tập, bạn sẽ nhớ rằng các con số đang đi từ trên cùng bên trái sang dưới cùng bên phải để bạn có thể tưởng tượng nó trong đầu.

Chỉ cần đảm bảo rằng bạn nhớ hướng của hình dạng và số chữ số trong mỗi hình dạng (ví dụ: trong ví dụ 2147483647, chúng ta có Tetris L gồm 4 chữ số và L có 3 chữ số).

Bạn có thể sử dụng kỹ thuật này để dễ dàng ghi nhớ bất kỳ số quan trọng nào (ví dụ: tôi nhớ số thẻ tín dụng 16 chữ số của mình, v.v.).

Cách dễ nhất để làm điều này cho các số nguyên là sử dụng hệ thập lục phân, với điều kiện là không có gì giống như Int.maxInt (). Lý do là thế này:

Giá trị không dấu tối đa

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

Các giá trị đã ký, sử dụng 7F làm giá trị được ký tối đa

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

Các giá trị đã ký, sử dụng 80 làm giá trị được ký tối đa

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

Cái này hoạt động ra sao? Điều này rất giống với chiến thuật nhị phân và mỗi chữ số hex chính xác là 4 bit. Ngoài ra, rất nhiều trình biên dịch hỗ trợ hex tốt hơn rất nhiều so với việc chúng hỗ trợ nhị phân.

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

Vì vậy, 7F bằng 01111111 / 7FFF bằng 0111111111111111. Ngoài ra, nếu bạn đang sử dụng điều này cho "hằng số cực kỳ cao", 7F ... là hex an toàn, nhưng đủ dễ để thử 7F và 80 và chỉ cần in chúng vào màn hình của bạn để xem nó là cái nào

0x7FFF + 0x0001 = 0x8000, do đó, tổn thất của bạn chỉ là một số, vì vậy sử dụng 0x7F ... thường không phải là một sự đánh đổi tồi cho mã đáng tin cậy hơn, đặc biệt là khi bạn bắt đầu sử dụng 32 bit trở lên

Đầu tiên viết ra 47 lần, (bạn thích Agent 47 , phải không?), Giữ khoảng trắng như được hiển thị (mỗi dấu gạch ngang là một vị trí cho một chữ số. 2 khe đầu tiên, sau đó 4)

--47----47

Hãy nghĩ rằng bạn có 12trong tay (vì 12 = một tá). Nhân số đó với 4, chữ số đầu tiên của số Đại lý 47, nghĩa là 47đặt kết quả ở bên phải của cặp đầu tiên bạn đã có

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

Sau đó nhân 12với 3(để tạo chữ số thứ hai của số Agent 47, nghĩa là 7bạn cần 7 - 4 = 3) và đặt kết quả sang bên phải của 2 cặp đầu tiên, vị trí cặp cuối cùng

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

Cuối cùng kéo từng chữ số một từ bàn tay của bạn bắt đầu từ chữ số bên phải nhất (2 trong trường hợp này) và đặt chúng vào khe trống đầu tiên bạn nhận được

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

Có bạn có nó! Đối với giới hạn âm, bạn có thể nghĩ rằng đó là 1 nhiều hơn về giá trị tuyệt đối so với giới hạn dương.

Thực hành một vài lần, và bạn sẽ nhận được hang của nó!

2GB

(có độ dài tối thiểu cho câu trả lời không?)

Giả sử .NET -

Console.WriteLine(Int32.MaxValue);

Nếu bạn tình cờ biết bảng ASCII của bạn tắt và không MaxInt:
!GH6G = 21 47 48 36 47

Quy tắc tốt nhất để ghi nhớ nó là:
21 (số ma thuật!)
47 (chỉ cần nhớ nó)
48 (tuần tự!)
36 (21 + 15, cả hai phép thuật!)
47 một lần nữa

Ngoài ra, dễ nhớ hơn 5 cặp hơn 10 chữ số.

Cách dễ nhất để nhớ là nhìn vào std::numeric_limits< int >::max()

Ví dụ: ( từ 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;
}

Điều thú vị là Int32.MaxValue có nhiều ký tự hơn 2.147.486.647.

Nhưng một lần nữa, chúng tôi đã hoàn thành mã,

Vì vậy, tôi đoán tất cả những gì chúng ta thực sự phải ghi nhớ là Int3<period>M<enter>, chỉ có 6 ký tự để nhập vào studio hình ảnh.

CẬP NHẬT Vì một số lý do tôi đã bị hạ cấp. Lý do duy nhất tôi có thể nghĩ đến là họ không hiểu câu nói đầu tiên của tôi.

"Int32.MaxValue" cần tối đa 14 ký tự để nhập. 2.147.486.647 mất 10 hoặc 13 ký tự để nhập tùy thuộc vào việc bạn có đặt dấu phẩy hay không.

Chỉ cần nhớ rằng 2 ^ (10 * x) xấp xỉ 10 ^ (3 * x) - có lẽ bạn đã quen với điều này với kilobytes / kibibytes, v.v. Đó là:

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

Vì một int sử dụng 31 bit (+ ~ 1 bit cho dấu hiệu), chỉ cần tăng gấp đôi 2 ^ 30 để nhận được khoảng 2 tỷ. Đối với một số nguyên không dấu sử dụng 32 bit, tăng gấp đôi với giá 4 tỷ. Tất nhiên, hệ số lỗi càng cao khi bạn càng lớn, nhưng bạn không cần ghi nhớ giá trị chính xác (Nếu bạn cần, bạn nên sử dụng hằng số được xác định trước cho nó). Giá trị gần đúng là đủ tốt để nhận thấy khi một cái gì đó có thể là nguy hiểm gần tràn.

đây là cách tôi làm để ghi nhớ 2.147.483.647

Đến một vùng thảo nguyên xa xôi của bộ ba Optimus hexed bốn mươi vách ngăn

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

Ý anh là gì? Nó đủ dễ để nhớ rằng đó là 2 ^ 32. Nếu bạn muốn một quy tắc ghi nhớ giá trị của số đó, một quy tắc thuận tiện là để chuyển đổi giữa nhị phân và thập phân nói chung:

2 ^ 10 ~ 1000

có nghĩa là 2 ^ 20 ~ 1.000.000

và 2 ^ 30 ~ 1.000.000.000

Nhân đôi số đó (2 ^ 31) là 2 tỷ và gấp đôi số đó một lần nữa (2 ^ 32) là 4 tỷ.

Đó là một cách dễ dàng để có được ước tính sơ bộ của bất kỳ số nhị phân nào. 10 số 0 trong nhị phân trở thành 3 số 0 ở dạng thập phân.

Trong Objective-C (iOS & OSX), chỉ cần nhớ các macro này:

#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 có nghĩa là bạn có sẵn 32 bit để lưu trữ số của mình. Bit cao nhất là bit dấu, điều này cho biết số đó là dương hay âm. Vì vậy, bạn có 2 ^ 31 bit cho số dương và số âm.

Với số 0 là số dương, bạn có phạm vi logic (đã đề cập trước đó)

+2147483647 đến -2147483648

Nếu bạn nghĩ đó là nhỏ, hãy sử dụng Int64:

+9223372036854775807 đến -9223372036854775808

Và tại sao bạn muốn nhớ số này? Để sử dụng trong mã của bạn? Bạn phải luôn sử dụng Int32.MaxValue hoặc Int32.MinValue trong mã của bạn vì đây là các giá trị tĩnh (trong lõi .net) và do đó sử dụng nhanh hơn so với tạo int mới bằng mã.

Tuyên bố của tôi: nếu biết con số này theo trí nhớ .. bạn chỉ đang thể hiện!

Hãy nhớ điều này: 21 IQ ITEM 47

Nó có thể được mã hóa bằng bất kỳ bảng điện thoại nào, hoặc bạn có thể tự viết một tờ giấy xuống giấy.

Để ghi nhớ "21 IQ ITEM 47", tôi sẽ sử dụng "Hitman: Codename 47 có 21 nhiệm vụ, mỗi nhiệm vụ đều là IQ ITEM".

Hoặc "Tôi làm sạch răng lúc 21 giờ 47 phút mỗi ngày, vì tôi có IQ cao và không thích đồ trong miệng".