Hamming Distance - Practice Coding Problems

Hamming Distance - Problem

Bit Manipulation Easy

The Hamming distance is a fundamental concept in computer science and information theory that measures how "different" two binary representations are. Given two integers x and y, you need to find the number of bit positions where these two numbers differ.

What you need to do:

Compare the binary representations of two integers bit by bit
Count how many positions have different bits (0 vs 1 or 1 vs 0)
Return this count as the Hamming distance

Example: If x = 1 (binary: 001) and y = 4 (binary: 100), they differ in 2 positions, so the Hamming distance is 2.

This problem is commonly used in error detection, data compression, and cryptography!

Input & Output

example_1.py — Basic Case

$ Input: x = 1, y = 4

› Output: 2

💡 Note: 1 in binary is 001, 4 in binary is 100. They differ at positions 0 and 2 (counting from right), so the Hamming distance is 2.

example_2.py — Same Numbers

$ Input: x = 3, y = 3

› Output: 0

💡 Note: Since both numbers are identical, their binary representations are the same. No positions differ, so the Hamming distance is 0.

example_3.py — Powers of 2

$ Input: x = 1, y = 8

› Output: 2

💡 Note: 1 is 0001 and 8 is 1000 in binary. They differ at the rightmost position (0 vs 1) and leftmost position (1 vs 0), giving a Hamming distance of 2.

Visualization

Tap to expand

Understanding the Visualization

Sequence Alignment

Align the two binary sequences (DNA strands) position by position

Mutation Detection

Use XOR as a 'mutation scanner' that highlights all positions with differences

Count Mutations

Count the total number of highlighted positions to get the mutation count

Key Takeaway

🎯 Key Insight: XOR operation naturally detects differences - it's like having a biological scanner that automatically highlights every position where DNA sequences differ, then we just count the highlights!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Using built-in popcount is constant time, or O(number of 1-bits) with Brian Kernighan's algorithm

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space

✓ Linear Space

Constraints

0 ≤ x, y ≤ 2³¹ - 1
Both integers are non-negative
Follow-up: Can you solve this in O(1) time?

Asked in

G Google 15 a Amazon 12 f Facebook 8 ⊞ Microsoft 6

The optimal solution uses the XOR operation to identify differing bits, then counts the 1s in the result. The key insight is that x ^ y produces 1s exactly where the bits differ, making this a one-liner in many languages with built-in popcount functions.

Common Approaches

Approach	Time	Space	Notes
✓ XOR + Bit Counting (Optimal)	O(1)	O(1)	Use XOR to find differing bits, then count the 1s

XOR + Bit Counting (Optimal) — Algorithm Steps

Compute XOR of the two numbers (x ^ y)
The result has 1s exactly where the original bits differed
Count the number of 1-bits in the XOR result
Return this count as the Hamming distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Numbers

x = 1 (binary: 001), y = 4 (binary: 100)

XOR Operation

1 ^ 4 = 001 ^ 100 = 101 (binary)

Count 1s

101 has two 1-bits, so Hamming distance = 2

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int hammingDistance(int x, int y) {
    // XOR gives us 1s where bits differ
    int xorResult = x ^ y;
    int count = 0;
    
    // Brian Kernighan's algorithm
    // Each iteration clears the rightmost 1-bit
    while (xorResult) {
        count++;
        xorResult &= xorResult - 1;
    }
    
    return count;
}

// Alternative: count bits manually
int hammingDistanceAlternative(int x, int y) {
    int xorResult = x ^ y;
    int count = 0;
    
    while (xorResult) {
        count += xorResult & 1;
        xorResult >>= 1;
    }
    
    return count;
}

int main() {
    int x, y;
    scanf("[%d,%d]", &x, &y);
    printf("%d\n", hammingDistance(x, y));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Using built-in popcount is constant time, or O(number of 1-bits) with Brian Kernighan's algorithm

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space

✓ Linear Space

Constraints

0 ≤ x, y ≤ 2³¹ - 1
Both integers are non-negative
Follow-up: Can you solve this in O(1) time?

89.0K Views

High Frequency

~8 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

XOR + Bit Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler