HNU实训训练作业训练一编程题15. 欧洲冠军联赛-CSDN博客

本文链接：https://blog.csdn.net/buhuiazaban/article/details/140262905

【问题描述】

欧洲冠军联赛常被誉为全世界最具影响力的俱乐部级赛事。在比赛的小组赛阶段，欧洲的各个足球俱乐部被分为八个小组，每个小组中四支球队。每个小组中的球队按照如下规则排序：

球队会根据比赛结果获得积分。一场比赛的双方被称为主队和客队。如果其中一方进球数多于另一方，那么进球较多的一方获得3 分，另一方获得0 分。如果双方打成平手，则各得1分。
球队的净胜球数是其进球数减去失球数（不考虑该球队在比赛中作为主队还是客队）。
积分较高的球队排名更加靠前。
如果两支球队积分相同，那么净胜球数较多的球队排名靠前。

小组的各队伍进行循环赛，即每两支球队之间进行两场比赛，双方交替作为主队。给定一个小组内12 场比赛的结果，请求出小组的出线队伍：即排名第一和第二的两支球队。

保证答案唯一。

【输入形式】

输入的第一行包含一个整数T，代表测试数据的组数。接下来是 T 组数据。

每组数据共有12 行，每行描述一场比赛，格式为：“主队队名主队进球数vs. 客队进球数客队队名”，其中“主队队名”和“客队队名”为字符串，“主队进球数”和“客队进球数”为两球队在本场比赛中各自的进球数量。

- 1 ≤ T ≤ 50
- 球队队名仅包含小写英文字母
- 球队队名长度不超过10 个字符
- 0 ≤ 进球数 ≤ 100

【输出形式】

对于每组数据，输出一行，包含两个字符串，代表排名第一和第二的球队的队名。

【样例输入】

2
manutd 8 vs. 2 arsenal 
lyon 1 vs. 2 manutd 
fcbarca 0 vs. 0 lyon 
fcbarca 5 vs. 1 arsenal 
manutd 3 vs. 1 fcbarca 
arsenal 6 vs. 0 lyon 
arsenal 0 vs. 0 manutd 
manutd 4 vs. 2 lyon 
arsenal 2 vs. 2 fcbarca 
lyon 0 vs. 3 fcbarca 
lyon 1 vs. 0 arsenal
fcbarca 0 vs. 1 manutd
a 3 vs. 0 b 
a 0 vs. 0 c 
a 0 vs. 0 d 
b 0 vs. 0 a 
b 4 vs. 0 c 
b 0 vs. 0 d 
c 0 vs. 0 a 
c 0 vs. 0 b 
c 1 vs. 0 d 
d 3 vs. 0 a 
d 0 vs. 0 b 
d 0 vs. 0 c

【样例输出】

manutd fcbarca 
d b

【样例说明】

第一组数据：每支球队的积分与净胜球数分别为：

manutd：16 分，净胜球数12。
fcbarca：8 分，净胜球数 4。
arsenal：5 分，净胜球数 −5。
lyon：4 分，净胜球数 −11。

第二组数据：每支球队的积分与净胜球数分别为：

d：7 分，净胜球数 2。
b：7 分，净胜球数 1。
a：7 分，净胜球数 0。
c：7 分，净胜球数 −3。

所有球队的积分相同，但是净胜球数较多的队伍排名更加靠前。

答案如下

def process_matches(matches):
    # 字典用于存储每支球队的积分和净胜球数
    teams = {}
    
    # 处理每场比赛
    for match in matches:
        # 解析比赛结果
        parts = match.split()
        team1_name = parts[0]
        team1_goals = int(parts[1])
        team2_goals = int(parts[3])
        team2_name = parts[4]
        
        # 初始化队伍信息
        if team1_name not in teams:
            teams[team1_name] = {'points': 0, 'goal_difference': 0}
        if team2_name not in teams:
            teams[team2_name] = {'points': 0, 'goal_difference': 0}
        
        # 更新积分和净胜球数
        if team1_goals > team2_goals:
            teams[team1_name]['points'] += 3
        elif team1_goals < team2_goals:
            teams[team2_name]['points'] += 3
        else:
            teams[team1_name]['points'] += 1
            teams[team2_name]['points'] += 1
        
        teams[team1_name]['goal_difference'] += (team1_goals - team2_goals)
        teams[team2_name]['goal_difference'] += (team2_goals - team1_goals)
    
    # 按照积分和净胜球数排序
    sorted_teams = sorted(teams.items(), key=lambda x: (-x[1]['points'], -x[1]['goal_difference']))
    
    # 返回排名第一和第二的球队名称
    return sorted_teams[0][0], sorted_teams[1][0]
n=int(input())
for i in range(n):
    lst=[]
    for j in range(12):
        a=input()
        lst.append(a)
    
    c,d=process_matches(lst)
    print(c+" "+d)

学到的知识

1.嵌套字典

Python 中的字典（dictionary）是一种键值对的数据结构，其中键（key）必须是唯一的且通常是不可变的（如字符串、数字或元组），而值（value）可以是任意数据类型，包括另一个字典。

例如，可以创建一个嵌套的字典结构，如下所示：

teams = {
    'manutd': {'points': 16, 'goal_difference': 12},
    'fcbarca': {'points': 8, 'goal_difference': 4},
    'arsenal': {'points': 5, 'goal_difference': -5},
    'lyon': {'points': 4, 'goal_difference': -11}
}

在这个例子中，teams字典的值是另外一组字典，每支球队的信息以键值对的形式存储在内部的字典中。这种嵌套字典的结构适合于需要组织和管理复杂数据的场景，比如处理多个球队的积分和净胜球数。

使用嵌套字典的好处包括：

结构化数据：能够清晰地表示数据的层次结构和关系。
简化访问：可以通过多级索引（键）快速访问和修改数据。
灵活性：允许每个球队的数据结构可以根据需要灵活扩展，如增加更多统计信息或历史数据。

总结来说，Python 的字典非常灵活，允许在值的位置使用几乎任何类型的数据，包括嵌套的字典，以帮助更好地组织和管理复杂的数据结构。

2.匿名函数排序

在 Python 中，可以使用匿名函数（lambda 函数）进行排序操作，特别是在需要一次性排序，且排序依据相对简单的情况下，lambda 函数非常方便。

示例：

假设有一个包含元组的列表，每个元组包含姓名和年龄，我们想根据年龄对这些人进行排序。

people = [
    ('Alice', 30),
    ('Bob', 25),
    ('Charlie', 35),
    ('David', 27)
]

# 使用 lambda 函数按照年龄进行排序
sorted_people = sorted(people, key=lambda x: x[1])

# 输出排序后的结果
for person in sorted_people:
    print(person)

解释：

lambda 函数的定义：lambda x: x[1] 定义了一个匿名函数，这个函数接受一个参数 x（这里是每个元组），并返回 x[1]，即元组的第二个元素，即年龄。这个函数作为 sorted() 函数的 key 参数传递进去，告诉 sorted() 函数按照元组的第二个元素（即年龄）进行排序。
sorted() 函数：sorted(people, key=lambda x: x[1]) 对 people 列表进行排序，排序的依据是 key 函数返回的结果，即按照年龄从小到大排序。
输出结果：最后通过循环输出排序后的结果，可以看到 sorted_people 已经按照年龄从小到大排序。