Binary & Number Systems

1. What is Binary?

You count in base 10 every day. That means you use 10 digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. When you run out of digits, you carry over to the next place. After 9 comes 10 -- you put a 1 in the "tens" column and start over.

Binary is base 2. You only have 2 digits: 0 and 1. That is it. When you run out (after 1), you carry over. After 1 comes 10 (which means "2" in binary).

Why only 0 and 1? Because computers are built from billions of tiny switches (transistors) that can only be in two states: off (0) or on (1). Binary is not a choice -- it is a physical limitation. Everything a computer does comes down to flipping these switches.

2. Counting in Binary

Counting in binary works exactly like counting in decimal, just with fewer digits. Watch the pattern:

3. Binary to Decimal (and Back)

Binary to Decimal

Each position in a binary number represents a power of 2, starting from 2^0 on the right. To convert, multiply each digit by its power of 2 and add them all up.

Decimal to Binary

Divide the number by 2 repeatedly. Write down the remainder each time. Read the remainders bottom-to-top.

4. Hexadecimal (Base 16)

Binary is great for computers but annoying for humans. The number 11010110 is hard to read. Hexadecimal (hex) solves this by grouping every 4 binary digits into one hex digit. Since 4 bits can represent 0-15, and we only have digits 0-9, we borrow letters A-F for 10-15.

Hex numbers are usually written with a 0x prefix to distinguish them from decimal. So 0xFF means "FF in hex" not "the letters FF."

Converting Binary to Hex

Group the binary digits into chunks of 4 (from the right), then convert each chunk:

Hex to Decimal

Each hex position is a power of 16. Multiply and add:

5. Octal (Base 8)

Octal uses digits 0-7. Each octal digit represents exactly 3 binary digits. You will mostly see octal in Unix/Linux file permissions (like chmod 755).

6. Bits, Bytes, and Data Sizes

A bit is a single 0 or 1. A byte is 8 bits grouped together. A byte can represent any value from 0 to 255 (2^8 = 256 possible values). Everything in a computer is measured in bytes.

Common Data Types and Their Sizes

7. Bitwise AND (&)

Bitwise AND compares two numbers bit by bit. For each position: if both bits are 1, the result is 1. Otherwise, the result is 0. Think of it as: "both must agree to let it through."

8. Bitwise OR (|)

Bitwise OR compares two numbers bit by bit. For each position: if either bit (or both) is 1, the result is 1. Only if both are 0 does the result stay 0.

9. Bitwise XOR (^)

XOR (exclusive OR) is the most interesting bitwise operation. For each position: if the bits are different, the result is 1. If they are the same, the result is 0. Think of it as a "difference detector."

10. Bitwise NOT (~)

NOT flips every single bit. Every 0 becomes 1, every 1 becomes 0. It is the only bitwise operation that works on a single number (not two).

11. Bit Shifting (Left & Right)

Shifting moves all bits left or right by a certain number of positions. Bits that "fall off" the edge are lost. New bits that enter from the other side are 0.

Left Shift (<<)

Shifts all bits to the left. Each left shift multiplies by 2.

Right Shift (>>)

Shifts all bits to the right. Each right shift divides by 2 (rounding down).

12. Two's Complement (Negative Numbers in Binary)

How does a computer store -5 when it only has 0s and 1s? It uses a system called two's complement. The leftmost bit is the sign bit: 0 = positive, 1 = negative.

How to Get the Two's Complement (Make a Number Negative)

Two steps: flip all the bits (NOT), then add 1.

13. Common Bit Manipulation Tricks

These are the bit tricks that show up in interviews and real systems code. Each one exploits a specific property of binary.

14. How Data is Actually Stored

Everything in your computer -- every photo, song, game, text message, and PDF -- is stored as a sequence of bytes. There is no "text" or "image" at the hardware level. It is all just bytes. The software decides how to interpret those bytes.

Endianness: Byte Order Matters

When a number needs more than 1 byte (like a 32-bit int), the question is: which byte comes first in memory? There are two conventions:

15. ASCII & Unicode

ASCII -- The Original Character Encoding

ASCII assigns a number (0-127) to each character. It uses 7 bits (usually stored in 1 byte). Here are the important ranges:

Unicode -- Characters for Every Language

ASCII only covers English (128 characters). Unicode covers every writing system on Earth -- over 150,000 characters including Chinese, Arabic, emoji, and ancient scripts. Unicode assigns each character a "code point" (like U+0041 for 'A').

UTF-8 is the most common encoding. It uses 1-4 bytes per character: ASCII characters use 1 byte (backward compatible), while other characters use 2-4 bytes. This is why a file with only English text is roughly 1 byte per character, but a file with Chinese or emoji is larger.

16. Files as Bytes -- PDFs, Images, and More

Every file on your computer is just a sequence of bytes. The first few bytes usually identify the file type -- this is called a magic number or file signature. Software reads these bytes to know what kind of file it is dealing with.

How a PDF is Structured

A PDF is not magic -- it is a structured byte sequence:

How Images are Stored

// Open a file and read its first 16 bytes
#include <fstream>
#include <iostream>
#include <iomanip>

int main() {
    std::ifstream file("document.pdf", std::ios::binary);
    unsigned char buffer[16];
    file.read(reinterpret_cast<char*>(buffer), 16);

    // Print each byte as hex
    for (int i = 0; i < 16; i++) {
        std::cout << std::hex << std::setw(2)
                  << std::setfill('0') << (int)buffer[i] << " ";
    }
    // Output: 25 50 44 46 2d 31 2e 37 ... (%PDF-1.7...)
    return 0;
}C++

17. Bitwise Operations in C++

Here is every bitwise operator in C++ with examples you can run.

Practical C++ Examples

// Count set bits (number of 1s in binary representation)
int countBits(int n) {
    int count = 0;
    while (n) {
        n &= (n - 1);  // Turn off the lowest set bit
        count++;
    }
    return count;
}

// Or use the built-in:
int bits = __builtin_popcount(42);  // = 3 (101010 has three 1s)C++

// Use bitmask as a set of flags
const int READ    = 1 << 0;  // 0001 = 1
const int WRITE   = 1 << 1;  // 0010 = 2
const int EXECUTE = 1 << 2;  // 0100 = 4

int perms = READ | WRITE;           // 0011 = can read and write
bool canRead = (perms & READ) != 0; // true
bool canExec = (perms & EXECUTE) != 0; // false
perms |= EXECUTE;                   // 0111 = add execute
perms &= ~WRITE;                    // 0101 = remove writeC++

// Subset enumeration with bitmasks
// Iterate over all subsets of {A, B, C} using a 3-bit mask
for (int mask = 0; mask < (1 << 3); mask++) {
    // mask goes: 000, 001, 010, 011, 100, 101, 110, 111
    if (mask & (1 << 0)) cout << "A ";
    if (mask & (1 << 1)) cout << "B ";
    if (mask & (1 << 2)) cout << "C ";
    cout << endl;
}
// Output: (empty), A, B, AB, C, AC, BC, ABCC++

// Print a number in binary (useful for debugging)
#include <bitset>
std::cout << std::bitset<8>(42) << std::endl;  // 00101010
std::cout << std::bitset<32>(-1) << std::endl; // 11111111111111111111111111111111C++

18. Practice Quiz

Test your understanding. Click an answer to check it.