ฉันไม่สามารถจำหมายเลขได้ ฉันต้องการกฎหน่วยความจำ

มันคือ 2,147,483,647 วิธีที่ง่ายที่สุดในการจดจำมันคือผ่านรอยสัก

Int32.MaxValueคำตอบที่ถูกต้องที่สุดที่ฉันสามารถคิดเป็น

หากคุณคิดว่าค่านี้จำยากเกินไปในฐาน 10 ให้ลองฐาน 2: 1111111111111111111111111111111111111

หากคุณสามารถจำหมายเลข Pi ทั้งหมดได้ดังนั้นหมายเลขที่คุณกำลังค้นหาอยู่ที่ตำแหน่ง 1,867,996,680 ถึง 1,867,996,689 ของตัวเลขทศนิยมของ Pi

สตริงที่เป็นตัวเลข 2147483647 จะปรากฏที่เลขทศนิยม 1,867,996,680 ของ Pi 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

แหล่งที่มา: http://www.subidiom.com/pi/

เป็น 10 หลักดังนั้นสมมติว่าเป็นหมายเลขโทรศัพท์ (สมมติว่าคุณอยู่ในสหรัฐฯ) 214-748-3647 ฉันไม่แนะนำให้เรียกมัน

แทนที่จะคิดว่ามันเป็นตัวเลขขนาดใหญ่ลองทำลายมันและมองหาแนวคิดที่เกี่ยวข้องเช่น:

• 2 การหยุดพักสนุกเกอร์สูงสุด (การหยุดพักสูงสุดคือ 147)
• 4 ปี (48 เดือน)
• 3 ปี (36 เดือน)
• 4 ปี (48 เดือน)

ด้านบนใช้กับจำนวนลบมากที่สุด บวกคือลบหนึ่ง

บางทีรายละเอียดข้างต้นอาจไม่น่าจดจำสำหรับคุณ (มันแทบจะไม่น่าตื่นเต้นสำหรับมัน!) แต่หวังว่าคุณจะได้รับความคิดที่มี!

ค่าลบ (32 บิต) ที่ใหญ่ที่สุด: -2147483648
(1 << 31)

ค่าบวก (32 บิต) ที่ใหญ่ที่สุด: 2147483647
~ (1 << 31)

ช่วยในการจำ: "เมาเขา AKA"

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

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

อย่างไรก็ตามให้ใช้ regex นี้ (จะพิจารณาว่าสตริงมีจำนวนเต็มไม่เป็นลบในรูปแบบทศนิยมที่ไม่เกิน Int32.MaxValue)

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

บางทีมันอาจช่วยให้คุณจำได้

นั่นเป็นวิธีที่ฉันจำได้2147483647:

• 214 - เพราะ 2.14 มีค่าประมาณ pi-1
• 48 = 6 * 8
• 64 = 8 * 8

เขียนในแนวนอน:

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

ตอนนี้คุณมี 2147483647

หวังว่านี่จะช่วยได้อย่างน้อย

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

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

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

ดังนั้น 2 ^ 31 (สูงสุด int ที่ลงนามแล้ว) คือ 2 ^ 30 (ประมาณ 1 พันล้าน) คูณ 2 ^ 1 (2) หรือประมาณ 2 พันล้าน และ 2 ^ 32 คือ 2 ^ 30 * 2 ^ 2 หรือประมาณ 4 พันล้าน วิธีการประมาณนี้มีความแม่นยำเพียงพอแม้กระทั่งประมาณ 2 ^ 64 (ซึ่งข้อผิดพลาดจะเพิ่มขึ้นประมาณ 15%)

หากคุณต้องการคำตอบที่แน่นอนคุณควรดึงเครื่องคิดเลขขึ้นมา

การประมาณความสามารถในการจัดเรียงคำที่มีประโยชน์:

• 2 ^ 16 ~ = 64,000 // uint16
• 2 ^ 32 ~ = 4 พันล้าน // uint32, IPv4, unixtime
• 2 ^ 64 ~ = 16 ล้านล้าน (aka 16 พันล้านล้านหรือ 16 ล้านล้านล้าน) // uint64, "bigint"
• 2 ^ 128 ~ = 256 ล้านล้านล้าน (aka 256 ล้านล้านล้านล้านล้าน) // IPv6, GUID

เพียงใช้เครื่องคิดเลขที่เหมาะสมแล้วพิมพ์ "7FFFFFFF" ในโหมด hex แล้วเปลี่ยนเป็นทศนิยม

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 จะถูกเซ็นชื่อเสมอ

Python 2

Python มีจำนวนเต็มความแม่นยำโดยพลการ แต่ใน Python 2 พวกมันจะถูกจับคู่กับจำนวนเต็ม C ดังนั้นคุณสามารถทำสิ่งนี้:

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

Python เปลี่ยนไปเป็นlongเมื่อจำนวนเต็มที่มากกว่า2^31 -1

ต่อไปนี้เป็นตัวช่วยจำสำหรับการจำ 2 ** 31 ให้ลบหนึ่งรายการเพื่อรับค่าจำนวนเต็มสูงสุด

A = 1, B = 2 c = 3 d = 4, E = 5, f = 6 กรัม = 7, H = 8, I = 9

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

ฉันใช้พลังของสองถึง 18 บ่อยครั้งมากพอที่จะจำได้ แต่ถึงแม้ฉันจะไม่ใส่ใจในการท่องจำ 2 ** 31 มันง่ายเกินไปที่จะคำนวณตามความจำเป็นหรือใช้ค่าคงที่หรือประมาณ 2G

32 บิตหนึ่งรายการสำหรับข้อมูล 31 บิต:

2^31 - 1 = 2147483647

ทำไม -1
เพราะเป็นครั้งแรกที่เป็นศูนย์เพื่อให้ที่ยิ่งใหญ่ที่สุดคือการนับลบหนึ่ง

แก้ไขสำหรับcantfindaname88

การนับคือ 2 ^ 31 แต่สิ่งที่ยิ่งใหญ่ที่สุดไม่สามารถเป็น 2147483648 (2 ^ 31) เพราะเรานับจาก 0 ไม่ใช่ 1

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

คำอธิบายอื่นที่มีเพียง 3 บิต: 1 สำหรับเครื่องหมาย 2 สำหรับข้อมูล

2^2 - 1 = 3

ต่ำกว่าค่าที่เป็นไปได้ทั้งหมดด้วย 3 บิต: (2 ^ 3 = 8 ค่า)

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

มันมี 32 บิตและสามารถเก็บค่าที่แตกต่าง 2 ^ 32 ครึ่งหนึ่งเป็นลบ

คำตอบคือ 2,147,483,647

และต่ำสุดคือ −2,147,483,648

(โปรดสังเกตว่ามีค่าลบมากกว่าหนึ่งค่า)

นอกเหนือจากเรื่องตลกถ้าคุณกำลังมองหากฎหน่วยความจำที่มีประโยชน์จริง ๆ มีสิ่งหนึ่งที่ฉันมักจะใช้เพื่อจดจำตัวเลขจำนวนมาก

คุณต้องแยกเลขของคุณออกเป็นส่วน ๆ จากตัวเลข 3-4 ตัวและจำไว้ด้วยการใช้การฉายภาพบนแป้นพิมพ์โทรศัพท์มือถือของคุณ การแสดงบนรูปภาพทำได้ง่ายกว่า:

ที่คุณสามารถดูจากนี้ไปคุณก็ต้องจำไว้ 3 รูปทรง 2 ของพวกเขามีลักษณะเหมือน Tetris L และเป็นหนึ่งในลักษณะเช่นเห็บ ซึ่งง่ายกว่าการจำตัวเลข 10 หลักอย่างแน่นอน

เมื่อคุณต้องการเรียกคืนหมายเลขเพียงแค่เรียกคืนรูปร่างลองนึกภาพ / ดูบนแป้นพิมพ์โทรศัพท์และฉายภาพรูปร่างนั้น บางทีในขั้นต้นคุณจะต้องมองไปที่แป้นพิมพ์ แต่หลังจากฝึกไปสักพักคุณจะจำได้ว่าตัวเลขนั้นมาจากบนซ้ายไปล่างล่างขวาดังนั้นคุณจะสามารถจินตนาการได้ในหัวของคุณ

เพียงให้แน่ใจว่าคุณจำทิศทางของรูปร่างและจำนวนหลักในแต่ละรูปร่าง (ตัวอย่างเช่นใน 2147483647 ตัวอย่างเรามี Tetris L 4 หลักและ L 3 หลัก L)

คุณสามารถใช้เทคนิคนี้เพื่อจดจำหมายเลขสำคัญใด ๆ ได้อย่างง่ายดาย (เช่นฉันจำหมายเลขบัตรเครดิต 16 หลักเป็นต้น)

วิธีที่ง่ายที่สุดในการทำเช่นนี้สำหรับจำนวนเต็มคือการใช้เลขฐานสิบหกโดยที่ไม่มีสิ่งใดเหมือน Int.maxInt () เหตุผลก็คือ:

ค่าสูงสุดที่ไม่ได้ลงชื่อ

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

ค่าที่เซ็นชื่อโดยใช้ 7F เป็นค่าที่ลงชื่อสูงสุด

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

ค่าที่ลงชื่อแล้วโดยใช้ 80 เป็นค่าที่ลงชื่อสูงสุด

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

มันทำงานอย่างไร นี่คล้ายกับแทคติกไบนารีและเลขฐานสิบหกแต่ละตัวมีขนาดเท่ากับ 4 บิต นอกจากนี้คอมไพเลอร์จำนวนมากยังสนับสนุน hex มากกว่าที่พวกเขาสนับสนุนไบนารี

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

ดังนั้น 7F เท่ากับ 01111111 / 7FFF เท่ากับ 0111111111111111 นอกจากนี้หากคุณใช้สิ่งนี้สำหรับ "ค่าคงที่ที่สูงมาก" 7F ... เป็นฐานสิบหกที่ปลอดภัย แต่มันง่ายพอที่จะลอง 7F และ 80 แล้วพิมพ์มัน ที่หน้าจอของคุณเพื่อดูว่าเป็นหน้าจอใด

0x7FFF + 0x0001 = 0x8000 ดังนั้นการสูญเสียของคุณเป็นเพียงตัวเลขเดียวดังนั้นการใช้ 0x7F ... โดยปกติแล้วจะไม่เป็นการแลกเปลี่ยนที่ไม่ดีสำหรับรหัสที่เชื่อถือได้มากขึ้นโดยเฉพาะเมื่อคุณเริ่มใช้ 32- บิตหรือมากกว่า

เขียนครั้งแรก 47 สองครั้ง (คุณชอบAgent 47ใช่ไหม) รักษาช่องว่างตามที่แสดง (แต่ละขีดเป็นช่องสำหรับตัวเลขหลักเดียว 2 ช่องแรกจากนั้น 4)

--47----47

คิดว่าคุณมี12อยู่ในมือ (เพราะ 12 = โหล) คูณด้วย4หลักแรกของหมายเลข Agent 47 เช่น47และวางผลลัพธ์ทางด้านขวาของคู่แรกที่คุณมีอยู่แล้ว

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

จากนั้นคูณ12ด้วย3(เพื่อให้ตัวเลขตัวที่สองของหมายเลข Agent 47 ซึ่งก็คือ7คุณต้องการ7 - 4 = 3) และวางผลลัพธ์ทางด้านขวาของ 2 คู่แรกซึ่งเป็นคู่สล็อตสุดท้าย

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

ในที่สุดลากตัวเลขหนึ่งตัวจากมือของคุณเริ่มจากหลักขวาสุด (2 ในกรณีนี้) และวางไว้ในช่องว่างแรกที่คุณได้รับ

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

ที่นั่นคุณมีมัน! สำหรับขีด จำกัด เชิงลบคุณสามารถคิดได้ว่าเป็น 1 ในค่าสัมบูรณ์มากกว่าขีด จำกัด บวก

ฝึกฝนสักสองสามครั้งแล้วคุณจะติดมัน!

2GB

(มีความยาวขั้นต่ำสำหรับคำตอบหรือไม่)

สมมติว่า. NET -

Console.WriteLine(Int32.MaxValue);

หากคุณรู้ตาราง ASCIIของคุณด้วยใจไม่ใช่MaxInt:
!GH6G = 21 47 48 36 47

กฎที่ดีที่สุดในการจดจำคือ:
21 (หมายเลขมายากล!)
47 (เพิ่งจำได้)
48 (ตามลำดับ!)
36 (21 +15 ทั้งสองเวทมนตร์!)
47อีกครั้ง

นอกจากนี้ยังง่ายต่อการจำ 5 คู่มากกว่า 10 หลัก

วิธีที่ง่ายที่สุดที่จะจำได้คือดู 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 ตัวอักษรที่จะพิมพ์ใน visual studio

อัปเดต ด้วยเหตุผลบางอย่างฉันถูกลงคะแนน เหตุผลเดียวที่ฉันคิดได้ก็คือพวกเขาไม่เข้าใจคำแถลงแรกของฉัน

"Int32.MaxValue" ใช้เวลาสูงสุด 14 ตัวอักษรในการพิมพ์ 2,147,486,647 ใช้ตัวอักษร 10 หรือ 13 ตัวขึ้นอยู่กับว่าคุณใส่เครื่องหมายจุลภาคหรือไม่

เพิ่งทราบว่า 2 ^ (10 * x) มีค่าประมาณ 10 ^ (3 * x) - คุณอาจคุ้นเคยกับเรื่องนี้ด้วยกิโลไบต์ / kibibytes เป็นต้นนั่นคือ:

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

เนื่องจาก int ใช้ 31 บิต (+ ~ 1 บิตสำหรับเครื่องหมาย) เพียงแค่เพิ่มเป็นสองเท่า ^ 2 เพื่อให้ได้ประมาณ 2 พันล้าน สำหรับ int ที่ไม่ได้ลงนามโดยใช้ 32 บิตให้เพิ่มเป็นสองเท่าเป็น 4 พันล้านครั้ง ปัจจัยความผิดพลาดจะเพิ่มขึ้นตามจำนวนที่มากขึ้นของหลักสูตร แต่คุณไม่จำเป็นต้องจดจำค่าที่แน่นอน (หากคุณต้องการคุณควรใช้ค่าคงที่ที่กำหนดไว้ล่วงหน้าสำหรับมัน) ค่าโดยประมาณดีพอสำหรับการสังเกตเมื่อบางสิ่งบางอย่างอาจเป็นอันตรายใกล้กับน้ำล้น

นี่คือวิธีที่ฉันทำเพื่อจดจำ 2,147,483,647

ไปยังไตรมาสสะวันนาที่ไกลออกไป optimus trio hexed สี่สิบ septenary

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

คุณหมายถึงอะไร มันควรจะง่ายพอที่จะจำได้ว่ามันคือ 2 ^ 32 หากคุณต้องการให้กฎจดจำค่าของตัวเลขนั้นกฎง่าย ๆ สำหรับการแปลงระหว่างไบนารีและทศนิยมโดยทั่วไป:

2 ^ 10 ~ 1,000

ซึ่งหมายถึง 2 ^ 20 ~ 1,000,000

และ 2 ^ 30 ~ 1,000,000,000

สองเท่า (2 ^ 31) คือ 2 พันล้าน rounghly และเพิ่มเป็นสองเท่า (2 ^ 32) คือ 4 พันล้าน

มันเป็นวิธีที่ง่ายในการประมาณคร่าวๆของเลขฐานสอง 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 สำหรับจำนวนบวกและลบ

ด้วยศูนย์ที่เป็นจำนวนบวกคุณจะได้รับช่วงตรรกะ (ที่กล่าวถึงก่อนหน้านี้)

+2147483647 ถึง -2147483648

หากคุณคิดว่าเล็กเกินไปให้ใช้ Int64:

+9223372036854775807 ถึง -9223372036854775808

และทำไมนรกที่คุณต้องการจดจำหมายเลขนี้ เพื่อใช้ในรหัสของคุณ? คุณควรใช้ Int32.MaxValue หรือ Int32.MinValue ในรหัสของคุณเนื่องจากค่าเหล่านี้เป็นค่าคงที่ (ภายใน. net core) และทำให้ใช้งานได้เร็วกว่าการสร้าง int ใหม่ด้วยรหัส

คำสั่งของฉัน: ถ้ารู้ว่าตัวเลขนี้ด้วยหน่วยความจำ .. คุณเพียงแค่แสดง!

จดจำสิ่งนี้: 21 IQ รายการที่ 47

มันสามารถเข้ารหัสด้วยแผ่นโทรศัพท์ใด ๆ หรือคุณสามารถเขียนลงบนกระดาษ

ในการจำ "21 IQ ITEM 47" ฉันจะไปกับ "Hitman: Codename 47 มี 21 ภารกิจซึ่งแต่ละไอเท็มไอคิวเอง"

หรือ "ฉันทำความสะอาดฟันเวลา 21:47 น. ทุกวันเพราะฉันมี IQ สูงและไม่ชอบสิ่งของในปากของฉัน"