自学内容网 自学内容网
自学内容网 > 正文

【2024年华为OD机试】(A卷,100分)- 猜字谜（Java & JS & Python&C/C++）

🕗 发布于 2025-01-14 21:12 华为od  java  javascript  python  c语言  

在这里插入图片描述

一、问题描述

小王设计了一个简单的猜字谜游戏，游戏的谜面是一个错误的单词，比如 nesw，玩家需要猜出谜底库中正确的单词。猜中的要求如下：

对于某个谜面和谜底单词，满足下面任一条件都表示猜中：

  1. 变换顺序以后一样的，比如通过变换 w 和 e 的顺序，nwes 跟 news 是可以完全对应的；
  2. 字母去重以后是一样的，比如 woood 和 wood 是一样的，它们去重后都是 wod。

请你写一个程序帮忙在谜底库中找到正确的谜底。谜面是多个单词，都需要找到对应的谜底，如果找不到的话，返回 not found。

输入描述

  1. 谜面单词列表，以 “,” 分隔。
  2. 谜底库单词列表，以 "," 分隔。

输出描述

匹配到的正确单词列表，以 "," 分隔。如果找不到，返回 not found。

备注

  • 单词的数量 N 的范围：0 < N < 1000
  • 词汇表的数量 M 的范围：0 < M < 1000
  • 单词的长度 P 的范围：0 < P < 20
  • 输入的字符只有小写英文字母，没有其他字符。

用例

输入
conection
connection,today
输出
connection
说明

谜面 conection 与谜底库中 connection 是匹配的。

输入
bdni,wooood
bind,wrong,wood
输出
bind,wood
说明

谜面 bdni 经过变换顺序后匹配 bind，wooood 去重后匹配 wood。

输入
abc
def,ghi
输出
not found

根据题目描述，谜面和谜底单词满足以下任一条件即表示猜中：

  1. 变换顺序后相同：例如，通过变换字母顺序，“nwes”与“news”可以完全对应。
  2. 字母去重后相同：例如，“woood”和“wood”去重后都是“wod”，因此它们被认为是相同的。

如果谜面和谜底单词同时满足这两个条件，根据题目的逻辑，仍然算作猜中。因此，我们可以采用以下方法来判断是否猜中：

  1. 去重：将谜面和谜底单词中的重复字母去掉。
  2. 排序：将去重后的字母按字典序排序。
  3. 对比：如果排序后的结果相同，则说明谜面和谜底单词满足条件，猜中。

思路具体步骤：

  1. 对谜面单词和谜底单词分别进行去重操作。
  2. 对去重后的字母进行字典序排序。
  3. 比较排序后的结果，如果相同，则猜中。

示例：

  • 谜面单词：nwes
  • 谜底单词：news
  1. 去重：
    • nwes 去重后为 nwes（无重复字母）。
    • news 去重后为 news（无重复字母）。
  2. 排序：
    • nwes 排序后为 ensw。
    • news 排序后为 ensw。
  3. 对比：
    • 排序后的结果相同，因此猜中。

总结：

如果谜面和谜底单词在去重并排序后结果相同，则算作猜中。这种方法可以同时处理变换顺序

二、JavaScript算法源码

以下是两段代码的中文详细注释和逻辑讲解：

代码 1：两个条件都满足才算猜中

代码逻辑
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const lines = [];
rl.on("line", (line) => {
  lines.push(line);

  if (lines.length === 2) {
    const issues = lines[0].split(",");  // 谜面数组
    const answers = lines[1].split(",");  // 谜底数组
    console.log(getResult(issues, answers));  // 调用 getResult 函数计算结果并输出
    lines.length = 0;  // 清空 lines 数组，准备接收下一组输入
  }
});

function getResult(issues, answers) {
  const ans = [];  // 存储每个谜面对应的谜底

  for (let issue of issues) {
    const str1 = [...new Set(issue)].sort().join("");  // 对谜面去重、排序后生成字符串
    let find = false;  // 标记是否找到匹配的谜底

    for (let answer of answers) {
      const str2 = [...new Set(answer)].sort().join("");  // 对谜底去重、排序后生成字符串
      if (str1 === str2) {  // 如果谜面和谜底去重排序后的字符串相同
        ans.push(answer);  // 将谜底加入结果数组
        find = true;  // 标记为找到
        // break; // 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下
      }
    }

    if (!find) {
      ans.push("not found");  // 如果没有找到匹配的谜底，加入 "not found"
    }
  }

  return ans.join(",");  // 将结果数组用逗号连接成字符串并返回
}
代码讲解

  1. 输入处理：

    • 使用 readline 模块读取输入。
    • 第一行是谜面数组 issues，第二行是谜底数组 answers。
    • 当输入两行后，调用 getResult 函数计算结果并输出。

  2. 去重和排序：

    • 对每个谜面 issue 和谜底 answer 进行去重和排序，生成字符串 str1 和 str2。
    • 去重使用 new Set()，排序使用 sort()。

  3. 匹配逻辑：

    • 如果 str1 和 str2 相同，说明谜面和谜底去重排序后的字符相同，匹配成功。
    • 将匹配的谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 输出结果：

    • 将结果数组 ans 用逗号连接成字符串并返回。

代码 2：唯一条件满足才算猜中

代码逻辑
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const lines = [];
rl.on("line", (line) => {
  lines.push(line);

  if (lines.length === 2) {
    const issues = lines[0].split(",");  // 谜面数组
    const answers = lines[1].split(",");  // 谜底数组
    console.log(getResult(issues, answers));  // 调用 getResult 函数计算结果并输出
    lines.length = 0;  // 清空 lines 数组，准备接收下一组输入
  }
});

function getResult(issues, answers) {
  const ans = [];  // 存储每个谜面对应的谜底

  for (let issue of issues) {
    const sorted_issue = [...issue].sort().join("");  // 对谜面排序后生成字符串
    const distinct_issue = [...new Set(issue)].join("");  // 对谜面去重后生成字符串
    let find = false;  // 标记是否找到匹配的谜底

    for (let answer of answers) {
      const sorted_answer = [...answer].sort().join("");  // 对谜底排序后生成字符串
      const distinct_answer = [...new Set(answer)].join("");  // 对谜底去重后生成字符串

      if (
        sorted_issue === sorted_answer ||  // 排序后字符串相同
        distinct_issue === distinct_answer  // 去重后字符串相同
      ) {
        ans.push(answer);  // 将谜底加入结果数组
        find = true;  // 标记为找到
        // break; // 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下
      }
    }

    if (!find) {
      ans.push("not found");  // 如果没有找到匹配的谜底，加入 "not found"
    }
  }

  return ans.join(",");  // 将结果数组用逗号连接成字符串并返回
}
代码讲解

  1. 输入处理：

    • 使用 readline 模块读取输入。
    • 第一行是谜面数组 issues，第二行是谜底数组 answers。
    • 当输入两行后，调用 getResult 函数计算结果并输出。

  2. 排序和去重：

    • 对每个谜面 issue 和谜底 answer 分别进行排序和去重，生成两个字符串：
      • sorted_issue 和 sorted_answer：排序后的字符串。
      • distinct_issue 和 distinct_answer：去重后的字符串。

  3. 匹配逻辑：

    • 如果 sorted_issue === sorted_answer 或 distinct_issue === distinct_answer，说明谜面和谜底满足其中一个条件，匹配成功。
    • 将匹配的谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 输出结果：

    • 将结果数组 ans 用逗号连接成字符串并返回。

两段代码的区别

  1. 匹配条件：

    • 代码 1：要求谜面和谜底去重排序后的字符串完全相同。
    • 代码 2：要求谜面和谜底排序后的字符串相同 或 去重后的字符串相同。

  2. 适用场景：

    • 代码 1：适用于严格匹配场景，谜面和谜底必须完全一致（去重排序后）。
    • 代码 2：适用于宽松匹配场景，谜面和谜底只需满足其中一个条件即可。

示例解析

输入
abc,bac,aa
cba,aab,xyz
代码 1 运行结果
cba,aab,not found
  • 解析：
    • abc 和 cba 去重排序后均为 abc，匹配成功。
    • bac 和 aab 去重排序后分别为 abc 和 ab，不匹配。
    • aa 和 xyz 去重排序后分别为 a 和 xyz，不匹配。
代码 2 运行结果
cba,aab,not found
  • 解析：
    • abc 和 cba 排序后均为 abc，匹配成功。
    • bac 和 aab 排序后分别为 abc 和 aab，不匹配。
    • aa 和 xyz 去重后分别为 a 和 xyz，不匹配。

总结

  • 代码 1 和代码 2 的核心逻辑相似，主要区别在于匹配条件的严格程度。
  • 代码 1 要求谜面和谜底去重排序后完全相同，代码 2 只需满足排序或去重中的一个条件即可。
  • 根据实际需求选择合适的匹配条件。

如果有其他问题，欢迎随时提问！

三、Java算法源码

以下是两段 Java 代码的中文详细注释和逻辑讲解：

代码 1：两个条件都满足才算猜中

代码逻辑
import java.util.ArrayList;
import java.util.Scanner;
import java.util.StringJoiner;
import java.util.TreeSet;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    String[] issues = sc.nextLine().split(",");  // 读取谜面数组
    String[] answers = sc.nextLine().split(",");  // 读取谜底数组

    System.out.println(getResult(issues, answers));  // 调用 getResult 函数计算结果并输出
  }

  public static String getResult(String[] issues, String[] answers) {
    ArrayList<String> ans = new ArrayList<>();  // 存储每个谜面对应的谜底

    for (String issue : issues) {
      String str1 = getSortedAndDistinctStr(issue);  // 对谜面去重、排序后生成字符串
      boolean find = false;  // 标记是否找到匹配的谜底

      for (String answer : answers) {
        String str2 = getSortedAndDistinctStr(answer);  // 对谜底去重、排序后生成字符串
        if (str1.equals(str2)) {  // 如果谜面和谜底去重排序后的字符串相同
          ans.add(answer);  // 将谜底加入结果数组
          find = true;  // 标记为找到
          // break; // 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下
        }
      }

      if (!find) {
        ans.add("not found");  // 如果没有找到匹配的谜底，加入 "not found"
      }
    }

    StringJoiner sj = new StringJoiner(",", "", "");  // 使用 StringJoiner 拼接结果
    for (String an : ans) {
      sj.add(an);
    }
    return sj.toString();  // 返回拼接后的字符串
  }

  public static String getSortedAndDistinctStr(String str) {
    TreeSet<Character> set = new TreeSet<>();  // 使用 TreeSet 去重并排序
    for (char c : str.toCharArray()) set.add(c);
    return set.toString();  // 返回去重排序后的字符串
  }
}
代码讲解

  1. 输入处理：

    • 使用 Scanner 读取输入。
    • 第一行是谜面数组 issues，第二行是谜底数组 answers。
    • 调用 getResult 函数计算结果并输出。

  2. 去重和排序：

    • 对每个谜面 issue 和谜底 answer 进行去重和排序，生成字符串 str1 和 str2。
    • 使用 TreeSet 实现去重和排序。

  3. 匹配逻辑：

    • 如果 str1 和 str2 相同，说明谜面和谜底去重排序后的字符相同，匹配成功。
    • 将匹配的谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 输出结果：

    • 使用 StringJoiner 将结果数组 ans 用逗号连接成字符串并返回。

代码 2：唯一条件满足才算猜中

代码逻辑
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] issues = sc.nextLine().split(",");  // 读取谜面数组
        String[] answers = sc.nextLine().split(",");  // 读取谜底数组

        System.out.println(getResult(issues, answers));  // 调用 getResult 函数计算结果并输出
    }

    public static String getResult(String[] issues, String[] answers) {
        ArrayList<String> ans = new ArrayList<>();  // 存储每个谜面对应的谜底

        for (String issue : issues) {
            String[] issueDeal = getSortedAndDistinctStr(issue);  // 对谜面排序和去重后生成字符串数组
            boolean find = false;  // 标记是否找到匹配的谜底

            for (String answer : answers) {
                String[] answerDeal = getSortedAndDistinctStr(answer);  // 对谜底排序和去重后生成字符串数组

                if(issueDeal[0].equals(answerDeal[0]) || issueDeal[1].equals(answerDeal[1])) {  // 如果排序后字符串相同或去重后字符串相同
                    ans.add(answer);  // 将谜底加入结果数组
                    find = true;  // 标记为找到
                    // break; // 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下
                }
            }

            if(!find) {
                ans.add("not found");  // 如果没有找到匹配的谜底，加入 "not found"
            }
        }

        StringJoiner sj = new StringJoiner(",","","");  // 使用 StringJoiner 拼接结果
        for (String an : ans) {
            sj.add(an);
        }
        return sj.toString();  // 返回拼接后的字符串
    }

    public static String[] getSortedAndDistinctStr(String str) {
        char[] arr = str.toCharArray();
        Arrays.sort(arr);  // 对字符数组排序
        String sorted_str = new String(arr);  // 生成排序后的字符串

        LinkedHashSet<Character> set = new LinkedHashSet<>();  // 使用 LinkedHashSet 去重
        for (char c : str.toCharArray()) set.add(c);
        String distinct_str = set.toString();  // 生成去重后的字符串

        return new String[]{sorted_str, distinct_str};  // 返回排序后和去重后的字符串数组
    }
}
代码讲解

  1. 输入处理：

    • 使用 Scanner 读取输入。
    • 第一行是谜面数组 issues，第二行是谜底数组 answers。
    • 调用 getResult 函数计算结果并输出。

  2. 排序和去重：

    • 对每个谜面 issue 和谜底 answer 分别进行排序和去重，生成两个字符串：
      • sorted_str：排序后的字符串。
      • distinct_str：去重后的字符串。

  3. 匹配逻辑：

    • 如果 sorted_str 相同 或 distinct_str 相同，说明谜面和谜底满足其中一个条件，匹配成功。
    • 将匹配的谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 输出结果：

    • 使用 StringJoiner 将结果数组 ans 用逗号连接成字符串并返回。

两段代码的区别

  1. 匹配条件：

    • 代码 1：要求谜面和谜底去重排序后的字符串完全相同。
    • 代码 2：要求谜面和谜底排序后的字符串相同 或 去重后的字符串相同。

  2. 适用场景：

    • 代码 1：适用于严格匹配场景，谜面和谜底必须完全一致（去重排序后）。
    • 代码 2：适用于宽松匹配场景，谜面和谜底只需满足其中一个条件即可。

示例解析

输入
abc,bac,aa
cba,aab,xyz
代码 1 运行结果
cba,not found,not found
  • 解析：
    • abc 和 cba 去重排序后均为 [a, b, c]，匹配成功。
    • bac 和 aab 去重排序后分别为 [a, b, c] 和 [a, b]，不匹配。
    • aa 和 xyz 去重排序后分别为 [a] 和 [x, y, z]，不匹配。
代码 2 运行结果
cba,aab,not found
  • 解析：
    • abc 和 cba 排序后均为 abc，匹配成功。
    • bac 和 aab 去重后分别为 bac 和 ab，不匹配。
    • aa 和 xyz 去重后分别为 a 和 xyz，不匹配。

总结

  • 代码 1 和代码 2 的核心逻辑相似，主要区别在于匹配条件的严格程度。
  • 代码 1 要求谜面和谜底去重排序后完全相同，代码 2 只需满足排序或去重中的一个条件即可。
  • 根据实际需求选择合适的匹配条件。

如果有其他问题，欢迎随时提问！

四、Python算法源码

以下是两段 Python 代码的中文详细注释和逻辑讲解：

代码 1：两个条件都满足才算猜中

代码逻辑
# 输入获取
issues = input().split(",")  # 读取谜面数组
answers = input().split(",")  # 读取谜底数组


# 算法入口
def getResult(issues, answers):
    ans = []  # 存储每个谜面对应的谜底

    for issue in issues:
        str1 = "".join(sorted(set(issue)))  # 对谜面去重、排序后生成字符串
        find = False  # 标记是否找到匹配的谜底

        for answer in answers:
            str2 = "".join(sorted(set(answer)))  # 对谜底去重、排序后生成字符串

            if str1 == str2:  # 如果谜面和谜底去重排序后的字符串相同
                ans.append(answer)  # 将谜底加入结果数组
                find = True  # 标记为找到
                # break # 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下

        if not find:
            ans.append("not found")  # 如果没有找到匹配的谜底，加入 "not found"

    return ",".join(ans)  # 将结果数组用逗号连接成字符串并返回


# 算法调用
print(getResult(issues, answers))
代码讲解

  1. 输入处理：

    • 使用 input() 读取输入。
    • 第一行是谜面数组 issues，第二行是谜底数组 answers。

  2. 去重和排序：

    • 对每个谜面 issue 和谜底 answer 进行去重和排序，生成字符串 str1 和 str2。
    • 使用 set() 去重，sorted() 排序，"".join() 将字符列表拼接成字符串。

  3. 匹配逻辑：

    • 如果 str1 和 str2 相同，说明谜面和谜底去重排序后的字符相同，匹配成功。
    • 将匹配的谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 输出结果：

    • 使用 ",".join(ans) 将结果数组 ans 用逗号连接成字符串并返回。

代码 2：唯一条件满足才算猜中

代码逻辑
# 输入获取
issues = input().split(",")  # 读取谜面数组
answers = input().split(",")  # 读取谜底数组


# 算法入口
def getResult(issues, answers):
    ans = []  # 存储每个谜面对应的谜底

    for issue in issues:
        sorted_issue = "".join(sorted(issue))  # 对谜面排序后生成字符串
        distinct_issue = "".join(set(issue))  # 对谜面去重后生成字符串
        find = False  # 标记是否找到匹配的谜底

        for answer in answers:
            sorted_answer = "".join(sorted(answer))  # 对谜底排序后生成字符串
            distinct_answer = "".join(set(answer))  # 对谜底去重后生成字符串

            if sorted_issue == sorted_answer or distinct_issue == distinct_answer:  # 如果排序后字符串相同或去重后字符串相同
                ans.append(answer)  # 将谜底加入结果数组
                find = True  # 标记为找到
                # break # 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下

        if not find:
            ans.append("not found")  # 如果没有找到匹配的谜底，加入 "not found"

    return ",".join(ans)  # 将结果数组用逗号连接成字符串并返回


# 算法调用
print(getResult(issues, answers))
代码讲解

  1. 输入处理：

    • 使用 input() 读取输入。
    • 第一行是谜面数组 issues，第二行是谜底数组 answers。

  2. 排序和去重：

    • 对每个谜面 issue 和谜底 answer 分别进行排序和去重，生成两个字符串：
      • sorted_issue 和 sorted_answer：排序后的字符串。
      • distinct_issue 和 distinct_answer：去重后的字符串。

  3. 匹配逻辑：

    • 如果 sorted_issue 相同 或 distinct_issue 相同，说明谜面和谜底满足其中一个条件，匹配成功。
    • 将匹配的谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 输出结果：

    • 使用 ",".join(ans) 将结果数组 ans 用逗号连接成字符串并返回。

两段代码的区别

  1. 匹配条件：

    • 代码 1：要求谜面和谜底去重排序后的字符串完全相同。
    • 代码 2：要求谜面和谜底排序后的字符串相同 或 去重后的字符串相同。

  2. 适用场景：

    • 代码 1：适用于严格匹配场景，谜面和谜底必须完全一致（去重排序后）。
    • 代码 2：适用于宽松匹配场景，谜面和谜底只需满足其中一个条件即可。

示例解析

输入
abc,bac,aa
cba,aab,xyz
代码 1 运行结果
cba,not found,not found
  • 解析：
    • abc 和 cba 去重排序后均为 abc，匹配成功。
    • bac 和 aab 去重排序后分别为 abc 和 ab，不匹配。
    • aa 和 xyz 去重排序后分别为 a 和 xyz，不匹配。
代码 2 运行结果
cba,aab,not found
  • 解析：
    • abc 和 cba 排序后均为 abc，匹配成功。
    • bac 和 aab 去重后分别为 bac 和 ab，不匹配。
    • aa 和 xyz 去重后分别为 a 和 xyz，不匹配。

总结

  • 代码 1 和代码 2 的核心逻辑相似，主要区别在于匹配条件的严格程度。
  • 代码 1 要求谜面和谜底去重排序后完全相同，代码 2 只需满足排序或去重中的一个条件即可。
  • 根据实际需求选择合适的匹配条件。

如果有其他问题，欢迎随时提问！

五、C/C++算法源码：

以下是 C++ 代码的中文详细注释和逻辑讲解：

代码逻辑

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_set>
#include <sstream>

using namespace std;

// 函数用于将字符串排序并去重
string sortAndDistinct(const string& s) {
    string sortedStr = s;  // 复制输入字符串
    sort(sortedStr.begin(), sortedStr.end());  // 对字符串进行排序
    auto last = unique(sortedStr.begin(), sortedStr.end());  // 去重，返回去重后的结束迭代器
    sortedStr.erase(last, sortedStr.end());  // 删除重复字符
    return sortedStr;  // 返回排序并去重后的字符串
}

// 算法入口
string getResult(const vector<string>& issues, const vector<string>& answers) {
    vector<string> ans;  // 存储每个谜面对应的谜底

    for (const string& issue : issues) {  // 遍历每个谜面
        string sortedIssue = sortAndDistinct(issue);  // 对谜面排序并去重
        bool find = false;  // 标记是否找到匹配的谜底

        for (const string& answer : answers) {  // 遍历每个谜底
            string sortedAnswer = sortAndDistinct(answer);  // 对谜底排序并去重

            if (sortedIssue == sortedAnswer) {  // 如果谜面和谜底排序并去重后的字符串相同
                ans.push_back(answer);  // 将谜底加入结果数组
                find = true;  // 标记为找到
                // break; // 如果一个谜面对应多个谜底，这里就不能break，如果一个谜面只对应一个谜底，那这里就要break，考试的时候都试下
            }
        }

        if (!find) {  // 如果没有找到匹配的谜底
            ans.push_back("not found");  // 加入 "not found"
        }
    }

    // 将结果拼接成逗号分隔的字符串
    stringstream result;  // 使用 stringstream 拼接结果
    for (size_t i = 0; i < ans.size(); ++i) {
        if (i != 0) {
            result << ",";  // 如果不是第一个元素，添加逗号
        }
        result << ans[i];  // 添加当前谜底
    }

    return result.str();  // 返回拼接后的字符串
}

int main() {
    // 输入获取
    string issuesInput, answersInput;
    getline(cin, issuesInput);  // 读取谜面输入
    getline(cin, answersInput);  // 读取谜底输入

    // 将输入字符串分割为vector
    vector<string> issues;  // 存储谜面数组
    vector<string> answers;  // 存储谜底数组
    stringstream ssIssues(issuesInput);  // 使用 stringstream 解析谜面输入
    stringstream ssAnswers(answersInput);  // 使用 stringstream 解析谜底输入
    string temp;

    while (getline(ssIssues, temp, ',')) {  // 按逗号分割谜面输入
        issues.push_back(temp);  // 将分割后的谜面加入数组
    }

    while (getline(ssAnswers, temp, ',')) {  // 按逗号分割谜底输入
        answers.push_back(temp);  // 将分割后的谜底加入数组
    }

    // 调用算法并输出结果
    cout << getResult(issues, answers) << endl;  // 调用 getResult 函数并输出结果

    return 0;
}

代码讲解

  1. 输入处理：

    • 使用 getline(cin, issuesInput) 和 getline(cin, answersInput) 读取谜面和谜底的输入。
    • 使用 stringstream 将输入字符串按逗号分割，并存储到 vector<string> 中。

  2. 排序和去重：

    • sortAndDistinct 函数对字符串进行排序和去重：
      • 使用 sort() 对字符串进行排序。
      • 使用 unique() 去重，并删除重复字符。

  3. 匹配逻辑：

    • 遍历每个谜面 issue，调用 sortAndDistinct 函数生成排序并去重后的字符串 sortedIssue。
    • 遍历每个谜底 answer，调用 sortAndDistinct 函数生成排序并去重后的字符串 sortedAnswer。
    • 如果 sortedIssue 和 sortedAnswer 相同，说明谜面和谜底匹配成功，将谜底加入结果数组 ans。

  4. 未匹配处理：

    • 如果遍历完所有谜底仍未找到匹配的，将 "not found" 加入结果数组。

  5. 结果拼接：

    • 使用 stringstream 将结果数组 ans 拼接成逗号分隔的字符串。

  6. 输出结果：

    • 调用 getResult 函数计算结果，并输出拼接后的字符串。

示例解析

输入
abc,bac,aa
cba,aab,xyz
运行结果
cba,not found,not found
  • 解析：
    • abc 和 cba 排序并去重后均为 abc，匹配成功。
    • bac 和 aab 排序并去重后分别为 abc 和 ab，不匹配。
    • aa 和 xyz 排序并去重后分别为 a 和 xyz，不匹配。

总结

  • 该代码通过排序和去重的方式，严格匹配谜面和谜底。
  • 核心逻辑是排序和去重后比较字符串是否相同。
  • 使用 stringstream 方便地拼接结果字符串。

如果有其他问题，欢迎随时提问！


原文地址：https://blog.csdn.net/m0_63168877/article/details/145078206

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2025