You must implement a solution with a linear runtime complexity and use only constant extra space.

Example 1:

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

Example 2:

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

Example 3:

Input: nums = [1]
Output: 1

Constraints:

• 1 <= nums.length <= 3 * 104
• -3 * 104 <= nums[i] <= 3 * 104
• Each element in the array appears twice except for one element which appears only once.

Solution: XOR

single_number ^ a ^ b ^ c ^ … ^ a ^ b ^ c … = single_number

Time complexity: O(n)
Space complexity: O(1)

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

Related Problems

• 花花酱 LeetCode 137. Single Number II

The post 花花酱 LeetCode 136. Single Number appeared first on Huahua's Tech Road.

You must implement an algorithm that runs in O(n) time and uses constant extra space.

Example 1:

Input: nums = [1,2,0]
Output: 3

Example 2:

Input: nums = [3,4,-1,1]
Output: 2

Example 3:

Input: nums = [7,8,9,11,12]
Output: 1

Constraints:

• 1 <= nums.length <= 5 * 105
• -231 <= nums[i] <= 231 - 1

Solution: Marking

First pass, marking nums[i] to INT_MAX if nums[i] <= 0
Second pass, use a negative number to mark the presence of a number x at nums[x – 1]
Third pass, the first positive number is the missing index i, return i +1
If not found return n + 1.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int firstMissingPositive(vector<int>& nums) {
    const int n = nums.size();
    for (int& x : nums)
      if (x <= 0) x = INT_MAX;
    
    for (int x : nums) {
      x = abs(x);
      if (x >= 1 && x <= n && nums[x - 1] > 0)
        nums[x - 1] *= -1;
    }
    
    for (int i = 0; i < n; ++i)
      if (nums[i] > 0)
        return i + 1;
    
    return n + 1;
  }
};

The post 花花酱 LeetCode 41. First Missing Positive appeared first on Huahua's Tech Road.

Input:
[4,3,2,7,8,2,3,1]

Output:
[5,6]

Solution

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 128 ms (beats 93.70%)
class Solution {
public:
  vector<int> findDisappearedNumbers(vector<int>& nums) {
    for (size_t i = 0; i != nums.size(); ++i) {
      int index = abs(nums[i]) - 1;
      if (nums[index] > 0) nums[index] *= -1;
    }
    vector<int> ans;
    for (size_t i = 0; i != nums.size(); ++i)
      if (nums[i] > 0) ans.push_back(i + 1);
    return ans;
  }
};

The post 花花酱 LeetCode 448. Find All Numbers Disappeared in an Array appeared first on Huahua's Tech Road.

Problem:

Given an array containing n distinct numbers taken from 0, 1, 2, …, n, find the one that is missing from the array.

For example,
Given nums = [0, 1, 3] return 2.

Note:
Your algorithm should run in linear runtime complexity. Could you implement it using only constant extra space complexity?

Idea:

sum / xor

Solution:

// Author: Huahua
class Solution {
public:
    // Solution 1: Sum
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        int x = (0+n)*(n+1)/2 - accumulate(nums.begin(), nums.end(), 0);
        return x;
    }
    
    // Solution 2: XOR
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        int x = 0;
        for(int i=1;i<=n;++i)
            x = x ^ i ^ nums[i-1];
        return x;
    }
};

The post 花花酱 LeetCode 268. Missing Number appeared first on Huahua's Tech Road.