位运算练习

找出唯一成对的数

1-1000这1000个数放在含有1001个元素的数组中，只有唯一的一个元素值重复，其他均只出现一次。每个数组元素只能访问一次，设计一个算法，将他找出来；不用辅助存储空间，能否设计一个算法实现？

解析：一个数和本身异或为0，任何数和0异或还是这个数。比如2和2异或为0，那么2和2和2异或就为2。

只要将1~1000全都异或，再异或上数组里的1000个数，结果就是要找的答案。因为要找的元素异或了3次，而其他数异或了2次。

 import java.util.Random;
 public class 唯一成对的数 {
     public static void main(String[] args) {
         int N=1001;
         int[] arr=new int[N];
         int len=arr.length;
         for(int i=0;i<len-1;i++)
         {
             arr[i]=i+1;
         }
         
         //最后一个数，是随机数
         arr[len-1]=new Random().nextInt(N-1)+1;
         //随机下标
         int index=new Random().nextInt(N);
         
         //交换随机下标的数和随机数
         int temp=arr[index];
         arr[index]=arr[len-1];
         arr[len-1]=temp;
         
         for(int i=0;i<N;i++)
             System.out.print(arr[i]+" ");
         
         System.out.println();
         
         int x1=0;
         //先将x1与1~N-1异或
         for(int i=1;i<=N-1;i++)
             x1=(x1^i);
         //再将x1与数组中各个数异或
         for(int i=0;i<N;i++)
             x1=(x1^arr[i]);
         
         System.out.println(x1);
     }
 }

 

找出落单的那个数

一个数组里除了某一个数字之外，其他的数字都出现了两次。请写程序找出这个只出现一次的数字。

解析：只需全部异或，异或的结果就是答案。因为成对的数都相互抵消了。

 

二进制中1的个数

请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。

例：9的二进制表示为1001，有2位是1。

法一：将数字1每次左移一位（就是1<<i），并与N进行与运算，如果结果等于(1<<i)，那么个数加1

 import java.util.Scanner;
 public class _1的个数 {
     public static void main(String[] args) {
         Scanner sc=new Scanner(System.in);
         int N=sc.nextInt();
         System.out.println(Integer.toString(N,2));
         int count=0;
         for(int i=0;i<32;i++)
         {
             if((N&(1<<i))==(1<<i))
             {
                 count++;
             }
         }
         
         System.out.println(count);
     }
 }​

法二：将N每次右移一位，并与1与运算，如果结果为1，则个数加1

法三：整数N，N=(N-1)&N就是将N的最右边的1消除。

　　1 0 1 0 0

-1    1 0 0 1 1

&——————

　　1 0 0 0 0

-1    0 1 1 1 1

&——————

　　0 0 0 0 0

 import java.util.Scanner;
 public class _1的个数 {
     public static void main(String[] args) {
         Scanner sc=new Scanner(System.in);
         int N=sc.nextInt();
         System.out.println(Integer.toString(N,2));
         int count=0;
         
         while(N!=0)
         {
             N=(N-1)&N;
             count++;
         }
         
         System.out.println(count);
     }
 }

​

是不是2的整数次方

用一条语句判断一个整数是不是2的整数次方。

解析：上题的思路 if(N&(N-1)==0)

 

将整数的奇偶位互换

将一个整数二进制表示的奇偶位互换

例：9的二进制：1001，互换后为0110

解析：将这个数与...10101010进行与运算，将偶数位提取，再与...01010101进行与远算，将奇数位提取。最后将提取到的偶数位右移一位，奇数位左移一位，两者异或，即得到互换效果。

 public class 奇偶位互换 {
     public static void main(String[] args) {
         int a=9;
         int b=m(a);
         System.out.println(Integer.toString(a,2));
         System.out.println(Integer.toString(b,2));
     }
     
     public static int m(int i)
     {
         int ou=i&0xaaaaaaaa;//和1010 1010 1010 。。。做与运算取出偶数位
         int ji=i&0x55555555;//和0101 0101 0101 。。。做与运算取出奇数位
         return (ou>>1)^(ji<<1);
     }
 }

 

0~1间浮点实数的二进制表示

给定一个介于0和1之间的实数（如0.625），类型为double，打印它的二进制表示（0.101），如果该数字无法精确地用32位以内的二进制表示，则打印“ERROR”

 public class 二进制小数 {
     public static void main(String[] args) {
         double num=0.875;
         StringBuilder sb=new StringBuilder("0.");
         while(num>0)
         {
             double r=num*2;
             if(r>=1)
             {
                 sb.append("1");
                 num=r-1;
             }
             else
             {
                 sb.append("0");
                 num=r;
             }
             if(sb.length()>34)
             {
                 System.out.println("ERROR");
                 return;
             }
         }
         System.out.println(sb.toString());
     }
 }

 

出现k次与出现1次

数组中只有一个数出现了1次，其他的数都出现了k次，请输出出现了1次的数。

解析：

　　2个相同的2进制数做不进位加法，结果为0

　　10个相同的10进制数做不进位加法，结果为0

　　k个相同的k进制数做不进位加法，结果为0

只要把所有数转为k进制，做一次不进位加法把它们都加起来，那么出现k次的数加完都会变为0，最终结果就是出现了1次的那个数。

public class 出现k次 {
    public static void main(String[] args) {
        int[] arr= {2,2,2,9,7,7,7,3,3,3,6,6,6,0,0,0};
        int len=arr.length;
        char[][] kRadix=new char[len][];//k进制字符数组
        int k=3;
        //转成k进制字符数组
        int maxLen=0;
        for(int i=0;i<len;i++)
        {
            kRadix[i]=new StringBuilder(Integer.toString(arr[i],k))
                                        .reverse().toString().toCharArray();
            //记录最长的数组长度
            if(kRadix[i].length>maxLen)
                maxLen=kRadix[i].length;
            
        }
        
        int[] resArr=new int[maxLen];//结果
        for(int i=0;i<len;i++)
        {
            //不进位加法
            for(int j=0;j<maxLen;j++)
            {
                if(j>=kRadix[i].length)
                    resArr[j]+=0;
                else
                    resArr[j]+=(kRadix[i][j]-'0');
            }
        }
        
        //k进制转10进制
        int res=0;
        for(int i=0;i<maxLen;i++)
        {
            //每一位模k，再乘这一位的权重得到10进制
            res+=(resArr[i]%k)*(int)(Math.pow(k,i));
        }
        System.out.println(res);
    }
}

 

参考：《算法很美》