华为OD笔试题记录-2024.4.21

密码解密

给定一段 “密文”字符串 s ，其中字符都是经过 “密码本” 映射的，现需要将“密文”解密并且输出。
链接：https://www.nowcoder.com/issue/tutorial?zhuanlanId=MVBqEM&uuid=2a6e236e15bc40b7b2d432c604d3e5fa

映射的规则：

( a−i ) 分别用(1−9 )表示；
(j−z ) 分别用(10∗−26∗ )表示。

题解

本人答案

public class Demo1 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map<String, String> map = new HashMap<>();
        for (int i = 1; i <= 26; i++) {
            String key = i > 9 ? i + "*" : i + "";
            char ch = (char) (i + 96);
            String value = String.valueOf(ch).toLowerCase();
            map.put(key, value);
        }
        String input = in.nextLine();
        String result = "";
        String str = "";
        for (int i = 0, len = input.length(); i < len; i++) {
            char ch = input.charAt(i);
            if (input.contains("*")) {
                str += String.valueOf(ch);
                if (ch == '*') {
                    result += map.get(str);
                    str = "";
                }
            } else {
                result += map.get(String.valueOf(ch));
            }
        }
        if (result.length() > 100) {
            result = result.substring(0, 100);
        }
        System.out.println(result);
    }
}

指令与幸运数

小明在玩一个游戏，游戏规则如下:在游戏开始前，小明站在坐标轴原点处(坐标值为0)给定一组指令和一个幸运数，每个指令都是一个整数，小明按照指定的要求前进或者后退指定的步数。

前进代表朝坐标轴的正方向走，后退代表朝坐标轴的负方向走，幸运数为一个整数，如果某个指令正好和幸运数相等，则小明行进步数加 1。

例如: 幸运数为 3，指令内[ 2 , 3 , 0 , −5 ]

指令为 2，表示前进 2步

指令为 3 正好好和幸运数相等，前进 3+1=4步

指令为 0,表示原地不动，既不前进，也不后退

指令为 5,表示后退 5步。

请你计算小明在整个游戏过程中，小明所处的最大坐标值。

输入描述
第一行输入 1 个数字，代表指令的总个数 n ( 1≤n≤100)

第二行输入 1 个数字，代表幸运数 m ( −100≤m≤100)

第三行输入 n 个指令，每个指令值的取值范围为: −100≤指令值≤100

输出描述
输出在整个游戏过程中，小明所处的最大坐标值。异常情况下输出：12345

链接：https://www.nowcoder.com/discuss/599203339292745728

题解

本人答案

public class Demo2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int beginPosition = 0;
        int orderNum = in.nextInt();
        int luckyNum = in.nextInt();

        int max = beginPosition;
        for (int i = 0; i < orderNum; i++) {
            int num = in.nextInt();
            beginPosition += num;
            if (num == luckyNum && luckyNum < 0) {
                beginPosition -= 1;
            } else if (num == luckyNum && luckyNum >= 0) {
                beginPosition += 1;
            }
            max = Math.max(max, beginPosition);
        }
        System.out.println(max);
    }
}

数据单元的变量替换

题目描述
将一个 csv 格式的数据文件中包含有单元格引用的内容替换为对应单元格内容的实际值。

comma separated values(CSV) 逗号分隔值，csv 格式的数据文件使用逗号 “,” 作为分隔符将各单元的内容进行分隔。

输入描述
输入只有一行数据，用逗号分隔每个单元格，行尾没有逗号。最多26个单元格，对应编号A~Z。

每个单元格的内容包含字母和数字，以及使用 ‘<>’ 分隔的单元格引用，例如：表示引用第一个单元的值。

每个单元格的内容，在替换前和替换后均不超过100个字符。

引用单元格的位置不受限制，允许排在后面的单元格被排在前面的单元格引用。

不存在循环引用的情况，比如下面这种场景是不存在的：

A单元恪：aCd8U

B单元格：KAyuZq0

不存在多重 ‘<>’ 的情况，一个单元只能引用一个其他单元格。比如下面这种场景是不存在的：

A单元格：aCdOu

B单元格：kAydzco

C单元格：y<>d

输出描述
输出替换后的结果

用例1
输入
1,200
输出
1,2100
说明
第二个单元中有对A单元的引用，A单元格的值为1，替换时，将A单元的内容替代的位置，并和其他内容合并。

用例2
输入
12,1
输出
112,1
说明
第一个单元中有对B单元的引用，B单元格的值为1，耆换时，将第二个数据第单元的内容替代的位置，并和其他内容合并

用例3
输入

输出
-1
说明
第一个单元中有错误的单元格引用方式，输出字符串"-1"表示错误

题解

本人答案

public class Demo3 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map<Integer, String> map = new HashMap<>();
        String line = in.nextLine();
        String[] lineArr = line.split(",");
        for (int i = 0, len = lineArr.length; i < len; i++) {
            map.put(i, lineArr[i]);
        }
        List<String> list = new LinkedList<>();
        Map<Integer, Integer> hash = new HashMap<>();
        for (int i = 0, len = lineArr.length; i < len; i++) {
            String grid = lineArr[i];
            for (int j = 0, gridLen = grid.length(); j < gridLen; j++) {
                char ch = grid.charAt(j);
                Integer key = Integer.parseInt(String.valueOf(ch));
                if (map.containsKey(key) && i != key) {
                    if (j == 0) j = 1;
                    grid = grid.substring(0, j) + map.get(key) + grid.substring(j);
                    hash.put(i, key);
                    break;
                }
            }
            list.add(grid);
            // 处理循环引用
            if (hash.containsKey(i) && hash.containsKey(hash.get(i)) && Objects.equals(i, hash.get(hash.get(i)))) {
                list.set(hash.get(i), lineArr[hash.get(i)]);
            }
        }
        String res = list.stream().collect(Collectors.joining(","));
        System.out.println(res);
    }
}