Binary Coder Challenges: Practice Problems to Sharpen Your SkillsBinary is the language of computers — a compact, powerful system built from just two symbols: 0 and 1. For anyone learning low-level programming, embedded systems, cryptography, data compression, or computer architecture, fluency with binary operations and representations is essential. This article offers a structured set of practice problems, explanations, and strategies to help you become a stronger “binary coder.” Problems range from beginner to advanced, with concrete examples and step-by-step solutions so you can learn by doing.
Why practice binary coding?
Working with binary strengthens understanding of:
- Fundamental data representation (integers, signed numbers, floating point, character encodings).
- Bitwise operations (AND, OR, XOR, NOT, shifts) used extensively in performance-critical code.
- Low-level algorithms (population counts, bit masks, parity checks).
- Systems thinking (how higher-level constructs map to hardware).
Practice helps convert abstract rules into intuitive tools. Below are progressive challenges grouped by topic, each with hints and full solutions so you can attempt them first and check your reasoning afterwards.
Section 1 — Basics: representations and conversions
Problem 1.1 — Binary to decimal (easy)
Convert the binary number 1101101₂ to decimal.
Hint: Multiply each bit by 2^position and sum.
Solution:
1101101₂ = 1·2^6 + 1·2^5 + 0·2^4 + 1·2^3 + 1·2^2 + 0·2^1 + 1·2^0
= 64 + 32 + 0 + 8 + 4 + 0 + 1 = 109.
Problem 1.2 — Decimal to binary (easy)
Convert decimal 213 to binary.
Hint: Repeated division by 2 or subtract largest powers of two.
Solution (division method):
213 ÷ 2 = 106 r1
106 ÷ 2 = 53 r0
53 ÷ 2 = 26 r1
26 ÷ 2 = 13 r0
13 ÷ 2 = 6 r1
6 ÷ 2 = 3 r0
3 ÷ 2 = 1 r1
1 ÷ 2 = 0 r1
Read remainders reverse: 11010101₂ = 213.
Problem 1.3 — Fixed-width representation (medium)
Represent −18 in 8-bit two’s complement.
Hint: Write +18 in binary, invert, add 1.
Solution:
18 = 00010010₂. One’s complement: 11101101. Add 1 → 11101110₂ = −18 in 8-bit two’s complement.
Section 2 — Bitwise operations and tricks
Problem 2.1 — Swap two integers using XOR (easy/algorithmic)
Given two integer variables a and b, swap their values without using a temporary variable using XOR operations. Show the three-step sequence and explain why it works.
Solution (pseudocode):
a = a ^ b b = a ^ b // now b = (a ^ b) ^ b = a a = a ^ b // now a = (a ^ b) ^ a(original b) = b(original) Why it works: XOR is its own inverse and cancels duplicate bits, letting the values be interchanged using only bitwise symmetry.
Problem 2.2 — Clear lowest set bit (medium)
Write an expression that clears the lowest set (1) bit of an integer x, leaving other bits unchanged.
Hint: Use x & (x – 1).
Solution: x & (x – 1) clears the least significant 1. Example: x = 0b101100 → x-1 = 0b101011 → x & (x-1) = 101000.
Problem 2.3 — Isolate lowest set bit (medium)
Return a value with only the least significant 1-bit of x set (all other bits 0).
Hint: Use x & (-x) with two’s complement.
Solution: value = x & (-x). Example: x = 0b101100 → -x = two’s complement → result 0b000100.
Section 3 — Counting and masks
Problem 3.1 — Population count (Hamming weight) (medium)
Write an efficient algorithm to count the number of set bits in a 32-bit unsigned integer. Provide a simple loop and a faster parallel approach.
Simple loop:
count = 0 while x != 0: count += x & 1 x >>= 1 Faster (Brian Kernighan’s):
count = 0 while x != 0: x = x & (x - 1) // clears lowest set bit count += 1 Parallel (bit-twiddling, 32-bit):
x = x - ((x >> 1) & 0x55555555) x = (x & 0x33333333) + ((x >> 2) & 0x33333333) x = (x + (x >> 4)) & 0x0F0F0F0F x = x + (x >> 8) x = x + (x >> 16) count = x & 0x0000003F Problem 3.2 — Create mask of n lower bits set (easy)
Create a value with the lowest n bits set to 1 (for 0 <= n <= word size).
Solution: (1 << n) – 1 (guard for n == word size).
Section 4 — Endianness, bytes, and packing
Problem 4.1 — Reverse bytes in 32-bit word (medium)
Given 0x12345678, produce 0x78563412. Provide a bitwise formula.
Solution (C-like):
x = ((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) | ((x & 0xFF000000) >> 24); Problem 4.2 — Check system endianness (easy)
How can a program detect little vs big endian?
Solution: Store a multi-byte integer, view its first byte. Example:
int x = 1; char *p = (char*)&x; if (p[0] == 1) -> little-endian else big-endian Section 5 — Signed integers and overflow
Problem 5.1 — Detect overflow on signed addition (medium)
Given signed integers a and b, how to detect overflow when computing a + b?
Hint: Overflow happens when a and b have same sign and result has different sign.
Solution (C-like):
int sum = a + b; bool overflow = ((a ^ sum) & (b ^ sum)) < 0; Alternate: check if (a > 0 && b > 0 && sum < 0) || (a < 0 && b < 0 && sum >= 0).
Problem 5.2 — Convert between signed magnitude, one’s complement, and two’s complement (advanced)
Given 8-bit signed-magnitude 1 0001101 (sign bit followed by magnitude 0001101), convert to two’s complement.
Solution sketch: If sign=0 => same. If sign=1 => represent negative magnitude: two’s complement = -magnitude in two’s complement. Example sign=1 magnitude 0001101 (13) → two’s complement for −13 in 8-bit: 11110011.
Section 6 — Floating point and binary fractions
Problem 6.1 — Binary fraction to decimal (easy)
Convert 0.1011₂ to decimal.
Solution: 0.1011₂ = 1·2^−1 + 0·2^−2 + 1·2^−3 + 1·2^−4 = 0.5 + 0 + 0.125 + 0.0625 = 0.6875.
Problem 6.2 — Build IEEE-754 single-precision representation (advanced)
Encode decimal −6.75 into IEEE-754 32-bit.
Solution (steps):
- Sign = 1.
- 6.75 in binary = 110.11₂ = 1.1011 × 2^2. Exponent = 2.
- Exponent field = 2 + 127 = 129 = 10000001₂.
- Mantissa (fraction) = 1011000… (fill to 23 bits): 10110000000000000000000.
Result bits: 1 10000001 10110000000000000000000 → Hex 0xC0D80000.
Section 7 — Coding challenges (put your skills to the test)
Below are progressive programming-style problems. Try to implement them in your preferred language.
Challenge A — Bit-reversal permutation (medium)
Given an n-bit integer, reverse the bit order (e.g., for 8-bit input 0b00011010 → 0b01011000). Provide an O(log n) sequence of masks and shifts.
Solution outline (32-bit example):
x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1) x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2) x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4) x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8) x = (x >> 16) | (x << 16) Challenge B — Next higher integer with same number of 1 bits (medium/hard)
Given x, find the next integer > x with the same population count. Known as “next permutation” of bits.
Solution (C-like):
unsigned next = 0; unsigned c = x; unsigned smallest = c & -c; unsigned ripple = c + smallest; unsigned ones = c ^ ripple; ones = (ones >> 2) / smallest; next = ripple | ones; Challenge C — Gray code conversion (easy/medium)
Convert binary to Gray code and back.
Binary to Gray: g = b ^ (b >> 1)
Gray to binary (iterative):
b = g while (g >>= 1) != 0: b ^= g Challenge D — Fast modulo for power-of-two divisor (easy)
Compute x % 2^n using bit operations.
Solution: x & ((1 << n) – 1)
Challenge E — Implement a bloom filter bit-array operations (advanced)
Design insert and membership test operations focusing on bit-array management, modulo hashing by bit masks, and concurrent updates.
Hints: Use atomic bitwise OR/AND for concurrency; wrap bit operations in functions that compute word index and bit offset; pick independent hash functions.
Section 8 — Real-world exercises and projects
- Build a small command-line tool that prints binary, hex, and decimal representations for signed/unsigned values and supports two’s complement and floating-point views.
- Implement a bitset class supporting rank/select operations (useful in succinct data structures).
- Create micro-benchmarks comparing popcount implementations across compilers and architectures.
- Implement an encoder/decoder for a simple custom binary protocol (pack fields into bitfields, analyze padding and alignment).
Section 9 — Common pitfalls and debugging tips
- Misunderstanding signed vs unsigned conversions — explicit casts matter.
- Undefined behavior on overflowing signed integers in C/C++ — prefer unsigned for bit-twiddling.
- Endianness vs bit order confusion — byte order affects multi-byte values; bit-reversal is independent of CPU endian.
- Watch for shifts equal to the word size; behavior may be undefined in C, so guard those cases.
Section 10 — Summary practice roadmap
- Week 1: Conversions, fixed-width representations, basic bit ops.
- Week 2: Masks, popcount tricks, byte manipulation.
- Week 3: Two’s complement edge cases, overflow detection, Gray codes.
- Week 4: Implement small projects (binary viewer, bitset), and tackle advanced challenges (next-permutation, Bloom filter).
If you want, I can:
- provide runnable code examples in a language you choose (C, C++, Python, Rust, Java),
- generate a printable worksheet with problems only (no solutions), or
- create test cases and expected outputs for automatic grading.
Leave a Reply