藍橋杯備賽算法（java）

導學

藍橋杯課程安排：

 

 

 

 參考書籍：

 

 學習方法：

 

 

位運算

 

 

 

 

 

1-1000這1000個數放在含有1001個元素的數組中，只有唯一的一個元素值重復，其它均只出現一次。
每個數組元素只能訪問一次，設計一個算法，將它找出來；不用輔助存儲空間，能否設計一個算法實現？

 

package 算法基礎;
import 算法基礎.數組隨機排序;
import java.util.Random;

/**
 * @Auther:zhushen
 * @Date:2021/1/13
 * @Description:位運算
 * @version:1.0
 */
public class 唯一成對的數 {
    /*
    1-1000這1000個數放在含有1001個元素的數組中，只有唯一的一個元素值重復，其它均只出現一次。
    每個數組元素只能訪問一次，設計一個算法，將它找出來；不用輔助存儲空間，能否設計一個算法實現？
     */
    public static void main(String[]args){
        System.out.println("============方法一============");
        //不使用輔助存儲空間
        //思路：將數組元素與正常無重復數組元素進行異或（數組元素為0—10中的整數）
　　　　　　 //異或 20         //代碼實現參考：兩個數交換值
        //num1 = num1^num2;
        //num2 = num1^num2;
        //num1 = num1^num2;
        int N = 11;
        int[]arr = new int[N];
        //填充整數
        for (int i =0;i<arr.length-1;i++){
            arr[i]=i+1;
        }
        //最后一個數，是隨機數
        arr[arr.length-1]= new Random().nextInt(N-1)+1;
        //隨機下標
        數組隨機排序.shuffle(arr);
        int x1 = 0;
        for(int i = 1;i<=N-1;i++){
            x1 = (x1^i);
        }
        for(int i = 0;i<N;i++){
            x1 = x1^arr[i];
        }
        for (int value : arr) {
            System.out.print(value);
        }
        System.out.println("\n"+x1);

        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;
            }
        }
    }
}

package 算法基礎;
import java.util.Random;

/**
 * @Auther:zhushen
 * @Date:2021/1/13
 * @Description:tools
 * @version:1.0
 */
public class 數組隨機排序 {


    /**
     * 隨機排序
     */

        private static Random rand = new Random();

        public static void swap(int[] a, int i, int j) {
        int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }

        public static void shuffle(int[] arr) {
            int length = arr.length;
            for (int i = length; i > 0; i--) {
                int randInd = rand.nextInt(i);
                swap(arr, randInd, i - 1);
            }
        }
    }

 

 

 一個數組里除了某一個數字之外，其他的數字都出現了兩次。請寫程序找出這個只出現一次的數字。

package 算法基礎;

import java.util.Random;

/**
 * @Auther:zhushen
 * @Date:2021/1/13
 * @Description:位運算
 * @version:1.0
 */
public class 找出落單的數 {
    public static void main(String[] args) {
        System.out.println("============方法一============");
        //不使用輔助存儲空間
        //思路：直接異或，A^A=0、A^0=A
        //代碼實現參考：兩個數交換值
        //num1 = num1^num2;
        //num2 = num1^num2;
        //num1 = num1^num2;
        int N = 11;
        int[]arr = new int[N];
        //填充整數
        for (int i =0;i<arr.length-1;i=i+2){
            arr[i+1]=arr[i]=i+1;
        }
        //最后一個數，是隨機數
        arr[arr.length-1]= new Random().nextInt(N-1)+1;
        //隨機下標
        數組隨機排序.shuffle(arr);
        int x1 = 0;
        for(int i = 0;i<N;i++){
            x1 = x1^arr[i];
        }
        for (int value : arr) {
            System.out.print(value);
        }
        System.out.println("\n"+x1);

        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]==1){
                System.out.println(i);
                break;
            }
        }
    }
}

 

請實現一個函數，輸入一個整數，輸出該數二進制表示中1的個數。
例：9的二進制表示為1001,有2位是1

package 算法基礎;

import java.util.Scanner;

/**
 * @Auther:zhushen
 * @Date:2021/1/13
 * @Description:位運算
 * @version:1.0
 */
public class 二進制中1的個數 {
    public static void main(String[] args) {
        System.out.println("請輸入要求的數：");
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        System.out.println(Integer.toString(N, 2));
        //方法一：
        //拿1從右向左與原數字做&運算
        int count = 0;
        //對比每一位
        for (int i = 0; i < 32; i++) {
            if ((N & (1 << i)) == (1 << i)) {
                count++;
            }
        }
        System.out.println(count);

        //方法二：把原數字往右移與1做&運算
        count = 0;
        for(int i = 0;i<32;i++){
            if(((N>>>i)&1)==1)
            count++;
        }
        System.out.println(count);

        //方法三：原數字-1，每次可消除一個1，然后原數字與-1后的數字做與運算。
        //現象（1）：1000-1=0111
        //現象（2）：1000&0111=0000
        count = 0;
        while(N!=0){
            N = ((N-1)&N);
            count++;
        }
        System.out.println(count);
    }
}

 

 用一條語句判斷一個整數是不是2的整數次方。

        int N = 18;
        System.out.println(Integer.toString(N, 2));
        if(((N-1)&N)==0){
4             System.out.println("是");
        }else{
            System.out.println("不是");
        } 

 

package 算法基礎;

import org.junit.Assert;

/**
 * @Auther:zhushen
 * @Date:2021/2/5
 * @Description:位運算，見一個記一個。
 * @version:1.0
 */
public class 整數的奇偶位互換 {
    public static void main(String[] args) {
        int a = 0b01000000_00000000_00000000_00000000;
        int b =m(a);
        Assert.assertEquals(b,0b10000000_00000000_00000000_00000000);
    }
    private static int m(int i){
        int ou = i&0xaaaaaaaa;//原數字和1010 1010 1010....(偶數位為1，奇數位為0)做與運算取出偶數位
        int ji = i&0x55555555;//原數字和0101 0101 0101....(偶數位為0，奇數位為1)做與運算取出奇數位
        return (ou>>1)^(ji<<1);//連起來
    }
}

 

(1)給定一個介於0和1之間的實數，(如0.625),類型為double,打印它的二進制表示（0.101,因為小數點后的二進制分別表示0.5,0.25.0.125......)。

(2)如果該數字無法精確地用32位以內的二進制表示，則打印“ERROR"

package 算法基礎;

import com.sun.org.apache.bcel.internal.generic.RETURN;

/**
 * @Auther:zhushen
 * @Date:2021/2/5
 * @Description:位運算，見一個記一個
 * @version:1.0
 */
public class 二進制表示浮點實數 {
    public static void main(String[] args) {
        double num = 0.625;
        StringBuilder sb = new StringBuilder("0.");
        while(num>0){
            //乘2挪整
            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());
    }
}

 

package 算法基礎;

/**
 * @Auther:zhushen
 * @Date:2021/2/6
 * @Description:
 * @version:1.0
 */
public class 出現k次與1次 {
    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;
        //轉成k進制字符數組
        int maxLen = 0;
        for(int i=0;i<len;i++){
            //求每個數字的三進制字符串並翻轉，然后轉為字符數組
            kRadix[i] = new StringBuffer(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);
    }
}