7a:T98c,// Formula 1: (n >> i) & 1 // Returns 0 if bit is clear, 1 if bit is set function checkBit(n: number, i: number): number { return (n >> i) & 1; } function isBitSet(n: number, i: number): boolean { return ((n >> i) & 1) === 1; } // Examples console.log(checkBit(42, 0)); // 0 (bit 0 is clear) console.log(checkBit(42, 1)); // 1 (bit 1 is set) console.log(checkBit(42, 3)); // 1 (bit 3 is set) console.log(checkBit(42, 4)); // 0 (bit 4 is clear) console.log(isBitSet(42, 3)); // true console.log(isBitSet(42, 4)); // false ---python # Formula 1: (n >> i) & 1 # Returns 0 if bit is clear, 1 if bit is set def check_bit(n: int, i: int) -> int: return (n >> i) & 1 def is_bit_set(n: int, i: int) -> bool: return ((n >> i) & 1) == 1 # Examples print(check_bit(42, 0)) # 0 (bit 0 is clear) print(check_bit(42, 1)) # 1 (bit 1 is set) print(check_bit(42, 3)) # 1 (bit 3 is set) print(check_bit(42, 4)) # 0 (bit 4 is clear) print(is_bit_set(42, 3)) # True print(is_bit_set(42, 4)) # False ---java public class BitCheck { // Formula 1: (n >> i) & 1 // Returns 0 if bit is clear, 1 if bit is set public static int checkBit(int n, int i) { return (n >> i) & 1; } public static boolean isBitSet(int n, int i) { return ((n >> i) & 1) == 1; } public static void main(String[] args) { System.out.println(checkBit(42, 0)); // 0 (bit 0 is clear) System.out.println(checkBit(42, 1)); // 1 (bit 1 is set) System.out.println(checkBit(42, 3)); // 1 (bit 3 is set) System.out.println(checkBit(42, 4)); // 0 (bit 4 is clear) System.out.println(isBitSet(42, 3)); // true System.out.println(isBitSet(42, 4)); // false } } ---cpp #include // Formula 1: (n >> i) & 1 // Returns 0 if bit is clear, 1 if bit is set int checkBit(int n, int i) { return (n >> i) & 1; } bool isBitSet(int n, int i) { return ((n >> i) & 1) == 1; } int main() { std::cout << checkBit(42, 0) << std::endl; // 0 (bit 0 is clear) std::cout << checkBit(42, 1) << std::endl; // 1 (bit 1 is set) std::cout << checkBit(42, 3) << std::endl; // 1 (bit 3 is set) std::cout << checkBit(42, 4) << std::endl; // 0 (bit 4 is clear) std::cout << std::boolalpha; std::cout << isBitSet(42, 3) << std::endl; // true std::cout << isBitSet(42, 4) << std::endl; // false return 0; }7b:Tbd3,// Formula 2: n & (1 << i) // Returns 0 if bit is clear, 2^i if bit is set function checkBitMask(n: number, i: number): number { return n & (1 << i); } function isBitSetMask(n: number, i: number): boolean { return (n & (1 << i)) !== 0; } // Examples - note the different non-zero values console.log(checkBitMask(42, 1)); // 2 (bit 1 is set, 2^1 = 2) console.log(checkBitMask(42, 3)); // 8 (bit 3 is set, 2^3 = 8) console.log(checkBitMask(42, 5)); // 32 (bit 5 is set, 2^5 = 32) console.log(checkBitMask(42, 4)); // 0 (bit 4 is clear) // Both work identically as boolean conditions console.log(isBitSetMask(42, 3)); // true console.log(isBitSetMask(42, 4)); // false ---python # Formula 2: n & (1 << i) # Returns 0 if bit is clear, 2^i if bit is set def check_bit_mask(n: int, i: int) -> int: return n & (1 << i) def is_bit_set_mask(n: int, i: int) -> bool: return (n & (1 << i)) != 0 # Examples - note the different non-zero values print(check_bit_mask(42, 1)) # 2 (bit 1 is set, 2^1 = 2) print(check_bit_mask(42, 3)) # 8 (bit 3 is set, 2^3 = 8) print(check_bit_mask(42, 5)) # 32 (bit 5 is set, 2^5 = 32) print(check_bit_mask(42, 4)) # 0 (bit 4 is clear) # Both work identically as boolean conditions print(is_bit_set_mask(42, 3)) # True print(is_bit_set_mask(42, 4)) # False ---java public class BitCheckMask { // Formula 2: n & (1 << i) // Returns 0 if bit is clear, 2^i if bit is set public static int checkBitMask(int n, int i) { return n & (1 << i); } public static boolean isBitSetMask(int n, int i) { return (n & (1 << i)) != 0; } public static void main(String[] args) { // Examples - note the different non-zero values System.out.println(checkBitMask(42, 1)); // 2 (bit 1 is set) System.out.println(checkBitMask(42, 3)); // 8 (bit 3 is set) System.out.println(checkBitMask(42, 5)); // 32 (bit 5 is set) System.out.println(checkBitMask(42, 4)); // 0 (bit 4 is clear) // Both work identically as boolean conditions System.out.println(isBitSetMask(42, 3)); // true System.out.println(isBitSetMask(42, 4)); // false } } ---cpp #include // Formula 2: n & (1 << i) // Returns 0 if bit is clear, 2^i if bit is set int checkBitMask(int n, int i) { return n & (1 << i); } bool isBitSetMask(int n, int i) { return (n & (1 << i)) != 0; } int main() { // Examples - note the different non-zero values std::cout << checkBitMask(42, 1) << std::endl; // 2 (bit 1 is set) std::cout << checkBitMask(42, 3) << std::endl; // 8 (bit 3 is set) std::cout << checkBitMask(42, 5) << std::endl; // 32 (bit 5 is set) std::cout << checkBitMask(42, 4) << std::endl; // 0 (bit 4 is clear) std::cout << std::boolalpha; // Both work identically as boolean conditions std::cout << isBitSetMask(42, 3) << std::endl; // true std::cout << isBitSetMask(42, 4) << std::endl; // false return 0; }7c:T98c,// Demonstrating positional values and checking bits across the range function explainBits(n: number, numBits: number = 8): void { console.log(` Number: ${n}`); console.log("Position | Value | Bit | Contributes"); console.log("---------|-------|-----|------------"); for (let i = numBits - 1; i >= 0; i--) { const bitValue = (n >> i) & 1; const positionalValue = 1 << i; const contributes = bitValue === 1 ? positionalValue : 0; console.log( ` ${i.toString().padStart(2)} | ${positionalValue.toString().padStart(3)} | ${bitValue} | ${contributes}` ); } // Verify: sum of contributions equals n let sum = 0; for (let i = 0; i < numBits; i++) { if ((n >> i) & 1) { sum += (1 << i); } } console.log(` Verification: sum of set bit values = ${sum}`); } explainBits(42); // Number: 42 // Position | Value | Bit | Contributes // ---------|-------|-----|------------ // 7 | 128 | 0 | 0 // 6 | 64 | 0 | 0 // 5 | 32 | 1 | 32 // 4 | 16 | 0 | 0 // 3 | 8 | 1 | 8 // 2 | 4 | 0 | 0 // 1 | 2 | 1 | 2 // 0 | 1 | 0 | 0 // Verification: sum of set bit values = 42 ---python # Demonstrating positional values and checking bits across the range def explain_bits(n: int, num_bits: int = 8) -> None: print(f" Number: {n}") print("Position | Value | Bit | Contributes") print("---------|-------|-----|------------") for i in range(num_bits - 1, -1, -1): bit_value = (n >> i) & 1 positional_value = 1 << i contributes = positional_value if bit_value == 1 else 0 print(f" {i:2} | {positional_value:3} | {bit_value} | {contributes}") # Verify: sum of contributions equals n total = sum((1 << i) for i in range(num_bits) if (n >> i) & 1) print(f" Verification: sum of set bit values = {total}") explain_bits(42) # Number: 42 # Position | Value | Bit | Contributes # ---------|-------|-----|------------ # 7 | 128 | 0 | 0 # 6 | 64 | 0 | 0 # 5 | 32 | 1 | 32 # 4 | 16 | 0 | 0 # 3 | 8 | 1 | 8 # 2 | 4 | 0 | 0 # 1 | 2 | 1 | 2 # 0 | 1 | 0 | 0 # Verification: sum of set bit values = 427d:T938,// Edge case demonstrations // 1. Checking bits in negative numbers (two's complement) const negOne = -1; console.log("Bits of -1:"); for (let i = 31; i >= 0; i--) { process.stdout.write(String((negOne >> i) & 1)); } console.log(); // 11111111111111111111111111111111 (all 1s!) // 2. Checking the sign bit (bit 31 in 32-bit) function isNegative(n: number): boolean { // For 32-bit integers, bit 31 is the sign bit return ((n >> 31) & 1) === 1; } console.log(isNegative(42)); // false console.log(isNegative(-42)); // true // 3. Safe bit check with bounds validation function safeBitCheck(n: number, i: number): number | null { if (i < 0 || i > 31) { console.warn(`Bit position ${i} out of valid range [0, 31]`); return null; } return (n >> i) & 1; } console.log(safeBitCheck(42, 3)); // 1 console.log(safeBitCheck(42, 50)); // null (with warning) // 4. Zero - all positions return 0 const zero = 0; console.log(`Bit 0 of 0: ${(zero >> 0) & 1}`); // 0 console.log(`Bit 15 of 0: ${(zero >> 15) & 1}`); // 0 ---python # Edge case demonstrations # 1. Checking bits in negative numbers (two's complement) # Python integers have arbitrary precision, so we need to mask for 32-bit neg_one = -1 & 0xFFFFFFFF # Simulate 32-bit print("Bits of -1 (32-bit):") print(''.join(str((neg_one >> i) & 1) for i in range(31, -1, -1))) # 11111111111111111111111111111111 # 2. Checking the sign bit (bit 31 in 32-bit representation) def is_negative_32bit(n: int) -> bool: """Check if a 32-bit integer is negative""" # Mask to 32 bits first, then check sign bit masked = n & 0xFFFFFFFF return ((masked >> 31) & 1) == 1 print(is_negative_32bit(42)) # False print(is_negative_32bit(-42)) # True # 3. Safe bit check with bounds validation def safe_bit_check(n: int, i: int, bit_width: int = 32) -> int | None: if i < 0 or i >= bit_width: print(f"Warning: Bit position {i} out of valid range [0, {bit_width-1}]") return None # Mask to ensure consistent behavior with negative numbers masked = n & ((1 << bit_width) - 1) return (masked >> i) & 1 print(safe_bit_check(42, 3)) # 1 print(safe_bit_check(42, 50)) # None (with warning) # 4. Zero - all positions return 0 zero = 0 print(f"Bit 0 of 0: {(zero >> 0) & 1}") # 0 print(f"Bit 15 of 0: {(zero >> 15) & 1}") # 07e:T424,// Unix-style file permissions using bits const PERM_READ = 0b100; // bit 2 = 4 const PERM_WRITE = 0b010; // bit 1 = 2 const PERM_EXEC = 0b001; // bit 0 = 1 function hasPermission(userPerms: number, required: number): boolean { return (userPerms & required) === required; } function checkReadPermission(perms: number): boolean { return ((perms >> 2) & 1) === 1; // Check bit 2 } function checkWritePermission(perms: number): boolean { return ((perms >> 1) & 1) === 1; // Check bit 1 } function checkExecPermission(perms: number): boolean { return (perms & 1) === 1; // Check bit 0 } // Example: rwx (read-write-execute) = 7 = 0b111 const rwx = 7; console.log(`Read: ${checkReadPermission(rwx)}`); // true console.log(`Write: ${checkWritePermission(rwx)}`); // true console.log(`Exec: ${checkExecPermission(rwx)}`); // true // Example: r-- (read-only) = 4 = 0b100 const readOnly = 4; console.log(`Read: ${checkReadPermission(readOnly)}`); // true console.log(`Write: ${checkWritePermission(readOnly)}`); // false7f:T4f1,// Feature flags for a game engine enum GameFeature { SHADOWS = 0, REFLECTIONS = 1, ANTIALIASING = 2, HDR = 3, VSYNC = 4, AMBIENT_OCCLUSION = 5, MOTION_BLUR = 6, RAY_TRACING = 7, } class FeatureManager { private flags: number = 0; isEnabled(feature: GameFeature): boolean { return ((this.flags >> feature) & 1) === 1; } enable(feature: GameFeature): void { this.flags |= (1 << feature); } disable(feature: GameFeature): void { this.flags &= ~(1 << feature); } getEnabledFeatures(): string[] { const enabled: string[] = []; for (const feature of Object.values(GameFeature)) { if (typeof feature === 'number' && this.isEnabled(feature)) { enabled.push(GameFeature[feature]); } } return enabled; } } const features = new FeatureManager(); features.enable(GameFeature.SHADOWS); features.enable(GameFeature.HDR); features.enable(GameFeature.RAY_TRACING); console.log(features.isEnabled(GameFeature.HDR)); // true console.log(features.isEnabled(GameFeature.VSYNC)); // false console.log(features.getEnabledFeatures()); // ['SHADOWS', 'HDR', 'RAY_TRACING']80:T53c,// Simplified IP header parsing (first byte contains version + IHL) // The first byte: VVVV IIII // V = Version (4 bits), I = Internet Header Length (4 bits) function parseIPHeaderByte(firstByte: number) { // Extract version (high 4 bits: positions 4-7) const version = (firstByte >> 4) & 0xF; // Shift right 4, mask low 4 bits // Extract IHL (low 4 bits: positions 0-3) const ihl = firstByte & 0xF; // Just mask low 4 bits return { version, ihl }; } // Example: IPv4 with typical 20-byte header // Binary: 0100 0101 = 0x45 = 69 const headerByte = 0x45; const { version, ihl } = parseIPHeaderByte(headerByte); console.log(`Version: ${version}`); // 4 (IPv4) console.log(`IHL: ${ihl}`); // 5 (5 × 4 = 20 bytes) // Checking individual flags in TCP header // TCP flags byte: CWR ECE URG ACK PSH RST SYN FIN function parseTCPFlags(flagsByte: number) { return { FIN: ((flagsByte >> 0) & 1) === 1, SYN: ((flagsByte >> 1) & 1) === 1, RST: ((flagsByte >> 2) & 1) === 1, PSH: ((flagsByte >> 3) & 1) === 1, ACK: ((flagsByte >> 4) & 1) === 1, URG: ((flagsByte >> 5) & 1) === 1, }; } // SYN-ACK packet: ACK + SYN = bit 4 + bit 1 = 16 + 2 = 18 const synAck = parseTCPFlags(18); console.log(synAck); // { FIN: false, SYN: true, ..., ACK: true, ... }81:T46e,// Representing {0, 1, 2, 3, 4} with bitmasks // Subset {1, 3, 4} = bit1 + bit3 + bit4 = 2 + 8 + 16 = 26 function isElementInSubset(subset: number, element: number): boolean { return ((subset >> element) & 1) === 1; } function subsetToArray(subset: number, universeSize: number): number[] { const result: number[] = []; for (let i = 0; i < universeSize; i++) { if ((subset >> i) & 1) { result.push(i); } } return result; } function arrayToSubset(elements: number[]): number { let subset = 0; for (const e of elements) { subset |= (1 << e); } return subset; } // Example const subset = 26; // {1, 3, 4} console.log(isElementInSubset(subset, 0)); // false console.log(isElementInSubset(subset, 1)); // true console.log(isElementInSubset(subset, 3)); // true console.log(isElementInSubset(subset, 4)); // true console.log(subsetToArray(subset, 5)); // [1, 3, 4] // Iterate through all subsets of {0, 1, 2} console.log("All subsets of {0, 1, 2}:"); for (let s = 0; s < (1 << 3); s++) { console.log(` ${s}: {${subsetToArray(s, 3).join(', ')}}`); }72:{"json":{"id":"seed_1274a38a5efe4b83d214c2b622b7b38e","slug":"checking-setting-clearing-toggling-bits","category":"Data Structures & Algorithms","topic":"Bit Manipulation","title":"Checking, Setting, Clearing, Toggling Bits","description":"Master the fundamental quartet of bit manipulation operations: checking, setting, clearing, and toggling individual bits. These precision operations form the bedrock of all advanced bit manipulation techniques and are essential for low-level programming, embedded systems, graphics programming, and algorithmic optimization.","difficulty":"INTERMEDIATE","estimatedMinutes":75,"pages":[{"id":"seed_1ede4063783c3706b7b22d6d807bcb18","title":"Check Bit at Position i","order":0,"content":[{"id":"opening-hook","title":"The Art of Bit Inspection","content":[{"data":{"content":"Before you can manipulate individual bits, you must first learn to **see** them. Checking whether a specific bit is set or clear is the most fundamental operation in bit manipulation—the equivalent of reading before writing, of observation before action.\n\nEvery advanced bit manipulation technique builds upon this foundation. Whether you're implementing permission systems, decoding protocol headers, optimizing set operations, or debugging low-level hardware interactions, the ability to query individual bit states is indispensable. This operation appears so frequently in systems programming that it becomes second nature to experienced engineers.\n\nIn this page, we'll develop a deep, intuitive understanding of how to check any bit at any position—with full clarity on the underlying mechanics, edge cases, and real-world applications."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand: (1) The fundamental formula for checking a bit at position i, (2) Why left-shifting 1 creates the perfect bit mask, (3) How the AND operation isolates exactly the bit we want, (4) The difference between returning boolean vs. returning the bit value, (5) Zero-indexed bit positions and their relationship to powers of two, and (6) Real-world applications in permission systems, flags, and protocol parsing.","variant":"info"},"type":"callout"}]},{"id":"problem-statement","title":"The Problem Statement","content":[{"data":{"content":"Let's formalize exactly what we're trying to accomplish:\n\n**Given:**\n- An integer `n` (our target number)\n- A position `i` (the bit position we want to inspect)\n\n**Goal:**\n- Determine whether the bit at position `i` in `n` is **set (1)** or **clear (0)**\n\n**Constraints and Conventions:**\n- Bit positions are **zero-indexed**, counting from the right (least significant bit)\n- Position 0 is the rightmost bit (LSB)\n- Position grows leftward toward the most significant bit (MSB)\n\nLet's visualize this with a concrete example. Consider the number **42** in 8-bit representation:"},"type":"text"},{"data":{"code":"Number: 42\nBinary: 0 0 1 0 1 0 1 0\n ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑\nPos: 7 6 5 4 3 2 1 0\n\nBit at position 0: 0 (clear)\nBit at position 1: 1 (set)\nBit at position 2: 0 (clear)\nBit at position 3: 1 (set)\nBit at position 4: 0 (clear)\nBit at position 5: 1 (set)\nBit at position 6: 0 (clear)\nBit at position 7: 0 (clear)\n\nVerification: 2¹ + 2³ + 2⁵ = 2 + 8 + 32 = 42 ✓","fileName":"bit_positions_visualization.txt","showLineNumbers":false},"type":"code"},{"data":{"content":"The question we must answer efficiently: **How can we extract information about just one of these bit positions without affecting or even needing to know the others?**\n\nThe naive approach would be to convert the number to a binary string, index into it, and read the character. But this is:\n- **Slow**: String conversion is O(log n) and involves memory allocation\n- **Wasteful**: We only need one bit but compute all of them\n- **Inelegant**: We have binary operators that work directly on bits\n\nThe elegant solution uses **bitwise operations** to query the exact bit we want in O(1) time with zero memory allocation."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"core-formula","title":"The Core Formula: (n >> i) & 1 or n & (1 << i)","content":[{"data":{"content":"There are two equivalent formulas for checking the bit at position `i`. Both are widely used, and understanding both gives you flexibility depending on context:\n\n**Formula 1: Shift the number right, then AND with 1**\n```\n(n >> i) & 1\n```\n\n**Formula 2: Create a mask by shifting 1 left, then AND with n**\n```\nn & (1 << i)\n```\n\nThese formulas produce slightly different results:\n- Formula 1 returns **0 or 1** (the actual bit value)\n- Formula 2 returns **0 or 2^i** (zero if clear, positional value if set)\n\nBoth tell you whether the bit is set, but Formula 1 normalizes the result to a boolean-like 0/1, while Formula 2 returns the \"weighted\" value of that bit position.\n\nLet's dissect each formula in detail."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Which Formula to Choose?","content":"Use (n >> i) & 1 when you need a clean 0 or 1 result (e.g., for boolean conditions, indexing arrays by bit values, or accumulating bit counts). Use n & (1 << i) when you only need to know if the bit is set and the actual value doesn't matter—the result is truthy (non-zero) if set, falsy (zero) if clear. In practice, both are equally fast and compile to similar machine code.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"formula-1-deep-dive","title":"Formula 1 Deep Dive: (n >> i) & 1","content":[{"data":{"content":"Let's trace through Formula 1 step by step with a concrete example.\n\n**Problem:** Check if bit 3 is set in the number 42.\n\n**Step 1: Start with n = 42**"},"type":"text"},{"data":{"code":"n = 42\nBinary: 0 0 1 0 1 0 1 0\n 7 6 5 4 3 2 1 0 ← bit positions\n\nWe want to check bit at position 3 (which has value 1)","fileName":"step1_original_number.txt","showLineNumbers":false},"type":"code"},{"data":{"content":"**Step 2: Right-shift n by i positions (n >> 3)**\n\nRight-shifting by 3 moves all bits 3 positions to the right. The rightmost 3 bits fall off, and zeros fill in from the left:"},"type":"text"},{"data":{"code":"Original: 0 0 1 0 1 0 1 0 (42)\n ↓ ↓ ↓ ↓ ↓\nAfter >> 3: 0 0 0 0 0 1 0 1 (5)\n\nThe bit that was at position 3 is now at position 0!\nThe rightmost 3 bits (0, 1, 0) were discarded.","fileName":"step2_right_shift.txt","showLineNumbers":false},"type":"code"},{"data":{"content":"**Step 3: AND with 1 to isolate the final bit ((n >> 3) & 1)**\n\nNow we AND the shifted result with 1. Since 1 in binary is `00000001`, this masks out everything except the least significant bit:"},"type":"text"},{"data":{"code":"n >> 3: 0 0 0 0 0 1 0 1 (5)\n & 0 0 0 0 0 0 0 1 (1)\n ─────────────────────\nResult: 0 0 0 0 0 0 0 1 (1)\n\nThe bit at position 3 was 1, so the result is 1.\nIf the bit had been 0, the result would be 0.","fileName":"step3_and_with_one.txt","showLineNumbers":false},"type":"code"},{"data":{"icon":"Info","title":"Why This Works","content":"Right-shifting brings our target bit to position 0 (the LSB). ANDing with 1 then isolates just that bit, giving us a clean 0 or 1 answer. It's like sliding a window over the number and then looking through a pinhole that shows only one bit.","variant":"note"},"type":"callout"},{"data":{"code":"$7a","fileName":"check_bit_formula1.ts","languages":[{"label":"TypeScript","value":"typescript"},{"label":"Python","value":"python"},{"label":"Java","value":"java"},{"label":"C++","value":"cpp"}]},"type":"code"}],"titleType":"number","titleNumber":3},{"id":"formula-2-deep-dive","title":"Formula 2 Deep Dive: n & (1 << i)","content":[{"data":{"content":"Formula 2 takes the opposite approach: instead of moving the bit to position 0, we create a **mask** that has a 1 only at position i, then AND that mask with the original number.\n\n**Problem:** Check if bit 3 is set in the number 42.\n\n**Step 1: Create the mask by shifting 1 left by i positions (1 << 3)**"},"type":"text"},{"data":{"code":"Original 1: 0 0 0 0 0 0 0 1\n ↓ ↓ ↓\nAfter << 3: 0 0 0 0 1 0 0 0 (8 = 2³)\n\nThis mask has exactly one bit set: at position 3.\nWe call this a \"single-bit mask\" or \"positional mask\".","fileName":"step1_create_mask.txt","showLineNumbers":false},"type":"code"},{"data":{"content":"**Step 2: AND the original number with the mask (42 & 8)**"},"type":"text"},{"data":{"code":"n = 42: 0 0 1 0 1 0 1 0\nmask = 8: 0 0 0 0 1 0 0 0\n & ─────────────────\nResult: 0 0 0 0 1 0 0 0 (8)\n\nSince bit 3 is set in n, the result equals the mask (8 = 2³).\nIf bit 3 were clear, the result would be 0.","fileName":"step2_and_with_mask.txt","showLineNumbers":false},"type":"code"},{"data":{"content":"**Comparing the results:**"},"type":"text"},{"data":{"rows":[["`(n >> i) & 1`","1","0"],["`n & (1 << i)`","2^i (positional value)","0"]],"headers":["Formula","Result when bit is SET","Result when bit is CLEAR"]},"type":"table"},{"data":{"content":"Both formulas give **zero** when the bit is clear, so they both work as boolean conditions. But Formula 2's non-zero result varies by position."},"type":"text"},{"data":{"code":"$7b","fileName":"check_bit_formula2.ts","languages":[{"label":"TypeScript","value":"typescript"},{"label":"Python","value":"python"},{"label":"Java","value":"java"},{"label":"C++","value":"cpp"}]},"type":"code"},{"data":{"icon":"AlertCircle","title":"Be Careful with Comparisons","content":"When using Formula 2, never compare the result directly to 1. The expression (n & (1 << i)) == 1 is WRONG for any position except i=0. Always compare to 0 (for falsy) or use != 0 (for truthy). Alternatively, use Formula 1 if you need the result to be exactly 0 or 1.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"understanding-bit-positions","title":"Understanding Bit Positions","content":[{"data":{"content":"A deep understanding of bit positions is essential for error-free bit manipulation. Let's cement this concept with a comprehensive reference.\n\n**The Position-Value Relationship:**\n\nEach bit position has an associated **positional value** equal to 2^position. When a bit is set at position i, it contributes 2^i to the number's total value:"},"type":"text"},{"data":{"rows":[["0","1","LSB (Least Significant Bit)"],["1","2",""],["2","4",""],["3","8",""],["4","16",""],["5","32",""],["6","64",""],["7","128","MSB (for 8-bit)"],["15","32,768","MSB (for 16-bit signed)"],["31","2,147,483,648","MSB (for 32-bit)"],["63","9.2 × 10^18","MSB (for 64-bit)"]],"headers":["Position","Value (2^i)","Name/Role"]},"type":"table"},{"data":{"code":"$7c","fileName":"bit_position_examples.ts","languages":[{"label":"TypeScript","value":"typescript"},{"label":"Python","value":"python"}]},"type":"code"},{"data":{"icon":"Sparkles","title":"Mental Model: Binary as a Sum","content":"Think of any integer as a sum of powers of two, where each bit position 'votes' on whether its power of two is included. Checking a bit is asking: 'Does this position vote yes (1) or no (0)?'","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"edge-cases-and-pitfalls","title":"Edge Cases and Pitfalls","content":[{"data":{"content":"Bit operations are low-level and unforgiving. Let's examine the edge cases and common pitfalls you need to handle correctly."},"type":"text"},{"data":{"items":["**Position out of bounds**: Checking bit 35 on a 32-bit integer is undefined behavior in C/C++. In JavaScript/Python, shifting by more than the bit width gives unexpected results.","**Negative numbers**: In two's complement, negative numbers have their MSB set. -1 in 32-bit is 0xFFFFFFFF (all bits set). Be careful when checking high-order bits.","**Zero**: All bits in zero are clear. Checking any position on 0 always returns 0.","**Position zero confusion**: Remember position 0 is the rightmost (LSB), not the leftmost. Off-by-one errors here cause subtle bugs.","**Signed vs unsigned shifts**: In some languages (Java), >> is arithmetic (sign-extending) while >>> is logical. Use >>> for unsigned behavior."],"title":{"icon":"AlertCircle","text":"Critical Edge Cases","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"code":"$7d","fileName":"edge_cases_demo.ts","languages":[{"label":"TypeScript","value":"typescript"},{"label":"Python","value":"python"}]},"type":"code"}],"titleType":"number","titleNumber":6},{"id":"real-world-applications","title":"Real-World Applications","content":[{"data":{"content":"The ability to check individual bits appears throughout systems programming and algorithm design. Let's explore several practical applications."},"type":"text"},{"data":{"tabs":[{"id":"permissions","label":"Permission Systems","content":[{"data":{"content":"Permission systems commonly represent capabilities as bits in an integer. Each bit position corresponds to a specific permission, and checking whether a user has a permission is a bit check."},"type":"text"},{"data":{"code":"$7e","fileName":"permissions.ts","showLineNumbers":true},"type":"code"}],"titleIcon":"Target"},{"id":"flags","label":"Feature Flags","content":[{"data":{"content":"Applications often use bit flags to track enabled features, configuration options, or state. A single integer can hold 32 or 64 boolean flags, making bit checking an efficient way to query configuration."},"type":"text"},{"data":{"code":"$7f","fileName":"feature_flags.ts","showLineNumbers":true},"type":"code"}],"titleIcon":"Zap"},{"id":"protocol","label":"Protocol Parsing","content":[{"data":{"content":"Network protocols and file formats often pack multiple pieces of information into individual bytes. Parsing such formats requires checking specific bits."},"type":"text"},{"data":{"code":"$80","fileName":"ip_header.ts","showLineNumbers":true},"type":"code"}],"titleIcon":"Code2"},{"id":"subsets","label":"Subset Representation","content":[{"data":{"content":"In competitive programming and combinatorics, sets are often represented as bitmasks. Each bit position corresponds to an element's presence or absence. Checking if an element is in a subset is a bit check."},"type":"text"},{"data":{"code":"$81","fileName":"subset_bitmask.ts","showLineNumbers":true},"type":"code"}],"titleIcon":"Sparkles"}],"defaultTab":"permissions"},"type":"tabs"}],"titleType":"number","titleNumber":7},{"id":"performance-considerations","title":"Performance Considerations","content":[{"data":{"content":"Bit operations are among the fastest operations a CPU can perform. Let's understand why and what guarantees you have."},"type":"text"},{"data":{"items":["**O(1) Time Complexity**: Checking a bit is always constant time regardless of the number's magnitude. CPUs have dedicated bit manipulation instructions.","**Single CPU Instruction**: On most architectures, (n >> i) & 1 compiles to a shift and AND—typically 2 instructions that execute in 1-2 clock cycles.","**No Memory Allocation**: Unlike string-based approaches, bit operations work entirely in CPU registers with zero heap allocation.","**Cache-Friendly**: Bit flags stored in a single integer are guaranteed to be loaded together, eliminating cache miss overhead vs. storing flags in separate variables.","**Parallelizable**: SIMD instructions can perform bit operations on multiple integers simultaneously for batch processing."],"title":{"icon":"Zap","text":"Performance Characteristics","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"Lightbulb","title":"When Bit Checking Shines","content":"Bit checking is especially valuable in hot paths where you're checking flags millions of times per second (game loops, packet processing, rendering pipelines). The difference between a bit check and a boolean property lookup might be negligible for one call, but across millions of iterations, it compounds significantly.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":8},{"id":"summary-and-key-takeaways","title":"Summary and Key Takeaways","content":[{"data":{"content":"You've now mastered the first and most fundamental bit manipulation operation: checking a bit at a specific position. Let's consolidate what we've learned."},"type":"text"},{"data":{"type":"ordered","items":["**Two Equivalent Formulas**: `(n >> i) & 1` returns 0 or 1; `n & (1 << i)` returns 0 or 2^i. Both work for boolean conditions.","**Zero-Indexed Positions**: Bit 0 is the rightmost (LSB). Position i has value 2^i when set.","**The Shift-and-Mask Pattern**: Right-shift brings the target bit to position 0, AND with 1 isolates it. Alternatively, create a mask and AND directly.","**Edge Cases**: Handle negative numbers carefully (sign bit), validate position bounds, and understand language-specific shift behaviors.","**Real Applications**: Permission systems, feature flags, protocol parsing, and subset representation all use bit checking extensively.","**O(1) Performance**: Bit checking is constant-time, uses no memory, and compiles to minimal machine instructions."],"title":{"icon":"CheckCircle","text":"Core Concepts Mastered","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that you can read bits, it's time to learn to write them. The next page covers **setting a bit at position i**—turning a 0 into a 1 without affecting any other bits. This is the logical complement to checking: once you can see, you can change."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now have a deep understanding of how to check whether any bit is set at any position in any integer. This foundational skill underlies all bit manipulation techniques. Next, we'll learn to modify bits by setting them to 1.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":9}],"isLocked":false},{"id":"seed_384c514783eaf1542a9d1073eeca562f","title":"Set Bit at Position i","order":1,"content":null,"isLocked":true},{"id":"seed_570221b69ff4bafcba6ca9d0a96f23b1","title":"Clear Bit at Position i","order":2,"content":null,"isLocked":true},{"id":"seed_a700abce97b54c102e60d41e9a3b4ab0","title":"Toggle Bit at Position i","order":3,"content":null,"isLocked":true},{"id":"seed_7ca19a300096bb1770281c73aeffc355","title":"Combining Operations","order":4,"content":null,"isLocked":true}]}}