Total Hamming Distance In C++

In this guide, we will delve into the concept of total hamming distance in C++ through various illustrations. The disparity between two strings of the same length, typically binary strings, is evaluated using a matrix known as total hamming distance. It quantifies the discrepancy in bit values at corresponding positions in two strings within the realms of computer science and information theory. The cumulative distance between any two elements within a string is the total of the individual Hamming distances for each pair. The process of computing the total Hamming distance in C++ involves a step-by-step approach of tallying the occurrences of zeros and ones at each bit position across all strings. Subsequently, the total Hamming distance is derived by multiplying the counts of 1's and 0's at that particular position. Finally, the products obtained for each bit position are aggregated to determine the ultimate total Hamming distance.

Input arr = 7, 13, 3

Initially, we will transform these decimal values into binary format to determine the Hamming distance:

7 in binary: 0111

13 in binary: 1101

3 in binary: 0011

Now, we will compute the Hamming distance for each pair and then combine the results.

hamming(7, 13) = 3

hamming(13, 3) = 3

hamming(7, 3) = 2

Adding them together: 3 + 3 + 2 = 8

So, the total Hamming distance is 8.

Example 1:

Let's consider an example to demonstrate the calculation of Total Hamming Distance in the C++ programming language.

#include <iostream>
#include <vector>

int totalHammingDistance(const std::vector<int>& nums) {
    int totalDist = 0;
    int n = nums.size();

    for (int i = 0; i < 32; ++i) { // Assuming integers are 32-bit
        int bitCount = 0;
        for (int num : nums) {
            bitCount += (num >> i) & 1; // Counting set bits at i-th position
        }
        totalDist += bitCount * (n - bitCount); // Hamming distance at i-th position
    }

    return totalDist;
}

int main() {
    std::vector<int> nums = {4, 14, 2};
    int totalDistance = totalHammingDistance(nums);
    std::cout << "Total Hamming Distance: " << totalDistance << std::endl;
    return 0;
}

Output:

Total Hamming Distance: 6

Explanation:

• ✅ In this example, the totalHammingDistance function is still present in the program. It calculates the total Hamming distance for an integer vector.
• ✅ Iterating through each bit position (assuming 32-bit integers in this example) is similar to the previous example.
• ✅ Next, the number of set bits ( 0's ) for each bit position is counted.
• ✅ After that, the count of set bits and the count of unset bits ( 0's ) at that position are multiplied to get the total Hamming distance, which is then added.
• ✅ Ultimately, it yields the overall Hamming distance.

Example 2:

Let's consider another instance to demonstrate the Total Hamming Distance in C++.

#include <bits/stdc++.h>
using namespace std;

// Function to calculate Hamming distance
int calculateHammingDistance(int num1, int num2) {
    int distance = 0;
    int maxValue = max(num1, num2);
    
    while (maxValue) {
        int bit1 = num1 & 1;
        int bit2 = num2 & 1;
        
        if (bit1 != bit2)
            distance++;
        
        maxValue >>= 1;
        num1 >>= 1;
        num2 >>= 1;
    }
    
    return distance;
}

// Main function
int main() {
    int number1 = 6, number2 = 10; // Change the numbers here
    int hammingDistance = calculateHammingDistance(number1, number2);
    
    // Printing the result
    cout << "Hamming Distance between " << number1 << " and " << number2 << " is: " << hammingDistance << endl;

    return 0;
}

Output:

Hamming Distance between 6 and 10 is: 2

Example 3:

Let's consider another instance to demonstrate the Total Hamming Distance concept in C++.

#include <iostream>

// Function to calculate Hamming distance
int hammingDistance(int x, int y) {
    int distance = 0;
    
    // XOR operation to find differing bits
    int xorResult = x ^ y;
    
    // Counting set bits in the XOR result
    while (xorResult) {
        distance += xorResult & 1;
        xorResult >>= 1;
    }
    
    return distance;
}

// Main function
int main() {
    int n1 = 4, n2 = 8; // Change the numbers here
    int hdist = hammingDistance(n1, n2);
    std::cout << "Hamming Distance between " << n1 << " and " << n2 << " is: " << hdist << std::endl;
    return 0;
}

Output:

Hamming Distance between 4 and 8 is: 2

Conclusion:

In summary, determining the overall Hamming distance in C++ serves as a valuable technique for gauging the disparities between distinct binary sequences. This knowledge holds relevance across diverse domains such as coding principles, error identification, and genetic code analysis. Within C++, there exist multiple methodologies for computing the total Hamming distance by leveraging efficient bitwise manipulation strategies. C++ algorithms accurately quantify the total discrepancy amid collections of binary strings by systematically examining corresponding bits within the provided integers and tallying the varying bits. These implementations showcase the language's adeptness in handling bitwise computations, ensuring optimal computational performance even when dealing with extensive data collections. On the whole, C++ equips developers with robust mechanisms to assess and quantify the Hamming distance, facilitating problem-solving endeavors across a spectrum of industries.