华为OD机试真题 - 石头剪刀布游戏（Python/JS/C/C++ 2024 D卷 100分）

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

专栏导读

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

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

一、题目描述

石头剪刀布游戏有 3 种出拳形状: 石头、剪刀、布。分别用字母 A,B,C 表示游戏规则：

出拳形状之间的胜负规则如下: A>B; B>C; C>A； 左边一个字母，表示相对优势形状。右边一个字母，表示相对劣势形状。
当本场次中有且仅有一种出拳形状优于其它出拳形状，则该形状的玩家是胜利者。否则认为是平局。当发生平局，没有赢家。有多个胜利者时，同为赢家。

例如 1: 三个玩家出拳分别是A,B,C，由于出现三方优势循环(即没有任何一方优于其它出拳者)，判断为平局。

例如 2: 两个玩家，出拳分别是 A，B，出拳 A的获胜。

例如 3: 三个玩家，出拳全部是 A，判为平局。

二、输入描述

在一场游戏中，每个玩家的信息为一行。玩家数量不超过 1000。

每个玩家信息有 2 个字段，用空格隔开：

玩家 ID:一个仅由 英文字母Q和数字组成的字符串。
出拳形状: 以英文大写字母表示，A、B、C 形状。

三、输出描述

输出为赢家的玩家 ID 列表(一个或多个)，每个 ID 一行，按字符串升序排列。

如果没有赢家，输出为“NULL"字符串。

四、测试用例

1、输入

abc1 A
xyz B

2、输出

abc1

3、说明

A比B有优势，abc1 胜出。

4、输入

abc1 A
def A
alic A
xyz B

5、输出

abc1
alic
def

6、说明

A为优胜方，有三个赢家。

五、解题思路

1. 使用HashMap统计每个出拳形状的数量
2. 读取每行玩家信息，获取出拳形状，统计出拳形状的数量
3. 创建胜利者列表winnerList
4. 判断是否有且仅有一种出拳形状优于其他出拳形状
5. 遍历统计结果
   • 如果有超过一个玩家出相同的出拳形状
   • 将这个出拳形状的玩家添加到胜利者列表中
   • 对胜利者列表进行排序
   • 输出胜利者的玩家ID列表

六、Python算法源码

def main():
    n = int(input())  # 读取玩家数量
    count_map = {}  # 使用字典统计每个出拳形状的数量

    for _ in range(n):
        line = input()  # 读取每行玩家信息
        shape = line[-1]  # 获取出拳形状
        if shape in count_map:
            count_map[shape] += 1
        else:
            count_map[shape] = 1

    winner_list = []  # 创建胜利者列表

    if len(count_map) == 1:  # 判断是否有且仅有一种出拳形状
        print("NULL")  # 输出"NULL"字符串
    else:
        for shape, count in count_map.items():  # 遍历统计结果
            if count > 1:  # 如果有超过一个玩家出相同的出拳形状
                winner_list.append(shape)  # 将这个出拳形状的玩家添加到胜利者列表中

        winner_list.sort()  # 对胜利者列表进行排序

        for winner in winner_list:  # 输出胜利者的玩家ID列表
            print(winner)

if __name__ == "__main__":
    main()

七、JavaScript算法源码

function main() {
    const n = parseInt(prompt("请输入玩家数量:")); // 读取玩家数量
    const countMap = new Map(); // 使用Map统计每个出拳形状的数量

    for (let i = 0; i < n; i++) {
        const line = prompt("请输入玩家信息:"); // 读取每行玩家信息
        const shape = line[line.length - 1]; // 获取出拳形状
        if (countMap.has(shape)) {
            countMap.set(shape, countMap.get(shape) + 1);
        } else {
            countMap.set(shape, 1);
        }
    }

    const winnerList = []; // 创建胜利者列表

    if (countMap.size === 1) { // 判断是否有且仅有一种出拳形状
        console.log("NULL"); // 输出"NULL"字符串
    } else {
        for (let [shape, count] of countMap.entries()) { // 遍历统计结果
            if (count > 1) { // 如果有超过一个玩家出相同的出拳形状
                winnerList.push(shape); // 将这个出拳形状的玩家添加到胜利者列表中
            }
        }

        winnerList.sort(); // 对胜利者列表进行排序

        for (let winner of winnerList) { // 输出胜利者的玩家ID列表
            console.log(winner);
        }
    }
}

// 调用主函数
main();

八、C算法源码

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

#define MAX_PLAYERS 100
#define MAX_SHAPES 256

int main() {
    int n;
    char shape;
    int countMap[MAX_SHAPES] = {0}; // 用数组统计每个出拳形状的数量
    char winnerList[MAX_SHAPES];
    int winnerCount = 0;

    // 读取玩家数量
    printf("请输入玩家数量: ");
    scanf("%d", &n);
    getchar(); // 吸收换行符

    // 读取每个玩家的出拳形状并统计数量
    for (int i = 0; i < n; i++) {
        char line[100];
        printf("请输入玩家信息: ");
        fgets(line, sizeof(line), stdin);
        shape = line[strlen(line) - 2]; // 获取出拳形状（倒数第二个字符）
        countMap[(int)shape]++;
    }

    // 判断是否有且仅有一种出拳形状
    int uniqueShapes = 0;
    for (int i = 0; i < MAX_SHAPES; i++) {
        if (countMap[i] > 0) {
            uniqueShapes++;
        }
    }

    if (uniqueShapes == 1) {
        printf("NULL\n");
    } else {
        // 记录出现超过一次的出拳形状
        for (int i = 0; i < MAX_SHAPES; i++) {
            if (countMap[i] > 1) {
                winnerList[winnerCount++] = (char)i;
            }
        }

        // 对胜利者列表进行排序
        for (int i = 0; i < winnerCount - 1; i++) {
            for (int j = i + 1; j < winnerCount; j++) {
                if (winnerList[i] > winnerList[j]) {
                    char temp = winnerList[i];
                    winnerList[i] = winnerList[j];
                    winnerList[j] = temp;
                }
            }
        }

        // 输出胜利者的玩家ID列表
        for (int i = 0; i < winnerCount; i++) {
            printf("%c\n", winnerList[i]);
        }
    }

    return 0;
}

九、C++算法源码

#include <iostream>
#include <unordered_map>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cout << "请输入玩家数量: ";
    cin >> n;
    cin.ignore();  // 清除换行符

    unordered_map<char, int> countMap; // 使用unordered_map统计每个出拳形状的数量
    vector<char> winnerList; // 创建胜利者列表

    // 读取每个玩家的出拳形状并统计数量
    for (int i = 0; i < n; i++) {
        string line;
        cout << "请输入玩家信息: ";
        getline(cin, line);
        char shape = line.back(); // 获取出拳形状（字符串的最后一个字符）
        countMap[shape]++;
    }

    // 判断是否有且仅有一种出拳形状
    if (countMap.size() == 1) {
        cout << "NULL" << endl;
    } else {
        // 记录出现超过一次的出拳形状
        for (const auto& entry : countMap) {
            if (entry.second > 1) {
                winnerList.push_back(entry.first);
            }
        }

        // 对胜利者列表进行排序
        sort(winnerList.begin(), winnerList.end());

        // 输出胜利者的玩家ID列表
        for (char winner : winnerList) {
            cout << winner << endl;
        }
    }

    return 0;
}

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

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

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