Total Hamming Distance - Practice Coding Problems

Total Hamming Distance - Problem

Total Hamming Distance

The Hamming distance between two integers is the number of bit positions where the corresponding bits differ. For example, the Hamming distance between 4 (binary: 100) and 14 (binary: 1110) is 2 because they differ at the 2nd and 3rd bit positions.

Given an integer array nums, your task is to calculate the sum of Hamming distances between all pairs of integers in the array.

Goal: Return the total sum of Hamming distances for all possible pairs (i, j) where i < j.

Example: For [4, 14, 2], we calculate:
• Hamming distance between 4 and 14: 2
• Hamming distance between 4 and 2: 2
• Hamming distance between 14 and 2: 2
• Total: 2 + 2 + 2 = 6

Input & Output

example_1.py — Basic case

$ Input: [4, 14, 2]

› Output: 6

💡 Note: Hamming distances: hamming(4,14) + hamming(4,2) + hamming(14,2) = 2 + 2 + 2 = 6. Breaking it down: 4(100₂) vs 14(1110₂) differs in 2 positions, 4(100₂) vs 2(010₂) differs in 2 positions, 14(1110₂) vs 2(010₂) differs in 2 positions.

example_2.py — Single element

$ Input: [1]

› Output: 0

💡 Note: Only one number in array, so no pairs exist. Total Hamming distance is 0.

example_3.py — Identical numbers

$ Input: [5, 5, 5]

› Output: 0

💡 Note: All numbers are identical (101₂), so Hamming distance between any pair is 0. Total: 0 + 0 + 0 = 0.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
0 ≤ nums[i] ≤ 10⁹
Time limit: The solution must handle the maximum input size efficiently

Visualization

Tap to expand

Understanding the Visualization

Setup Checkpoints

Examine each of the 32 bit positions as security checkpoints

Count Access Patterns

For each checkpoint, count how many fingerprints show '1' (access granted) vs '0' (access denied)

Calculate Mismatches

At each checkpoint, mismatches occur between '1' and '0' groups. Total mismatches = count_1s × count_0s

Sum All Checkpoints

Add up mismatches from all 32 checkpoints to get total Hamming distance

Key Takeaway

🎯 Key Insight: By analyzing bit positions independently rather than comparing pairs, we transform an O(n²) problem into an O(n) solution using the mathematical relationship: total_distance = Σ(count_1s × count_0s) across all bit positions.

Asked in

f Facebook 42 G Google 38 ⊞ Microsoft 31 a Amazon 25

The optimal solution uses bit-wise counting instead of comparing all pairs. For each of the 32 bit positions, we count how many numbers have a 1-bit and how many have a 0-bit at that position. The contribution to the total Hamming distance from each bit position is (count_of_1s × count_of_0s). This reduces time complexity from O(n²) to O(n) and is the key insight that makes this problem solvable for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × k)	O(1)	Compare every pair of numbers and count bit differences
Bit-wise Counting (Optimal)	O(n × k)	O(1)	Count bits at each position and use mathematical formula

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all pairs (i, j) where i < j
For each pair, XOR the two numbers to get differing bits
Count the number of 1-bits in the XOR result (Hamming distance)
Add this distance to the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Pair

Choose two numbers from the array

XOR Operation

XOR the numbers to find differing bits

Count Bits

Count the 1-bits in XOR result

Add to Total

Add the count to running total

Code -

solution.c — C

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

int countBits(int n) {
    int count = 0;
    while (n) {
        count += n & 1;
        n >>= 1;
    }
    return count;
}

int totalHammingDistance(int* nums, int numsSize) {
    int total = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            total += countBits(nums[i] ^ nums[j]);
        }
    }
    
    return total;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[],\n");
    
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", totalHammingDistance(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

n² for all pairs, k for counting bits in each XOR result (k ≤ 32 for 32-bit integers)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

89.2K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler