### Problem statement

Given an array `nums`

of `n`

integers where `nums[i]`

is in the range `[1, n]`

, return an array of all the integers in the range `[1, n]`

that do not appear in `nums`

.

#### Example 1

```
Input: nums = [4,3,2,7,8,2,3,1]
Output: [5,6]
```

#### Example 2

```
Input: nums = [1,1]
Output: [2]
```

#### Constraints

`n == nums.length`

.`1 <= n <= 10^5`

.`1 <= nums[i] <= n`

.

#### Follow up

Could you do it without extra space and in `O(n)`

runtime? You may assume the returned list does not count as extra space.

### Solution 1: Marking the appearances

You can use a vector of `bool`

to mark which value appeared in the array.

#### Code

```
#include <vector>
#include <iostream>
using namespace std;
vector<int> findDisappearedNumbers(vector<int>& nums) {
vector<bool> exist(nums.size() + 1, false);
for (auto& i : nums) {
exist[i] = true;
}
vector<int> result;
for (int i = 1; i <= nums.size(); i++) {
if (!exist[i]) {
result.push_back(i);
}
}
return result;
}
void print(vector<int>& nums) {
cout << "[";
for (auto& n : nums) {
cout << n << ",";
}
cout << "]\n";
}
int main() {
vector<int> nums = {4,3,2,7,8,2,3,1};
auto result = findDisappearedNumbers(nums);
print(result);
nums = {1,1};
result = findDisappearedNumbers(nums);
print(result);
}
```

```
Output:
[5,6,]
[2,]
```

#### Complexity

Runtime:

`O(n)`

, where`n = nums.length`

.Extra space: much less than

`O(n)`

.`vector<bool>`

is optimized for space efficiency; it stores single bits.

### Solution 2: Follow up

You could use the indices of the array `nums`

to mark the appearances of its elements because they are identical (`[1, n]`

vs. `[0, n-1]`

).

One way of marking the appearance of an index `j`

is making the element `nums[j]`

to be negative. Then the indices `j`

's whose `nums[j]`

are unchanged (still positive) are the ones that do not appear in `nums`

.

#### Code

```
#include <vector>
#include <iostream>
using namespace std;
vector<int> findDisappearedNumbers(vector<int>& nums) {
int j;
for (int i{0}; i < nums.size(); i++) {
j = abs(nums[i]);
nums[j - 1] = -abs(nums[j - 1]);
}
vector<int> result;
for (int i{1}; i <= nums.size(); i++) {
if (nums[i - 1] > 0) {
result.push_back(i);
}
}
return result;
}
void print(vector<int>& nums) {
cout << "[";
for (auto& n : nums) {
cout << n << ",";
}
cout << "]\n";
}
int main() {
vector<int> nums = {4,3,2,7,8,2,3,1};
auto result = findDisappearedNumbers(nums);
print(result);
nums = {1,1};
result = findDisappearedNumbers(nums);
print(result);
}
```

```
Output:
[5,6,]
[2,]
```

#### Complexity

Runtime:

`O(N)`

, where`N = nums.length`

.Extra space:

`O(1)`

(the returned list does not count as extra space).

### Conclusion

Solution 2 helps to avoid allocating extra memory but it is not straightforward to understand.

Though Solution 1 requires some extra space, that memory is not much since

`vector<bool>`

is optimized for space efficiency. Moreover, it is easier to understand than Solution 2.

*What is your approach? The problem was picked from* *leetcode.com**, where you can submit your solution in any programming language and check the performance.*

*Thanks for reading. Feel free to share your thought about my content and check out my* *FREE book “10 Classic Coding Challenges”**.*