## DEV Community # Solution: Missing Number

This is part of a series of Leetcode solution explanations (index). If you liked this solution or found it useful, please like this post and/or upvote my solution post on Leetcode's forums.

#### Description:

(Jump to: Solution Idea || Code: JavaScript | Python | Java | C++)

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.

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

#### Examples:

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.
Example 4:
Input: nums = 
Output: 1
Explanation: n = 1 since there is 1 number, so all numbers are in the range [0,1]. 1 is the missing number in the range since it does not appear in nums.

#### Constraints:

• `n == nums.length`
• `1 <= n <= 10^4`
• `0 <= nums[i] <= n`
• All the numbers of `nums` are unique.

#### Idea:

(Jump to: Problem Description || Code: JavaScript | Python | Java | C++)

The sum of the numbers from 1 to N is the Nth triangular number, defined as N * (N + 1) / 2. It stands to reason, then, that we can simply find the difference between the Nth triangular number and the sum of nums, which should be our missing number.

#### Javascript Code:

``````const missingNumber = nums =>
nums.length * (nums.length + 1) / 2 - nums.reduce((a,c) => a + c)
``````

#### Python Code:

``````class Solution:
def missingNumber(self, nums: List[int]) -> int:
return len(nums) * (len(nums) + 1) // 2 - sum(nums)
``````

#### Java Code:

``````class Solution {
public int missingNumber(int[] nums) {
return nums.length * (nums.length + 1) / 2 - Arrays.stream(nums).sum();
}
}
``````

#### C++ Code:

``````class Solution {
public:
int missingNumber(vector<int>& nums) {
return nums.size() * (nums.size() + 1) / 2 - accumulate(nums.begin(), nums.end(), 0);
}
};
`````` Nithish Kumar

Hey sean , Thank you for sharing this problem. I really like it. After seeing the problem des. , i came up with this solution. Is this a better approach?

const findMissing = arr => {
const orginal = Array.from({length:arr.length+1} , (_,i) => i);
return orginal.filter(v => arr.indexOf(v) === -1)
}  