数组中只出现一次的两个数字

class Solution:
    # 异或运算：相同数字为0，相异数字为1
    # 空间复杂度：O(1)  时间复杂度：O(n)
    def FindNumsAppearOnce(self , array: List[int]) -> List[int]:
        res = [0, 0]
        temp = 0
        for i in range(len(array)):
            temp ^= array[i]  # 0 ^ 数 = 数
        k = 1
        # 找到两个数不相同的第一位
        while k & temp == 0:
            k <<= 1  # 左移，右边补零
        for i in range(len(array)):
            # 遍历数组，对每个数分类
            if k & array[i] == 0:
                res[0] ^= array[i]
            else:
                res[1] ^= array[i]
        res.sort()
        return res

class Solution:
    # 哈希表
    # 空间复杂度：O(n)  时间复杂度：O(n)
    def FindNumsAppearOnce(self , array: List[int]) -> List[int]:
        mp = {}
        res = []
        for i in array:
            if i in mp:
                mp[i] += 1
            else:
                mp[i] = 1
        for i in mp:
            if mp[i] == 1:
                res.append(i)
        res.sort()
        return res

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param array int整型一维数组 
# @return int整型一维数组
#
class Solution:
    def FindNumsAppearOnce(self , array ):
        import collections
        array_count = collections.Counter(array)
        return [key for key,value in array_count.items() if value==1]
        # write code here

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型vector 
     * @return int整型vector
     */
    vector<int> FindNumsAppearOnce(vector<int>& array) {
        // write code here
        int temp=0;
        for(int i=0;i<array.size();i++){
            temp^=array[i];
        }
        int ll=1;
        while(1){
            if(temp&ll)break;
            ll<<=1;
        }
        int a=0,b=0;
        for(int i=0;i<array.size();i++){
            if(ll&array[i])a^=array[i];
            else b^=array[i];
        }
        if(a<=b){
            return {a,b};
        }else{
            return {b,a};
        }
    }
};

import java.util.*;

public class Solution {
    public int[] FindNumsAppearOnce (int[] array) {
        //    使用HashMap统计数值出现的次数
        //    key -- 数值，value -- 该数值出现的次数
        Map<Integer, Integer> red = new HashMap<>();
        //    ans用来保存结果值
        int[] ans = new int[2];
        //    index用来控制ans的索引，指向当前数值存储的位置
        int index = 0;
        //    扫描一次数组，进行统计
        for(int num : array)
            red.put(num, red.getOrDefault(num, 0) + 1);
        //    扫描一次HashMap，寻找之出现一次的数值并记录
        //    当index等于2，说明已经找到了这两个数值，不必继续扫表
        for(Map.Entry<Integer, Integer> entry : red.entrySet()){
            if(entry.getValue() == 1)
                ans[index ++] = entry.getKey();
            if(index == 2)
                break;
        }
        //    结果需要非降序排列，因此这里做了个排序
        Arrays.sort(ans);
        return ans;
    }
}

public class Solution {
    public int[] FindNumsAppearOnce (int[] array) {
        // 用以提取异或结果
        Function<IntPredicate, Integer> getXor = (intPredicate) -> Arrays.stream(array)
                .filter(intPredicate).reduce((a, b) -> a ^ b).getAsInt();
         
        // 提取全量数据的异或结果
        int xorResult = getXor.apply(a -> true);
        // 取全量异或结果的末位
        int lastBit = xorResult ^ (xorResult & (xorResult - 1));
         
        int[] result = new int[2];
        // 按数据与全量异或结果的末位是否相等，进行二次异或
        result[0] = getXor.apply(a -> (a & lastBit) == lastBit);
        result[1] = getXor.apply(a -> (a & lastBit) == 0);
        Arrays.sort(result);
        return result;
    }
}

from collections import Counter
class Solution:
    def FindNumsAppearOnce(self , nums: List[int]) -> List[int]:
        counter = Counter(nums)
        return sorted([counter.most_common()[-2:][0][0], counter.most_common()[-2:][1][0]])

public int[] FindNumsAppearOnce (int[] nums) {
        // write code here
        int[] ret = new int[2];
        if (nums.length == 0) {
            return null;
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.remove(nums[i]);
                continue;
            }
            map.put(nums[i], 1);
        }
        int i = 0;
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            ret[i++] = entry.getKey();
        }
        return ret;
    }

#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型vector
     */
    vector<int> FindNumsAppearOnce(vector<int>& nums) {
        // write code here
        int temp = 0;
        for(int v : nums){
            temp ^= v;
        }
        int mask=temp&-temp;
        int a=0;
        int b=0;
        for(int v : nums){
            if((v&mask)==0){
                a ^= v;
            }else{
                b ^= v;
            }
        }
        if(a>b){
            a ^= b;
            b ^= a;
            a ^= b;
        }
        return vector<int>{a, b};
    }
};

public int[] FindNumsAppearOnce (int[] array) {
        // write code here
        Map<Integer, Integer> map = new LinkedHashMap<>();
        for (int arr : array) {
            if (map.containsKey(arr)) {
                map.remove(arr);
            } else {
                map.put(arr, arr);
            }
        }
        int[] ints = map.entrySet().stream().mapToInt(e -> e.getKey()).sorted().toArray();
        return  ints;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] array) {
        int ans=0;
        for(int i=0;i<array.length;i++){
            ans=ans^array[i];
        }
        int h=1;
        while((h&ans)==0){
            h<<=1;
        }
        int group1=0;
        int group2=0;
        for(int i=0;i<array.length;i++){
            if((h&array[i])==0){
                group1=group1^array[i];
            }else{
                group2=group2^array[i];
            }
        }
        
        return new int[]{Math.min(group1,group2),Math.max(group1,group2)};

    }
}

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型vector 
     * @return int整型vector
     */
    vector<int> FindNumsAppearOnce(vector<int>& array) {
        // write code here
        set<int> s;

        for(const auto num : array)
        {
            if(s.count(num) == 0)
                s.insert(num);
            else 
                s.erase(num);
        }
        return vector<int>{*s.begin(),*(++s.begin())};
    }
};