题目链接

牛牛的考试

题目描述

根据一套"坊间传说"的蒙题规则来选择答案：

  1. 三长一短选最短：四个选项中，恰好有一个选项的长度严格小于其他三个。
  2. 三短一长选最长：四个选项中，恰好有一个选项的长度严格大于其他三个。
  3. 参差不齐就选C：既不满足上述两个条件的其他所有情况。

输入描述:

  • 第一行是一个整数 T，代表题目数量。
  • 接下来有 T 道题，每道题包括4行字符串，分别代表A、B、C、D四个选项。

输出描述:

  • 对每道题，根据规则输出应选的选项字母（A、B、C或D），每个字母占一行。

示例:

  • 输入: 
    3
A.3.141592653589
B.2.718281828459
C.0.618033988749
D.0.577215664901532860
A.wo_shi_cuo_de
B.wo_bu_dui
C.wo_shi_dui_de
D.C_shi_dui_de
A.3.141592653589
B.2.718281828459
C.0.618033988749
D.0.577215664901
  • 输出: 
    D
B
C

解题思路

这道题的核心是精确地实现题目给出的三条逻辑规则。对于每一道题，我们需要分析其四个选项的长度。

  1. 处理多组输入: 程序需要先读取一个整数 T，然后用一个循环来处理 T 道题目。

  2. 读取并存储选项长度: 在每次循环中，我们需要读取 A、B、C、D 四个选项的字符串。最关键的信息是它们的长度。一个很好的做法是创建一个包含长度和对应选项名（'A', 'B', 'C', 'D'）的结构或配对列表，例如 [(lenA, 'A'), (lenB, 'B'), (lenC, 'C'), (lenD, 'D')]。

  3. 分析长度分布: 为了判断属于哪种情况，我们需要知道这四个长度中的最大值、最小值以及它们出现的次数。

    • 找出四个长度中的最小值 min_len 和最大值 max_len。
    • 统计 min_len 出现了几次（min_count）。
    • 统计 max_len 出现了几次（max_count）。

  4. 应用规则:

    • 情况一 (三长一短): 如果 min_count 恰好等于 1，这意味着有且仅有一个选项长度最短。我们就找到了"三长一短"的情况，应该选择这个最短的选项。
    • 情况二 (三短一长): 如果不满足情况一，我们接着判断 max_count 是否恰好等于 1。如果是，这意味着有且仅有一个选项长度最长。这就对应"三短一长"，应该选择这个最长的选项。
    • 情况三 (参差不齐): 如果以上两种情况都不满足，那么无论长度分布如何（例如：四个一样长、两长两短、四个都不同等），都属于"参差不齐"。此时，直接选择 'C'。

  5. 输出结果: 根据判断结果，输出对应的选项字母，并换行。

这个逻辑流程严谨地覆盖了所有可能性，能正确解决问题。

代码

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

void solve() {
    vector<pair<int, char>> options(4);
    char option_char = 'A';
    map<int, int> counts;
    int min_len = 601, max_len = 0;

    for (int i = 0; i < 4; ++i) {
        string s;
        cin >> s;
        options[i] = { (int)s.length(), option_char++ };
        counts[s.length()]++;
        min_len = min(min_len, (int)s.length());
        max_len = max(max_len, (int)s.length());
    }

    if (counts[min_len] == 1) { // 三长一短
        for (const auto& opt : options) {
            if (opt.first == min_len) {
                cout << opt.second << endl;
                return;
            }
        }
    } else if (counts[max_len] == 1) { // 三短一长
        for (const auto& opt : options) {
            if (opt.first == max_len) {
                cout << opt.second << endl;
                return;
            }
        }
    } else { // 参差不齐
        cout << 'C' << endl;
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

class Option {
    int length;
    char name;

    Option(int length, char name) {
        this.length = length;
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            solve(sc);
        }
    }

    private static void solve(Scanner sc) {
        List<Option> options = new ArrayList<>();
        int minLen = 601, maxLen = 0;
        int minCount = 0, maxCount = 0;
        char shortest = ' ', longest = ' ';

        for (int i = 0; i < 4; i++) {
            String s = sc.next();
            options.add(new Option(s.length(), (char)('A' + i)));
        }

        for (Option opt : options) {
            minLen = Math.min(minLen, opt.length);
            maxLen = Math.max(maxLen, opt.length);
        }

        for (Option opt : options) {
            if (opt.length == minLen) {
                minCount++;
                shortest = opt.name;
            }
            if (opt.length == maxLen) {
                maxCount++;
                longest = opt.name;
            }
        }
        
        if (minCount == 1) {
            System.out.println(shortest);
        } else if (maxCount == 1) {
            System.out.println(longest);
        } else {
            System.out.println('C');
        }
    }
}

def solve():
    options = []
    option_chars = ['A', 'B', 'C', 'D']
    for i in range(4):
        s = input()
        options.append((len(s), option_chars[i]))

    lengths = [opt[0] for opt in options]
    
    min_len = min(lengths)
    max_len = max(lengths)
    
    min_count = lengths.count(min_len)
    max_count = lengths.count(max_len)
    
    if min_count == 1:
        # 找到最短的那个
        for length, char in options:
            if length == min_len:
                print(char)
                return
    elif max_count == 1:
        # 找到最长的那个
        for length, char in options:
            if length == max_len:
                print(char)
                return
    else:
        print('C')

t = int(input())
for _ in range(t):
    solve()

算法及复杂度

  • 算法: 模拟、条件判断。
  • 时间复杂度: ，其中 T 是题目数量，L 是单个选项字符串的最大长度。主要耗时在于读取 T * 4 个字符串的输入。对于每道题的逻辑判断部分，其操作是常数级别的，可以认为是 。
  • 空间复杂度: 。每次处理一道题时，需要存储4个选项字符串，所以空间开销取决于最长的那个选项。由于题目是逐个处理的，这个空间可以被重复使用。