返回目录

题目描述

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

游戏规则：

1. 出拳形状之间的胜负规则如下：

   A > B；
   B > C；
   C > A；

   ">" 左边一个字母，表示相对优势形状。右边一个字母，表示相对劣势形状。

2. 当本场次中有且仅有一种出拳形状优于其他出拳形状，则该形状的玩家是胜利者。否则认为是平局。

   例如1：三个玩家出拳分别是A，B，C。由于三方优势循环（即没有任何一方优于其他出拳者），判断为平局。

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

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

3. 当发生平局，没有赢家。有多个胜利者时，同为赢家。

输入描述

在一场游戏中，每个玩家的信息为一行。玩家数量不超过1000。每个玩家信息有2个字段，用空格隔开；

1. 玩家ID：一个仅由英文字母和数字组成的字符串
2. 出拳形状：以英文大写字母表示，A、B、C形状。
3. ~出拳时间：正整数，越小表示时间越早~

例如：

abc1 A
xyz B

解释：玩家abc1出拳为石头（A）。玩家xyz出拳为剪刀（B）

输出描述

输出为赢家的玩家ID列表（一个或多个），每个ID一行，按字符串升序排列。如果没有赢家，输出为”NULL“字符串。

例如：

abc1

示例：

题目解析

本题可以定义三个数组，分别统计出手势A、B、C的人名。

统计完后，再计数下非空数组的个数：

• 如果有三个，则说明三个手势都存在，平局
• 如果有一个，则说明只有一个手势，平局
• 如果有两个，则需要继续检查：

1. 如果只有手势A，B，那么赢家就是手势A的玩家
2. 如果只有手势A，C，那么赢家就是手势C的玩家
3. 如果只有手势B，C，那么赢家就是手势B的玩家

最后将赢家人名进行字典序升序即可。

这样最后字典key的数量就是手势数量，如果key只有2个，那么就判断：

字典没有'A'的key => 只有手势B，C，那么赢家就是手势B的玩家

字典没有'B'的key => 只有手势A，C，那么赢家就是手势C的玩家

字典没有'C'的key => 只有手势A，B，那么赢家就是手势A的玩家

Python算法源码

MAX_SIZE = 1000
MAX_NAME_LENGTH = 100

def cmp(a, b):
    return (a > b) - (a < b)

def main():
    A = [''] * MAX_SIZE
    A_size = 0

    B = [''] * MAX_SIZE
    B_size = 0

    C = [''] * MAX_SIZE
    C_size = 0

    while True:
        s = input()

        if len(s) == 0:
            break

        name, gesture = s.split()

        if gesture == 'A':
            A[A_size] = name
            A_size += 1
        elif gesture == 'B':
            B[B_size] = name
            B_size += 1
        elif gesture == 'C':
            C[C_size] = name
            C_size += 1
        else:
            print("NULL")
            return

    kinds = 0
    if A_size > 0:
        kinds += 1
    if B_size > 0:
        kinds += 1
    if C_size > 0:
        kinds += 1

    if kinds == 1 or kinds == 3:
        print("NULL")
    else:
        if A_size > 0:
            if B_size > 0:
                A = sorted(A[:A_size])
                for name in A:
                    print(name)
            else:
                C = sorted(C[:C_size])
                for name in C:
                    print(name)
        else:
            B = sorted(B[:B_size])
            for name in B:
                print(name)

if __name__ == "__main__":
    main()

C算法源码

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

void getResult() {
    char player[50], gesture;
    char* dic[3][50];
    int count[3] = {0};
    int kinds = 0;
  
    while (1) {
        if (scanf("%s %c", player, &gesture) != 2) {
            break;
        }

        // 如果有人不按套路出，则此局作废
        if (gesture < 'A' || gesture > 'C') {
            printf("NULL\n");
            return;
        }

        // 统计各个手势的人名
        int idx = gesture - 'A';
        dic[idx][count[idx]] = malloc(strlen(player) + 1);
        strcpy(dic[idx][count[idx]], player);
        count[idx]++;
    }

    for (int i = 0; i < 3; i++) {
        if (count[i] > 0) {
            kinds++;
        }
    }

    if (kinds == 1 || kinds == 3) {
        // 只有一种手势，或者三种手势都有，则平局
        printf("NULL\n");
    } else {
        char** ans = NULL;

        if (count[0] == 0) {
            // 没有A手势，只有B、C手势，则B赢
            ans = dic[1];
        } else if (count[1] == 0) {
            // 没有B手势，只有A、C手势，则C赢
            ans = dic[2];
        } else {
            // 没有C手势，只有A、B手势，则A赢
            ans = dic[0];
        }

        // 输出结果
        for (int i = 0; i < count[ans == dic[0] ? 0 : (ans == dic[1] ? 1 : 2)]; i++) {
            printf("%s\n", ans[i]);
            free(ans[i]);
        }
    }
}

int main() {
    getResult();
    return 0;
}

Java算法源码

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        final int MAX_SIZE = 1000;
        final int MAX_NAME_LENGTH = 100;

        String[] A = new String[MAX_SIZE];
        int A_size = 0;

        String[] B = new String[MAX_SIZE];
        int B_size = 0;

        String[] C = new String[MAX_SIZE];
        int C_size = 0;

        Scanner scanner = new Scanner(System.in);

        while (true) {
            String s = scanner.nextLine();

            if (s.length() == 0) {
                break;
            }

            String[] parts = s.split(" ");
            String name = parts[0];
            String gesture = parts[1];

            if (gesture.equals("A")) {
                A[A_size++] = name;
            } else if (gesture.equals("B")) {
                B[B_size++] = name;
            } else if (gesture.equals("C")) {
                C[C_size++] = name;
            } else {
                System.out.println("NULL");
                return;
            }
        }

        int kinds = 0;
        if (A_size > 0) kinds++;
        if (B_size > 0) kinds++;
        if (C_size > 0) kinds++;

        if (kinds == 1 || kinds == 3) {
            System.out.println("NULL");
        } else {
            if (A_size > 0) {
                if (B_size > 0) {
                    Arrays.sort(A, 0, A_size);
                    for (int i = 0; i < A_size; i++) {
                        System.out.println(A[i]);
                    }
                } else {
                    Arrays.sort(C, 0, C_size);
                    for (int i = 0; i < C_size; i++) {
                        System.out.println(C[i]);
                    }
                }
            } else {
                Arrays.sort(B, 0, B_size);
                for (int i = 0; i < B_size; i++) {
                    System.out.println(B[i]);
                }
            }
        }
    }
}