陈浪平的博客
0%

8月12日华为笔试

发表于 更新于 分类于 Disqus：
本文字数： 4.1k 阅读时长 ≈ 4 分钟

前言

很简单….真的也没什么好说的，就是单纯记录下吧

第一题

假设咖啡卖 5 元，每个客户可能给你 5、10、20 元的纸币，初始情况下你没有任何纸币，问是否能够找零。如果能找零就输出 true，总用户数， 否则输出 false,失败的用户index。
例如：
5,5,5,10 => true,4
10,10 => false,1

那就直接做呗…还能有什么呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
import java.util.Scanner;

public class Main {

    private static boolean success = true;

    public static void main(String[] args) {

        // money[0]=5元个数 money[1]=10元个数 money[2]=20元个数 其实money[2]并没有用...
        int[] money = new int[3];
        for (int i = 0; i < money.length; i++) {
            money[i] = 0;
        }
        Scanner sc = new Scanner(System.in);
        int index = 1;
        String s = sc.nextLine();
        String[] split = s.split(",");
        for (int i = 0; i < split.length; i++) {
            int spend = Integer.valueOf(split[i]);
            helper(money, spend, index);
            index++;
            if (!success) {
                break;
            }
        }
        if (success) {
            System.out.println("true," + (index - 1));
        }
    }

    private static void helper(int[] money, int spend, int index) {
        if (spend == 20) {
            // 找15元
            // 1. 10+5
            if (money[1] >= 1 && money[0] >= 1) {
                money[1] -= 1;
                money[0] -= 1;
                return;
            }
            // 2. 5+5+5
            if (money[0] >= 3) {
                money[0] -= 3;
                return;
            }
            // 找不出来
            System.out.println("false," + index);
            success = false;
        } else if (spend == 10) {
            // 找5元
            if (money[0] >= 1) {
                money[0] -= 1;
                money[1] += 1;
            } else {
                System.out.println("false," + index);
                success = false;
            }
        } else if (spend == 5) {
            money[0] += 1;
        } else {
            System.out.println("false," + index);
            success = false;
        }

    }
}

第二题

小明步长s, 有一个 M x N 的矩阵， 1 表示能走 0 表示不能走，小明可以横着走竖着走，方向不限制，问小明能否从左上角走到右下角，左上角和右下角确保一定是1。

思路上么肯定是dfs，然后不知道为什么就只过了80%。后来去网上看了说什么往回走，我这个方法就是往回走，而且我也把重复的去掉了，但是不知道为什么就是不能AC。

后来想了一下，可能是不用每次都刚好走完的意思吧….

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import java.util.Scanner;

/**
 * @author chenlangping
 * @date 2020/8/12
 */
public class Main {

    private static int s = 0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        s = sc.nextInt();
        int m = sc.nextInt();
        int n = sc.nextInt();
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
            }
        }

        int i = arr.length - 1;
        int j = arr[0].length - 1;
        if (s <= 0) {
            System.out.println(0);
        }

        if (dfs(arr, i, j)) {
            System.out.print(1);
        } else {
            System.out.print(0);
        }
    }

    private static boolean dfs(int[][] arr, int i, int j) {

        if (arr[i][j] != 1) {
            return false;
        }

        // 此时的a[i][j] 一定是1
        arr[i][j] = 0;
        if ((i == s && j == s) || (i == 0 && j == s) || (i == s && j == 0)) {
            return true;
        } else if (i < s || j < s) {
            return false;
        } else if (arr[i - s][j] == 1 && arr[i][j - s] == 1) {
            return dfs(arr, i - s, j) || dfs(arr, i, j - s);
        } else if (arr[i - s][j] == 1 && arr[i][j - s] == 0) {
            return dfs(arr, i - s, j);
        } else if (arr[i - s][j] == 0 && arr[i][j - s] == 1) {
            return dfs(arr, i, j - s);
        } else if (arr[i - s][j] == 0 && arr[i][j - s] == 0){
            return false;
        }
        return false;
    }
}

第三题

给定一个字符串和一个奇数，按照X型来输出，比如给的奇数是5，那么index应该是下面这样：

image-20200813002112498

然后得到这个X字型的图之后，从上到下按照列进行输出，比如上面的就应该输出 1,8,15,3,6,10,13.....

这题乍一看肯定是模拟一下最容易想到，但是这样开一个二维数组，我感觉必然是空间要超的（后来看帖子好像也没超….）

那就老老实实找规律慢慢做喽：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author chenlangping
 * @date 2020/8/12
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String allLine = sc.nextLine();
        String[] split = allLine.split(",");
        String s = split[0];


        //
        int length = s.length();
        int num = Integer.valueOf(split[1]);

        List<Character> result = new ArrayList<>(length);

        int k = 2 * num - 3;
        int turn = 0;
        for (int i = 0; i < num - 1; i = i + 2) {
            int h = k - 4 * turn;
            int j = i;
            while (j < length) {
                result.add(s.charAt(j));
                j += h;
                h = k - h;
                if (h == 0) {
                    h = k - 4 * i;
                }
            }
            turn++;
        }

        int middle = num - 1;
        while (middle < length) {
            result.add(s.charAt(middle));
            middle = middle + k;
        }

        turn = 0;
        for (int i = num - 2; i > 0; i -= 2) {
            int h = 4 * turn + 3;
            int j = i;
            while (j < length) {
                result.add(s.charAt(j));
                j += h;
                h = k - h;
                if (h == 0) {
                    h = k;
                }
            }
            turn++;
        }

        for (Character character : result) {
            System.out.print(character);
        }

    }
}

总结

华为这笔试应该是毫无难度的，但是我第二题应该是考虑得不够仔细，稍微扣了一点。