Kalkulador ng Binary
Magsagawa ng binary addition, subtraction, multiplication, at division. Mag-convert sa pagitan ng binary at decimal. Libreng math calculator. Agarang resulta.
Ang Sistema ng Bilang na Binary: Paano Nagbilang ang mga Kompyuter
Ang sistema ng bilang na binary (base-2) ay gumagamit lamang ng dalawang digit — 0 at 1 — na tinatawag na bits (binary digits). Ang bawat kompyuter, smartphone, at digital device ay panloob na nag-iimbak at nagproseso ng lahat ng impormasyon sa binary, dahil ang mga electrical circuit ay maaasahan na magrepresenta ng dalawang magkaibang estado: mataas na boltahe (1) at mababang boltahe (0).
Ang bawat posisyon sa isang binary number ay kumakatawan sa isang kapangyarihan ng 2, na tumataas mula kanan hanggang kaliwan:
| Posisyon | 2⁷ | 2⁶ | 2⁵ | 2⁴ | 2³ | 2² | 2¹ | 2⁰ |
|---|---|---|---|---|---|---|---|---|
| Halaga | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
Paglilipat ng binary sa decimal: Ipagparami ang bawat bit sa halaga ng lugar nito at ipagsama ang lahat ng resulta.
Halimbawa: 10110101₂ = 1×128 + 0×64 + 1×32 + 1×16 + 0×8 + 1×4 + 0×2 + 1×1 = 128 + 32 + 16 + 4 + 1 = 181
Paglilipat ng decimal sa binary: Paulit-ulit na hatiin ng 2, itala ang labi sa bawat hakbang, pagkatapos basahin ang mga labi mula sa ilalim hanggang sa tuktok.
Halimbawa: I-convert ang 181 sa binary:
- 181 ÷ 2 = 90 labi 1
- 90 ÷ 2 = 45 labi 0
- 45 ÷ 2 = 22 labi 1
- 22 ÷ 2 = 11 labi 0
- 11 ÷ 2 = 5 labi 1
- 5 ÷ 2 = 2 labi 1
- 2 ÷ 2 = 1 labi 0
- 1 ÷ 2 = 0 labi 1
Basahin ang mga labi mula sa ilalim hanggang sa tuktok: 10110101₂ ✓
Binary Arithmetic: Pagdaragdag, Pagbabawas, at Pagpaparami
Ang binary arithmetic ay sumusunod sa parehong mga panuntunan tulad ng decimal, ngunit ang mga carry ay nangyayari sa 2 sa halip na 10.
Mga panuntunan sa pagdaragdag ng binary: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (carry 1), 1+1+1=11 (carry 1)
Halimbawa: 1011₂ + 1101₂ (11 + 13 = 24)
1011 + 1101 ------ 11000
Paggawa mula kanan hanggang kaliwan: 1+1=10 (isulat 0, carry 1); 1+0+1=10 (isulat 0, carry 1); 0+1+1=10 (isulat 0, carry 1); 1+1+1=11 (isulat 1, carry 1); ang huling carry ay nagsusulat ng 1. Resulta: 11000₂ = 24 ✓
Two's complement (binary subtraction): Ang mga kompyuter ay nakayana sa mga negatibong numero at pagbabawas gamit ang two's complement representation. Upang mahanap ang two's complement ng isang numero: baligtarin ang lahat ng bits, pagkatapos magdagdag ng 1.
Halimbawa: −13 sa 8-bit two's complement: +13 = 00001101₂ → baligtarin ang lahat ng bits → 11110010₂ → magdagdag ng 1 → 11110011₂
Pinahihintulutan nito ang pagbabawas na maisagawa bilang pagdaragdag: 20 − 13 = 20 + (−13).
Binary multiplication ay eleganteng: ang bawat partial product ay 0 (pagpaparami sa 0) o ang numero mismo (pagpaparami sa 1), na inililipat sa kaliwa. Halimbawa: 1011₂ × 101₂ (11 × 5 = 55):
1011
× 101
-----
1011 (1011 × 1)
0000 (1011 × 0, inilipat)
1011 (1011 × 1, inilipat ng dalawang beses)
-------
110111₂ = 55 ✓
Binary sa Computing: Bits, Bytes, at Mga Laki ng Data
Ang pag-unawa sa mga binary unit ay mahalaga para sa sinumang nagtatrabaho sa mga kompyuter, storage, o bilis ng network:
| Unit | Laki | Maximum na Halaga (unsigned) | Kadalasang Ginagamit |
|---|---|---|---|
| Bit | 1 binary digit | 1 | Boolean flag, solong binary na halaga |
| Nibble | 4 bits | 15 (hex: F) | Isang hexadecimal na digit |
| Byte | 8 bits | 255 | Solong character (ASCII), color channel |
| Word | 16 bits | 65,535 | Legacy 16-bit systems, Unicode basic |
| Double Word (DWORD) | 32 bits | 4,294,967,295 | 32-bit integers, IPv4 addresses |
| Quad Word (QWORD) | 64 bits | 18,446,744,073,709,551,615 | Modern integers, pointers, timestamps |
Mga halaga ng kulay: Ang mga kulay sa web ay gumagamit ng 24-bit RGB (8 bits bawat channel). #FF5733 = R:255, G:87, B:51. Ang bawat 8-bit na channel ay maaaring magrepresenta ng 256 na kulay (0–255). Kabuuang posibleng kulay: 256³ = 16,777,216 (mga 16.7 milyon).
Mga permiso sa file sa Unix/Linux: rwxr-xr-- = 111 101 100 sa binary = 7, 5, 4 sa octal = chmod 754. Ang bawat set ng 3 bits ay kumakatawan sa read (r=4), write (w=2), at execute (x=1) na mga permiso para sa may-ari, grupo, at iba pa.
Bitwise Operations at ang mga Aplikasyon Nito
Ang mga bitwise operation ay nagmamanipula sa mga indibidwal na bits sa loob ng mga integer. Sila ay pangunahing sa low-level programming, cryptography, network programming, at performance-critical code.
| Operasyon | Simbolo | Pag-uugali | Halimbawa |
|---|---|---|---|
| AND | & | 1 kung PANG-DALAWA bits ay 1 | 1010 & 1100 = 1000 |
| OR | | | 1 kung ANUMANG bit ay 1 | 1010 | 1100 = 1110 |
| XOR | ^ | 1 kung ang mga bit ay IBA | 1010 ^ 1100 = 0110 |
| NOT | ~ | Baligtarin ang lahat ng bits | ~1010 = 0101 |
| Left Shift | << | Ilipat ang mga bits sa kaliwa (×2 bawat shift) | 1011 << 1 = 10110 (×2) |
| Right Shift | >> | Ilipat ang mga bits sa kanan (÷2 bawat shift) | 1011 >> 1 = 0101 (÷2) |
Praktical na paggamit:
- Bit masking: Suriin kung ang isang tiyak na bit ay naka-set:
if (flags & 0b0100) {... }— suriin kung ang bit 2 ay 1. - Pagse-set ng isang bit:
flags = flags | 0b0100— nagse-set ng bit 2 sa 1 anuman ang kasalukuyang halaga. - Paglilinis ng isang bit:
flags = flags & ~0b0100— linis ng bit 2 sa 0. - Mabilis na pagpaparami/paghahati sa pamamagitan ng mga kapangyarihan ng 2:
n << 3= n × 8;n >> 2= n ÷ 4. Ang mga bit shift ay mga operasyon sa antas ng CPU, mas mabilis kumpara sa pagpaparami. - Pagsusuri kung pares/hindi pares:
if (n & 1) { /* hindi pares */ }— ang huling bit ng anumang hindi pares na numero ay palaging 1.
Paghahambing ng mga Sistema ng Numero: Binary, Octal, Decimal, Hexadecimal
Ang agham ng kompyuter ay gumagamit ng apat na sistema ng numero, na ang bawat isa ay angkop sa iba't ibang konteksto:
| Sistema | Base | Digits | Kadalasang Ginagamit |
|---|---|---|---|
| Binary (base-2) | 2 | 0, 1 | Mga operasyon ng CPU, storage, logic |
| Octal (base-8) | 8 | 0–7 | Mga permiso sa file ng Unix, mas lumang mga sistema |
| Decimal (base-10) | 10 | 0–9 | Mga numero na madaling mabasa ng tao |
| Hexadecimal (base-16) | 16 | 0–9, A–F | Mga address ng memorya, mga code ng kulay, machine code |
Mabilis na pagpapalit: binary ↔ hex (4 binary digits = 1 hex digit):
| Binary | Hex | Decimal | Binary | Hex | Decimal |
|---|---|---|---|---|---|
| 0000 | 0 | 0 | 1000 | 8 | 8 |
| 0001 | 1 | 1 | 1001 | 9 | 9 |
| 0010 | 2 | 2 | 1010 | A | 10 |
| 0011 | 3 | 3 | 1011 | B | 11 |
| 0100 | 4 | 4 | 1100 | C | 12 |
| 0101 | 5 | 5 | 1101 | D | 13 |
| 0110 | 6 | 6 | 1110 | E | 14 |
| 0111 | 7 | 7 | 1111 | F | 15 |
Ang 4-bit na paggupuhan na ito ay ginagawang lubhang kapaki-pakinabang ang hex bilang isang compact na notasyon para sa binary data: ang 32-bit na halaga na 11001010 00111111 10110101 00001100 ay mas madali isulat bilang CA3FB50C.
Binary sa Networking: IP Addresses at Subnet Masks
Ang pag-unawa sa binary ay mahalaga para sa network engineering dahil ang mga IPv4 address ay talagang 32-bit na binary na numero, at ang subnetting — ang proseso ng paghahati ng mga network — ay nakasalalay lamang sa mga binary na operasyon.
Ang isang IPv4 address tulad ng 192.168.1.100 ay notasyon na madaling mabasa ng tao para sa 32-bit na binary na halaga:
11000000.10101000.00000001.01100100
Ang isang subnet mask ay nagtutuos kung aling bahagi ng address ang nagpapakilala sa network at kung alin ang nagpapakilala sa host. Ang mask na 255.255.255.0 sa binary ay:
11111111.11111111.11111111.00000000
Ang bitwise AND ng IP address at subnet mask ay nagbibigay ng network address:
| Component | Decimal | Binary |
|---|---|---|
| IP Address | 192.168.1.100 | 11000000.10101000.00000001.01100100 |
| Subnet Mask | 255.255.255.0 | 11111111.11111111.11111111.00000000 |
| Network (AND) | 192.168.1.0 | 11000000.10101000.00000001.00000000 |
Ang CIDR notation (hal., /24) ay nagsasabi sa iyo kung gaano karaming leading 1-bits ang nasa subnet mask. Ang isang /24 mask ay may 24 na ones na sinusundan ng 8 na zeros, na nagpapahintulot ng 2⁸ − 2 = 254 na gamit na host address bawat subnet. Ang isang /16 mask ay nagpapahintulot ng 65,534 na host. Ang mga network engineer ay gumagamit ng binary mental math araw-araw upang magplano ng mga subnet, kalkulahin ang mga broadcast address, at mag-troubleshoot ng pagruruta.
Binary sa Cryptography at Seguridad
Ang mga modernong algorithm ng pag-encrypt ay gumagana nang buo sa binary na antas, na nagmamanipula ng mga indibidwal na bit sa pamamagitan ng mga kombinasyon ng XOR, bit shifts, at substitution operations. Ang pag-unawa sa binary ay ang gateway sa pag-unawa kung paano gumagana ang digital na seguridad.
XOR encryption (ang pundasyon ng modernong ciphers): Ang XOR ay may natatanging katangian — ang paglalapat nito ng dalawang beses gamit ang parehong key ay nagbabalik ng orihinal na halaga: A ⊕ K ⊕ K = A. Ginagawa itong XOR na batayan ng mga stream ciphers at one-time pads.
Halimbawa: pag-encrypt ng byte na 01001101 (litra 'M' sa ASCII) gamit ang key na 10110010:
- Plaintext: 01001101
- Key: 10110010
- XOR (encrypt): 11111111
- XOR muli gamit ang parehong key (decrypt): 01001101 = 'M' ✓
Mga laki ng key sa modernong encryption: Ang AES-128 ay gumagamit ng 128-bit na key, na nangangahulugang mayroong 2¹²⁸ ≈ 3.4 × 10³⁸ na posibleng key — higit pa sa bilang ng mga atom sa observable na uniberso. Ang AES-256 ay gumagamit ng 256-bit na key na may 2²⁵⁶ na posibilidad. Kahit ang pinakamabilis na supercomputers ay hindi maaaring mag-brute-force ng mga key space na ito. Ang bawat karagdagang bit ay dina-double ang search space, na kung bakit mahalaga ang haba ng key nang exponentially sa cryptography.
Ang mga hash function tulad ng SHA-256 ay naglalabas ng 256-bit (32-byte) na binary na output mula sa anumang input. Kahit na ang pagbabago ng isang bit sa input ay naglalabas ng ganap na iba't ibang hash — isang katangian na tinatawag na "avalanche effect" na nagpapaginhawa sa mga hash na kapaki-pakinabang para sa pagpapatunay ng integridad ng data, pag-iimbak ng mga password, at pagpapalakas ng teknolohiya ng blockchain.
Binary at quantum computing: Habang ang mga klasikal na computer ay gumagamit ng binary bits (0 o 1), ang mga quantum computer ay gumagamit ng qubits na maaaring umiiral sa isang superposition ng parehong mga estado nang sabay-sabay. Ang isang klasikal na 256-bit na key ay may 2²⁵⁶ na posibleng halaga na dapat suriin nang sunud-sunod; ang isang quantum computer na nagpapatakbo ng algorithm ni Grover ay maaaring maghanap sa espasyong ito sa √(2²⁵⁶) = 2¹²⁸ na operasyon. Ito ang dahilan kung bakit binuo ang post-quantum cryptography — upang lumikha ng mga binary-based na encryption scheme na mananatiling secure kahit laban sa mga quantum na kalaban.
Mga Madalas Itanong
Bakit gumagamit ang mga kompyuter ng binary sa halip na decimal?
Ang mga elektronikong sirkito ay pinaka-maaasahan sa dalawa lamang na magkaibang estado: on (mataas na boltahe ≈ 1) at off (mababang boltahe ≈ 0). Ang pagpapakita ng 10 magkaibang estado para sa decimal ay magkakailangan ng mas tumpak na kontrol sa boltahe at magiging mas madaling maapektuhan ng electrical noise. Ang pagiging simple ng binary ay nagpapahintulot sa bilyon-bilyong mga transistor na gumana nang maaasahan sa mga bilis ng GHz na may bilyong mga operasyon bawat segundo.
Ano ang pinakamalaking numero na maaaring hawakan ng isang byte?
Ang isang byte (8 bits) ay maaaring kumatawan sa 2⁸ = 256 na magkaibang halaga. Para sa mga unsigned integer: 0 hanggang 255. Para sa mga signed integer (two's complement): −128 hanggang 127. Ang pinakamalaking halaga ng unsigned byte sa binary ay 11111111₂ = 255; sa hex ito ay FF.
Paano ko i-convert ang isang negatibong numero sa binary?
Gamitin ang two's complement: (1) I-convert ang positibong bersyon sa binary, (2) I-flip ang lahat ng mga bit (0→1, 1→0), (3) Magdagdag ng 1. Halimbawa — −13 sa 8-bit: +13 = 00001101₂, i-flip ang mga bit = 11110010₂, magdagdag ng 1 = 11110011₂. Ito ang paraan kung paano nag-iimbak ang lahat ng modernong kompyuter ng mga negatibong integer.
Ano ang pagkakaiba ng binary at hexadecimal?
Pareho silang positional number systems na ginagamit sa computing. Ang binary (base-2) ay gumagamit lamang ng 0 at 1 — ang katutubong wika ng mga kompyuter. Ang hexadecimal (base-16) ay gumagamit ng 0–9 at A–F bilang isang compact na notasyon para sa binary — ang bawat 4 na binary digit ay tumutugma sa eksaktong 1 na hex digit. Ang Hex ay ginagamit para sa mga memory address, color codes (#RRGGBB), at machine code dahil mas compact at readable ito kaysa sa raw na binary.
Sa ano ginagamit ang mga bitwise operation?
Ang mga bitwise operation (AND, OR, XOR, NOT, shifts) ay nagmamanipula sa mga indibidwal na bit sa loob ng mga integer. Karaniwang gamit: bit flags at permissions (Unix chmod), pagsusuri kung even/odd (n & 1), mabilis na pagpaparami/paghahati sa pamamagitan ng mga kapangyarihan ng 2 (bit shifting), mga algoritmo ng enkripsyon, hash functions, CRC error detection, network subnet masks, at pagbuo ng laro (compact na pag-iimbak ng estado sa isang solong integer).
Ano ang binary floating point at bakit ang 0.1 + 0.2 ≠ 0.3 sa programming?
Ang karamihan sa mga modernong kompyuter ay gumagamit ng IEEE 754 binary floating point, na kumakatawan sa mga decimal fraction sa binary. Tulad ng 1/3 = 0.3333... na hindi maaaring kumatawan nang eksakto sa decimal, ang 1/10 ay hindi maaaring kumatawan nang eksakto sa binary (it's an infinitely repeating binary fraction). Ito ay nagdudulot ng maliliit na pagkakamali sa pag-round: sa karamihan ng mga wika, 0.1 + 0.2 = 0.30000000000000004. Gumamit ng integer arithmetic (trabahuin sa cents, hindi sa dollars) o decimal libraries para sa eksaktong mga kalkulasyon sa pananalapi.
Paano ginagamit ang binary sa data storage at file sizes?
Ang storage ay sinusukat sa bytes (8 bits), kilobytes (1,024 bytes), megabytes (1,024 KB), gigabytes (1,024 MB), at iba pa. Tandaan: ang mga gumagawa ng hard drive ay gumagamit ng SI prefixes (1 KB = 1,000 bytes) habang ang mga operating system ay gumagamit ng binary prefixes (1 KiB = 1,024 bytes), na nagiging sanhi ng halata na "nawawalang puwang" na pagkakaiba kapag bumibili ka ng storage. Ang isang 1 TB drive ay nagpapakita ng ~931 GiB sa Windows dahil 1,000,000,000,000 ÷ 1,073,741,824 ≈ 931.
Ano ang binary-coded decimal (BCD)?
Ang BCD ay nag-encode ng bawat decimal digit bilang isang 4-bit na binary group: 0=0000, 1=0001,..., 9=1001. Kaya ang decimal na 93 sa BCD ay 1001 0011. Ang BCD ay ginagamit sa mga sistemang pampinansyal (iniiwas ang mga pagkakamali sa pag-round ng floating-point), digital clocks at displays (ang mga 7-segment display ay nag-decode ng BCD nang direkta), at mga lumang mainframe system. Ito ay mas mababa sa space-efficient kaysa sa purong binary ngunit iniiwasan ang mga pagkakamali sa pag-convert ng decimal-to-binary sa mga kritikal na aplikasyon.