PTA(BasicLevel)-1018 锤子剪刀布

一、问题定义

大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如下：

        剪刀 > 布， 锤子 > 剪刀， 布 > 锤子

现给出两人的交锋记录，请统计双方的胜、平、负次数，并且给出双方分别出什么手势的胜算最大。

      输入格式：
       输入第 1 行给出正整数 N（≤），即双方交锋的次数。随后 N 行，每行给出一次交锋的信息，即甲、乙双方同时给出的的手势。C 代表“锤子”、J 代表“剪刀”、B 代表“布”，第 1 个字母代表甲方，第 2 个代表乙方，中间有 1 个空格。

      输出格式：
       输出第 1、2 行分别给出甲、乙的胜、平、负次数，数字间以 1 个空格分隔。第 3 行给出两个字母，分别代表甲、乙获胜次数最多的手势，中间有 1 个空格。如果解不唯一，则输出按字母序最小的解。

      输入样例：
       10
       C J
       J B
       C B
       B B
       B C
       C C
       C B
       J B
       B C
       J J

       输出样例：
       5 3 2
       2 3 5
       B B

二、解题

python:最后一例超时

def jCB(a, b):
    if a == b:
        return states[2]
    else:
        return Table[(a, b)]

def sucessGeture(suc):
    max_cnt = max(list(suc.values()))
    max_gess = [key for key in suc.keys() if suc[key] == max_cnt]
    return sorted(max_gess)[0]

def myPrint(array):
    print("{} {} {}".format(array[0], array[1], array[2]))

cnt = input()
Alpha = [0, 0, 0]  # 甲乙
Beta = [0, 0, 0]
Suc_Alpha = {ges:0 for ges in ["J", "C", "B"]}  # count the succeed hand
Suc_Beta = {ges:0 for ges in ["J", "C", "B"]}

states = [(1, -1), (-1, 1), (0, 0)] # >, <, =
Table = { ("C", "J"):states[0], ("C", "B"):states[1],
         ("J", "C"):states[1], ("B", "C"):states[0],
         ("B", "J"):states[1], ("J", "B"):states[0]} 

for j in range(int(cnt)):
    Gestures = input()
    A, B = Gestures[0], Gestures[2]
    Ans_a, Ans_b = jCB(A, B)[0], jCB(A, B)[1]  # 1 0 -1
    if Ans_a == 1:
        Alpha[0] += 1      # succeed
        Beta[2] += 1
        Suc_Alpha[A] += 1   # count success gesture
    elif Ans_b == 1:
        Beta[0] += 1       # failed
        Alpha[2] += 1
        Suc_Beta[B] += 1
    elif Ans_a == 0:        # equal
        Alpha[1] += 1
        Beta[1] += 1

myPrint(Alpha)
myPrint(Beta)
print(sucessGeture(Suc_Alpha), sucessGeture(Suc_Beta))

C++

#include <iostream>
using namespace std;

int count(char *JCB, char hand_chr)
{
    int length = 3;
    for ( int i = 0; i < length; i++) {
        if (JCB[i] == hand_chr) {
            return i;
        }
    }
}

int findMax(int *suc)
{   // linear search
    int max = suc[0];
    for (int i = 1; i < 3; i++) {
        if (max < suc[i]) {
            max = suc[i];
        }
    }
    return max;
}

char findMinChr(char *max_chrs, int max_cnt)
{   // find min_chr in max_chrs
    if (max_cnt == 0) {
        return 'B';
    } else {
        char min_chr = max_chrs[0];
        for (int i = 1; i < max_cnt ; i++) {
            if (min_chr > max_chrs[i]) {
                min_chr = max_chrs[i];
            }
        }
        return min_chr;
    }
}
int main(int argc, char *argv[])
{
    int N, max_A, max_B, max_cnt= 0;
    char max_chrs[3];
    char max_chr_A, max_chr_B = ' ';

    int cnt_A[3] = {0, 0, 0};
    int cnt_B[3] = {0, 0, 0};
    int suc_A[3] = {0, 0, 0};
    int suc_B[3] = {0, 0, 0};

    char JCB[3] = {'J', 'C', 'B'};
    char A, B = ' ';
    cin >> N;   //cout << N << "\n";

    // C J B
    for (int i = 0; i < N; i++) {
         cin >> A >> B;   //cout << A << " " << B << "\n";
        if (A == B) {
            cnt_A[1] += 1;
            cnt_B[1] += 1;
        } else if ((A == 'C' && B == 'J') ||
                   (A == 'J' && B == 'B') ||
                    (A == 'B' && B == 'C')) {
            cnt_A[0] += 1;
            cnt_B[2] += 1;
            suc_A[count(JCB, A)] += 1; // succeed count

        } else if ((A == 'C' && B == 'B') ||
                   (A == 'J' && B == 'C') ||
                    (A == 'B' && B == 'J')) {
            cnt_A[2] += 1;
            cnt_B[0] += 1;
            suc_B[count(JCB, B)] += 1;
        }
    }

    cout << cnt_A[0] << " " << cnt_A[1] << " " << cnt_A[2] << "\n";
    cout << cnt_B[0] << " " << cnt_B[1] << " " << cnt_B[2] << "\n";

    max_A = findMax(suc_A);
    max_B = findMax(suc_B);
    // 有重复代码
    for (int i, j = 0; i < 3; i++) {
        if (suc_A[i] == max_A) {
            max_chrs[j] = JCB[i];
            j++;
            max_cnt++;
        }
    }
    max_chr_A = findMinChr(max_chrs, max_cnt);

    max_cnt = 0;
    for (int i, j = 0; i < 3; i++) {
        if (suc_B[i] == max_B) {
            max_chrs[j] = JCB[i];
            j++;
            max_cnt++;
        }
    }
    max_chr_B = findMinChr(max_chrs, max_cnt);
    cout << max_chr_A << " " << max_chr_B;
    return 0;
}