Hamming Distance

                                            
class Solution {
public:
    int hammingDistance(int x, int y) {
        int xorResult = x ^ y;
        int count = 0;
        
        while (xorResult > 0) {
            count += xorResult & 1;
            xorResult >>= 1;
        }
        
        return count;
    }
};

                                            
class Solution {
    public int hammingDistance(int x, int y) {
        int xor = x ^ y;
        int count = 0;
        
        while (xor != 0) {
            count += xor & 1;
            xor >>= 1;
        }
        
        return count;
    }
}

                                            
class Solution(object):
    def hammingDistance(self, x, y):
        """
        :type x: int
        :type y: int
        :rtype: int
        """
        return bin(x ^ y).count('1')

                                            
int hammingDistance(int x, int y) {
    int xor_result = x ^ y;
    int count = 0;
    
    while (xor_result > 0) {
        if (xor_result & 1) {
            count++;
        }
        xor_result = xor_result >> 1;
    }
    
    return count;
}

                                            
function hammingDistance(x: number, y: number): number {
    let xor = x ^ y;
    let count = 0;
    while (xor !== 0) {
        count += xor & 1;
        xor = xor >> 1;
    }
    return count;
};

                                            
class Solution {
    /**
     * @param Integer $x
     * @param Integer $y
     * @return Integer
     */
    function hammingDistance($x, $y) {
        $xor = $x ^ $y;
        $count = 0;
        while ($xor > 0) {
            if ($xor & 1 == 1) {
                $count++;
            }
            $xor >>= 1;
        }
        
        return $count;
    }
}

                                            
class Solution {
    func hammingDistance(_ x: Int, _ y: Int) -> Int {
        var xor = x ^ y
        var count = 0
        while xor > 0 {
            count += xor & 1
            xor >>= 1
        }
        return count
    }
}

                                            
class Solution {
    fun hammingDistance(x: Int, y: Int): Int {
        var xor = x xor y
        var count = 0
        while (xor != 0) {
            count += xor and 1
            xor = xor ushr 1
        }
        return count
    }
}

                                            
class Solution {
  int hammingDistance(int x, int y) {
    int xor = x ^ y;
    int count = 0;
    while (xor != 0) {
      count += xor & 1;
      xor >>= 1;
    }
    return count;
  }
}

                                            
func hammingDistance(x int, y int) int {
    xor := x ^ y
    distance := 0
    for xor != 0 {
        if xor&1 == 1 {
            distance++
        }
        xor = xor >> 1
    }
    return distance
}

                                            
# @param {Integer} x
# @param {Integer} y
# @return {Integer}
def hamming_distance(x, y)
    (x ^ y).to_s(2).count("1")
end

                                            
object Solution {
    def hammingDistance(x: Int, y: Int): Int = {
        (x ^ y).toBinaryString.count(_ == '1')
    }
}

                                            
impl Solution {
    pub fn hamming_distance(x: i32, y: i32) -> i32 {
        (x ^ y).count_ones() as i32
    }
}

                                            
(define/contract (hamming-distance x y)
  (-> exact-integer? exact-integer? exact-integer?)
  (let loop ((count 0) (xor-result (bitwise-xor x y)))
    (cond
      [(zero? xor-result) count]
      [else (loop (+ count (bitwise-and xor-result 1)) (arithmetic-shift xor-result -1))])))

                                            
-spec hamming_distance(X :: integer(), Y :: integer()) -> integer().
hamming_distance(X, Y) ->
    count_bits_set(X bxor Y).

count_bits_set(0) ->
    0;
count_bits_set(N) ->
    1 + count_bits_set(N band (N - 1)).

To solve this coding challenge, we need to calculate the Hamming distance between two integers, defined as the number of positions at which the corresponding bits differ. This can be achieved by following a step-by-step approach.

Explanation

The Hamming distance between two integers can be computed by performing a bitwise XOR operation. The XOR operation (

^

) between two bits returns

1

if the bits are different and

0

if they are the same. When we apply the XOR operation on two integers, we obtain a binary number where each

1

represents a bit position where the two original integers had different bits. Counting the number of

1s

in this binary number gives us the Hamming distance. We can break down the solution into the following steps:

Perform the XOR operation on the two integers to obtain the differing bits.
Convert the result of the XOR operation into its binary representation.
Count the number of
1s

in the binary representation, which indicates the number of differing positions.

Let's now present the corresponding pseudocode with detailed comments.

Pseudocode

                                            
# Define a function to calculate the Hamming distance between two integers
function calculateHammingDistance(integer x, integer y):
# Perform XOR operation between x and y
integer xorResult = x XOR y

# Convert the result of XOR operation to its binary representation
string binaryRepresentation = convertToBinary(xorResult)

# Initialize a counter to count the number of differing bit positions (1s in binary representation)
integer differingBitCount = 0

# Iterate through each character in the binary representation
for each character in binaryRepresentation:
# If the character is '1', it indicates a differing bit position
if character is '1':
# Increment the counter by 1
differingBitCount += 1

# Return the count of differing bit positions as the Hamming distance
return differingBitCount

# Helper function to convert an integer to its binary representation as a string
function convertToBinary(integer num):
string binaryString = ""
# Edge case: if the number is zero, return "0"
if num is 0:
return "0"

# While the number is greater than zero
while num > 0:
# Prepend the remainder of division by 2 to the binary string
binaryString = (num % 2) + binaryString
# Divide the number by 2 for the next iteration
num = num / 2

# Return the constructed binary representation string
return binaryString

Step-by-Step Explanation/Detailed Steps in Pseudocode

Function Definition : Define a function
calculateHammingDistance

that takes two integer inputs,
x

and
y

.
XOR Operation : Perform the XOR operation on
x

and
y

and store the result in
xorResult

.
Binary Conversion : Convert
xorResult

to its binary representation using the helper function
convertToBinary

.
Initialize Counter : Initialize a counter
differingBitCount

to zero, which will keep track of differing bit positions.
Iterate Binary String : Loop through each character in the binary representation string:

If the character is '1', increment
differingBitCount

by one.

Return Result : After the loop, return
differingBitCount

as the Hamming distance.
Helper Function : Define the
convertToBinary

function:

Check if the number is zero and return "0" if true.
Generate the binary representation by repeatedly dividing the number by 2 and prepending the remainder to a string.
Return the binary string.

By following these detailed steps, we ensure that the Hamming distance is accurately computed based on the bitwise differences between the input integers.