Single Number

                                            
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int result = 0;
        for (int num : nums) {
            result ^= num;
        }
        return result;
    }
};

                                            
class Solution {
    public int singleNumber(int[] nums) {
        int result = 0;
        for (int num : nums) {
            result ^= num;
        }
        return result;
    }
}

                                            
class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        result = 0
        for num in nums:
            result ^= num
        return result

                                            
int singleNumber(int* nums, int numsSize) {
    int result = 0;
    for (int i = 0; i < numsSize; i++) {
        result ^= nums[i];
    }
    return result;
}

                                            
public class Solution {
    public int SingleNumber(int[] nums) {
        int result = 0;
        foreach (int num in nums) {
            result ^= num;
        }
        return result;
    }
}

                                            
/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function(nums) {
    let result = 0;
    for (let num of nums) {
        result ^= num;
    }
    return result;
};

                                            
function singleNumber(nums: number[]): number {
    let result = 0;
    
    for (let num of nums) {
        result ^= num;
    }
    
    return result;
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function singleNumber($nums) {
        $single = 0;
        foreach ($nums as $num) {
            $single ^= $num;
        }
        return $single;
    }
}

                                            
class Solution {
    func singleNumber(_ nums: [Int]) -> Int {
        var result = 0
        for num in nums {
            result ^= num
        }
        return result
    }
}

                                            
class Solution {
    fun singleNumber(nums: IntArray): Int {
        var result = 0
        for (num in nums) {
            result = result xor num
        }
        return result
    }
}

                                            
class Solution {
  int singleNumber(List<int> nums) {
    int result = 0;
    
    for (int num in nums) {
      result ^= num;
    }
    
    return result;
  }
}

                                            
func singleNumber(nums []int) int {
    result := 0
    for _, num := range nums {
        result ^= num
    }
    return result
}

                                            
# @param {Integer[]} nums
# @return {Integer}
def single_number(nums)
    nums.reduce(:^)
end

                                            
object Solution {
    def singleNumber(nums: Array[Int]): Int = {
        nums.reduce((num1, num2) => num1 ^ num2)
    }
}

                                            
impl Solution {
    pub fn single_number(nums: Vec<i32>) -> i32 {
        let mut result = 0;
        
        for num in nums {
            result ^= num;
        }
        
        result
    }
}

                                            
(define/contract (single-number nums)
  (-> (listof exact-integer?) exact-integer?)
  (foldl (λ (num res) (bitwise-xor res num)) 0 nums))

                                            
-spec single_number(Nums :: [integer()]) -> integer().
single_number(Nums) ->
    lists:foldl(fun(X, Acc) -> X bxor Acc end, 0, Nums).

To solve this coding challenge, the main task is to find the single number in an array where every other element appears exactly twice. The solution must have a linear time complexity and use only constant extra space. This challenge can be efficiently solved using the XOR bitwise operation.

Explanation

The XOR (exclusive or) operation has some useful properties:

\( n \oplus n = 0 \) for any integer \( n \).
\( n \oplus 0 = n \) for any integer \( n \).
\( a \oplus b = b \oplus a \) (commutative property).
\( (a \oplus b) \oplus c = a \oplus (b \oplus c) \) (associative property).

Using these properties, if we XOR all numbers in the array, the numbers that appear twice will cancel each other out and result in zero, effectively leaving the only single number in the array. Here's an extremely detailed, step-by-step explanation:

Initialize a result variable to 0 : This will hold the result of the XOR operations.
Iterate through each number in the array : During each iteration, XOR the current number with the result variable and update the result variable with the outcome.
Return the result : After processing all numbers, the result variable will contain the single number.

Detailed Steps in Pseudocode

Initialization :

Begin by initializing a variable named
single_number_result

to 0. This will be used to accumulate the XOR results.

Iteration and XOR Operation :

Loop through each element in the input array, which we call
number_list

.
Within the loop, XOR the
single_number_result

with the current element and assign the result back to
single_number_result

.

Return the final result :

After the loop completes, the
single_number_result

variable will contain the unique element, which only appeared once in the array.

Here is the pseudocode with comments:

                                            
# Initialize result variable to store XOR outcome
single_number_result = 0

# Loop through each element in the input array called `number_list`
for each element in number_list:
    # XOR the current element with the result variable
    single_number_result = single_number_result XOR(element)

# The result after all XOR operations will be the single number
return single_number_result

In detail:

single_number_result = 0

initializes the result to zero.
The
for each element in number_list

loop iterates through every item in the array.
Inside the loop,
single_number_result = single_number_result XOR(element)

updates the result using the XOR operation.
Finally,
return single_number_result

returns the element that appears only once.

By following the above steps, you ensure that every duplicate pair of elements cancels out, leaving just the single unique number. This algorithm runs in linear time, \(O(n)\), and uses constant space, \(O(1)\), meeting the challenge's requirements.