bin_dec_hex - ออนไลน์ใน Cloud

โครงการ:

ชื่อ

bin_dec_hex - วิธีใช้สัญกรณ์ไบนารี ทศนิยม และเลขฐานสิบหก

DESCRIPTION

คนส่วนใหญ่ใช้ระบบเลขฐานสิบ ระบบนี้ใช้สัญลักษณ์สิบตัวเพื่อเป็นตัวแทน
ตัวเลข เมื่อใช้สัญลักษณ์ทั้งสิบนี้หมดแล้ว ให้เริ่มใหม่ทั้งหมดและเพิ่มค่า
ตำแหน่งไปทางซ้าย ตัวเลข 0 จะแสดงก็ต่อเมื่อเป็นสัญลักษณ์เดียวในลำดับ
หรือถ้าไม่ใช่คนแรก

หากฟังดูคลุมเครือ นี่คือสิ่งที่ฉันได้พูดไปแล้วเป็นตัวเลข:

0
1
2
3
4
5
6
7
8
9
10
11
12
13

เป็นต้น

แต่ละครั้งที่ตัวเลขเก้าเพิ่มขึ้น จะถูกรีเซ็ตเป็น 0 และตำแหน่งก่อนหน้า (เป็น
ซ้าย) เพิ่มขึ้น (จาก 0 ถึง 1) จากนั้นหมายเลข 9 จะเห็นเป็น "00009" และเมื่อเรา
ควรเพิ่ม 9 เรารีเซ็ตเป็นศูนย์และเพิ่มหลักก่อน 9 ดังนั้น
ตัวเลขกลายเป็น "00010" เราไม่เขียนเลขศูนย์นำหน้า เว้นแต่จะเป็นตัวเลขเดียว
(หมายเลข 0). และแน่นอน เราเขียนเลขศูนย์หากเกิดขึ้นที่ใดก็ได้ภายในหรือต่อท้าย a
จำนวน:

"00010" -> " 0010" -> " 010" -> " 10" แต่ไม่ใช่ " 1 "

นี่เป็นพื้นฐานที่ดี คุณรู้อยู่แล้ว ทำไมฉันถึงบอก ปกติแล้ว คอมพิวเตอร์
ไม่แสดงตัวเลขที่มี 10 หลักที่แตกต่างกัน พวกเขาใช้เพียงสองสัญลักษณ์ที่แตกต่างกัน
คือ "0" และ "1" ใช้กฎเดียวกันกับชุดตัวเลขนี้ แล้วคุณจะได้ไบนารี
ระบบการนับ:

0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101

เป็นต้น

หากคุณนับจำนวนแถว คุณจะเห็นว่าตัวเลขเหล่านี้ต่างกัน 14 ตัว NS
ตัวเลขเหมือนกันและมีความหมายเหมือนกับในรายการแรกเราแค่ใช้ต่างกัน
การเป็นตัวแทน ซึ่งหมายความว่าคุณต้องรู้จักการเป็นตัวแทนที่ใช้หรือตามที่เป็นอยู่
เรียกว่าระบบเลขหรือฐาน โดยปกติถ้าเราไม่ระบุให้ชัดเจน
ระบบการนับที่ใช้ เราใช้ระบบทศนิยมโดยปริยาย หากเราต้องการใช้อย่างอื่น
ระบบการนับ เราต้องทำให้ชัดเจน มีวิธีการที่นำมาใช้กันอย่างแพร่หลายในการ
ทำเช่นนั้น รูปแบบทั่วไปอย่างหนึ่งคือการเขียน 1010(2) ซึ่งหมายความว่าคุณเขียนตัวเลขลงใน
การแทนค่าไบนารี มันคือเลขสิบ หากคุณจะเขียน 1010 โดยไม่ระบุ
ฐาน ตัวเลขจะถูกตีความว่าเป็นหนึ่งพันสิบโดยใช้ฐาน 10

ในหนังสือรูปแบบอื่นเป็นเรื่องปกติ มันใช้ตัวห้อย (ตัวอักษรน้อย, มากหรือน้อยใน
ระหว่างสองแถว) คุณสามารถเว้นวงเล็บในกรณีนั้นและจด
ตัวเลขในอักขระปกติตามด้วยสองตัวที่อยู่ด้านหลัง

เนื่องจากระบบการนับที่ใช้เรียกอีกอย่างว่าฐาน เราพูดถึงเลข 1100 ฐาน 2
เลข 12 ฐาน 10

ภายในระบบเลขฐานสอง เป็นเรื่องปกติที่จะเขียนเลขศูนย์นำหน้า ตัวเลขเขียนไว้
ลงในชุดสี่ แปด หรือสิบหก ขึ้นอยู่กับบริบท

เราสามารถใช้รูปแบบไบนารีเมื่อพูดคุยกับคอมพิวเตอร์ (...การเขียนโปรแกรม...) แต่ตัวเลข
จะมีตัวแทนขนาดใหญ่ ตัวเลข 65'535 (มักอยู่ในระบบทศนิยม a ' is
ใช้เพื่อแยกบล็อกสามหลักเพื่อให้อ่านง่าย) จะถูกเขียนเป็น
1111111111111111(2) ซึ่งเท่ากับ 16 คูณหลัก 1 ซึ่งยากและมีแนวโน้มที่จะผิดพลาด
ดังนั้น เรามักจะใช้ฐานอื่นที่เรียกว่าเลขฐานสิบหก ใช้ 16 แบบที่แตกต่างกัน
สัญลักษณ์ ขั้นแรกให้ใช้สัญลักษณ์จากระบบทศนิยม ต่อจากนั้นเราดำเนินการต่อด้วย
ตัวอักษร เราได้ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E และ F นี่
เลือกระบบเพราะรูปเลขฐานสิบหกสามารถแปลงเป็นระบบเลขฐานสองได้มาก
อย่างง่ายดาย (และย้อนกลับ)

ยังมีอีกระบบหนึ่งที่ใช้อยู่เรียกว่าระบบฐานแปด สิ่งนี้พบได้บ่อยใน
สมัยก่อนแต่ไม่ค่อยได้ใช้แล้ว อย่างที่คุณอาจพบว่ามีการใช้งานในบางครั้ง คุณ
ควรจะชินกับมันและเราจะแสดงมันด้านล่าง เป็นเรื่องเดียวกันกับอีกเรื่องหนึ่ง
การเป็นตัวแทน แต่มีแปดสัญลักษณ์ที่แตกต่างกัน

ไบนารี (2)
ฐานแปด (8)
ทศนิยม (ฮิต)
เลขฐานสิบหก (16)

(2) (8) (10) (16) (XNUMX)
00000 0 0 0
00001 1 1 1
00010 2 2 2
00011 3 3 3
00100 4 4 4
00101 5 5 5
00110 6 6 6
00111 7 7 7
01000 10 8 8
01001 11 9 9
01010 12 10 ก
01011 13 บ
01100 14 12 ค
01101 15 13 วัน
01110 16 14 อี
01111 17 15 เอฟ
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15

คอมพิวเตอร์ส่วนใหญ่ที่ใช้ในปัจจุบันนี้ใช้ไบต์ที่แปดบิต ซึ่งหมายความว่าพวกเขาเก็บ
ครั้งละแปดบิต คุณจะเห็นได้ว่าเหตุใดระบบฐานแปดจึงไม่สามารถใช้งานได้จริง:
คุณต้องมีตัวเลขสามหลักเพื่อแทนแปดบิต ซึ่งหมายความว่าคุณต้องใช้
หนึ่งหลักที่สมบูรณ์เพื่อแทนสองบิตเท่านั้น (2+3+3=8) นี่เป็นของเสีย สำหรับเลขฐานสิบหก
หลัก คุณต้องการเพียงสองหลักเท่านั้นซึ่งใช้อย่างสมบูรณ์:

(2) (8) (10) (16) (XNUMX)
11111111 377 255 เอฟ

คุณสามารถดูว่าทำไมเลขฐานสองและเลขฐานสิบหกจึงสามารถแปลงได้อย่างรวดเร็ว: สำหรับเลขฐานสิบหกแต่ละตัว
หลัก มีเลขฐานสองสี่หลักพอดี ใช้เลขฐานสอง: นำสี่หลักจาก
ทางขวาและทำเลขฐานสิบหกจากมัน (ดูตารางด้านบน) ทำซ้ำจนกระทั่ง
ไม่มีตัวเลขอีกต่อไป และในทางกลับกัน: หาเลขฐานสิบหก แต่ละ
หลัก เขียนเลขฐานสองที่เทียบเท่ากัน

คอมพิวเตอร์ (หรือมากกว่า parsers ที่ทำงานอยู่) จะมีช่วงเวลาที่ยากลำบากในการแปลง a
ตัวเลขที่ชอบ 1234(16). ดังนั้นเลขฐานสิบหกจะถูกระบุด้วยคำนำหน้า นี้
คำนำหน้าขึ้นอยู่กับภาษาที่คุณเขียน คำนำหน้าบางส่วนคือ "0x" สำหรับ C, "$"
สำหรับ Pascal, "#" สำหรับ HTML เป็นเรื่องปกติที่จะถือว่าถ้าตัวเลขเริ่มต้นด้วยศูนย์ มัน
เป็นเลขฐานแปด ไม่สำคัญว่าจะใช้อะไร ตราบใดที่คุณรู้ว่ามันคืออะไร ฉันจะใช้ "0x"
สำหรับเลขฐานสิบหก "%" สำหรับเลขฐานสองและ "0" สำหรับเลขฐานแปด ตัวเลขต่อไปนี้คือ .ทั้งหมด
เหมือนกัน แค่การแสดง (ฐาน) ต่างกัน: 021 0x11 17 %00010001

ในการทำเลขคณิตและการแปลง คุณต้องเข้าใจอีกสิ่งหนึ่ง มันเป็นอะไรบางอย่าง
คุณรู้อยู่แล้ว แต่บางทีคุณอาจยังไม่ "เห็น" เลย:

ถ้าคุณเขียน 1234 (ไม่มีคำนำหน้าจึงเป็นทศนิยม) คุณกำลังพูดถึงเลขหนึ่ง
พัน สองร้อยสามสิบสี่ ตามสูตรดังนี้

1 * 1000 = 1000
2 * 100 = 200
3 * 10 = 30
4 * 1 = 4

นอกจากนี้ยังสามารถเขียนเป็น:

1*10^3
2*10^2
3*10^1
4*10^0

โดยที่ ^ หมายถึง "พลังของ"

เราใช้ฐาน 10 และตำแหน่ง 0,1,2 และ 3 ตำแหน่งขวาสุดควร
ห้ามคูณด้วย 10 วินาทีจากขวาควรคูณด้วย
10. ตัวที่สามจากขวาคูณด้วย 10 สองครั้ง นี้ต่อไปเพื่อสิ่งที่
มีการใช้ตำแหน่ง

มันเหมือนกันในการนำเสนออื่น ๆ ทั้งหมด:

0x1234 จะเป็น

1*16^3
2*16^2
3*16^1
4*16^0

01234 จะเป็น

1*8^3
2*8^2
3*8^1
4*8^0

ตัวอย่างนี้ไม่สามารถทำได้สำหรับไบนารีเนื่องจากระบบนั้นใช้เพียงสองสัญลักษณ์เท่านั้น อื่น
ตัวอย่าง:

%1010 จะเป็น

1*2^3
0*2^2
1*2^1
0*2^0

การแปลงเป็นรูปแบบเลขฐานสิบหกจะง่ายกว่าและเพียงแค่แปล %1010
เป็น 0xA สักพักคุณจะชินกับมัน ไม่ต้องทำการคำนวณใดๆ
อีกต่อไป แต่ให้รู้ว่า 0xA หมายถึง 10

ในการแปลงเลขฐานสิบเป็นเลขฐานสิบหก คุณสามารถใช้วิธีถัดไป มันจะใช้เวลา
บ้างก็จะสามารถประมาณการได้ แต่จะง่ายขึ้นเมื่อใช้ระบบ
บ่อยขึ้น. เราจะดูวิธีอื่นในภายหลัง

ก่อนอื่นคุณต้องรู้ว่าระบบอื่นจะใช้ตำแหน่งได้กี่ตำแหน่ง ในการทำเช่นนั้น คุณ
จำเป็นต้องทราบจำนวนสูงสุดที่คุณจะใช้ นั่นไม่ได้ยากอย่างที่คิด ใน
ทศนิยม จำนวนสูงสุดที่คุณสามารถสร้างด้วยตัวเลขสองหลักคือ "99" สูงสุดสำหรับ
สาม: "999" หมายเลขต่อไปจะต้องมีตำแหน่งพิเศษ ย้อนกลับความคิดนี้แล้วคุณจะ
หาเลขได้โดยการเอา 10^3 (10*10*10 คือ 1000) ลบ 1 หรือ 10^2 ลบ
หนึ่ง.

ซึ่งสามารถทำได้สำหรับเลขฐานสิบหกเช่นกัน:

16^4 = 0x10000 = 65536
16^3 = 0x1000 = 4096
16^2 = 0x100 = 256
16^1 = 0x10 = 16

หากตัวเลขน้อยกว่า 65'536 จะพอดีในสี่ตำแหน่ง ถ้าจำนวนมากกว่า
มากกว่า 4'095 คุณต้องใช้ตำแหน่ง 4 คุณสามารถลบ 4'096 จาก .ได้กี่ครั้ง
ตัวเลขที่ไม่ต่ำกว่าศูนย์คือหลักแรกที่คุณจดไว้ นี่จะเป็น .เสมอ
ตัวเลขตั้งแต่ 1 ถึง 15 (0x1 ถึง 0xF) ทำเช่นเดียวกันสำหรับตำแหน่งอื่นๆ

มาลองกันที่ 41'029. มีขนาดเล็กกว่า 16^4 แต่ใหญ่กว่า 16^3-1 หมายความว่าเรา
ต้องใช้สี่ตำแหน่ง เราสามารถลบ 16^3 จาก 41'029 สิบครั้งโดยไม่ต้องไป
ต่ำกว่าศูนย์. หลักซ้ายสุดจะเป็น "A" ดังนั้นเราจึงมี 0xA???? ตัวเลขคือ
ลดเหลือ 41'029 - 10*4'096 = 41'029-40'960 = 69. 69 เล็กกว่า 16^3 แต่ไม่ใหญ่
มากกว่า 16^2-1 หลักที่สองจึงเป็น "0" และตอนนี้เรามี 0xA0 หรือไม่ 69 เล็กกว่า
16^2 และใหญ่กว่า 16^1-1 เราสามารถลบ 16^1 (ซึ่งก็แค่ 16 ธรรมดา) สี่ครั้งและ
เขียน "4" เพื่อรับ 0xA04? ลบ 64 จาก 69 (69 - 4*16) และหลักสุดท้ายคือ 5 -->
0xA045.

วิธีอื่นสร้างตัวเลขจากด้านขวา ลอง 41'029 อีกครั้ง หารด้วย
16 และไม่ใช้เศษส่วน (เฉพาะจำนวนเต็ม)

41'029 / 16 คือ 2'564 ส่วนที่เหลือเป็น 5. เขียนลงไป 5.
2'564 / 16 คือ 160 โดยเหลือเศษ 4 เขียน 4 ก่อน 5
160/16 คือ 10 โดยไม่มีเศษเหลือ นำหน้า 45 ด้วย 0
10 / 16 อยู่ด้านล่างหนึ่ง จบที่นี่และเติม 0xA ข้างหน้า ลงท้ายด้วย 0xA045

วิธีที่จะใช้ขึ้นอยู่กับคุณ ใช้สิ่งที่เหมาะกับคุณ ฉันใช้ทั้งคู่โดยไม่ต้อง
จะบอกว่าผมใช้วิธีไหนในแต่ละกรณีก็แล้วแต่จำนวนนะครับผมว่า
ความจริงก็คือ ตัวเลขบางตัวจะเกิดขึ้นบ่อยครั้งขณะตั้งโปรแกรม ถ้าตัวเลขใกล้เคียง
ที่ฉันคุ้นเคยแล้วฉันจะใช้วิธีแรก (เช่น 32'770 ซึ่งเป็น 32'768
+ 2 และฉันเพิ่งรู้ว่ามันคือ 0x8000 + 0x2 = 0x8002)

สำหรับไบนารีสามารถใช้วิธีการเดียวกันได้ ฐานคือ 2 ไม่ใช่ 16 และจำนวน
ตำแหน่งจะเติบโตอย่างรวดเร็ว การใช้วิธีที่สองมีข้อดีที่คุณเห็น
ง่ายมากถ้าคุณควรจะเขียนเลขศูนย์หรือหนึ่ง: ถ้าคุณหารด้วยสองเศษที่เหลือ
จะเป็นศูนย์หากเป็นจำนวนคู่และอีกหนึ่งถ้าเป็นเลขคี่:

41029 / 2 = 20514 ส่วนที่เหลือ 1
20514 / 2 = 10257 ส่วนที่เหลือ 0
10257 / 2 = 5128 ส่วนที่เหลือ 1
5128 / 2 = 2564 ส่วนที่เหลือ 0
2564 / 2 = 1282 ส่วนที่เหลือ 0
1282 / 2 = 641 ส่วนที่เหลือ 0
641 / 2 = 320 ส่วนที่เหลือ 1
320 / 2 = 160 ส่วนที่เหลือ 0
160 / 2 = 80 ส่วนที่เหลือ 0
80 / 2 = 40 ส่วนที่เหลือ 0
40 / 2 = 20 ส่วนที่เหลือ 0
20 / 2 = 10 ส่วนที่เหลือ 0
10 / 2 = 5 ส่วนที่เหลือ 0
5 / 2 = 2 ส่วนที่เหลือ 1
2 / 2 = 1 ส่วนที่เหลือ 0
1/2 ต่ำกว่า 0 ส่วนที่เหลือ 1

เขียนผลลัพธ์จากขวาไปซ้าย: %1010000001000101

จัดกลุ่มตามสี่:

1010000001000101%
%101000000100 0101
%10100000 0100 0101
%1010 0000 0100 0101

แปลงเป็นเลขฐานสิบหก: 0xA045

กลุ่ม %1010000001000101 โดยสามและแปลงเป็นฐานแปด:

1010000001000101%
%1010000001000 101
%1010000001 000 101
%1010000 001 000 101
%1010 000 001 000 101
%1 010 000 001 000 101
%001 010 000 001 000 101
1 2 0 1 0 5 --> 0120105

ดังนั้น: %1010000001000101 = 0120105 = 0xA045 = 41029
หรือ: 1010000001000101(2) = 120105(8) = A045(16) = 41029(10)
หรือ: 1010000001000101(2) = 120105(8) = A045(16) = 41029

ขั้นแรก ขณะเพิ่มตัวเลข คุณจะแปลงเป็นทศนิยมแล้วเปลี่ยนกลับ
ในรูปแบบเดิมหลังจากทำการบวก หากใช้ระบบเลขอื่น
บ่อยครั้ง คุณจะเห็นว่าคุณจะสามารถคิดเลขได้โดยตรงในฐานที่เป็น
ใช้แล้ว. ในการแทนค่าใด ๆ ก็เหมือนกัน ให้เติมตัวเลขทางด้านขวา จด
หลักขวาสุดจากผลลัพธ์ จำหลักอื่น ๆ และใช้ในถัดไป
กลม. ดำเนินการต่อด้วยตัวเลขที่สองจากด้านขวาและอื่น ๆ :

%1010 + %0111 --> 10 + 7 --> 17 --> %00010001

จะกลายเป็น

1010%
%0111+
-
|||+-- เพิ่ม 0 + 1 ผลลัพธ์คือ 1 ไม่มีอะไรต้องจำ
||+--- เพิ่ม 1 + 1 ผลลัพธ์คือ %10 จด 0 และจำ 1
|+---- เพิ่ม 0 + 1 + 1(จำได้) ผลลัพธ์ = 0 จำ 1
+ ----- เพิ่ม 1 + 0 + 1 (จำได้) ผลลัพธ์ = 0 จำ 1
ไม่มีอะไรเพิ่ม จำ 1 ผลลัพธ์ = 1
--------
%10001 คือผลลัพธ์ ฉันชอบเขียนเป็น %00010001

สำหรับค่าต่ำ ให้ลองทำการคำนวณด้วยตัวเอง แล้วตรวจสอบด้วยเครื่องคิดเลข
ยิ่งคำนวณเองยิ่งพบว่าตัวเองไม่ได้ทำ
ความผิดพลาด ในที่สุด คุณจะทำแคลคูลัสในฐานอื่น ๆ ได้ง่ายเหมือนที่คุณทำใน
ทศนิยม.

เมื่อตัวเลขเยอะขึ้น คุณจะต้องรู้ว่าคอมพิวเตอร์ไม่ได้เรียกว่า a
คอมพิวเตอร์เพียงเพื่อให้มีชื่อที่ดี มีเครื่องคิดเลขหลายแบบให้เลือกใช้
พวกเขา. สำหรับ Unix คุณสามารถใช้ "bc" ซึ่งย่อมาจาก Binary Calculator มันคำนวณไม่
เป็นทศนิยมเท่านั้น แต่ในทุกฐานคุณจะต้องการใช้ (ในหมู่พวกเขาไบนารี)

สำหรับผู้ที่ใช้ Windows: เริ่มเครื่องคิดเลข (start->programs->accessories->calculator) และ
หากจำเป็น ให้คลิก view->scientific ตอนนี้คุณมีเครื่องคำนวณทางวิทยาศาสตร์และสามารถคำนวณได้
ในรูปแบบเลขฐานสองหรือเลขฐานสิบหก

ใช้ bin_dec_hex ออนไลน์โดยใช้บริการ onworks.net