Bit Manipulation

📖 Before We Start — The Big Picture

Every number stored in memory is just a sequence of bits (binary digits: 0 or 1). An int in Java is 32 bits — 32 on/off switches. When you write int x = 13, the computer stores it as 00000000 00000000 00000000 00001101.

Bitwise operators let you flip, combine, and interrogate those switches individually. AND (&) keeps a bit only if both are 1 — it's a mask. OR (|) sets a bit if either is 1. XOR (^) is 1 when bits differ — its superpower is that the same number XORed with itself cancels to 0, which is how you find unique elements without extra space. Left shift (<<) multiplies by 2; right shift (>>) divides by 2.

⚡ Why Bits Matter in DSA

Every number in your computer is stored as a sequence of bits (0s and 1s). Bit manipulation lets you operate on these bits directly — and these operations are the fastest thing your CPU can do.

🔢 Bitwise Operators — Your Toolkit

🔥 Java Built-in Bit Methods

Interviewers know these exist. You can often use them if the question isn't specifically about implementing them from scratch.

🔄 Two's Complement — How Negatives Work

Java uses two's complement to store negative numbers. To negate a number: flip all bits, then add 1.

 5 in binary:  00000101
~5 (flip):    11111010
+1:           11111011  →  this is -5

// Key insight: -n == ~n + 1
// So: n & (-n) gives you the LOWEST SET BIT of n
// Example: 12 = 1100, -12 = 0100 → 12 & (-12) = 0100 = 4

This n & (-n) trick (isolating the lowest set bit) appears constantly in advanced problems like Binary Indexed Trees (Lecture 23).

🔧 Core Bit Tricks — The 6 Operations You Must Memorize

Get / Set / Clear / Toggle — The Big Four

// n = 13 = 1101 (binary), k = 1

// CHECK bit 1:  (13 >> 1) & 1 = (110) & 1 = 0 // bit 1 is NOT set

// SET bit 1:    13 | (1 << 1) = 1101 | 0010 = 1111 = 15

// CLEAR bit 2:  13 & ~(1 << 2) = 1101 & 1011 = 1001 = 9

// TOGGLE bit 0: 13 ^ (1 << 0) = 1101 ^ 0001 = 1100 = 12

Advanced: Clearing a Range of Bits

Sometimes you need to clear all bits from the Most Significant Bit (MSB) down to index i, or from index i down to 0.

// 1. Clear all bits from MSB down to index i (inclusive)
int mask1 = (1 << i) - 1;
n = n & mask1;

// 2. Clear all bits from index i down to 0 (inclusive)
int mask2 = ~((1 << (i + 1)) - 1);
n = n & mask2;

🧮 Brian Kernighan's Algorithm — Count Set Bits in O(k)

The trick: n & (n-1) removes the lowest set bit of n. Repeat until n becomes 0. The number of iterations = number of set bits.

int countSetBits(int n) {
    int count = 0;
    while (n != 0) {
        n = n & (n - 1);  // remove lowest set bit
        count++;
    }
    return count;
}

// Dry run: n = 13 (1101)
// Iteration 1: n = 1101 & 1100 = 1100 (12), count = 1
// Iteration 2: n = 1100 & 1011 = 1000 (8),  count = 2
// Iteration 3: n = 1000 & 0111 = 0000 (0),  count = 3
// Return 3 ✓

⚡ Power of 2 Check — The One-Liner

A number is a power of 2 if and only if it has exactly one set bit.

boolean isPowerOfTwo(int n) {
    return n > 0 && (n & (n - 1)) == 0;
}

// 16 = 10000 → 16 & 15 = 10000 & 01111 = 00000 → true ✓
//  6 = 00110 →  6 &  5 = 00110 & 00101 = 00100 → false ✓
// EDGE CASE: n must be > 0! (0 is NOT a power of 2)

🎯 XOR Patterns — The Interview Favorite

XOR (^) has three magical properties that make it the most useful bitwise operator in interviews:

🔄 XOR Cancellation — Find the Unique Element

Problem: Every element in an array appears twice except one. Find the unique one in O(1) space.

int singleNumber(int[] nums) {
    int result = 0;
    for (int n : nums) result ^= n;
    return result;
}

// Dry run: [4, 1, 2, 1, 2]
// 0 ^ 4 = 4
// 4 ^ 1 = 5
// 5 ^ 2 = 7
// 7 ^ 1 = 6  (1 cancelled)
// 6 ^ 2 = 4  (2 cancelled)
// Return 4 ✓ — only the unique number survives!

The "Missing Number" Extension

What if you have an array containing n distinct numbers in the range [0, n], and you need to find the missing one? (LeetCode 268)

Instead of summing everything (which risks integer overflow), you can XOR all the array values AND XOR all the numbers from 0 to n. Every number will appear twice (once in the array, once in the 0..n range) except the missing number. They all cancel out, leaving just the missing number!

🔀 XOR Partitioning — Find TWO Unique Elements

When TWO elements are unique, XOR gives us their combined XOR. We then split the array using any differing bit:

int[] twoUnique(int[] nums) {
    int xor = 0;
    for (int n : nums) xor ^= n;  // xor = a ^ b

    int rightmostBit = xor & (-xor);  // isolate lowest differing bit

    int a = 0, b = 0;
    for (int n : nums) {
        if ((n & rightmostBit) != 0) a ^= n;  // group 1
        else b ^= n;                          // group 2
    }
    return new int[]{a, b};
}

// Why this works:
// Step 1: XOR all → get a^b (some bits are set where a,b differ)
// Step 2: Pick any set bit → this bit is 1 in one number, 0 in the other
// Step 3: Split into two groups by this bit → each group has ONE unique
// Step 4: XOR each group → pairs cancel, unique survives

🎭 Bitmask Techniques

📦 Subset Generation Using Bitmask

For an array of n elements, each subset corresponds to an n-bit number (0 to 2ⁿ-1). If bit j is set, include element j.

List<List<Integer>> subsets(int[] nums) {
    int n = nums.length;
    List<List<Integer>> result = new ArrayList<>();

    for (int mask = 0; mask < (1 << n); mask++) {
        List<Integer> subset = new ArrayList<>();
        for (int j = 0; j < n; j++) {
            if ((mask & (1 << j)) != 0) {
                subset.add(nums[j]);
            }
        }
        result.add(subset);
    }
    return result;
}

// For nums = [a, b, c], n=3, masks 0..7:
// mask=0 (000): []
// mask=1 (001): [a]
// mask=2 (010): [b]
// mask=3 (011): [a, b]
// mask=4 (100): [c]
// mask=5 (101): [a, c]
// mask=6 (110): [b, c]
// mask=7 (111): [a, b, c]

⚡ Useful Shift Tricks

🧮 The Half-Adder Pattern (Addition without `+`)

This is a universally asked FAANG question (LeetCode 371). How do you add two numbers without using the + operator?

Think about how binary addition works: 1+0=1, 0+1=1, 0+0=0, 1+1=0 (with a carry of 1). Does that look familiar? It's exactly an XOR operation!

• a ^ b computes the sum without any carry.
• (a & b) << 1 computes the carry bits (and shifts them left so they add to the next column).

public int getSum(int a, int b) {
    while (b != 0) {
        int sum = a ^ b;            // step 1: sum without carry
        int carry = (a & b) << 1;    // step 2: find carry and shift
        a = sum;
        b = carry;                  // repeat until carry is zero
    }
    return a;
}

⏱ Complexity Patterns in Bit Manipulation

💪 In-Lecture Practice Problems

Work through these in order. Don't look at the solution before attempting!

public int hammingWeight(int n) {
    int count = 0;
    while (n != 0) {
        n &= (n - 1);  // drops the lowest set bit
        count++;
    }
    return count;
}

public int singleNumber(int[] nums) {
    int res = 0;
    for (int n : nums) res ^= n;
    return res;
}

public int[] singleNumber(int[] nums) {
    int xor = 0;
    for (int n : nums) xor ^= n;
    
    int diffBit = xor & (-xor);
    
    int a = 0, b = 0;
    for (int n : nums) {
        if ((n & diffBit) == 0) a ^= n;
        else b ^= n;
    }
    
    return new int[]{a, b};
}

public List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> res = new ArrayList<>();
    int n = nums.length;
    int total = 1 << n;
    
    for (int mask = 0; mask < total; mask++) {
        List<Integer> curr = new ArrayList<>();
        for (int j = 0; j < n; j++) {
            if ((mask & (1 << j)) != 0) {
                curr.add(nums[j]);
            }
        }
        res.add(curr);
    }
    return res;
}

public int missingNumber(int[] nums) {
    int res = nums.length;
    for (int i = 0; i < nums.length; i++) {
        res ^= i;
        res ^= nums[i];
    }
    return res;
}

public boolean isPowerOfTwo(int n) {
    if (n <= 0) return false;
    // A power of 2 has exactly one '1' bit
    return (n & (n - 1)) == 0;
}

public int[] countBits(int n) {
    int[] ans = new int[n + 1];
    for (int i = 1; i <= n; i++) {
        ans[i] = ans[i >> 1] + (i & 1); 
    }
    return ans;
}

public int reverseBits(int n) {
    int result = 0;
    for (int i = 0; i < 32; i++) {
        int bit = (n >> i) & 1;
        result = result | (bit << (31 - i));
    }
    return result;
}

public char findTheDifference(String s, String t) {
    char ans = 0;
    for (char c : s.toCharArray()) ans ^= c;
    for (char c : t.toCharArray()) ans ^= c;
    return ans;
}

public int singleNumber(int[] nums) {
    int ans = 0;
    for (int i = 0; i < 32; i++) {
        int sum = 0;
        for (int num : nums) {
            if (((num >> i) & 1) == 1) sum++;
        }
        if (sum % 3 != 0) {
            ans = ans | (1 << i);
        }
    }
    return ans;
}

📝 Assignment

✅ Lecture Completion Checklist

Check each item off as you master it. Don't proceed to Lecture 4 until all are checked.