nocoder - 华为

前言

华为开放的机试题难度等级分为：入门、简单、中等、较难、困难。我会根据难度等级分类列举几个题目的代码实现。

（代码 不一定是我的原创，我把这些算法集中记录下来，是希望感兴趣的朋友拿来就用或者一起研究算法。

另外，像这种企业面试现场让你写算法，有现成的api方法没必要自己去写，因为你写的可能漏洞百出，还可能不正确，做算法题要善于利用现有资源，毕竟java之父老人家的脑回路不会差）

1. 难度 - 困难

1.1 排序

1.1.1 HJ28 - 素数伴侣

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader((System.in)));
        String Str;
        while ((Str = br.readLine()) != null) {
            int n = Integer.valueOf(Str);
            String[] numArr = br.readLine().split(" ");
            int oddNum = 0;
            List<Integer> inputNums = new ArrayList<>();
            for (int i = 0; i < numArr.length; i++) {
                if (Integer.valueOf(numArr[i]) % 2 == 1) { //奇数
                    oddNum++;
                }
                inputNums.add(Integer.valueOf(numArr[i]));
            }
            //奇数数组
            int[] oddArr = new int[oddNum];
            //偶数数组
            int[] doubArr = new int[n - oddNum];
            int oddIndex = 0, doubIndex = 0;
            for (int i : inputNums) {
                if (i % 2 == 0) { //偶数
                    doubArr[doubIndex++] = i;
                } else {  //奇数
                    oddArr[oddIndex++] = i;
                }
            }

            //开始组合
            int count = 0;
            int nums[] = new int[n - oddNum];
            boolean[] use;
            for (int i = 0; i < oddArr.length; i++) {
                use = new boolean[n - oddNum];
                if (find(oddArr[i], doubArr, nums, use)) {
                    count++;
                }
            }
            System.out.println(count);
        }
    }

    /**
     * 奇偶数加和判定素数
     *
     * @param odd    奇数
     * @param douArr 偶数数组
     * @param nums
     * @param use
     * @return
     */
    private static boolean find(int odd, int[] douArr, int[] nums, boolean[] use) {
        for (int j = 0; j < douArr.length; j++) {
            if (isPrime(odd + douArr[j]) && !use[j]) {
                use[j] = true;
                if (nums[j] == 0 || find(nums[j], douArr, nums, use)) {//再次判定
                    nums[j] = odd;
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 判定是否为素数
     */
    private static boolean isPrime(int a) {
        if (a <= 1) {
            return false;
        }
        // 用a 去除以2到a-1之间的正整数，如果a能被除了a之外的数字整除，即说明该数不是素数
        for (int i = 2; i <= a - 1; i++) {
            if (a % i == 0) {
                return false;
            }
        }
        return true;
    }
}

2. 难度 - 较难

2.1 字符串

2.1.1 HJ33 整数与IP地址间的转换

import java.io.IOException;
import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String ipStr = in.nextLine();
            String longStr = in.nextLine();
            System.out.println(ipToLong(ipStr));
            System.out.println(longToIP(longStr));
        }
        in.close();
    }
        
    private static long ipToLong(String ipStr) {
        String[] ips = ipStr.split("\\.");
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < ips.length; i++) {
            String ipIntStr = Integer.toBinaryString(Integer.parseInt(ips[i]));
            if (ipIntStr.length() < 8) {
                while (ipIntStr.length() != 8)
                    ipIntStr = "0" + ipIntStr;
            }
            sb.append(ipIntStr);
        }
        return Long.valueOf(sb.toString(), 2);
    }
    
    private static String longToIP(String ipStr) {
        String binary = Long.toBinaryString(Long.parseLong(ipStr));
        StringBuilder sb = new StringBuilder();
        String s;
        int n;
        while (binary.length() > 0) {
            if (binary.length() % 8 != 0) {
                s = binary.substring(0, binary.length() % 8);
                binary = binary.substring(binary.length() % 8);
            } else {
                s = binary.substring(0, 8);
                binary = binary.substring(8);
            }
            n = Integer.parseInt(s, 2);
            if (binary.length() != 0) {
                sb.append(n + ".");
            } else {
                sb.append(n);
            }
        }
        return sb.toString();
    }
}