华为4.10实习笔试题

题目一

题目描述：连续输入字符串，以空格键分割，输入字符串个数为n，请按长度为8拆分每个字符串后输出新的字符串数组，输出的字符串按照升序排列。长度不是8整数的在后面补0，空字符串不处理。第一个输入的字符串为个数n，后面的为n个待处理的字符串。
测试用例：
输入：

2 abc 1234567890

输出：

12345678 90000000 abc00000

java版本：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Huawei1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String str = sc.nextLine().trim();
        String[] strs = str.split(" ");
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            StringBuffer line = new StringBuffer(strs[i]);
            if (line.length() % 8 != 0) {
                line.append("0000000");
            }
            while (line.length() >= 8) {
                list.add(line.substring(0, 8));
                line = line.delete(0, 8);
            }
        }
        Collections.sort(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
    }
}

题目二

题目描述：给定一个字符串，字符串包含数字、大小写字母以及括号（包括大括号，中括号，小括号），括号可以嵌套，即括号里面可以出现数字和括号。
按照如下规则对字符串进行展开，不需要考虑括号不成对的问题，不考虑数字后面没有括号的情况，即 2a2(b)不考虑。

• 数字表示括号里的字符串重复的次数，展开后的字符串不包含括号
• 将字符串进行逆序展开

测试用例：
输入：

abc3(A)

输出：

AAAcba

java版本：

import java.util.LinkedList;
import java.util.Scanner;

public class Huawei2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine().trim();
        // 第一个stack存放整个字符串，用于最后出栈输出
        LinkedList<Character> stack1 = new LinkedList<>();
        // 第二个stack存放每一个括号里面需要重复的内容
        LinkedList<Character> stack2 = new LinkedList<>();
        // 第三个stack存放括号前面的数字
        LinkedList<Character> stack3 = new LinkedList<>();
        for (int i = 0; i < str.length(); i++) {
            char temp = str.charAt(i);
            // 遇到a-z,A-Z,0-9以及 (,[,{ 三种左括号直接入栈
            if ((temp >= 'A' && temp <= 'Z') || (temp >= 'a' && temp <= 'z') || (temp >= '0' && temp <= '9')) {
                stack1.push(temp);
            }
            if (temp == '(' || temp == '[' || temp == '{') {
                stack1.push(temp);
            }
            // 遇到右括号弹出括号内容以及前面可能存在的数字
            if (temp == ')' || temp == ']' || temp == '}') {
                if (temp == ')') {
                    while (stack1.getFirst() != '(') {
                        stack2.push(stack1.pop());
                    }
                }
                if (temp == ']') {
                    while (stack1.getFirst() != '[') {
                        stack2.push(stack1.pop());
                    }
                }
                if (temp == '}') {
                    while (stack1.getFirst() != '{') {
                        stack2.push(stack1.pop());
                    }
                }
                // 弹出左边的括号
                stack1.pop();
                // 弹出括号内容写入StringBuffer
                StringBuffer sb = new StringBuffer();
                while (!stack2.isEmpty()) {
                    sb.append(stack2.pop());
                }
                // 弹出左括号前面的数字，一定要判断 stack1 是不是为空！！！
                while (!stack1.isEmpty() && stack1.getFirst() >= '0' && stack1.getFirst() <= '9') {
                    stack3.push(stack1.pop());
                }
                if (!stack3.isEmpty()) {
                    StringBuffer sbNum = new StringBuffer();
                    while (!stack3.isEmpty()) {
                        sbNum.append(stack3.pop());
                    }
                    int count = Integer.parseInt(sbNum.toString());
                    StringBuffer add = new StringBuffer();
                    for (int j = 0; j < count; j++) {
                        add.append(sb.toString());
                    }
                    // 将括号里的内容复制count次，再压入到主栈 stack1 中
                    for (int k = 0; k < add.length(); k++) {
                        stack1.push(add.charAt(k));
                    }
                } else {
                    // 如果出现左边括号前没有数字的情况，如abc2{{A}},则把之前弹出的括号内的内容重新压入栈中
                    for (int j = 0; j < sb.length(); j++) {
                        stack1.push(sb.charAt(j));
                    }
                }

            }
        }
        while (!stack1.isEmpty()) {
            System.out.print(stack1.pop());
        }
        System.out.println();
    }
}

考试时只通过了80%的测试用例，经过排查发现可能存在两处问题：

1. 在从栈中弹出括号前面的数字时，需要先判断栈是否为空，避免遇到用例“3(AB)”时，出现NoSuchElementException（stack.getFirst()）或NullPointerException(stack1.peekFirst())错误
   
2. 如果出现括号前面没有数字的情况，如abc2((ABC))，应该先判断有没有读到数字，如果没有则将之前弹出的括号里的内容再次压入到栈 stack1 中。
   

题目三

题目描述：在N*M的地图上，每个点的海拔不同，从当前位置只能访问上下左右四个点且是没有访问过的点，此外下一步选择的点的海拔必须大于当前点。求从点A到点B一共有多少条路径，输出路数总数取余$10^9$。左上角的坐标为（0,0），右下角的坐标为（N-1,M-1）
测试用例：
输入：第一行为地图大小，下面n行为每个点的海拔，最后一行前两个为A坐标（x,y）,后两个为B坐标（z,v）

4 5
0 1 0 0 0
0 2 3 0 0
0 0 4 5 0
0 0 7 6 0
0 1 3 2

输出：

2

java版本：使用回溯法，递归求解，代码没有测试过，遇到复杂地图可能会超时

import java.util.Scanner;

public class Huawei3 {
    public int find(int[][] pos, int[] B, int i, int j, int n, int m) {
        if (i >= 0 && i < n && j >= 0 && j < m && i == B[0] && j == B[1]) {
            return 1;
        }
        int a = 0, b = 0, c = 0, d = 0;
        if (i >= 0 && i < n && j >= 0 && j < m && i + 1 < n && pos[i + 1][j] > pos[i][j]) {
            a = find(pos, B, i + 1, j, n, m);
        }
        if (i >= 0 && i < n && j >= 0 && j < m && i - 1 >= 0 && pos[i - 1][j] > pos[i][j]) {
            b = find(pos, B, i - 1, j, n, m);
        }
        if (i >= 0 && i < n && j >= 0 && j < m && j + 1 < m && pos[i][j + 1] > pos[i][j]) {
            c = find(pos, B, i, j + 1, n, m);
        }
        if (i >= 0 && i < n && j >= 0 && j < m && j - 1 >= 0 && pos[i][j - 1] > pos[i][j]) {
            d = find(pos, B, i, j - 1, n, m);
        }
        return a + b + c + d;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] pos = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                pos[i][j] = sc.nextInt();
            }
        }
        int[] A = new int[2];
        int[] B = new int[2];
        A[0] = sc.nextInt();
        A[1] = sc.nextInt();
        B[0] = sc.nextInt();
        B[1] = sc.nextInt();
        Huawei3 ob = new Huawei3();
        int count = ob.find(pos, B, A[0], A[1], n, m);
        System.out.println(count);
    }
}

第二种思路：使用迭代的方式，太晚了，待写。。。。

在这里插入代码片