Maximum Hamming Distances - Practice Coding Problems

Maximum Hamming Distances - Problem

Maximum Hamming Distances

You're given an array nums of integers and an integer m, where each element nums[i] satisfies 0 <= nums[i] < 2^m. Your task is to find the maximum Hamming distance for each element in the array.

The Hamming distance between two integers is the number of bit positions where they differ when represented as m-bit binary numbers (with leading zeros if necessary).

Return an array answer where answer[i] represents the maximum Hamming distance between nums[i] and any other element in the array.

Example: If nums = [4, 14, 2] and m = 4, then:
• 4 in binary: 0100
• 14 in binary: 1110
• 2 in binary: 0010

The maximum Hamming distance for 4 is 3 (compared to 14: they differ in 3 positions).

Input & Output

example_1.py — Basic Case

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

› Output: [3, 2, 3]

💡 Note: For 4 (0100): max distance is 3 with 14 (1110). For 14 (1110): max distance is 2 with 2 (0010). For 2 (0010): max distance is 3 with 14 (1110).

example_2.py — Duplicate Numbers

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

› Output: [2, 2, 2]

💡 Note: For 1 (01): max distance is 2 with 3 (11). For second 1 (01): also 2 with 3 (11). For 3 (11): max distance is 2 with either 1 (01).

example_3.py — Single Element

$ Input: nums = [5], m = 3

› Output: [0]

💡 Note: With only one element, there's no other element to compare with, so the maximum Hamming distance is 0.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ m ≤ 20
0 ≤ nums[i] < 2^m
Each number can be represented using exactly m bits

Visualization

Tap to expand

Key Insight: Use XOR to find bit differences efficiently, then optimize with frequency maps instead of checking all pairs!

Understanding the Visualization

Convert to Binary

Represent each number as an m-bit binary string

Compare Bit Positions

For each pair, count positions where bits differ

Find Maximum

For each number, identify the other number with maximum differences

Optimize with Frequency Map

Use smart complement generation instead of checking all pairs

Key Takeaway

🎯 Key Insight: The maximum Hamming distance problem can be solved efficiently by recognizing that we need to find numbers with the most bit differences. Instead of checking all pairs (O(n²)), we can use frequency counting and systematic complement generation to reduce complexity significantly.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25 Apple 18

The key insight is to avoid the O(n²) brute force approach by using frequency counting and smart bit manipulation. For each number, we systematically generate potential complements starting from the maximum possible distance (m) and work downward. The first complement we find that exists in our frequency map gives us the maximum Hamming distance. This approach leverages the fact that XOR operations directly show bit differences, and we can generate complements by strategically flipping specific bit positions.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Bit Manipulation (Optimal)	O(n × m × 2^k)	O(n)	Use frequency counting and bit manipulation to find maximum distances efficiently
Brute Force (Nested Loops)	O(n² × m)	O(1)	Compare every element with every other element to find maximum Hamming distance

Optimized Bit Manipulation (Optimal) — Algorithm Steps

Count frequency of each number in the array
For each unique number, try to construct its complement that would give maximum Hamming distance
The maximum possible distance is m (all bits different)
For each number, check if numbers exist that would give distances from m down to 0
Use bit manipulation to efficiently check possible complements

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build a frequency map of all numbers in the array

Generate Complements

For each number, systematically generate potential complements

Check Distances

Start from maximum possible distance and work downward

Find First Match

Return the first (maximum) distance where a complement exists

Code -

solution.c — C

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

typedef struct {
    int key;
    int value;
} MapEntry;

typedef struct {
    MapEntry* entries;
    int size;
    int capacity;
} HashMap;

HashMap* createMap(int capacity) {
    HashMap* map = malloc(sizeof(HashMap));
    map->entries = malloc(sizeof(MapEntry) * capacity);
    map->size = 0;
    map->capacity = capacity;
    return map;
}

int getValue(HashMap* map, int key) {
    for (int i = 0; i < map->size; i++) {
        if (map->entries[i].key == key) {
            return map->entries[i].value;
        }
    }
    return 0;
}

void setValue(HashMap* map, int key, int value) {
    for (int i = 0; i < map->size; i++) {
        if (map->entries[i].key == key) {
            map->entries[i].value = value;
            return;
        }
    }
    if (map->size < map->capacity) {
        map->entries[map->size].key = key;
        map->entries[map->size].value = value;
        map->size++;
    }
}

int hasKey(HashMap* map, int key) {
    return getValue(map, key) > 0;
}

int checkComplements(int originalNum, int currentNum, int bitsToFlip, int m, int pos, HashMap* freq) {
    if (pos == m) {
        if (bitsToFlip == 0 && hasKey(freq, currentNum)) {
            return currentNum != originalNum || getValue(freq, originalNum) > 1;
        }
        return 0;
    }
    
    if (checkComplements(originalNum, currentNum, bitsToFlip, m, pos + 1, freq)) {
        return 1;
    }
    
    if (bitsToFlip > 0) {
        return checkComplements(originalNum, currentNum ^ (1 << pos), bitsToFlip - 1, m, pos + 1, freq);
    }
    
    return 0;
}

int findMaxDistance(int num, int m, HashMap* freq) {
    for (int dist = m; dist >= 0; dist--) {
        if (checkComplements(num, num, dist, m, 0, freq)) {
            return dist;
        }
    }
    return 0;
}

int* maximumHammingDistances(int* nums, int numsSize, int m, int* returnSize) {
    *returnSize = numsSize;
    
    HashMap* freq = createMap(numsSize * 2);
    for (int i = 0; i < numsSize; i++) {
        setValue(freq, nums[i], getValue(freq, nums[i]) + 1);
    }
    
    int* result = malloc(sizeof(int) * numsSize);
    for (int i = 0; i < numsSize; i++) {
        result[i] = findMaxDistance(nums[i], m, freq);
    }
    
    free(freq->entries);
    free(freq);
    return result;
}

int main() {
    int nums[1000];
    int count = 0, m;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " ");
    }
    m = nums[--count];
    
    int returnSize;
    int* result = maximumHammingDistances(nums, count, 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 × 2^k)

For each element, we might need to check up to 2^k possible complements where k is much smaller than m in practice

✓ Linear Growth

Space Complexity

O(n)

We use a hash map to store frequency of numbers, which takes O(n) space in worst case

⚡ Linearithmic Space

56.4K Views

Medium-High Frequency

~25 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

Optimized Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler