懂二进制

public class Solution {
    /**
     * 获得两个整形二进制表达位数不同的数量
     * 
     * @param m 整数m
     * @param n 整数n
     * @return 整型
     */
    public int countBitDiff(int m, int n) {
		String str=Integer.toBinaryString(m^n);
        str=str.replaceAll("0","");
		return str.length();
    }
}

//JAVA 
public int countBitDiff(int m, int n) {

        int dif=m^n;//先将二者做异或运算，得到结果；
        int cnt=0;
        while(dif!=0){
            dif=dif&(dif-1);
            cnt++;
        }             //统计一个整数dif含有多少个1；
        return cnt;
    }

int countBitDiff(int m, int n) 
{
	int len = 32;
	int difNum = 0;
	while(len)
	{
		int m_low = m&1; //取m最后一位，下同
		int n_low = n&1;
		if((m_low != n_low)) //直接两个数的最后一位对比
			difNum++;    //不同就计数+1
		m = m >> 1;   //m往右移动一位，下次循环就可以取倒数第二位，下同
		n = n >> 1;
		len--;
	}
	return difNum;
}

两个知识点:用位运算异或，两个数异或相同为0，不同为1.得到结果再去求1的个数
class Solution {
public:
    int countBitDiff(int m, int n)
    {
		int count=0;
        int val=m^n;
        while(val)
        {
            count++;
            val=val&(val-1);
        } 
        return count;
    }
};

int countBitDiff(int m, int n) {
		return numberOfOne(m^n);//m^n，m与n异或，其结果中不同位为１，相同位为０．
}
//统计整数a中数字1的个数
int numberOfOne(int a){
        int count = 0;
        while(a){
            a &= a-1;
            count++;
        }
        return count;
}

    public int countBitDiff(int m, int n) {
		return Integer.bitCount(m^n);
    }

    public int countBitDiff(int m, int n) {
        int res = m ^ n;
        return Integer.bitCount(res);
    }

class Solution {
public:
    // 存放int整数的二进制的32位
    vector<int> getBinary(int x)
    {
        vector<int> xBinary;
        for(int i=0; i<32; i++)
        {
            do{
                xBinary.push_back(x%2);
            }while(x/=2);
            if(x/2==0)
            {
                xBinary.push_back(0);
            }
        }
        return xBinary;
    }
    // 32位每位进行对比
    int countBitDiff(int m, int n)
    {
        int count=0;
        vector<int> mBinary, nBinary;
        mBinary = getBinary(m);
        nBinary = getBinary(n);
        for(int i=0; i<32; i++)
        {
            if(mBinary[i]!=nBinary[i])
            {
                count+=1;
            }
        }
        return count;
    }
};

class Solution {
public:
    int countBitDiff(int m, int n) {
        int count = 0;
        while(m||n){//当有一者为0后，0%2=0，相当于给不够位补零了。
            if(m%2 != n%2)
                count++;
            m /= 2;
            n /= 2;
        }
        return count;
    }
};
/*排行第一的思路很精妙，异或运算将两个数中不同位标注为1，在通过按位与运算，统计1的个数，即不同位 个数。不过这种代码浓缩度高，不见得时间复杂度小，按位与运算计算机执行要比普通加减乘除复杂，需要每一位比较。不过思路还是值得学习。*/
class Solution {
public:
    int countBitDiff(int m, int n) {
        int mn,count = 0;
        mn = m^n;//异或，相同会变0，不同会变1，和数学上有区别，这里是按二进制每位进行异或处理。
        while( mn != 0 ){//不为零说明其中有1存在，而1的个数正是两个数二进制位不同的个数。
            mn &= (mn-1);//mn = mn&(mn-1),mn-1即将以最末尾的1变成了零。而&运算为按位与运算，两者相同位都为1，才为1，每次除去最末尾的1。
            count++;
        }
        return count;
    }
};

public class Solution {
/* 看是否同奇偶? */
    public int countBitDiff(int m, int n) {
        int count = 0;
        while(m != 0 || n != 0) {
            if(m%2!=n%2) { count++; }
            m/=2;
            n/=2;
        }
        return count;
    }
}

class Solution {
public:
    /**
     * 获得两个整形二进制表达位数不同的数量
     * 
     * @param m 整数m
     * @param n 整数n
     * @return 整型
     */
    int countBitDiff(int m, int n) {
        int diffs = 0;
        int xornum = m^n;
        while(xornum){
            if((xornum & 0x80000000) == 0x80000000){
                diffs ++;
            }
            xornum <<= 1;
        }
        
        return diffs;
    }
};

int countBitDiff(int m, int n)
    {
        int iCount = 0;
        for(int i = 0; i != 32; ++i)
            if((m>>i&1) != (n>>i&1))
                ++iCount;         
        return iCount;
    }

public class Solution {
    /**
     * 获得两个整形二进制表达位数不同的数量
     * 
     * @param m 整数m
     * @param n 整数n
     * @return 整型
     */
    public int countBitDiff(int m, int n) {
        int tmp=m^n;
        if(tmp==0) return 0;
        int count=0;
        while(tmp!=0){
            count++;
            tmp=tmp&(tmp-1);
        }
        return count;
    }
}

class Solution {
public:
    /**
     * 获得两个整形二进制表达位数不同的数量
     * 
     * @param m 整数m
     * @param n 整数n
     * @return 整型
     */
    int countBitDiff(int m, int n) {
        int sum=0;
        int c = n^m;
        while (c != 0) {
            if (c & 1 == 1) {
                sum++;
            }
            c = c >> 1;
        }
        return sum;
    }
};

    public int countBitDiff(int m, int n) {
        int cnt = 0;
        // 按位异或，不同的位为1
        int x = m ^ n;
        while (x > 0) {
            // x&1使得只保留最低位，计数器加上该结果（即统计1个数）
            cnt += (x & 1);
            // 向右位移
            x >>= 1;
        }
        return cnt;
    }

public int countBitDiff(int m, int n) {
        int x=m^n;
        String binStr=Integer.toBinaryString(x);
        char [] chars=binStr.toCharArray();
        int count=0;
        for(char c:chars){
            if(c=='1'){
                count++;
            }
        }
        return count;
    }

int countBitDiff(int m, int n) {         int cnt=0;         while(m!=0 || n!=0){             if((m%2 != n%2)) cnt++;             m/=2;             n/=2;         }         return cnt;     }
};

class Solution {
public:
    int countBitDiff(int m, int n) {         int result=m^n;
        int count=0;
        while(result)
        {
            count++;
            result=(result-1)&result;
        }
        return count;
    }
};