Converter ng Binary patungong Decimal
I-convert ang mga binary na numero patungong decimal at decimal patungong binary nang agad. Sumusuporta sa hanggang 64-bit na mga numero. Libreng converter.
Pangunawa sa Pagpapalit ng Binary to Decimal
Ang binary (base-2) ay gumagamit lamang ng mga digit 0 at 1. Bawat posisyon ay kumakatawan sa isang kapangyarihan ng 2, na doble mula sa kaliwa hanggang kanan. Upang makapalit ng binary sa decimal, isumite ang bawat binary digit sa kaniyang lugar ng halaga at sumala ang mga resulta.
Halimbawa: Palitan 1011₂ sa decimal
- Posisyon 3 (kaliwa): 1 × 2³ = 1 × 8 = 8
- Posisyon 2: 0 × 2² = 0 × 4 = 0
- Posisyon 1: 1 × 2¹ = 1 × 2 = 2
- Posisyon 0 (kanan): 1 × 2⁰ = 1 × 1 = 1
- Mga kabuuang: 8 + 0 + 2 + 1 = 11
Para sa decimal to binary, ulitin ang pag-iwas ng 2 at record ang mga salungatan mula sa ibaba hanggang sa itaas. 11 ÷ 2 = 5 R1, 5 ÷ 2 = 2 R1, 2 ÷ 2 = 1 R0, 1 ÷ 2 = 0 R1 → pagbabasa ng mga salungatan papunta sa itaas: 1011.
Ang posisyon na ito ng pagpapalitan ay gumagana ng parehong paraan tulad ng decimal — lamang may ibang base. Sa decimal (base-10), ang numero 347 ay nangangahulugan ng 3×10² + 4×10¹ + 7×10⁰ = 300 + 40 + 7. Ang binary ay gumagamit ng parehong prinsipyo ng kapangyarihan ng 2 sa halip na kapangyarihan ng 10.
Talahanayan ng mga Halaga ng Posisyon ng Binary
Ang 8-bit byte ay ang pangunahing yunit ng pag-iimbak ng computer. Dito ang kumpletong talahanayan ng mga halaga ng posisyon para sa mga numero ng 8-bit (0–255):
| Posisyon ng bit | Kapangyarihan ng 2 | Halaga ng decimal |
|---|---|---|
| Bit 7 (MSB) | 2⁷ | 128 |
| Bit 6 | 2⁶ | 64 |
| Bit 5 | 2⁵ | 32 |
| Bit 4 | 2⁴ | 16 |
| Bit 3 | 2³ | 8 |
| Bit 2 | 2² | 4 |
| Bit 1 | 2¹ | 2 |
| Bit 0 (LSB) | 2⁰ | 1 |
Ang isang byte ay maaaring kumatawan ng anumang halaga mula 0 (00000000₂) hanggang 255 (11111111₂). Dalawang bytes (16 bits) ay kumakubkob 0–65,535. Apat na bytes (32 bits) ay kumakubkob 0–4,294,967,295.
Talahanayan ng Pangingibabaw ng 2 na Nakapalibang
Para sa mga programador at siyentipiko ng computer, ang pagkilala sa mga kapangyarihan ng 2 hanggang 2⁶⁴ ay mahalaga para sa pag-unawa sa pag-iimbak ng memoria, mga uri ng datos, at mga limitasyon ng sistema:
| Kapangyarihan | Halaga ng decimal | Signipikasyon |
|---|---|---|
| 2⁰ | 1 | Pinakamaliit na yunit (1 bit) |
| 2⁸ | 256 | 1 byte range (0–255) |
| 2¹⁰ | 1,024 | 1 KiB (kibibyte) |
| 2¹⁶ | 65,536 | 16-bit range; TCP port limit |
| 2²⁰ | 1,048,576 | 1 MiB (mebibyte) |
| 2²⁴ | 16,777,216 | 24-bit color (16.7M colors) |
| 2³⁰ | 1,073,741,824 | 1 GiB (gibibyte) |
| 2³² | 4,294,967,296 | 32-bit address space; IPv4 max |
| 2⁴⁰ | 1,099,511,627,776 | 1 TiB (tebibyte) |
| 2⁶⁴ | 18,446,744,073,709,551,616 | 64-bit address space; modern CPUs |
Ang pagkakaiba sa pagitan ng mga prefix ng binary (KiB, MiB, GiB — kapangyarihan ng 2) at mga prefix ng SI (KB, MB, GB — kapangyarihan ng 10). 1 GB = 1,000,000,000 bytes; 1 GiB = 1,073,741,824 bytes. Ang ~7% na pagkakaiba ay nagpapaliwanag kung bakit ang isang "500 GB" na hard drive ay nagpapakita ng ~465 GiB sa iyong OS (na karaniwang gumagamit ng mga yunit ng binary sa loob).
Mga Karaniwang Halaga ng Binary sa Pagprograma
Ang mga halaga ng binary na ito ay madalas na ginagamit sa pagprograma, networking, at pamamahala ng sistema:
| Binary | Decimal | Hexadecimal | Context |
|---|---|---|---|
| 00000000 | 0 | 0x00 | NULL byte, black color channel |
| 00001010 | 10 | 0x0A | Line feed (LF) character — Unix newline |
| 00001101 | 13 | 0x0D | Carriage return (CR) — Windows newline part |
| 00100000 | 32 | 0x20 | Space character (ASCII) |
| 01000001 | 65 | 0x41 | ASCII 'A' |
| 01100001 | 97 | 0x61 | ASCII 'a' (nakakaiba sa 'A' ng bit 5) |
| 01111111 | 127 | 0x7F | Localhost IP (last octet); DEL character |
| 10000000 | 128 | 0x80 | Start of extended ASCII / sign bit |
| 11000000 | 192 | 0xC0 | Class C network prefix (192.x.x.x) |
| 11111111 | 255 | 0xFF | Broadcast; max byte; white in RGB |
Pagpapalitan ng Binary, Hexadecimal, at Octal
Ang mga programador ay gumagamit ng iba't ibang base ng numero depende sa konteksto. Dito ang paunang halaga ng mga numero sa bawat sistema:
| Decimal | Binary | Hexadecimal | Octal | Use Case |
|---|---|---|---|---|
| 0 | 0000 | 0x0 | 0o0 | Zero / null |
| 7 | 0111 | 0x7 | 0o7 | Unix permission (rwx) |
| 10 | 1010 | 0xA | 0o12 | — |
| 15 | 1111 | 0xF | 0o17 | Max 4-bit (nibble) |
| 16 | 10000 | 0x10 | 0o20 | — |
| 127 | 1111111 | 0x7F | 0o177 | Max signed 8-bit |
| 255 | 11111111 | 0xFF | 0o377 | Max unsigned 8-bit |
| 511 | 111111111 | 0x1FF | 0o777 | Unix permission rwxrwxrwx |
| 1023 | 1111111111 | 0x3FF | 0o1777 | Max 10-bit (ADC) |
Ang hexadecimal ay ang pinakakaraniwang pangalang pang-abay para sa binary dahil ang bawat hex digit ay nakakapalitan ng eksaktong 4 binary bits — na nagpapalitan ng pagbabago ng madali. Ang octal ay nakakapalitan ng 3 bits per digit at ginagamit lamang para sa mga pagpapalitan ng Unix ng mga pagpapalitan ng mga file (hal. chmod 755 = 111 101 101 sa binary = rwxr-xr-x).
Ang mga Bilang na Binarya (Dalawang Kumpirmasyon)
Ang mga kompyuter ay nagpapahayag ng mga negatibong bilang gamit ang dalawang kumpirmasyon — ang standard na ipinagbabatay ng IEEE at ginagamit ng higit sa lahat ng mga modernong prosesor. Sa isang 8-bit na sistema ng dalawang kumpirmasyon:
| Binarya | Decimang Hindi Nagbabago | Pinagsama (Dalawang Kumpirmasyon) |
|---|---|---|
| 00000000 | 0 | 0 |
| 00000001 | 1 | +1 |
| 01111111 | 127 | +127 (pinakamataas na positibo) |
| 10000000 | 128 | −128 (pinakamababang negatibo) |
| 10000001 | 129 | −127 |
| 11111110 | 254 | −2 |
| 11111111 | 255 | −1 |
Upang negahin ang isang bilang sa dalawang kumpirmasyon: inverter ang lahat ng bit at idagdag ang 1. Halimbawa, +5 = 00000101 → inverter → 11111010 → idagdag 1 → 11111011 = −5.
Ang mga saklaw para sa karaniwang uri ng integer:
| Uri | Bits | Ang Pagkakaiba sa Pagkakaiba | Signed Range |
|---|---|---|---|
| byte / uint8 | 8 | 0 hanggang 255 | −128 hanggang +127 |
| short / int16 | 16 | 0 hanggang 65,535 | −32,768 hanggang +32,767 |
| int / int32 | 32 | 0 hanggang 4,294,967,295 | −2,147,483,648 hanggang +2,147,483,647 |
| long / int64 | 64 | 0 hanggang 18.4 × 10¹⁸ | −9.2 × 10¹⁸ hanggang +9.2 × 10¹⁸ |
Ang Binarya sa Bawat-araw na Teknolohiya
Ang binarya ang pangunahing base ng lahat ng modernong kompyuter dahil sa mga transistor ay may dalawang matatag na estado (nasa-on/nasa-wala, 1/0). Mga pangunahing aplikasyon:
- Mga laki ng mga file: 1 kilobyte = 2¹⁰ = 1,024 bytes; 1 megabyte = 2²⁰ = 1,048,576 bytes; 1 gigabyte = 2³⁰ bytes
- Ang mga kulay: Ang mga kulay RGB ay tatlong 8-bit na halaga. #FF5733 sa hex = (255, 87, 51) sa desimal = (11111111, 01010111, 00110011) sa binarya
- ASCII encoding: Ang titik na 'A' = desimal 65 = binarya 01000001; 'a' = 97 = 01100001
- Unicode: Ang karamihan ng mga karakter ng teksto ay nakatago sa 16-bit na binarya (0–65,535 range)
- IP addresses: Ang mga adres ng IPv4 ay apat na 8-bit na mga grupo: 192.168.1.1 = 11000000.10101000.00000001.00000001
Ang pag-unawa sa binarya ay direktang nagtutulungan sa pagprograma (bitwise na operasyon, mga flag), networking (IP/subnet na paglutas), at pagtatrabaho sa mababang-haba hardware.
Ang Arithmetika ng Binarya: Pagdaragdag at Pagkuha
Ang arithmetika ng binarya ay sumusunod sa parehong mga batas ng desimal, ngunit may dalawang digit lamang. Ang talahanayan ng pagdaragdag ay:
| A | B | Sum | Carry |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 1 | 0 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 |
Halimbawa: 1011 + 0110
Ang pagtatrabaho sa kaliwa hanggang kanan: 1+0=1, 1+1=10 (isulat 0 carry 1), 0+1+1=10 (isulat 0 carry 1), 1+0+1=10 (isulat 0 carry 1). Resulta: 10001 (desimal: 11+6=17)
Ang pagkuha sa hardware ay karaniwang isinasagawa sa pamamagitan ng pagdaragdag ng dalawang kumpirmasyon ng subtrahend. Upang makalikha ng A−B, ang prosesor ay naglalarawan ng A + (−B), kung saan −B ay ang dalawang kumpirmasyon ng B. Ang isang single adder circuit ay maaaring magtanggap ng parehong pagdaragdag at pagkuha.
Ang mga Operasyon ng Bit
Ang mga wika ng programasyon ay nagbibigay ng mga operator ng bit na nagpapagana sa pagmanipula ng mga bit na indibidwal. Ang mga ito ay pangunahing pangunahin para sa mababang-haba na pagprograma, mga sistemang embedded, at pagpapalaki ng pagganap:
| Operasyon | Simbolo | Halimbawa (8-bit) | Result | Use Case |
|---|---|---|---|---|
| AND | & | 10110101 & 11110000 | 10110000 | Masking ng mga bit, pagkuha ng mga field |
| OR | | | 10110101 | 00001111 | 10111111 | Pagpapanumbalik ng mga bit, pagkombinasyon ng mga flag |
| XOR | ^ | 10110101 ^ 11111111 | 01001010 | Toggling ng mga bit, simple encryption |
| NOT | ~ | ~10110101 | 01001010 | Bit inversion |
| Left shift | << | 00000101 << 2 | 00010100 | Multiply by 2ⁿ |
| Right shift | >> | 00010100 >> 2 | 00000101 | Divide by 2ⁿ |
Ang pagpapalit ng bit ay mas mabilis kaysa sa pagpapalit ng mga bilang sa maraming prosesor. x << 1 ay pantay sa x × 2, at x >> 1 ay pantay sa x ÷ 2 (integer division). Ang mga motor ng laro at mga firmware na embedded ay gumagamit ng mga operasyon na ito nang husto para sa pagganap.
Ang Binary-Coded Decimal (BCD)
Ang Binary-Coded Decimal ay nagpapahayag ng bawat desimal na digit gamit ang kanyang sariling 4-bit na anyo ng binarya. Hindi tulad ng binarya, ang BCD ay nagtataguyod ng estruktura ng desimal:
| Desimal | Pure Binarya | BCD |
|---|---|---|
| 0 | 0000 | 0000 |
| 5 | 0101 | 0101 |
| 9 | 1001 | 1001 |
| 10 | 1010 | 0001 0000 |
| 42 | 101010 | 0100 0010 |
| 99 | 1100011 | 1001 1001 |
| 255 | 11111111 | 0010 0101 0101 |
Ang BCD ay mas mababa sa kapal ng lugar kaysa sa binarya (10 sa 16 na maaaring 4-bit na kombinasyon ang ginagamit), ngunit ito ay nagpapalawak sa pagpapakita ng desimal — bawat nibble ay direktang nagpapakita ng isang ipinakita na digit. Ang BCD ay ginagamit sa mga oras ng digital, mga kalkulator, mga sistema ng pananalapi (kung saan ang tumpak na pagpapakita ng desimal ay mahalaga), at mga mas matandang mga database ng mainframe (COBOL, IBM EBCDIC).
Floating-Point Binary (IEEE 754)
Mga numero sa decimal na may bahagi ng pangkat (tulad ng 3.14) ay naitala sa binaryo gamit ang pamantayan ng IEEE 754. Ang isang 32-bit (single-precision) float ay may tatlong bahagi:
| Field | Bits | Purpose |
|---|---|---|
| Sign | 1 | 0 = positibo, 1 = negatibo |
| Exponent | 8 | Biased exponent (bias = 127) |
| Mantissa (significand) | 23 | Bahagi ng pangkat (implikadong unang 1) |
Halimbawa: Ang numero sa decimal na −6.5 sa IEEE 754 single-precision:
- Sign = 1 (negatibo)
- 6.5 sa binaryo = 110.1₂ = 1.101 × 2² (normalized)
- Exponent = 2 + 127 (bias) = 129 = 10000001₂
- Mantissa = 10100000000000000000000 (23 bits, implikadong unang 1 ay inilagay)
- Pangkalahatang pagtatanghal: 1 10000001 10100000000000000000000
Ito ang kung bakit 0.1 + 0.2 ≠ 0.3 sa karamihan ng mga wika ng programasyon — ang bahagi ng decimal 0.1 ay may pagtatagpo ng walang hangganan sa binaryo (tulad ng 1/3 sa decimal = 0.333…), kaya't kailangang isapubliko, na nagdaragdag ng maliit na mga pagkakamali. Para sa mga paglilinang ng pera, gamitin ang mga libreria ng aritmetika ng decimal (modulo ng decimal ng Python, BigDecimal ng Java) sa halip na floating-point.
Character Encoding: Mula sa ASCII hanggang UTF-8
Ang teksto ay naitala bilang mga numero sa binaryo na nakamapag-ugnay sa mga karakter. Ang pag-unlad ng encoding ng karakter ay sumasalamin sa pagpapalawak ng pandaigdig ng kompyuter:
| Encoding | Year | Bits per Character | Characters Supported | Notes |
|---|---|---|---|---|
| ASCII | 1963 | 7 (naitala sa 8) | 128 | Mga titik ng Ingles, mga numero, mga pagsasapilit |
| Extended ASCII (ISO 8859-1) | 1987 | 8 | 256 | Mga karakter ng Kanluraning Europa (é, ñ, ü) |
| UTF-8 | 1993 | 8–32 (variable) | 1,112,064 | Walang hangganan sa ASCII; standard ng web |
| UTF-16 | 1996 | 16–32 (variable) | 1,112,064 | Gamit sa Java, Windows, JavaScript internal |
| UTF-32 | 2000 | 32 (fixed) | 1,112,064 | Fixed width; nagpapalaki ng espasyo para sa teksto ng Latin |
Ang UTF-8 ay nag-encode ng mga karakter ng ASCII sa isang byte (katumbas sa plain ASCII), mga karakter ng Europa sa 2 bytes, mga karakter ng CJK sa 3 bytes, at mga emoji sa 4 bytes. Ang 98% sa lahat ng mga pahina ng web ay gumagamit ng encoding ng UTF-8 (ayon sa W3Techs, 2024).
Binary Logic Gates
Ang mga gate ng logika ay ang mga pangunahing gusali ng lahat ng mga digital na sirkito. Ang bawat gate ay nagtatagpo ng isang simpleng operasyon ng binaryo sa isang o dalawang input bit:
| Gate | Symbol | Truth Table (A,B → Output) | Description |
|---|---|---|---|
| AND | A·B | 0,0→0; 0,1→0; 1,0→0; 1,1→1 | Ang output ay 1 lamang kapag ang dalawang input ay 1 |
| OR | A+B | 0,0→0; 0,1→1; 1,0→1; 1,1→1 | Ang output ay 1 kapag ang isa sa mga input ay 1 |
| NOT | ¬A | 0→1; 1→0 | Inverts ang input |
| NAND | ¬(A·B) | 0,0→1; 0,1→1; 1,0→1; 1,1→0 | AND na sumunod sa NOT — universal gate |
| XOR | A⊕B | 0,0→0; 0,1→1; 1,0→1; 1,1→0 | Ang output ay 1 kapag ang mga input ay magkaiba |
Ang gate ng NAND ay tinatawag na universal gate dahil ang anumang iba pang logika ay maaaring itayo gamit lamang ang mga gate ng NAND. Ang mga CPU ng moderno ay naglalaman ng bilyong mga transistor na pinagsama-sama sa mga gate ng NAND at NOR, na pagkatapos ay pinagsama-sama sa mga adder, mga multiplexer, mga flip-flop, at lahat ng iba pang mga gusali ng pangunahin ng isang processor. Ang chip ng Apple M3 ay naglalaman ng humigit-kumulang 25 bilyong transistor — bawat isa ay isang mikroskopiko na switch ng binaryo na nasa on (1) o off (0).
Ang gate ng XOR ay may isang espesyal na katangian: ito ay nagtatagpo ng 1 kapag ang dalawang input ay magkaiba. Ito ang pangunahing base ng pagbabago ng binaryo (ang bit ng sum ng isang half adder), pagtangka ng mga pagkakamali (parity checks), at simple encryption (XOR cipher).
Kasaysayan ng Binary: Mula sa Leibniz hanggang sa Modernong Computing
Ang sistema ng numero ng binary ay may malalim na kasaysayan ng panitikang intelektwal:
| Taon | Tao/Pangyayari | Kontribusyon |
|---|---|---|
| ~300 BK | Pingala (matematiko mula sa India) | Ginamit ang sistema ng binary tulad ng sistema upang ilarawan ang mga tukoy ng pormang panitik |
| 1679 | Gottfried Leibniz | Formal na inilarawan ang modernong aritmetika ng binary; nakita ang mga koneksyon sa Chinese I Ching |
| 1847 | George Boole | Nilathala ang "The Mathematical Analysis of Logic" — pangunahing basehan ng Boolean algebra |
| 1937 | Claude Shannon (thesis mula sa MIT) | Nakita ng Boolean algebra ang maaaring modelong mga switching circuit ng elektrikal |
| 1945 | John von Neumann | Pinangunahan ang arkitektura ng computer na may storage ng programa (von Neumann architecture) |
| 1971 | Intel 4004 | Unang komersyal na microprocessor — 2,300 transistor, 4-bit binary |
| 2024 | Modernong CPUs | Billions ng transistor; 64-bit binary architecture standard |
Ang insikto ni Leibniz na ang lahat ng mga numero ay maaaring isulat gamit lamang ang 0 at 1 ay matematikal lamang — hindi niya inakala ang mga computer na elektroniko. Ang thesis ni Shannon noong 1937 ay naglikha ng teoretikal na basehan para sa lahat ng mga digital electronics. Ito ay tinawag na "posibleng pinakamahalagang thesis ng ika-20 siglo."
Binary sa Networking: IP Addresses at Subnet Masks
Ang pag-unawa sa binary ay mahalaga para sa administrasyon ng network. Ang mga adres ng IPv4 at subnet mask ay mga numero ng binary na 32-bit:
| Deskripsyon | Dotted Decimal | Binary |
|---|---|---|
| Adres ng IP | 192.168.1.100 | 11000000.10101000.00000001.01100100 |
| Subnet mask (/24) | 255.255.255.0 | 11111111.11111111.11111111.00000000 |
| Adres ng network | 192.168.1.0 | 11000000.10101000.00000001.00000000 |
| Adres ng broadcast | 192.168.1.255 | 11000000.10101000.00000001.11111111 |
Ang adres ng network ay kinakalcula ng pag-and- ng IP sa subnet mask. Ang adres ng broadcast ay nagtatag ng lahat ng mga bit ng host sa 1. Ang bilang ng mga magagamit na mga adres ng host = 2^(32−prefix) − 2. Para sa isang /24 network: 2⁸ − 2 = 254 na magagamit na mga host.
Mga karaniwang mga sukat ng subnet:
| CIDR | Subnet Mask | Hosts | Tipikal na Gamit |
|---|---|---|---|
| /32 | 255.255.255.255 | 1 | Isang host na ruta |
| /30 | 255.255.255.252 | 2 | Punktong-punktong link |
| /24 | 255.255.255.0 | 254 | Standard na LAN |
| /16 | 255.255.0.0 | 65,534 | Malaking campus network |
| /8 | 255.0.0.0 | 16,777,214 | Class A allocation |
Mga Kadalasang Tinatanong
Paano ko ba isasalin ang binary 1100 sa decimal?
1100 sa binary: 1×8 + 1×4 + 0×2 + 0×1 = 8 + 4 = 12. Kaya ang binary 1100 = 12 sa decimal.
Ang 255 sa binary ay ano?
255 sa binary ay 11111111 — ang lahat ng walong bit ay nakatayo sa 1. Ito ay ang pinakamataas na halaga ng isang single byte at nakikita sa networking (subnet mask 255.255.255.0) at mga kulay (puno na red = 255, 0, 0).
Paano ko ba isasalin ang decimal 100 sa binary?
Magpahangganan ng pag-iiba ng 2: 100÷2=50 R0, 50÷2=25 R0, 25÷2=12 R1, 12÷2=6 R0, 6÷2=3 R0, 3÷2=1 R1, 1÷2=0 R1. Pagbabasa ng mga natitirang salinlahi sa itaas: 1100100₂. Pwede mong tukuyin: 64+32+4 = 100. ✓
Ang pagkakaiba ng binary at hexadecimal?
Ang binary ay gumagamit ng base 2 (digmaan 0–1); ang hexadecimal ay gumagamit ng base 16 (digmaan 0–9, A–F). Ang hex ay compact na pangalang pang-abay para sa binary — bawat hex digito ay kumakatawan sa 4 na bit ng binary. Halimbawa, ang hex FF = binary 11111111 = decimal 255.
Kung bakit ginagamit ng mga computer ang binary kaysa sa decimal?
Ang mga sirkito ng elektrikal ay karaniwang binary: isang transistor ay nasa on (1) o off (0), at ang kundisyon ay nasa mataas o mababa. Ang decimal ay kinakailangan ng 10 na mga iba't ibang antas ng kundisyon, na mahirap itong isakatuparan nang may tiyaga sa hardware. Ang binary ay madaling matolerante sa kaguluhan at nakakapareho sa mga operasyon ng logicong totoo o mali.
Ang dalawang komplemento?
Ang dalawang komplemento ay ang pangunahing paraan para sa pagpapahayag ng mga integer na may tanda (positibo at negatibo) sa binary. Upang matukoy ang dalawang komplemento (negatibo) ng isang numero: inisyal ang lahat ng mga bit at idagdag ang 1. Sa isang 8-bit na sistema, +5 ay 00000101, at −5 ay 11111011. Ang bitang sa kaliwa ay ang bitang tanda: 0 = positibo, 1 = negatibo. Ang sistema na ito ay nagpapahintulot sa mga sirkito ng hardware na gamitin ang parehong sirkito ng pagbabagong-paunawa para sa pagbabagong-paunawa at pagbabawas.
Paano ko ba isasalin ang binary sa hexadecimal?
Magkumpol ang mga bit ng binary sa mga pangkat ng 4 mula sa kaliwa hanggang kanan, at isalin ang bawat pangkat. Halimbawa: 10110101₂ → 1011 0101 → B5₁₆. Ang mga kumpol ay: 0000=0, 0001=1, 0010=2, ..., 1001=9, 1010=A, 1011=B, 1100=C, 1101=D, 1110=E, 1111=F.