华为OD机试 - 密室逃生游戏（Python/JS/C/C++ 2024 E卷 100分）

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

小强在参加《密室逃生》游戏，当前关卡要找到符合给定密-码 K（升序的不重复小写字母组成）的箱子，并给出箱子编号，箱子编号为 1~N。

每个箱子中都有一个字符串，字符串由大写字母、小写字母、数字、标点符号、空格组成，需要在这些字符串中找到所有的字母，忽略大小写后排列出对应的密-码，并返回匹配密-码的箱子序号。

提示：满足条件的箱子不超过 1 个。

二、输入描述

第一行为 key 的字符串，
第二行为箱子 boxes，为数组样式，以空格分隔

• 箱子 N 数量满足 1 ≤ N ≤ 10000，
• ≤ K.length ≤ 50，
• 密-码仅包含小写字母的升序字符串，且不会有重复字母，
• 密-码 K 长度 1 ≤ K.length ≤ 26。

三、输出描述

返回匹配的箱子编号

如果不存在包含要求的密-码的箱子，则返回 -1。

四、测试用例

测试用例1：

1、输入

abc
s,sdf134 A2c4b

2、输出

2

3、说明

第 2 个箱子中的 Abc，符合密-码 abc。

测试用例2：

1、输入

xyz
Hello World XYZ123

2、输出

3

3、说明

第3个箱子中的 XYZ123 提取字母后为 x, y, z，排序后为 xyz，与密-码匹配。

五、解题思路

1. 输入读取：
   • 使用 Scanner 读取第一行作为密-码 K。
   • 读取第二行并将其按空格分隔，得到所有的箱子字符串。
2. 处理每个箱子：
   • 对于每个箱子字符串，遍历其中的每个字符。
   • 过滤出字母字符，忽略大小写，将其转换为小写。
   • 使用 TreeSet 来存储这些字母，以去重并自动排序。
3. 比较与输出：
   • 将 TreeSet 中的字母拼接成字符串。
   • 与密-码 K 进行比较。
   • 如果匹配，则记录当前箱子的编号并输出。
   • 如果遍历所有箱子后仍未找到匹配的箱子，则输出 -1。

六、Python算法源码

# Python版本

# 导入必要的模块
import sys

def main():
    # 读取密-码 K，去除首尾空白字符
    K = sys.stdin.readline().strip()
    
    # 读取所有箱子字符串，按空格分隔
    boxes_line = sys.stdin.readline().strip()
    boxes = boxes_line.split()
    
    # 遍历每个箱子
    for i in range(len(boxes)):
        box = boxes[i]
        letters_set = set()
        
        # 提取字母并转换为小写，存入集合去重
        for c in box:
            if c.isalpha():
                letters_set.add(c.lower())
        
        # 将集合中的字母排序并拼接成字符串
        sorted_letters = ''.join(sorted(letters_set))
        
        # 比较与密-码 K
        if sorted_letters == K:
            # 输出箱子编号（1-based）
            print(i + 1)
            return
    
    # 如果没有匹配的箱子，输出 -1
    print(-1)

# 调用主函数
if __name__ == "__main__":
    main()

七、JavaScript算法源码

// JavaScript版本

// 引入读取输入的模块
const readline = require('readline');

// 创建接口实例
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 存储输入的行
const input = [];

// 读取每一行输入
rl.on('line', (line) => {
    input.push(line.trim());
    // 当输入行数达到2行时，开始处理
    if (input.length === 2) {
        rl.close();
    }
}).on('close', () => {
    // 第一行是密-码 K
    const K = input[0];
    
    // 第二行是箱子字符串，按空格分隔
    const boxes = input[1].split(' ');
    
    // 遍历每个箱子
    for (let i = 0; i < boxes.length; i++) {
        const box = boxes[i];
        const lettersSet = new Set();
        
        // 提取字母并转换为小写，存入Set去重
        for (let c of box) {
            if (/[a-zA-Z]/.test(c)) {
                lettersSet.add(c.toLowerCase());
            }
        }
        
        // 将Set中的字母排序并拼接成字符串
        const sortedLetters = Array.from(lettersSet).sort().join('');
        
        // 比较与密-码 K
        if (sortedLetters === K) {
            // 输出箱子编号（1-based）
            console.log(i + 1);
            process.exit(0);
        }
    }
    
    // 如果没有匹配的箱子，输出 -1
    console.log(-1);
});

八、C算法源码

// C语言版本

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

// 定义最大箱子数量和字符串长度
#define MAX_BOXES 10000
#define MAX_STR_LEN 1001

int main() {
    char K[51]; // 密-码 K，最大长度50
    char boxes_line[MAX_BOXES * MAX_STR_LEN]; // 存储所有箱子字符串
    char *boxes[MAX_BOXES]; // 存储每个箱子的指针
    int box_count = 0;
    
    // 读取密-码 K
    if (scanf("%50s", K) != 1) {
        // 输入错误，退出
        printf("-1\n");
        return 0;
    }
    
    // 读取剩余行作为箱子字符串
    // 使用 getchar() 读取换行符后的内容
    getchar(); // 读取换行符
    if (fgets(boxes_line, sizeof(boxes_line), stdin) == NULL) {
        // 输入错误，退出
        printf("-1\n");
        return 0;
    }
    
    // 分割箱子字符串，按空格分隔
    char *token = strtok(boxes_line, " \n");
    while (token != NULL && box_count < MAX_BOXES) {
        boxes[box_count++] = token;
        token = strtok(NULL, " \n");
    }
    
    // 遍历每个箱子
    for (int i = 0; i < box_count; i++) {
        char letters[27] = {0}; // 存储26个字母
        int letter_present[26] = {0}; // 标记字母是否存在
        int unique_count = 0;
        
        // 提取字母并转换为小写，标记存在的字母
        for (int j = 0; boxes[i][j] != '\0'; j++) {
            if (isalpha(boxes[i][j])) {
                char lc = tolower(boxes[i][j]);
                if (!letter_present[lc - 'a']) {
                    letter_present[lc - 'a'] = 1;
                    letters[unique_count++] = lc;
                }
            }
        }
        
        // 排序字母
        for (int m = 0; m < unique_count - 1; m++) {
            for (int n = m + 1; n < unique_count; n++) {
                if (letters[m] > letters[n]) {
                    char temp = letters[m];
                    letters[m] = letters[n];
                    letters[n] = temp;
                }
            }
        }
        letters[unique_count] = '\0'; // 添加字符串结束符
        
        // 比较与密-码 K
        if (strcmp(letters, K) == 0) {
            // 输出箱子编号（1-based）
            printf("%d\n", i + 1);
            return 0;
        }
    }
    
    // 如果没有匹配的箱子，输出 -1
    printf("-1\n");
    return 0;
}

九、C++算法源码

// C++版本

#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false); // 关闭同步，加快输入速度
    cin.tie(0); // 取消 cin 的 tie
    
    string K; // 密-码 K
    cin >> K;
    
    string boxes_line; // 存储所有箱子字符串
    getline(cin, boxes_line); // 读取剩余行
    while(boxes_line.empty()) { // 如果第一次getline读取的是空行，继续读取
        getline(cin, boxes_line);
    }
    
    // 分割箱子字符串，按空格分隔
    vector<string> boxes;
    string box;
    stringstream ss(boxes_line);
    while(ss >> box){
        boxes.push_back(box);
    }
    
    // 遍历每个箱子
    for(int i = 0; i < boxes.size(); i++){
        string box_str = boxes[i];
        set<char> letters_set;
        
        // 提取字母并转换为小写，存入 set 去重并排序
        for(char c : box_str){
            if(isalpha(c)){
                letters_set.insert(tolower(c));
            }
        }
        
        // 构建排序后的字母字符串
        string sorted_letters = "";
        for(auto c : letters_set){
            sorted_letters += c;
        }
        
        // 比较与密-码 K
        if(sorted_letters == K){
            // 输出箱子编号（1-based）
            cout << (i + 1) << "\n";
            return 0;
        }
    }
    
    // 如果没有匹配的箱子，输出 -1
    cout << "-1\n";
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。