Maximum Hamming Distances

Maximum Hamming Distances - Problem

Given an array nums and an integer m, with each element nums[i] satisfying 0 ≤ nums[i] < 2^m, return an array answer.

The answer array should be of the same length as nums, where each element answer[i] represents the maximum Hamming distance between nums[i] and any other element nums[j] in the array.

The Hamming distance between two binary integers is defined as the number of positions at which the corresponding bits differ (add leading zeroes if needed).

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,1,4,2], m = 3

› Output: [3,2,3,3]

💡 Note: For nums[0]=3 (011): max distance is with nums[2]=4 (100), differing in 3 positions. For nums[1]=1 (001): max distance is 2 (with nums[2]=4 or nums[3]=2). For nums[2]=4 (100): max distance is 3 (with nums[0]=3 or nums[3]=2). For nums[3]=2 (010): max distance is 3 (with nums[2]=4).

Example 2 — Small Array

$ Input: nums = [1,0], m = 1

› Output: [1,1]

💡 Note: 1 (binary: 1) and 0 (binary: 0) differ in 1 position, so maximum distance for both is 1.

Example 3 — Same Numbers

$ Input: nums = [2,2,2], m = 2

› Output: [0,0,0]

💡 Note: All numbers are identical, so Hamming distance between any pair is 0.

Constraints

2 ≤ nums.length ≤ 10⁴
1 ≤ m ≤ 20
0 ≤ nums[i] < 2^m

Visualization

Tap to expand

Asked in

G Google 45 f Meta 32 a Amazon 28 M Microsoft 23

The key insight is that Hamming distance is calculated by XORing two numbers and counting set bits. The brute force approach compares every pair to find maximum distance for each number. Time: O(n²×m), Space: O(1). Advanced optimizations can analyze bit patterns but still require pairwise comparisons for correctness.

Common Approaches

✓ Bit Manipulation Optimization

⏱️ Time: O(n² × m) Space: O(1)

For each number, we want to find another number in the array that has the maximum number of differing bits. We can analyze bit positions to determine which numbers are most different.

Brute Force

⏱️ Time: O(n² × m) Space: O(1)

For each element in the array, calculate the Hamming distance with every other element and keep track of the maximum. The Hamming distance is computed by XORing two numbers and counting the set bits.

Prefix Sum

⏱️ Time: N/A Space: N/A

Optimized Bit Analysis

⏱️ Time: O(n² × m) Space: O(m)

Instead of comparing every pair, we can analyze the distribution of bits at each position. For each number, we want to maximize differences by finding numbers with opposite bit patterns.

Bit Manipulation Optimization — Algorithm Steps

Step 1: For each number, we need to find its complement pattern
Step 2: Check which other numbers have bits that differ most
Step 3: Use XOR to quickly calculate bit differences

Visualization

Tap to expand

Step-by-Step Walkthrough

XOR Operation

XOR two numbers to find differing bit positions

Count Set Bits

Count 1s in the XOR result

Track Maximum

Keep the highest bit count

Code -

solution.c — C

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

int popcount(int n) {
    int count = 0;
    while (n) {
        count++;
        n &= (n - 1); // Brian Kernighan's algorithm
    }
    return count;
}

int* solution(int* nums, int numsSize, int m, int* returnSize) {
    *returnSize = numsSize;
    int* answer = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        int maxDist = 0;
        for (int j = 0; j < numsSize; j++) {
            if (i != j) {
                // Use XOR to find differing bits efficiently
                int diff = nums[i] ^ nums[j];
                // Count set bits using efficient algorithm
                int hammingDist = popcount(diff);
                if (hammingDist > maxDist) {
                    maxDist = hammingDist;
                }
            }
        }
        answer[i] = maxDist;
    }
    
    return answer;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int m;
    scanf("%d", &m);
    
    int returnSize;
    int* result = solution(nums, numsSize, m, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

Still need to compare each pair, XOR and bit counting takes O(m)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for bit operations

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Bit Manipulation Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler