24.4.10华为笔试_华为4.10笔试题

华为笔试共有三道题，分值分别为100，200，300，场景应用题，阅读量较大

---

第一题 计费统计

计算用户话单
每条记录包括 时间戳、客户标识、计费因子、计费时长，要求记录中同一客户同一计费因子在相同时间戳上只能计费一次，选择第一次记录的数据，计算每个用户的总费用

输入
第1行 表示数据的条数n
n行数据记录
第n+1行 计费因子个数m
m行计费因子

示例：
5
1627845600,client1,factorA,10
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845610,client1,factorB,8
1627845620,client2,factorB,20
2
factorA,5
factorB,6
1
2
3
4
5
6
7
8
9
10

输出
客户以及对应的话单总费用，按客户标识字典序升序排序

示例：
client1,10
client2,23
1
2
3

自定义输入：
无重复记录
5
1627845600,client1,factorA,10
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845610,client1,factorB,8
1627845620,client2,factorB,20
2
factorA,5
factorB,6


存在重复记录
7
1627845600,client1,factorA,10
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845610,client1,factorB,8
1627845600,client1,factorA,5
1627845605,client2,factorB,50
1627845620,client2,factorB,20
2
factorA,5
factorB,6

计费时长超出范围
5
1627845600,client1,factorA,101
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845610,client1,factorB,8
1627845620,client2,factorB,20
2
factorA,5
factorB,6

计费时长超出范围，同时下面有相同记录
6
1627845600,client1,factorA,101
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845600,client1,factorA,10
1627845610,client1,factorB,8
1627845620,client2,factorB,20
2
factorA,5
factorB,6

不存在计费因子
6
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845600,client1,factorA,10
1627845610,client1,factorB,8
1627845620,client2,factorB,20
1627845605,client2,factorC,15
2
factorA,5
factorB,6

多个用户
6
1627845605,client2,factorB,15
1627845610,client1,factorA,5
1627845600,client1,factorA,10
1627845610,client1,factorB,8
1627845620,client2,factorB,20
1627845605,client3,factorC,15
2
factorA,5
factorB,6
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
66
67
68
69
70
71
72

思路分析

1. 使用数组进行接收输入数据，可以获得每条记录的字段
2. 使用map对计费因子进行接收，为后续使用可以快速查询
3. 遍历记录的数组，对每条记录进行不同情况的处理

代码如下：

import java.util.*;

/**
 * @author Joey
 * @version 1.0
 */
public class First {
    public static void main(String[] args) {
        // please define the JAVA input here. For example: Scanner s = new Scanner(System.in);
        Scanner in = new Scanner(System.in);
        int N = Integer.parseInt(in.nextLine());
        String[][] records = new String[N][];
        for (int i = 0; i < N; i++) {
            records[i] = in.nextLine().split(",");
            //System.out.println(Arrays.toString(records[i]));
        }

        int n = Integer.parseInt(in.nextLine());
        Map<String, Integer> factor = new HashMap<>();
        for (int i = 0; i < n; i++) {
            String[] factors = in.nextLine().split(",");
            //System.out.println(Arrays.toString(factors));
            factor.put(factors[0], Integer.parseInt(factors[1]));
        }
        //System.out.println(factor.toString());
        // please finish the function body here.
        //遍历一次数据即可
        //存放记录
        Set<String> set = new HashSet<>();
        //存放结果
        Map<String, Integer> result = new TreeMap();

        for (String[] record : records) {
            //首先查看是否有同样记录存在，如果存在跳过
            String key = record[0] + record[1] + record[2];
            if (set.contains(key)) continue;

            set.add(key); //将记录放进set

            //未有相同记录，判断计费时长是否合法，并计算当前记录总费用
            Integer time = Integer.parseInt(record[3]);
            if (time < 0 || time > 100) time = 0;

            Integer total = time == 0 ? 0 : time * factor.getOrDefault(record[2], 0);
            result.put(record[1], result.getOrDefault(record[1], 0) + total);
        }
        //System.out.println(result.toString());


        // please define the JAVA output here. For example: System.out.println(s.nextInt());
        Iterator<Map.Entry<String, Integer>> iterator = result.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next = iterator.next();
            System.out.println(next.getKey() + "," + next.getValue());
        }
    }
 }
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

小结

想的过于复杂，考场上不能快速确定Collection对数据进行处理，需要加强Collection、Map等的使用，主要是遍历方式。

---

第二题 相似图片分类

统计每类的相似度之和

规则：
1、相似度大于0，则相似
2、A和B相似，B和C相似，但A和C不相似。那么认为A和C间接相似，可以把ABC归为一类，但不计算AC的相似度
3、结果从大到小输出

输入
第1行 表示图片的张数n
n*n矩阵，表示第 i 张图片和第 j 张图片的相似度

示例：
5
0 0 50 0 0
0 0 0 25 0
50 0 0 0 15
0 25 0 0 0
0 0 15 0 0
1
2
3
4
5
6
7

输出
输出每个分类的相似度之和，从大到小排列

示例：
65 25
1
2

自定义输入：
第一组
5
0 0 50 0 0
0 0 0 25 0
50 0 0 0 15
0 25 0 0 0
0 0 15 0 0

第二组
6
0 20 0 30 0 0
20 0 0 0 0 0
0 0 0 60 0 0
30 0 60 0 0 0
0 0 0 0 0 20
0 0 0 0 20 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

思路分析

看到分类，想到了并查集，本来可以直接ac，败在不知道如何调整输出

代码如下：

package ee.exams.huawei4_10;

import java.util.*;

/**
 * @author Joey
 * @version 1.0
 */
public class Second {
    private static int[] father;
    private static void init() {
        for (int i = 0; i < father.length; i++) {
            father[i] = i;
        }
    }
    private static int find(int u) {
        if (u == father[u]) {
            return u;
        }
        else return father[u] = find(father[u]);
    }
    private static boolean isSame(int u, int v) {
        u = find(u);
        v = find(v);
        return u == v ? true : false;
    }
    //加入 边 u->v
    private static void join(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == v) return;
        father[u] = v;
    }
    public static void main(String[] args) {
        // please define the JAVA input here. For example: Scanner s = new Scanner(System.in);
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int[][] images = new int[N][N];
        for (int i = 0; i < N * N; i++) {
            images[i / N][i % N] = in.nextInt();
        }
        //System.out.println(Arrays.toString(images[0]));


        // please finish the function body here.
        //可以使用并查集
        father = new int[N];
        init();
        //遍历图像，加入并查集中
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                if (images[i][j] > 0) {
                    join(i, j);

                }
            }
        }
        //System.out.println(Arrays.toString(father));

        //获得并查集的情况下，如何获得集合
        //再次遍历图，判断两张图是否同一集合，如果是，且相似度不为0，统计结果
        //这里使用Map存放分类，分类的key为每个集合的根节点
        //考场上就是这里没想清楚
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                if (isSame(i, j) && images[i][j] != 0) {
                    map.put(find(i), map.getOrDefault(find(i), 0) + images[i][j]);
                }
            }
        }
        //System.out.println(map.toString());
        //获取map的values即可，存入List中，考场上也是这里没想好，map、list之间转换不够熟悉
        Collection<Integer> values = map.values();
        List<Integer> list = new ArrayList<>(values);
        list.sort((a,b)->{
            return b.compareTo(a);
        });

        // please define the JAVA output here. For example: System.out.println(s.nextInt());
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
            if (i != list.size() - 1) System.out.print(" ");
        }
    }
}

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

小结

1. 能够想到并查集，并将并查集的主要代码写出
2. 对集合类之间的转换、遍历方式、不够熟悉