位运算应用

题目

　　题1：找出唯一成对的数。

　　题2：找出落单的那个数。

　　题3：二进制中1的个数。

　　题4：是不是2的整数次方。

　　题5：将整数的奇偶位互换。

　　题6：0~1间的浮点实数的二进制表示。

　　题7：出现k次与出现1次。

　　题目来源为蓝桥杯的一个培训课（主讲人：郑未）。

测试设计

　c++程序中使用的产生随机数的测试头文件，如下：

/**
    调用格式    
            a = GenerateDiffNumber(min,max,num);
            a = Repeatedrandomnumber(min,max,num);//默认num为奇数 
            a = D_B(N);//默认为32位二进制 
            a = random_3();//1个随机数 
            a = decimal();//0~1的随机数 
            a = radixto(num,base)//十进制转换为其他进制（2<=base<=34） string radixto(int num, int base) 
            Stringflip(array, basin, base);//一组十进制数array[len]，转换为base进制数，使用string类型的basin[len]存储 
            a = oonra(N); //注意使用vector<int>().swap(a);释放容器，vector<int> oonra(int N) 
            a = krepetition(k); //重复数为k只有1个不重复，输入k。
     
                                            [author]:zlc,[date]:20204/19

**/
#include<vector>
#include<iostream>
#include<cstdlib>
#include<ctime>
#include<cstring>
#include<algorithm>  
using namespace std; 
vector<int> GenerateDiffNumber(int min,int max,int num)
{
    int rnd;
    vector<int> diff;
    vector<int> tmp;//存储剩余的数
    //初始化
    for(int i = min;i < max+1 ; i++ )
        tmp.push_back(i);
    srand((unsigned)time(0)); //初始化随机数种子
    for(int i = 0 ; i < num ; i++)
    {
        do{
            rnd = min+rand()%(max-min+1);
        }while(tmp.at(rnd-min)==-1);
        diff.push_back(rnd);
        tmp.at(rnd-min) = -1;
    }
    return diff;
}

vector<int> Repeatedrandomnumber(int min,int max,int num) 
{
    int rnd, i, j;
    vector<int> pack;//存储数据 
    vector<int> tank(num); 
    srand((unsigned)time(0)); //初始化随机数种子
    
    pack = GenerateDiffNumber(min,max,num/2+1);
    int len = pack.size();
    for(i=0; i<len-1; i++)
        pack.push_back(pack[i]);
    tank = GenerateDiffNumber(1,num,num);
    for(i=0; i<num; i++){
        rnd = pack[tank[i]-1];//数组下标需要-1 
        tank[i] = rnd;
    }
    return tank;
}

vector<int> D_B(int N)
{
    int i=0;
    vector<int> can(32);//默认初始值为32个0 
    while(N){
        if(N%2 == 1)
            can[31-i] = 1;
        N /= 2;
        i++;
    } 
    return can;
} 

int random_3()//产生一个随机数 
{
    int rnd;
    srand((unsigned)time(0)); //初始化随机数种子
    rnd = rand();
    return rnd;
    //return rnd%10;//得到个位数 
}

double decimal()
{
    double x;
    x = 1.0 / random_3();
    return x;
}

int base = 10;//默认为十进制
string radixto(int num, int base)//十进制转换为其他进制（2<=base<=34） 
{
    int i, cur;
    string ch, st;
    //思路为短除法，且一次性得到翻转的进制数 
    st = "";
    if(num==0)
        return "0";
    while(num){
        cur = num%base;
        if(cur <= 9) {
            ch = cur+'0';
            st.append(ch);    
        }
        else {
            ch = cur-10+'A';
            st.append(ch);    
        }
        num /= base;
    } 
    
    return st;
}

void* Stringflip(int arr[], string basin[], int base)
{
    string st;
    int len = sizeof(arr)*2;
    for(int i=0; i<len; i++){//遍历每一个要转换的数 
        st = radixto(arr[i], base);
        reverse(st.begin(),st.end());  
        basin[i].append(st);
    } 
}

 
vector<int> oonra(int N)//只有一个不重复数组 Only one non repeating array,没有控制的随机长度 
{
    int rnd, i, j, num, sum=0;
    bool flag = true;
    vector<int> pack;//存储重复数，清空后存储最终数据  
    vector<int> holder; //存储未乱序的原始数组
    srand((unsigned)time(0)); //初始化随机数种子
    num = rand()%6+1;//得到数组中的种类数，默认不大于6 
    
    pack = GenerateDiffNumber(2,10,num);//默认数据的重复个数不超过10个 

    int len;
    for(j=0; j<num; j++){//得到需要的随机数组的总长度 
        sum += pack[j];
        if(pack[j]==1)
            flag = false;
    } 

    if(flag){
        sum = sum-pack[0]+1;
        pack[0] = 1;    
    }
    
    holder =  GenerateDiffNumber(1,N,num);//得到未重复的原始数据，N远大于6

    for(i=0; i<num; i++){
        len = pack[i];
        rnd = holder[i];
        for(j=1; j<len; j++)
            holder.push_back(rnd);
    }

    vector<int> tank; //储存乱序因子
    
    tank = GenerateDiffNumber(1,sum,sum);//乱序因子 

    pack.clear();
    for(int i=0; i<sum; i++){
        rnd = holder[tank[i]-1];//数组下标需要-1 
        pack.push_back(rnd);
    }

    //释放容器 
    vector<int>().swap(holder);
    vector<int>().swap(tank);
       return pack;
} 

vector<int> krepetition(int k)
{
    vector<int> pack;//存储未乱序的原始数组 
    vector<int> holder; //存储重复数，清空后存储最终数据
    int num, i, j;
    srand((unsigned)time(0)); //初始化随机数种子
    num = rand()%6+1;//得到数组中的种类数，默认不大于6 
    pack = GenerateDiffNumber(1,100,num);//默认数据的重复个数不超过10个 
    int rnd;
    for(i=0; i<num-1; i++){
        rnd = pack[i];
        for(j=1; j<k; j++)
            pack.push_back(rnd);
    }
    int len = pack.size();
    
    vector<int> tank; //储存乱序因子
    
    tank = GenerateDiffNumber(1,len,len);//乱序因子 

    for(int i=0; i<len; i++){
        rnd = pack[tank[i]-1];//数组下标需要-1 
        holder.push_back(rnd);
    }
    
    vector<int>().swap(pack);
    vector<int>().swap(tank);
    return holder;
}


/**
    语句解释：
        1、tmp.at(rnd-min)==-1 // vector的一个函数，查得的资料如下，
        Access element.Returns a reference to the element at position n in the vector.
        The function automatically checks whether n is within the bounds of valid elements in the vector,
        throwing an out_of_range exception if it is not (i.e., if n is greater than, or equal to, its size). 
        This is in contrast with member operator[], that does not check against bounds.  
        （中译）
        访问元素。返回对向量中位置n处元素的引用。
        该函数自动检查n是否在向量中有效元素的范围内，如果n不在范围外，
        则抛出一个异常（即，如果n大于或等于其大小）。这与不检查边界的成员运算符[]形成对比。 
        这便是一个使数组得到不重复数据的关键点。 
        2、 int min, max, num;//在[min,max]取num个数。 
**/                    

 笔记与代码

 （代码主要为Java和C++）

 

                import java.util.Random;
                public class wei{
                    public static void main(String[] args) {
                        int N = 1001;
                        int[] arr = new int[N];
                        for (int i = 0; i < arr.length; i++) {
                            arr[i] = i + 1;
                        }
                        int index = new Random().nextInt(N);
                        arr[arr.length - 1] = arr[index];
                        arr[index] = new Random().nextInt(N - 1) + 1;
                        int x = 0;
                        for (int i = 1; i < N; i++) {
                            x ^= i;
                        }
                        for (int i = 0; i < N; i++) {
                            x ^= arr[i];
                            System.out.printf("%d  ", arr[i]);
                        }
                        System.out.println();
                        System.out.println(x);
                        System.out.println("==========");
                            int[] helper = new int[N];
                            for (int i = 0; i < N; i++) {
                                  helper[arr[i]]++;
                            }
                            for (int i = 0; i < N; i++) {
                                  if (helper[i] == 2) {
                                        System.out.println(i);
                                        break;
                                  }
                            }
                    }
                }

/**
    题目数据只有一个重复，其他数据唯一 。
    思路1：辅助空间计数法，开辟一个长度为1000的数组 ，扫描题目数组，并计数。
    伪代码：
            int helper[1001];
            memset(helper, 0, sizeof(helper));//全0数组 
            for(int i from 1 to 1001) 
                helper[array[i]]++;
            for(int j from 1 to 1000) 
                if(helper[j] == 2)
                    cout<< j;
                    break;
    时间复杂度为：O(n),但是需要开辟辅助空间
    思路2：由异或的自反性 A^B^B=A^0=A可设计一个时间复杂度为O(n)，且在原址上操作的算法
    伪代码：
            int x = 0 ;
            for(int i from 1 to 1000) 
                x ^= i;
            for(int j from 0 to 1000) 
                x ^= array[j]
            cout<< x;
    测试设计，设计一个能生成指定范围内的乱序数据的头文件 
**/
#include "randomnumber.h"//调用生成[a,b]内不重复n个数的头文件 
#define N 1000 
using namespace std;

int main()
{
    int x = 0, i, j;
    vector<int> array(N+1);
    array = GenerateDiffNumber(1,N,N);
    array[N] = rand()%N;//产生一个重复的数 
    for(i=1; i<=N; i++)
        x ^= i; 
    /*测试可用N=10测方便观察 
    for(i=0; i<N; i++)
        cout<< array[i] <<' ';
    cout<< endl;
    */
    for(j=0; j<N+1; j++)
        x ^= array[j];
    cout<< x; 
    return 0;
}

/**
    题2：找出落单的那个数。一个数组里除了某一个数字之外，其他的数字出现了
    两次。请写程序找出这个出现一次的数字。
     
    思路1：辅助空间，数组的长度取决于最大值，浪费空间。
        伪代码： 
                int maxsize = array[0];
                for(i from 1 to n)
                    maxsize = maxsize > array[i] ? maxsize : array[i];
                int helper[maxsize];
                memset(helper, 0, sizeof(helper));
                for(int i from 1 to n) 
                helper[array[i]]++;
                for(int j from 1 to n) 
                    if(helper[j] == 1)
                        cout<< j;
                        break;
                
    思路2：冒泡查找，最坏情况为O(n^2)
        伪代码：
                int index;
                bool flag;
                for(i from 0 to n)
                    index = array[i];
                    flag = true;
                    for(j from i to n)
                         if(index == array[j])
                             flag = flase;
                             break;
                    if(flag)
                        cout<< index;
                        break;         
    思路3：位运算的异或， A^B^B=A^0=A
        伪代码：
                int x = 0;
                for(i from 0 to n)
                    x ^= array[i];
                cout<< x; 
    
    测试设计，设计一个头文件得到一组如题示的数据。 
**/

#include "randomnumber.h"
#define N 23 
using namespace std;
int main()
{
    int x = 0, i, j;
    vector<int> array(N);
    array = Repeatedrandomnumber(1,100,N);
    
    for(i=0; i<N; i++)
        cout<< array[i] <<' ';
    cout<< endl;
    
    for(j=0; j<N; j++)
        x ^= array[j];
    cout<< x; 
    return 0;    
} 

 

                        import java.util.Scanner;
                        public class num1 {
                          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);
                            count = 0;
                            for (int i = 0; i < 32; i++) {
                              if (((N >>> i) & 1) == 1)
                                count++;
                            }
                            System.out.println(count);
                            count = 0;
                            while (N != 0) {
                              N = ((N - 1) & N);
                              count++;
                            }
                            System.out.println(count);
                          }
                        }

/**
    题3：二进制中1的个数
    请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。
    例：9的二进制表示1001，有2位是1。
    
    思路1：位运算运用，1&1=1,1&0=0,0&0=0,0&1=0。搭配 <<。
         伪代码：
                 int count = 0;
                 for(i from 0 to 32)
                     if((N&(1<<i)) == (1<<i))
                         count++; 
                         
    思路2：位运算应用，使用>>>运算符用0填充最高位，使原有的数据一个一个地退到低位，再与1做判断。
        伪代码：
                int count = 0;
                 for(i from 0 to 32)
                     if((N>>>i)&1) == 1)
                         count++; 
                         
    思路3：位运算应用，n-1与n使得二者的1错位相与便能消掉该错位的1，直至把n的1全部去掉。
         伪代码：
                 int count = 0;
                 while(N!=0){
                     N = ((N-1)&N);
                     count++;
                } 
    
    测试设计：不妨设计一个进制转换头文件。 
**/
#include "randomnumber.h"
int main()
{
    int N = random_3();
    int count = 0;
    vector<int> array;
    cout<< N <<endl;
    
    array = D_B(N);
    while(N!=0){
         N = ((N-1)&N);    
         count++;
    } 
    
    for(int i=0; i<32; i++)
        cout<< array[i];
    cout<< endl;
    cout<< count;
    
    return 0;
}

/**
    题4：是不是2的整数次方。
    用一条语句判断一个整数是不是2的整数次方。
     
    思路1：因为2的整数次幂的二进制数只有一个1，所以(N-1)&N就可以置0 。
        伪代码：
                if(((N-1)&N) == 0) is an integral multiple of 2.
                else isn't an integral multiple of 2.
    
    测试设计：得到一个随机数。 
**/
#include "randomnumber.h"
int main()
{
    int N = random_3();
    cout<< N;
    if(((N-1)&N) == 0)
        cout<< " yes";
    else
        cout<< " no"; 
    return 0; 
} 

 

                import java.util.Scanner;
                public class ji {
                    public static void main(String[] args) {
                        Scanner scanner=new Scanner(System.in);
                        int Number=scanner.nextInt();
                        int ou=Number & 0xaaaaaaaa;  
                        int ji=Number & 0x55555555; 
                        int result=(ou>>1) ^ (ji<<1);  
                        System.out.println("交换前："+Integer.toString(Number, 2));
                        System.out.println("交换后："+Integer.toString(result, 2));
                    }
                
                }

/**
    题目：将整数的奇偶位互换
    思路1：时间复杂度为O(1)的方法是应用位运算的知识，101010...10&N得到奇数位的值，010101...01得到偶数位的值，再用异或运算把二者拼在一起。
    （0xaaaaaaaa为十六进制表示32位的二进制数，0x十六进制标示，每4位二进制数表示一位十六进制数，a表示1010）
    
    伪代码 ：
            int ou = N&0xaaaaaaaa;
            int ji = N&0x55555555;
            int result = (ou>>1) ^ (ji<<1);//奇偶位互换
    
    测试设计：得到随机数与二进制数。 
**/
#include "randomnumber.h"
int main()
{
    int N = random_3();
    vector<int> array1;
    vector<int> array2;
    
    array1 = D_B(N);
    for(int i=0; i<32; i++)
        cout<< array1[i];
    cout<< endl;
    int ou = N&0xaaaaaaaa;
    int ji = N&0x55555555;
    int result = (ou>>1) ^ (ji<<1);
    array2 = D_B(result);
    
    for(int i=0; i<32; i++)
        cout<< array2[i];
    
    return 0;
}

                    public class xiaoshu {
                      public static void main(String[] args) {
                        double num = 0.625;
                        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());
                      }
                    }

/**
    题6：0~1间浮点实数的二进制表示。给定一个介于0和1之间的实数，（如0.625），类型为double，打印
    它的二进制表示（0.101，因为小数点后的二进制分别表示0.5，0.25，0.123...）。如果该数字无法精确
    地用32位以内的二进制表示，则打印"ERROR"
    思路1：当小于1大于0时，r = N*2得到0则第一位为0则记忆该数且N=r，否则则记忆该数为1且N=r-1，依
    次类推，直到N==0。得到的数组长度长于32则输出"ERROR"。
    
    伪代码：
            string sb = "0.";
             while(N>0)
                 double r = N*2;
                 if(r>=1) sb.append("1"); N = r-1;
                 else sb.append("0"); N = r;
             if(sb.length()>34) cout<< "ERROR";
             else cout<< sb;
    
    测试设计：得到0~1的随机数。        
**/
#include<cstring>
#include "randomnumber.h"
int main()
{
    string sb = "0.";
    double r, N = decimal();
    
    while(N>0){
        r = N*2;
         if(r>=1) {
             sb.append("1");
            N = r-1;
        }
         else{
             sb.append("0"); 
            N = r;    
        } 
    }
    
    if(sb.length()>34) 
        cout<< "ERROR";
    else 
        cout<< sb;
    return 0;    
} 

                public class _07_出现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][];
                    int k = 3;
                
                    int maxLen = 0;
                    //转成k进制字符数组
                    //对于每个数字
                    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');
                      }
                    }
                
                    int res = 0;
                    for (int i = 0; i < maxLen; i++) {
                      res += (resArr[i] % k) * (int) (Math.pow(k, i));// 8%3=2,
                    }
                    System.out.println(res);
                  }
                }

/**
    题7：出现k次与出现1次。数组中只有一个数出现了1次，其他的数都出现了k次，
    请输出只出现了1次的数。
    
    思路： k个相同的k进制数做不进位加法，结果为0（可以用模运算进行解释）
        伪代码：
                //转成k进制字符数组并翻转 
                int maxlen=0;
                for(i from 0 to array.length())
                    kRadix[i] =  tocharArray(array[i]);
                    if(kRadix[i].length() > maxlen) 
                        maxlen = kRadix[i].length();
                //不进位加法
                int resArr[maxlen];
                for(i from 0 to array.length()) 
                    for(j from 0 to maxlen)
                        if(j>=kRadix[i].length())
                            resArr[j] += 0;
                        else
                            resArr[j] += (kRadix[i][j] - '0');
                int res = 0;
                for(i from 0 to maxlen)
                    res += (resArr[i]%k)*(int)(pow(k,i));
    
    测试设计：设法得到题目所描述的数组，并设计k进制数的互换与字符串的翻转。 
**/
#include "randomnumber.h"
#include<cmath>
//int array[] = {2, 2, 2, 39, 7, 7, 7, 3, 3, 3, 6, 6, 6, 0, 0, 0};//例子 
int k;
vector<int> array;
void init()
{
    int res;
    cin>> k;
    array = krepetition(k);
    for(int i=0; i<array.size(); i++){
        cout<< array[i] << ' ';
    }
    cout<< endl;
}

int main()
{
    int maxlen=0, i, j, len;
    init();
    len = array.size();
    
    string kRadix[len];
    
    for(i=0; i<len; i++){
        kRadix[i] =  radixto(array[i], k);//求每个数字的三进制字符串并翻转，然后转为字符数组，默认k为3
        if(kRadix[i].length() > maxlen) 
            maxlen = kRadix[i].length();
    }

    int resArr[maxlen];
    memset(resArr, 0, sizeof(resArr));//全0数组 
    for(i=0; i<len; i++) {
        for(j=0; j<maxlen; j++)
            if(j>=kRadix[i].length())
                resArr[j] += 0;
            else
                resArr[j] += (kRadix[i][j]- '0');
    }
    
    int res = 0;
    for(i=0; i<maxlen; i++)
        res += (resArr[i]%k)*(int)(pow(k,i));
    cout<< res;
    vector<int>().swap(array);
    return 0;
}