# Question

Formatted question description: https://leetcode.ca/all/268.html

Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.

Example 1:

Input: nums = [3,0,1]
Output: 2
Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.


Example 2:

Input: nums = [0,1]
Output: 2
Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.


Example 3:

Input: nums = [9,6,4,2,3,5,7,0,1]
Output: 8
Explanation: n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.


Constraints:

• n == nums.length
• 1 <= n <= 104
• 0 <= nums[i] <= n
• All the numbers of nums are unique.

Follow up: Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?

# Algorithm

Use the summation formula of the arithmetic sequence to find the sum of all the numbers between 0 and n, and then traverse the array to calculate the cumulative sum of the given numbers, and then do the subtraction, the difference is the missing number.

Or, use bit. The idea is that since there is one missing number between 0 and n, XOR the complete array between 0 and n, and then the same number will become 0, and the rest is missing number.

# Code

• 
public class Missing_Number {

class Solution {
public int missingNumber(int[] nums) {
int missing = nums.length; // @note: key, add highest number
for (int i = 0; i < nums.length; i++) {
missing ^= i ^ nums[i];
}
return missing;
}
}
}

############

class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
int ans = n;
for (int i = 0; i < n; ++i) {
ans ^= (i ^ nums[i]);
}
return ans;
}
}

• // OJ: https://leetcode.com/problems/missing-number/
// Time: O(N)
// Space: O(1)
class Solution {
public:
int missingNumber(vector<int>& A) {
return (1 + A.size()) * A.size() / 2 - accumulate(begin(A), end(A), 0);
}
};

• class Solution:
def missingNumber(self, nums: List[int]) -> int:
return reduce(xor, (i ^ v for i, v in enumerate(nums, 1)))

############

class Solution(object):
def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
n = len(nums)
return (n * (n + 1)) / 2 - sum(nums)


• func missingNumber(nums []int) (ans int) {
n := len(nums)
ans = n
for i, v := range nums {
ans ^= (i ^ v)
}
return
}

• /**
* @param {number[]} nums
* @return {number}
*/
var missingNumber = function (nums) {
const n = nums.length;
let ans = n;
for (let i = 0; i < n; ++i) {
ans ^= i ^ nums[i];
}
return ans;
};


• class Solution {
/**
* @param Integer[] $nums * @return Integer */ function missingNumber($nums) {
$n = count($nums);
$sumN = ($n + 1) * $n / 2; for ($i = 0; $i <$n; $i++) {$sumN -= $nums[$i];
}
return \$sumN;
}
}