算法题(2)

 

参考：十道算法题[二]

 

public class Test1 {

    /**
     * 删除下标为k的元素
     */
    public static int[] deleteK(int[] arr,int k) throws Exception {

        if(arr==null){
            throw new Exception("数组不能为空");
        }
        if(k>arr.length){
            throw new Exception("k不能大于数组长度");
        }

        for (int i = k; i < arr.length-1; i++) {
            arr[i] = arr[i+1];
        }

        int[] dest = new int[arr.length-1];
        System.arraycopy(arr,0,dest,0,arr.length-1);
        return dest;
    }

    /**
     * 找出常用的数字：
     * 给你一个长度为n的数组，其中有一个数字出现的次数至少为n/2，找出这个数字
     */
    public static void findMajorityElement2(int[] arrays) {

        // 装载栈的元素
        int candidate = -1;

        // 栈的大小(长度)
        int count = 0;


        // 遍历给出的数组
        for (int i = 0; i < arrays.length; i++) {


            // 判断该栈为空，那么直接将元素入栈
            if (count == 0) {

                candidate = arrays[i];
                count++;

            } else if (candidate == arrays[i]) { // 该元素是否与栈的元素一致-->入栈(栈多一个元素)
                count++;
            } else {
                // 只要不一致-->出栈(栈少一个元素)
                count--;

            }
        }

        // 只要该数字出现次数大于数组长度的2/1，那么留下来的数字肯定在栈顶中
        System.out.println("找出常用的数字：" + candidate);

    }

    /**
     * 利用等差公式找到缺失的数字
     *
     * @param arrays
     */
    public static void missingNumber2(int[] arrays) {

        // 套用等差求和公式
        int sum = (arrays[0] + arrays[arrays.length - 1]) * (arrays.length + 1) / 2;


        // 遍历数组，得出的sum减去数组每一位元素，最后即是缺失的数字

        for (int value : arrays) {
            sum -= value;
        }


        System.out.println("找到缺失的数字：" + sum);


    }

    /**
     * 移动元素0到数组最后
     *
     * @param arrays
     */
    public static void moveZero(int[] arrays) {


        // 在j前面的元素都不是0
        int j = 0;


        for (int i = 0; i < arrays.length; i++) {

            if (arrays[i] != 0) {

                // 跟j进行交换，保证j的前面都不是0
                int temp = arrays[i];
                arrays[i] = arrays[j];
                arrays[j]  = temp;

                j++;
            }
        }

        // 直至i遍历完毕后，j前面都不是0，j-i都是0(这就完成我们的任务了)
        System.out.println("移动元素0到数组最后" + Arrays.toString(arrays));
    }

    /**
     * 找出数组的单个数字
     * @param nums
     * @return
     */
    public static int singleNumber(int[] nums) {

        // 第一个数和数组后面的数做^运算，留下的必然是单个数字
        int k = nums[0];
        for (int i = 1; i < nums.length; i++) {
            k ^= nums[i];
        }
        return k;
    }

    /**
     * 画星星
     */
    public static void drawStar() {

        // 我要画5行的星星
        int row = 5;


        for (int i = 1; i <= row; i++) {

            // 空格数等于最大行数 - 当前行数
            for (int j = 1; j <= row - i; j++) {
                System.out.print(" ");
            }

            // 星星数等于(当前行数*2-1)
            for (int j = 1; j <= i * 2 - 1; j++) {

                System.out.print("*");

            }

            // 每画一行就换一次行
            System.out.println();
        }
    }

    /**
     * 将罗马数字转成阿拉伯数字，实际上就是一个查表的过程
     *
     * @param roman
     * @return
     */
    public static int digitsToValues(char roman) {

        // 定义罗马数字
        char digits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};

        // 罗马数字对应的阿拉伯数字
        int values[] = {1, 5, 10, 50, 100, 500, 1000};


        for (int i = 0; i < digits.length; i++) {

            if (digits[i] == roman) {
                return values[i];
            }
        }
        return 0;
    }

    /**
     * 将罗马数字转成阿拉伯数字
     *
     * @param r

     */
    public static int romanToNumber(String r) {
        int sum = 0;
        char[] arr = r.toCharArray();
        for (char c : arr) {
            sum += digitsToValues(c);
        }
        return sum;
    }

    /**
     * 啤酒与饮料题目,乘10去掉小数
     */
    public static void beerAndDrink() {

        int i,j;
        for (i = 0; i < 823/23; i++) {
            for (j = 0; j < 823/19; j++) {
                if(23*i+19*j==823&&i<j){
                    System.out.println("啤酒："+i+"饮料："+j);
                }

            }

        }
    }

    /**
     * 获取26字母的大小写数组
     * @return
     */
    public static char[] getArr(){
        StringBuffer sb = new StringBuffer();
        for (int i = 1; i <= 26; i++) {//获取大写的26个字母
            sb.append((char)(64+i));
        }
        String low = sb.toString().toLowerCase();//转小写
        sb.append(low);
        char[] arr = sb.toString().toCharArray();//数组输出
        return arr;
    }

    /**
     * 获取map,key是原数组，value是左移k位的数组
     * @param k
     * @return
     */
    public static Map getMap( int k){
        char[] arr = getArr();
        char[] dest = new char[arr.length];
        System.arraycopy(arr,0,dest,k,arr.length-k);
        System.arraycopy(arr,arr.length-k,dest,0,k);
        Map map = new HashMap();
        for (int i = 0; i < arr.length; i++) {
            map.put(arr[i],dest[i]);
        }
        return map;
    }

    /**
     * 根据value获取key，无返回value
     * @param m
     * @param v
     * @return
     */
    public static Object getKey(Map m,Object v){
        Object key = null;
        for (Object o : m.keySet()) {
            if(v.equals(m.get(o))){
                key = o;
            }
        }
        if(key==null){
            return v;
        }
        return key;
    }

    /**
     * 加密
     * @param str
     * @param k
     * @return
     */
    public static String Encryption(String str, int k) {

        Map map = getMap(k);

        char[] c = str.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if(map.containsKey(c[i])){
                c[i] = (char) map.get(c[i]);
            }
        }
        return String.copyValueOf(c);
    }

    /**
     * 解密
     * @param str
     * @param k
     * @return
     */
    public static String Decrypt(String str, int k) {

        Map map = getMap(k);

        char[] c = str.toCharArray();
        for (int i = 0; i < c.length; i++) {
            c[i]=(char)getKey(map,c[i]);
        }
        return String.copyValueOf(c);
    }

    /**
     * 求最大公约数
     *
     * @param num1
     * @param num2
     */
    public static int gcd(int num1, int num2) {


        // 求余数
        int r = num1 % num2;

        // 如果余数为0，那么除数就是最大公约数
        if (r == 0) {
            return num2;
        } else {

            // 否则，则用除数和余数来进行运算
            return gcd(num2, r);
        }

    }


    public static void main(String[] args) throws Exception {
        int[] arr = {1,2,5,4,6,8};
        System.out.println("删除下标为k的元素:"+ Arrays.toString(deleteK(arr,3)));
        int[] arr1 = {1,2,3,3,3};
        findMajorityElement2(arr1);
        int[] arr2 = {0,1,3,4,5};
        missingNumber2(arr2);
        moveZero(arr2);
        int[] arr3 = {1,2,1,2,3};
        System.out.println("找出数组的单个数字:"+singleNumber(arr3));

        System.out.println("画三角形星星----");
        drawStar();
        System.out.println("将罗马数字转成阿拉伯数字:"+romanToNumber("XVIII"));
        beerAndDrink();
        String e = Encryption("hello world!",2);
        String d = Decrypt(e,2);
        System.out.println("加密后："+e);
        System.out.println("解密后："+d);
        System.out.println("最大公约数："+gcd(5,20));
    }
}