笔试时间：2025年10月9日

往年笔试合集：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

在一副牌中，数字1-10各有4张。发牌员先后给Tk与wida各发5张牌，此时牌堆还剩30张牌。两名玩家按照下列规则决定胜负：

1. 若两人都无法从自己的5张手牌中选出3张牌，使得它们之和为10的倍数，则比较各自手牌中的最大数字，数字较大者获胜；若最大数字相同，则本局平局；
2. 若仅有一人可以选出这样的3张牌，则该名玩家直接获胜；
3. 若两人都可以选出这样的3张牌，则各自都选择一种方案，使得余下2张牌数字之和为x时，比较((x-1) mod 10) + 1的大小（即把0-9中的0视作10），值较大者获胜；若两值相同，则本局平局。

现给出两名玩家的手牌，请判断每局比赛的结果。

输入描述

每个测试文件包含多组独立测试数据。第一行输入一个整数N（1≤N≤100）表示测试数据组数，每组测试数据的格式如下：

• 第一行输入5个整数a_i（1≤a_i≤10），表示Tk的手牌；
• 第二行输入5个整数b_i（1≤b_i≤10），表示wida的手牌。

保证输入合法：同一种数字的牌在两人手牌中的总数量不超过4。

输出描述

对于每一组测试数据，新起一行输出比赛结果：

• 若Tk获胜，输出Tk；
• 若wida获胜，输出wida；
• 若平局，输出emm。

样例输入

3

10 1 9 2 3

6 6 6 6 1

6 6 6 6 1

10 1 9 2 3

3 3 3 1 1

3 2 2 1 1

样例输出

Tk

wida

emm

样例说明：

以第一组测试数据为例：

• Tk可选{10,1,9}，三数之和为20，是10的倍数；余下两牌之和为5，对应比较值为5；
• wida无法选出任意3张牌使其和为10的倍数；
• 按照规则，只有Tk能凑成10的倍数，故Tk获胜。

参考题解

解题思路：

胜负判定分为三种情况：

1. 只有一人能凑出10的倍数：直接获胜
2. 两人都不能凑出10的倍数：比较最大单张牌
3. 两人都能凑出10的倍数：比较余下两张牌的和经过特殊计算后的值

第一步：判断能否凑出10的倍数

• 从5张牌中选出3张，检查其和是否为10的倍数
• 由于牌值范围是1-10，10的倍数可能是10、20、30
• 如果找不到这样的组合，则标记为"不能凑出"

第二步：根据不同情况比较胜负

• 情况1：一人能凑，一人不能 - 能凑出10的倍数的人直接获胜
• 情况2：两人都不能凑 - 比较各自手牌中的最大数字
• 情况3：两人都能凑 - 计算比较值：((x - 1) % 10) + 1

C++：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

pair<bool, int> calu(vector<int>& hs) {
    int max_sc = -1;
    bool flag = false;
    
    // 枚举所有3张牌的组合
    for (int i = 0; i < 5; i++) {
        for (int j = i + 1; j < 5; j++) {
            for (int k = j + 1; k < 5; k++) {
                int sum = hs[i] + hs[j] + hs[k];
                if (sum % 10 == 0) {
                    flag = true;
                    int remain = 0;
                    for (int l = 0; l < 5; l++) {
                        if (l != i && l != j && l != k) {
                            remain += hs[l];
                        }
                    }
                    int cur = ((remain - 1) % 10) + 1;
                    max_sc = max(max_sc, cur);
                }
            }
        }
    }
    
    if (flag) {
        return {true, max_sc};
    } else {
        return {false, *max_element(hs.begin(), hs.end())};
    }
}

void solve() {
    vector<int> tk(5), wida(5);
    for (int i = 0; i < 5; i++) cin >> tk[i];
    for (int i = 0; i < 5; i++) cin >> wida[i];
    
    auto [tkmk, tkval] = calu(tk);
    auto [wdmk, wdval] = calu(wida);
    
    if (tkmk && !wdmk) {
        cout << "Tk" << endl;
        return;
    }
    if (!tkmk && wdmk) {
        cout << "wida" << endl;
        return;
    }
    
    if (tkval > wdval) {
        cout << "Tk" << endl;
    } else if (wdval > tkval) {
        cout << "wida" << endl;
    } else {
        cout << "emm" << endl;
    }
}

int main() {
    int N;
    cin >> N;
    for (int i = 0; i < N; i++) {
        solve();
    }
    return 0;
}

Java：

import java.util.*;

public class Solution {
    static class Result {
        boolean canMake;
        int value;
        Result(boolean canMake, int value) {
            this.canMake = canMake;
            this.value = value;
        }
    }
    
    static Result calu(int[] hs) {
        int maxSc = -1;
        boolean flag = false;
        
        // 枚举所有3张牌的组合
        for (int i = 0; i < 5; i++) {
            for (int j = i + 1; j < 5; j++) {
                for (int k = j + 1; k < 5; k++) {
                    int sum = hs[i] + hs[j] + hs[k];
                    if (sum % 10 == 0) {
                        flag = true;
                        int remain = 0;
                        for (int l = 0; l < 5; l++) {
                            if (l != i && l != j && l != k) {
                                remain += hs[l];
                            }
                        }
                        int cur = ((remain - 1) % 10) + 1;
                        maxSc = Math.max(maxSc, cur);
                    }
                }
            }
        }
        
        if (flag) {
            return new Result(true, maxSc);
        } else {
            int max = Arrays.stream(hs).max().getAsInt();
            return new Result(false, max);
        }
    }
    
    static void solve(Scanner sc) {
        int[] tk = new int[5];
        int[] wida = new int[5];
        
        for (int i = 0; i < 5; i++) tk[i] = sc.nextInt();
        for (int i = 0; i < 5; i++) wida[i] = sc.nextInt();
        
        Result tkResult = calu(tk);
        Result wdResult = calu(wida);
        
        if (tkResult.canMake && !wdResult.canMake) {
            System.out.println("Tk");
            return;
        }
        if (!tkResult.canMake && wdResult.canMake) {
            System.out.println("wida");
            return;
        }
        
        if (tkResult.value > wdResult.value) {
            System.out.println("Tk");
        } else if (wdResult.value > tkResult.value) {
            System.out.println("wida");
        } else {
            System.out.println("emm");
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        for (int i = 0; i < N; i++) {
            solve(sc);
        }
        sc.close();
    }
}

Python：

import sys
from itertools import combinations

def calu(hs):
    max_sc = -1
    flag = False
    for combo in combinations(hs, 3):
        if sum(combo) % 10 == 0:
            flag = True
            tmp = list(hs)
            for card in combo:
                tmp.remove(card)
            remain = sum(tmp)
            cur = ((remain - 1) % 10) + 1
            if cur > max_sc:
                max_sc = cur
    if flag:
        return (True, max_sc)
    el