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

这里主要就是用到了按位异或的性质，按位异或的一个重要性质就是，如果一组数中每一个元素出现的此时都是偶数，只有一个是奇数，那么只需要把这个数组中所有的数据都按位异或起来，最终剩下的数就是那个数，这是由于按位异或自身的原理所产出的算法原理

class Solution 
{
public:
    vector<int> singleNumber(vector<int>& nums) 
    {
        int ret=0;
        for(auto ch :nums)
        {
            ret=ret^ch;
        }
        int lsb= ret==INT_MIN? ret:(ret&(-ret));
        int type1=0,type2=0;
        for(auto num:nums)
        {
            if(num &lsb)
            {
                type1 ^=num;
            }
            else
            {
                type2 ^=num;
            }
        }
        return {type1,type2};
    }
};

这个题本身就是基于上面题目的原理产生的，按位异或可以找到一组数中唯一出现的数，那么在这个题中却有两个数都唯一出现的，那么首先要做的就是进行分类，让这两个数归类到两个类中，以此能让其分开

那么分类的原理就是让所有数都按位异或，最终得到的就是这两个数按位异或的结果，那现在要做的就是要找到这两个数的不同点，然后把这两个数分开，具体方法就是用到了前面总结的找到不一样的1，令ret&(-ret)，这样就可以找到二进制中最右侧的1，而这个1就是区分这两组数据的唯一标准

那下来做的就是把nums中的元素都和前面ret&(-ret)的结果按位异或，由于最右侧1的不同，就会天然的把数组里面的数据分成两组，而这两个不同的数据也会被分到两组中，这样找到了唯二的数据

这里解决方法很多，可以用哈希表，排序，等等，这里采用是位图的思想，同时利用鸽巢原理进行一定程度的优化

class Solution 
{
public:
    bool isUnique(string astr) 
    {
        if(astr.size()>26)
        {
            return false;
        }

        int bitmap=0;
        for(auto ch : astr)
        {
            if((bitmap>>(ch-'a'))&1==1)
            {
                return false;
            }
            else
            {
                bitmap=bitmap | (1<<(ch-'a'));
            }
        }
        return true;
    }
};

此题需要用到按位与和按位异或的性质，按位与的性质除了相同为0，相异为1外，还有一个性质是无进位相加，因此可以利用这个性质解题，先用按位异或进行无进位相加，再求出进位是多少，再继续循环相加即可

而进位其实就是直接用的性质是两个数的二进制位都为1，则要进1，如果有一个为0则为0，其实这就是按位与的操作，但是由于进位要进1，因此这里把运算出的结果左移一个单位其实就是最终的结果，那么依据这个原理就可以求出最终的结果，当进位为0的时候循环结束

class Solution {
public:
    int getSum(int a, int b) 
    {
        while(b!=0)
        {
            int x=a^b;
            int carry=(a&b)<<1;
            a=x;
            b=carry;
        }
        return a;
    }
};

对于这个题首先可以采用哈希表的方法解决，但更好的方法是使用位运算，需要一定的观察

这里采用的是比特位计数的方法，原理就是通过观察这些数，找到每一个单独的比特位拥有的独特的规律，那对于这个题来说，规律就是对于数组nums，它当中每一个数的某一个比特位相加，最终相加的结果%3得到的就是这唯独一个数据的比特位的值，下图来解释

这里是举了具体的例子，如果把它抽象成字母来代表其中的数据，其实也是一样的，因为数字要不然是三个一组，要不然一个一组，而三个一组的数据最终都能被三整除，最后唯独不同的就是一个一组的数据

利用这个原理，就能很轻松的把原来的ret的每一个比特位都得到，得到每一个比特位最终这个数就是我们要求的数据

class Solution 
{
public:
    int singleNumber(vector<int>& nums) 
    {
        int ret=0;
        for(int i=0;i<32;i++)
        {
            int sum=0;
            for(auto ch:nums)
            {
                sum+=(ch>>i) & 1;
            }
            sum%=3;
            ret = ret | (sum<<i);
        }
        return ret;
    }
};

本题实现原理其实就是前面两个题的结合，分别是消失的数字和只出现一次的数字III，但这个题的解法还有很多种，其中一种是借助鸽巢原理进行排序解决，也是一种思维较为巧妙的一种解法，可以借鉴学习

下面展示的是位运算的传统解法，鸽巢原理后续进行补充

class Solution 
{
public:
    vector<int> missingTwo(vector<int>& nums) 
    {
        int n=nums.size();
        // 找到两个数按位异或的结果
        int ret=0;
        for(int i=1;i<=n+2;i++)
        {
            ret ^= i;
        }
        for(auto ch : nums)
        {
            ret ^= ch;
        }
        // ret就是两个数按位异或的结果
        // 现在把这两个数分开找到即
        int lsb=ret&(-ret);    // 找到不同点
        int type1=0,type2=0;
        for(int i=1;i<=n+2;i++)
        {
            if(i & lsb)
            {
                type1 ^= i;
            }
            else
            {
                type2 ^= i;
            }
        }
        for(auto p : nums)
        {
            if(p & lsb)
            {
                type1 ^= p;
            }
            else
            {
                type2 ^= p;
            }
        }
        return {type1 , type2};
    }
};