(B卷,100分)- 全量和已占用字符集（Java & JS & Python）

题目描述

给定两个字符集合，一个是全量字符集，一个是已占用字符集，已占用字符集中的字符不能再使用。

要求输出剩余可用字符集。

输入描述

1. 输入一个字符串 一定包含@，@前为全量字符集 @后的为已占用字符集
2. 已占用字符集中的字符一定是全量字符集中的字符
3. 字符集中的字符跟字符之间使用英文逗号隔开
4. 每个字符都表示为字符+数字的形式用英文冒号分隔，比如a:1标识一个a字符
5. 字符只考虑英文字母，区分大小写
6. 数字只考虑正整型 不超过100
7. 如果一个字符都没被占用 @标识仍存在，例如 a:3,b:5,c:2@

输出描述

• 输出可用字符集
• 不同的输出字符集之间用回车换行
• 注意 输出的字符顺序要跟输入的一致，如下面用例不能输出b:3,a:2,c:2
• 如果某个字符已全部占用 则不需要再输出

用例

题目解析

考察字符串操作

2023.06.30

增加处理：7、如果一个字符都没被占用 @标识仍存在，例如 a:3,b:5,c:2@

JavaScript算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

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

rl.on("line", (line) => {
  const sArr = line.split("@");

  if (sArr.length == 1) return sArr[0];

  const [all, used] = sArr.map((str) =>
    str.split(",").map((kv) => kv.split(":"))
  );

  const remain = new Map(all);

  used.forEach((kv) => {
    const [key, val] = kv;
    const newVal = remain.get(key) - val;
    if (newVal > 0) {
      remain.set(key, newVal);
    } else {
      remain.delete(key);
    }
  });

  const ans = [];
  for (let entry of remain.entries()) {
    ans.push(entry.join(":"));
  }

  console.log(ans.join(","));
});

Java算法源码

import java.util.*;

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

    String str = sc.next();

    System.out.println(getResult(str));
  }

  public static String getResult(String str) {
    String[] sArr = str.split("@");

    if (sArr.length == 1) {
      return sArr[0];
    }

    String[][][] tmp =
        Arrays.stream(sArr)
            .map(
                s1 ->
                    Arrays.stream(s1.split(",")).map(s2 -> s2.split(":")).toArray(String[][]::new))
            .toArray(String[][][]::new);

    String[][] all = tmp[0];
    String[][] used = tmp[1];

    // 注意 输出的字符顺序要跟输入的一致，如用例不能输出b:3,a:2,c:2
    // 因此这里用LinkedHashMap维护输入顺序
    LinkedHashMap<String, Integer> allMap = new LinkedHashMap<>();
    for (String[] arr : all) {
      allMap.put(arr[0], Integer.parseInt(arr[1]));
    }

    HashMap<String, Integer> usedMap = new HashMap<>();
    for (String[] arr : used) {
      usedMap.put(arr[0], Integer.parseInt(arr[1]));
    }

    for (String key : usedMap.keySet()) {
      if (allMap.containsKey(key)) {
        int remain = allMap.get(key) - usedMap.get(key);
        if (remain > 0) {
          allMap.put(key, remain);
        } else {
          allMap.remove(key);
        }
      }
    }

    StringJoiner sj = new StringJoiner(",");
    for (Map.Entry<String, Integer> entry : allMap.entrySet()) {
      sj.add(entry.getKey() + ":" + entry.getValue());
    }
    return sj.toString();
  }
}

Python算法源码

# 输入获取
s = input()


# 算法入口
def getResult():
    all, used = s.split("@")

    if used == "":
        return all

    allMap = {}
    for k, v in list(map(lambda x: x.split(":"), all.split(","))):
        allMap[k] = int(v)

    usedMap = {}
    for k, v in list(map(lambda x: x.split(":"), used.split(","))):
        usedMap[k] = int(v)

    for k in usedMap.keys():
        # 已占用字符集中的字符一定是全量字符集中的字符
        diff = allMap[k] - usedMap[k]
        if diff > 0:
            allMap[k] = diff
        else:
            # 如果某个字符已全部占用 则不需要再输出
            allMap.pop(k)

    return ",".join(map(lambda x: ":".join(map(str, x)), allMap.items()))


# 算法调用
print(getResult())