编程统计候选人的得票数。有若干位候选人（n<=10），候选人姓名从键盘输入（候选人姓名不区分大小写，姓名最长为9个字节），若干位选民，选民每次输入一个得票的候选人的名字（姓名最长为9个字节），若选民输错候选人姓名，则按废票处理。程序自动统计各候选人的得票结果，并按照得票数由高到低的顺序排序。最后输出各选票人得票结果和废票信息。 输入格式: 先输入候选人人数n和n名候选人姓名，再输入选民人数m和m位选民的选票。 输出格式: 先根据选票结果由高到低输出各候选人得票结果，再根据废票情况输出废票信息（换行后，输出提示信息“invalid vote:”，再输出废票信息）。 输入样例1: 3 zhang li wang 9 Wang Zhang zhuang LI Liao ZHANG WANG Wang wang 输出样例1: wang:4 zhang:2 li:1 invalid vote: zhuang Liao 输入样例2: 2 liu yang 5 Liu liu YANG yang Liu 输出样例2: liu:3 yang:2

嗯，用户想写一个投票统计程序，需要处理候选人的输入，统计有效票和废票，还要按照得票数排序输出。首先，我得理清楚需求。根据用户提供的引用内容，特别是引用[2]和[3]，程序需要支持多个候选人，输入时候选人的姓名不区分大小写，但输出时要保持原大小写。废票是指选民输入的姓名不在候选人列表中，或者输入的名字超过长度限制？
首先，输入部分的结构。根据样例，输入的第一行是候选人数n，然后是n个候选人的姓名。接下来是选民数量m，然后是m次投票输入。比如输入样例1中，3代表三个候选人，然后是zhang、li、wang，之后是9次投票。程序需要处理这些输入，统计每个候选人的得票数，并记录无效票。
接下来，如何存储候选人信息。可能需要一个结构体或字典，保存原始姓名（用于输出）和一个不区分大小写的键。比如，键可以是小写的姓名，这样选民输入不管大小写都能匹配。例如，候选人名字是"Zhang"，选民输入"zhang"或"ZHANG"都应视为有效票。所以需要将候选人姓名统一转换为小写来比较，但存储的时候保留原样。
然后处理选票。每次输入一个名字，首先检查长度是否超过9字节。根据引用[2]，姓名最长为9个字节，这里可能需要考虑不同字符的字节数，比如中文和英文字符。不过题目中的例子都是英文，可能问题简化了，按字符数处理？或者题目中的“字节”指的是字符数？比如每个字符占一个字节，所以最长9个字符。需要明确如何处理。假设这里的姓名是英文字母，最长9个字符，所以检查输入的字符串长度是否超过9，如果超过，算作废票。或者可能题目中的9字节是指存储限制，而实际输入的选民投票只要严格匹配候选人的名字（不区分大小写）即可。根据样例输入1中的废票情况，比如选民输入zhuang，而候选人中没有这个，所以废票。所以可能不需要检查输入的长度，只要输入的字符串是否在候选人列表（不区分大小写）中。比如引用[3]中的输入样例1，选民输入了“zhuang”和“Liao”，这两个都不在候选人列表中，所以是废票。这说明程序需要将选票与候选人列表进行比较，不区分大小写，但输出候选人名字时用原始的大小写。
所以步骤可能是：

读取候选人数n。
读取n个候选人的姓名，保存原始形式，并同时保存小写形式作为键。
读取选民数m。
读取m个投票，每个投票进行处理：
a. 将该投票转换为小写，检查是否存在对应的候选人。
b. 如果存在，对应的候选人票数加一。
c. 否则，记录为废票。
统计完成后，按票数从高到低排序候选人。
输出结果，先输出有效票的统计，然后输出废票信息。

关于输入格式，比如引用[3]中的输入样例，候选人的姓名可能是在同一行，以空格分隔？例如输入样例1中的第一行是3，然后是三个名字zhang li wang，可能在同一行。或者每个候选人的名字单独一行？需要看题目描述的输入格式。根据引用[3]的输入样例1中的输入部分：
输入样例1:
3
zhang
li
wang
9
Wang
Zhang
zhuang
LI
Liao
ZHANG
WANG
Wang
wang
看起来候选人的名字是每个占一行？或者可能候选人的名字在同一行，用空格分隔？比如样例中的输入可能结构是：
第一行是候选人数3，接下来的三行是三个名字。然后选民数是9，接下来的九行是选票。或者，比如输入样例中的候选人是同一行输入的？
需要看问题描述中的输入格式。根据引用[3]中的输入样例1的结构，用户可能输入的候选人姓名是每个占一行。例如：
输入样例1中，第一行是3，接着是三个候选人的姓名，每个占一行。然后是选民数9，接着是九个投票，每个占一行。比如：
3
zhang
li
wang
9
Wang
Zhang
zhuang
LI
Liao
ZHANG
WANG
Wang
wang
但是样例的输出中，候选人名字是原样输出，例如输入样例1的输出是wang:4，而候选人中的输入是“wang”（小写），但输出时变成首字母大写？或者可能是候选人输入的是小写，但输出时保持原样？
或者可能候选人的姓名在输入时是任意形式，程序需要保留原样。比如，候选人输入是“Zhang”，则输出时保持“Zhang”。而选民输入的是“wang”，转换为小写后匹配到“zhang”或者“wang”对应的候选人？
需要仔细看问题描述。根据引用[2]，候选人姓名不区分大小写，输入的时候可能不区分，但保存时保留原样。例如，程序需要将输入的候选人姓名存储起来，作为显示时的名字。而选民的输入会被处理为小写，然后与候选人的小写版本比较。
所以，处理步骤大致如下：

输入候选人数n。
输入n个候选人的姓名，保存到列表，每个元素包含原始姓名和小写后的键。
输入选民数m。
输入m个投票，每个投票处理为小写，查找是否存在对应的候选人。如果有，该候选人票数加一；否则，记录废票。

在存储候选人时，可以使用字典，键是小写的姓名，值是原始姓名和票数。例如：
candidates = {
'zhang': {'name': 'Zhang', 'votes': 0},
'li': {'name': 'li', 'votes': 0},
'wang': {'name': 'Wang', 'votes': 0}
}
当处理选票时，将输入的姓名转为小写，检查是否在字典的键中。如果是，增加票数；否则，废票。
接下来，统计完成后，需要将候选人按票数排序，降序排列。如果票数相同，如何处理排序顺序？问题中没有说明，可能按候选人输入的原始顺序？或者按字母顺序？例如，样例1的输出是wang:4，zhang:2，li:1。原来的候选人是按输入顺序zhang、li、wang，但输出时按票数排序。所以票数高的先输出，相同票数的话可能按输入顺序？或者可能按字母顺序？比如样例中的输出顺序wang、zhang、li可能因为票数高到低，而原本候选人的顺序是zhang、li、wang。所以在票数相同时，可能需要保持输入顺序？
因此，在排序时，需要先按票数降序，再按候选人的输入顺序升序？或者不处理，按照原始顺序？
例如，假设两个候选人票数相同，那么他们在输出时的顺序应该与输入时的顺序一致。例如，候选人A和B，输入顺序是A先，B后，如果票数相同，输出顺序A在前。因此，在存储候选人时，可以保留他们的输入顺序，排序时如果票数相同，则按输入的顺序排列。
这样，在Python中，可以先将候选人的数据存储为一个列表，每个元素包含原始姓名、票数。然后排序时，使用sorted函数，key为负票数和输入顺序的索引。例如：
sorted_candidates = sorted(enumerate(candidates_list), key=lambda x: (-x[1]['votes'], x[0]))
其中，enumerate得到每个候选人的输入顺序索引，排序时先按票数降序，再按输入顺序升序。
接下来，废票的处理。废票需要收集所有无效的选票，并在最后输出。例如，样例1中的废票是zhuang和Liao，输出的时候按输入顺序记录。例如，选民输入的无效票按出现的顺序被记录，并在输出时按照出现顺序显示。
所以，废票的列表需要保存原始输入的姓名，而不仅仅是小写后的。比如，选民输入“zhuang”，这不在候选人列表中，所以废票列表中记录“zhuang”；输入“Liao”记录为“Liao”。
因此，废票的处理步骤是，每次输入投票时，先转换为小写，然后检查是否存在于候选人的键中。如果不存在，将原始输入添加到废票列表。
现在，关于输入的处理，如何读取候选人和选票？
假设输入格式如下：
输入分为三个部分：

第一行是候选人数n。
接下来的n行，每行是一个候选人的姓名。
然后是一个整数m，表示选民人数。
接下来的m行，每行是一个投票的姓名。

但根据引用[3]的输入样例，比如输入样例1中的输入格式是：
3
zhang li wang
9
Wang Zhang zhuang LI Liao ZHANG WANG Wang wang
看起来候选人的姓名可能在同一行，以空格分隔？因为样例中的候选人部分是3，然后是三个名字在同一行。这可能与问题描述中的输入格式有关。
例如，引用[3]的输入样例1的输入格式可能为：
第一行是候选人数3，第二行是三个候选人名字，空格分隔。第三行是选民数9，第四行是9个投票，每个用空格分隔？
但这样的话，样例中的选民投票部分可能有多个行？比如样例中的投票部分是9个名字，可能分布在多行？
或者，可能每个投票单独一行？
这需要明确输入格式。例如，根据问题描述中的输入样例，输入样例1中的选民投票部分是：
9
Wang
Zhang
zhuang
LI
Liao
ZHANG
WANG
Wang
wang
但原输入样例的显示可能有换行。所以，必须根据题目给出的输入格式来处理。
例如，在引用[3]的输入样例1中，输入是：
3
zhang li wang
9
Wang Zhang zhuang LI Liao ZHANG WANG Wang wang
这里候选人部分输入的是同一行中的三个名字，用空格分隔。而选票部分输入的是同一行的九个名字，用空格分隔。但这样的话，选票的数量是9，但实际输入的名字数目是九个吗？
比如，原样例中的输入部分：
选民票数9，后面跟着的一行是9个名字？或者每个选民输入单独一行？
这需要看问题描述中的输入格式。根据引用[3]的描述：“输入样例1: 3 zhang li wang 9 Wang Zhang zhuang LI Liao ZHANG WANG Wang wang”可能实际输入的结构是：
第一行是3，然后同一行是三个名字；第二行是9，然后同一行是九个名字？或者可能输入是多行的？
这可能会影响程序的读取方式。例如，如果候选人的姓名在同一行，用空格分隔，那么程序需要将第一行的n后的所有名字分割处理。
例如，在Python中，读取候选人的部分可能是：
n = int(input())
candidate_names = input().split()
这样，当输入样例是3 zhang li wang时，n=3，然后candidate_names = ['zhang', 'li', 'wang']。但输入样例中的输入可能被分成多行。例如，用户输入3，然后回车，然后在下一行输入三个名字。此时，程序读取n之后，再读取下一行作为候选人的名字。
因此，需要明确输入的结构。例如，假设候选人姓名是在同一行输入，用空格分隔。而选民的投票也是同一行输入，用空格分隔？
或者，可能每个候选人的姓名单独一行，选民投票也每行一个？
比如，输入样例中的描述可能有不同的结构。例如，在输入样例1中，输入的结构可能如下：
3
zhang
li
wang
9
Wang
Zhang
zhuang
LI
Liao
ZHANG
WANG
Wang
wang
这样的话，候选人姓名每行一个，选民票数9，之后每行一个投票。这更可能，因为样例输出中的废票包含zhuang和Liao，而选民输入的票是按顺序处理的。
但原输入样例的显示可能因为排版问题，看起来在同一行。需要根据问题描述中的输入格式来确认。
根据引用[3]的输入样例描述：
输入样例1:
3
zhang li wang
9
Wang Zhang zhuang LI Liao ZHANG WANG Wang wang
输出样例1:
wang:4
zhang:2
li:1
invalid vote:
zhuang Liao
这表明候选人名字在同一行输入，用空格分隔，选民的投票也在同一行输入，用空格分隔。例如，候选人部分，输入3，然后下一行输入三个名字，用空格分隔。选民数输入9，然后下一行输入9个名字，用空格分隔。这可能吗？比如，当输入选民票数m之后，所有的选票都在同一行用空格分隔？
这样，在程序中，候选人姓名需要从输入的一行中分割出来，而选民的投票也需从一行中分割。例如，在Python中，处理候选人：
n = int(input())
names_line = input().strip()
candidate_names = names_line.split()
然后处理选民：
m = int(input())
votes_line = input().strip()
votes = votes_line.split()
但这样的话，假设所有选票都在同一行输入。例如，输入样例1中的选民投票是9次，所以选票列表的长度必须是9。例如，在输入样例1中，输入的一行是“Wang Zhang zhuang LI Liao ZHANG WANG Wang wang”，分割后得到9个元素？
原样例的输入选民票数是9，分割后的选票数量是9吗？原输入样例中的选票部分分割后是：
["Wang", "Zhang", "zhuang", "LI", "Liao", "ZHANG", "WANG", "Wang", "wang"] → 共9个，对吗？是的。所以这说明选民的输入可能是在同一行，用空格分隔。
因此，在程序中，处理选票时，需要读取一行，然后分割成多个投票。但这样的话，如果选民输入的票数超过m，或者不足，如何处理？题目可能假设输入是正确的，即选票的数量等于m。例如，当输入m=9时，后续的选票行分割后的元素数目必须等于9。否则视为错误？或者可能允许选民输入多行，但合并所有行的输入？
假设题目中的输入格式是：候选人的姓名在同一行，用空格分隔；选民的投票也同一行，用空格分隔。这样，在处理时，需要注意分割后的数量是否正确。
因此，在Python中，处理步骤：

读取候选人数n。
读取一行，分割为n个候选人的姓名，保存到列表。如果分割后的数目不等于n，如何处理？题目可能假设输入是正确的。
读取选民数m。
读取一行，分割为m个投票。同样，假设数目正确。

这样的处理方式适用于输入样例中的情况。例如，输入样例1中的候选人部分，输入的是三个名字，选票部分是九个名字。
因此，程序的结构大致如下：
读取n → 读取一行分割为n个名字 → 处理候选人。
读取m → 读取一行分割为m个投票 → 处理每个投票。
但是，如果选民的投票数m很大，或者需要分多行输入怎么办？例如，如果m=9，但选票分两行输入，每行5个名字，那么分割后的总数可能超过m。这时如何处理？
题目中的输入样例可能假设所有选票都在同一行输入，分割后的数目等于m。因此，在编写程序时，可能需要按此处理。但实际情况可能不同，需要看问题描述的具体要求。例如，引用[3]的问题描述中可能规定选票是每次输入一个名字，即每个名字单独一行。例如，输入样例中的选民票数为9，后面有9行输入。这样，处理方式不同。
这个时候，必须仔细分析问题描述中的输入格式。例如，引用[3]中的问题描述的输入格式部分可能如下：
输入格式:
第一行给出候选人数n（n<=10），随后n行给出各候选人姓名（不区分大小写，最长9字节）。接下来一行给出选民人数m，随后m行每行给出一个选票的姓名。
例如，如果输入格式是每个候选人姓名单独一行，选民的每个投票单独一行，则处理方式不同。这时，需要循环读取n次候选人姓名，然后循环读取m次投票。
因此，需要确认输入格式。根据引用[3]的输入样例，比如输入样例1中的选民票数9后面跟着的一行中有9个名字吗？或者每个名字占一行？
原输入样例的输出显示废票是“zhuang Liao”，而这两个名字在输入中的顺序是第三个和第四个选票。例如，假设输入选票的顺序是：
Wang（有效 → wang的票数+1）
Zhang（有效 → zhang的票数+1）
zhuang（废票）
LI（有效 → li的票数+1）
Liao（废票）
ZHANG（有效 → zhang的票数+1）
WANG（有效 → wang的票数+1）
Wang（有效 → wang的票数+1）
wang（有效 → wang的票数+1）
那么总的有效票是：
wang的票数：Wang（1）、WANG（1）、Wang（1）、wang（1） → 4次？
或者，如果选票输入的顺序是同一行的，那么顺序可能如输入样例中的选票顺序，得到每个的统计。
因此，可能选民的每个投票是在同一行，用空格分隔。因此，程序需要读取整个选票行，分割后处理每个元素作为单独的投票。
在这种情况下，Python代码的结构可能如下：
n = int(input())
candidates = input().split()
m = int(input())
votes = input().split()
然后检查len(votes) == m？如果输入时选票数目不等于m，如何处理？题目可能假设输入是正确的，所以不需要处理错误情况。
所以，程序的处理步骤：

读取候选人数n。
读取n个候选人的姓名，可能存在同一行，用空格分隔。
读取选民数m。
读取m个选票，可能存在同一行，用空格分隔。
处理每个选票，统计有效票和废票。

现在，针对候选人的姓名，需要保存原始的大小写形式，并为每个候选人建立一个字典，其中键是小写的姓名，值是原始姓名和票数。例如：
例如，候选人输入是zhang、li、wang：
candidates_dict = {
'zhang': {'name': 'zhang', 'votes': 0},
'li': {'name': 'li', 'votes': 0},
'wang': {'name': 'wang', 'votes': 0}
}
但根据问题描述中的输出样例，输出中的候选人姓名是首字母大写的，比如输出样例1中的wang:4，但输入的候选人是小写的。这可能与输入样例中的候选人姓名有关。例如，在输入样例1中，候选人姓名是zhang（小写），li（小写），wang（小写），但输出时原样输出。所以程序需要保存候选人姓名的原始输入形式。例如，用户输入的是“Zhang”，程序就保存为“Zhang”，输出时使用原样。
因此，在代码中，候选人的姓名存储为原始字符串，而键是小写后的字符串。
现在，处理选票的逻辑：
对于每个投票，检查其小写形式是否存在于候选人的键中。如果存在，对应的候选人票数加一。否则，加入废票列表。
废票需要记录原始输入的姓名，而不是小写后的。
例如，投票输入的是“Wang”，转换为小写“wang”，存在，则对应的候选人票数加一。废票列表中不记录这个。
例如，投票输入的是“zhuang”，不在候选人中，废票列表添加“zhuang”。
接下来，处理输出：
首先，按照得票数由高到低排序。如果得票数相同，按候选人的输入顺序排序。例如，在输入样例2中，输出是liu:3，yang:2。假设输入顺序是liu、yang，所以即使票数相同，输入顺序早的先出现。
然后，输出废票信息，按选票输入的先后顺序，每个废票的原始姓名。
因此，废票列表应该按顺序保存所有无效的投票的原始名称。
代码结构的大致步骤：
读取候选人和选票：
n = int(input())
raw_candidates = input().split() # 假设输入在同一行，用空格分隔
或者，如果每个候选人单独一行，则循环读取n次：
raw_candidates = [input().strip() for _ in range(n)]
candidates_dict = {}
original_names = [] # 保存原始顺序，用于排序时相同票数的情况
for name in raw_candidates:
key = name.lower()
if key in candidates_dict:
# 根据问题描述，候选人姓名可能不重复？假设输入的是唯一的。
# 如果有重复，如何处理？题目可能假设候选人的姓名唯一。
pass # 忽略重复或处理错误？
candidates_dict[key] = {'original': name, 'votes': 0}
original_names.append(name)
m = int(input())
votes = input().split() # 假设选票在同一行用空格分隔
或者循环读取m次：
votes = [input().strip() for _ in range(m)]
invalid_votes = []
for vote in votes:
key = vote.strip().lower()
if key in candidates_dict:
candidates_dict[key]['votes'] += 1
else:
invalid_votes.append(vote.strip())
然后，将候选人按票数降序和输入顺序升序排列：
创建一个列表，保存每个候选人的原始输入顺序索引、原始名称、票数
sorted_candidates = []
for idx, name in enumerate(original_names):
key = name.lower()
sorted_candidates.append( (idx, name, candidates_dict[key]['votes']) )
排序：先按票数降序，再按输入顺序升序
sorted_candidates.sort(key=lambda x: (-x[2], x[0]))
输出结果：
for item in sorted_candidates:
print(f"{item[1]}:{item[2]}")
输出废票信息
if invalid_votes:
print("\ninvalid vote:")
print(' '.join(invalid_votes))
但根据样例输出，例如输入样例1的输出中，废票部分是“invalid vote:”后跟废票列表，用空格分隔。例如：
invalid vote:
zhuang Liao
注意，样例中的输出在“invalid vote:”后换行，然后输出废票？或者是否在同一行？
根据样例1的输出：
输出样例1:
wang:4
zhang:2
li:1
invalid vote:
zhuang Liao
看起来“invalid vote:”单独占一行，然后废票在同一行用空格分隔。或者可能原输出中，invalid vote后面有一个换行，之后是废票信息。例如：
invalid vote:
zhuang Liao
这可能与输出要求有关。根据问题描述中的输出样例，例如输出样例1中的“invalid vote:”后换行，然后输出废票信息。或者可能输出是在同一行？
原输出样例中的显示可能是在输出有效票后，换行，然后输出“invalid vote:”，再换行，接着是废票信息？或者原样例的输出中，“invalid vote:”之后同一行是废票？
需要根据样例的输出来判断。例如，样例1的输出：
invalid vote:
zhuang Liao
这可能是“invalid vote:”之后换行，然后废票信息单独一行。但根据原样例的输出，可能不是这样。例如，在样例1中，输出可能为：
wang:4
zhang:2
li:1
invalid vote: zhuang Liao
或者：
invalid vote:
zhuang Liao
但根据问题描述中的输出样例，例如输入样例1的输出显示：
invalid vote: zhuang Liao
这可能表示在输出完有效票后，换行，然后输出“invalid vote:”后接废票信息，用空格分隔。
例如，正确的输出格式是先输出有效票，每个一行，按格式“姓名:票数”。然后输出一个空行，再输出“invalid vote:”后接所有废票的姓名，用空格分隔。或者可能是在有效票之后换行，然后输出“invalid vote:”行，再换行后输出废票信息？
根据样例的输出描述，例如输出样例1中的最后两行：
invalid vote:
zhuang Liao
这可能表示在输出有效票后，有一个空行，然后输出“invalid vote:”行，再输出废票信息。或者可能“invalid vote:”后面紧跟废票信息，用空格分隔。
根据样例的输出，例如，样例1的输出中：
invalid vote: 后有两个废票，zhuang和Liao。输出是“invalid vote:”后面跟着这两个词，用空格分隔。但原样例的输出显示“invalid vote:”后换行吗？
例如，样例的输出可能为：
（有效票部分）
wang:4
zhang:2
li:1
invalid vote: zhuang Liao
或者：
（有效票部分）
wang:4
zhang:2
li:1
invalid vote:
zhuang Liao
根据原问题描述中的样例输出，可能“invalid vote:”后面换行，然后输出废票信息。例如，样例中的输出显示：
invalid vote: 后换行，再输出废票。这可能意味着在输出完有效票后，换行，然后输出“invalid vote:”，再换行，然后输出废票信息。或者，是否应该在同一行？
例如，在输出样例1中，输出是：
wang:4
zhang:2
li:1
invalid vote:
zhuang Liao
这表示在有效票之后有一个空行，然后是“invalid vote:”行，再是废票信息。但原样例的输出可能不是这样，可能“invalid vote:”和废票信息在同一行？
可能原样例中的输出是：
invalid vote: zhuang Liao
因此，在代码中，处理废票的输出方式应为：换行后输出“invalid vote:”，然后接着输出废票列表，用空格分隔。例如：
print("\ninvalid vote:")
print(' '.join(invalid_votes))
但根据样例的输出，可能“invalid vote:”后面直接接废票信息，用空格分隔，并且不换行。比如，在样例1中，输出为：
invalid vote: zhuang Liao
所以，正确的处理方式是，在有效票输出后，换行，输出“invalid vote:”加上废票列表，用空格分隔。例如：
if invalid_votes:
print("\ninvalid vote:", ' '.join(invalid_votes))
else:
print("\ninvalid vote:")
或者，在输出有效票后，换行，然后输出“invalid vote:”，然后换行，输出废票列表？
这需要看问题描述中的样例。例如，输出样例1中的“invalid vote:”后面跟着废票信息在同一行吗？例如，原样例的输出是：
invalid vote: zhuang Liao
如果是这样，那么代码应该：
print("\ninvalid vote:", ' '.join(invalid_votes))
但如果原样例的输出中的“invalid vote:”之后换行，然后废票信息另起一行，那么代码应该：
print("\ninvalid vote:")
print(' '.join(invalid_votes))
根据原样例的输出描述，例如输出样例1中的invalid vote后的内容是“zhuang Liao”，这可能是在同一行。例如，输出为：
invalid vote: zhuang Liao
因此，正确的做法是在同一行输出。
因此，处理废票部分的代码：
if invalid_votes:
print("\ninvalid vote:", ' '.join(invalid_votes))
else:
print("\ninvalid vote:")
这样，当有废票时，输出“invalid vote:”和废票列表；否则，输出“invalid vote:”后面没有内容。
现在，测试样例输入1的情况：
输入：
3
zhang li wang
9
Wang Zhang zhuang LI Liao ZHANG WANG Wang wang
候选人的处理：
raw_candidates = ['zhang', 'li', 'wang']
candidates_dict的键为小写的'zhang', 'li', 'wang'，对应的原样保存。
选民的选票是：['Wang', 'Zhang', 'zhuang', 'LI', 'Liao', 'ZHANG', 'WANG', 'Wang', 'wang']
处理每个投票：
Wang → 小写'wang' → 存在于候选人中，所以原样保存的'wang'的票数加一。
Zhang → 小写'zhang' → 存在，票数加一。
zhuang → 小写'zhuang'不存在，废票，保存原样。
LI → 小写'li'存在，票数加一。
Liao → 不存在，废票。
ZHANG → 存在，票数加一。
WANG → 存在，票数加一。
Wang → 存在，票数加一.
wang → 存在，票数加一.
所以，各候选人的票数：
zhang的票数是2次（Zhang和ZHANG）。
li的票数是1次（LI）。
wang的票数是4次（Wang, WANG, Wang, wang → 原输入中的四个）。
废票列表是['zhuang', 'Liao'].
排序后的顺序是wang（4票）、zhang（2）、li（1）。
输出：
wang:4
zhang:2
li:1
invalid vote: zhuang Liao
符合样例的输出。
接下来，样例输入2：
输入：
2
liu yang
5
Liu liu YANG yang Liu
候选人：liu、yang.
选票：Liu（小写liu，存在）、liu（存在）、YANG（存在）、yang（存在）、Liu（存在）。
所以，liu的票数是Liu、liu、Liu → 3票；yang的票数是YANG、yang → 2票。
输出：
liu:3
yang:2
invalid vote: （无废票）
所以，输出末尾是：
invalid vote: （没有内容）
现在，处理输入格式可能的问题，例如，候选人姓名可能包含空格？题目中可能不允许，因为候选人姓名是从键盘输入，每次输入一个候选人的名字，所以假设每个候选人的名字是一个单词，没有空格。例如，输入用空格分隔多个候选人名字，每个名字是独立的。
综上，程序的步骤大致如下：
Python代码：
n = int(input())
raw_candidates = input().split() # 读取候选人名字，同一行用空格分隔
candidates_dict = {}
original_order = {} # 保存每个候选人的输入顺序
for idx, name in enumerate(raw_candidates):
key = name.lower()
if key in candidates_dict:
# 如果候选人重复，如何处理？根据题目描述，可能假设候选人名字唯一
pass # 这里假设输入没有重复的候选人名字
candidates_dict[key] = {'name': name, 'votes': 0}
original_order[key] = idx # 保存输入顺序
m = int(input())
votes = input().split() # 读取选票，同一行用空格分隔
invalid_votes = []
for vote in votes:
stripped_vote = vote.strip()
key = stripped_vote.lower()
if key in candidates_dict:
candidates_dict[key]['votes'] += 1
else:
invalid_votes.append(stripped_vote)
转换为列表并按票数排序
candidate_list = []
for key in candidates_dict:
candidate_list.append( (original_order[key], candidates_dict[key]['name'], candidates_dict[key]['votes']) )
排序：按票数降序，输入顺序升序
candidate_list.sort(key=lambda x: (-x[2], x[0]))
输出结果
for item in candidate_list:
print(f"{item[1]}:{item[2]}")
处理废票输出
print("\ninvalid vote:", end='')
if invalid_votes:
print(" " + ' '.join(invalid_votes))
else:
print()
但根据样例的输出，例如在输入样例1中，“invalid vote:”后面有一个空格，然后跟着废票。或者原样例的输出中，“invalid vote:”后面没有空格？
根据样例1的输出，显示“invalid vote: zhuang Liao”，所以应该在输出时，将“invalid vote:”和废票用空格连接。例如：
print("\ninvalid vote:", ' '.join(invalid_votes))
这样，当使用print函数时，参数中的多个值会被空格分隔。例如：
print("a", "b", "c") → a b c
所以，在代码中：
if invalid_votes:
print("\ninvalid vote:", ' '.join(invalid_votes))
else:
print("\ninvalid vote:")
这将确保不管是否有废票，“invalid vote:”都会被输出，后面跟着废票列表，用空格分隔。如果没有废票，则输出“invalid vote:”后面无内容。
例如，在输入样例2中，输出：
liu:3
yang:2
invalid vote:
这样符合样例的输出。
综上，完整的Python代码如下：
n = int(input())
candidates = input().split()
candidate_dict = {}
original_order = {} # 保存每个候选人的输入顺序索引
for idx, name in enumerate(candidates):
key = name.lower()
if key not in candidate_dict:
candidate_dict[key] = {'name': name, 'votes': 0}
original_order[key] = idx
m = int(input())
votes = input().split()
invalid_votes = []
for vote in votes:
stripped_vote = vote.strip()
key = stripped_vote.lower()
if key in candidate_dict:
candidate_dict[key]['votes'] += 1
else:
invalid_votes.append(stripped_vote)
准备排序的列表
sorted_list = []
for key in candidate_dict:
sorted_list.append( (original_order[key], candidate_dict[key]['name'], candidate_dict[key]['votes']) )
排序：按票数降序，输入顺序升序
sorted_list.sort(key=lambda x: (-x[2], x[0]))
输出有效票
for item in sorted_list:
print(f"{item[1]}:{item[2]}")
输出废票
print("\ninvalid vote:", end='')
if invalid_votes:
print(' ' + ' '.join(invalid_votes))
else:
print()
测试这个代码是否符合样例输入的情况。
对于输入样例1：
输入：
3
zhang li wang
9
Wang Zhang zhuang LI Liao ZHANG WANG Wang wang
处理候选人：
candidates = ['zhang', 'li', 'wang']
original_order的键是小写：
'zhang' → 0
'li' → 1
'wang' → 2
选票处理：
votes列表是['Wang', 'Zhang', 'zhuang', 'LI', 'Liao', 'ZHANG', 'WANG', 'Wang', 'wang']
处理每个投票：
Wang → 'wang' → 存在，票数+1 → wang的票数初始为0，现在变为1.
Zhang → 'zhang' → 存在，票数+1 → zhang的票数变为1.
zhuang → 不存在，废票列表添加'zhuang'.
LI → 'li' → 存在，票数+1 → li的票数变为1.
Liao → 不存在，废票列表添加'Liao'.
ZHANG → 'zhang' → 票数+1 → 变为2.
WANG → 'wang' → 票数+1 → 变为2.
Wang → 'wang' → 变为3.
wang → 'wang' → 变为4.
所以，每个候选人的票数：
zhang → 2票.
li → 1票.
wang →4票.
排序后的顺序是按票数降序：wang（4）、zhang（2）、li（1）。
输出：
wang:4
zhang:2
li:1
然后，废票列表是['zhuang', 'Liao'] → 输出：
invalid vote: zhuang Liao
符合样例。
对于输入样例2：
输入：
2
liu yang
5
Liu liu YANG yang Liu
候选人处理：
candidates = ['liu', 'yang']
original_order:
'liu' → 0
'yang' → 1
选票列表是['Liu', 'liu', 'YANG', 'yang', 'Liu']
处理：
Liu → 'liu' → 存在，票数+1 → liu票数1.
liu → 存在，票数+1 → 2.
YANG → 'yang' → 存在，票数+1 → 1.
yang → 存在，票数+1 → 2.
Liu → 存在，票数+1 →3.
所以，liu的票数3，yang的票数2.
排序后：liu（3）、yang（2）.
输出：
liu:3
yang:2
废票列表为空，所以输出：
invalid vote:
符合样例。
因此，这段代码应该能正确处理问题中的需求。### 分步实现说明

读取输入数据

候选人数n和对应的候选人姓名
选民人数m和所有投票记录

构建候选人字典

使用小写姓名作为键，保存原始姓名和票数，并记录输入顺序

统计有效票与废票

遍历投票记录，通过小写匹配判断有效性
有效票累加至对应候选人，废票记录原始输入内容

排序输出结果

按票数降序排列，若票数相同则按输入顺序
废票按输入顺序输出

代码实现
n = int(input())
candidates = input().split()

# 存储候选人的小写键、原始姓名、输入顺序和票数
candidate_dict = {}
original_order = {}
for idx, name in enumerate(candidates):
key = name.lower()
candidate_dict[key] = {'name': name, 'votes': 0}
original_order[key] = idx

m = int(input())
votes = input().split()

invalid_votes = []
for vote in votes:
stripped_vote = vote.strip()
key = stripped_vote.lower()
if key in candidate_dict:
candidate_dict[key]['votes'] += 1
else:
invalid_votes.append(stripped_vote)

# 转换为列表并排序（按票数降序，输入顺序升序）
sorted_list = sorted(
[(original_order[key], candidate_dict[key]['name'], candidate_dict[key]['votes']) for key in candidate_dict],
key=lambda x: (-x[2], x[0])
)

# 输出有效票结果
for item in sorted_list:
print(f"{item[1]}:{item[2]}")

# 输出废票信息
print("\ninvalid vote:", end='')
if invalid_votes:
print(' ' + ' '.join(invalid_votes))
else:
print()
登录后复制
输入输出示例
输入样例1
3
zhang li wang
9
Wang Zhang zhuang LI Liao ZHANG WANG Wang wang
登录后复制
输出样例1
wang:4
zhang:2
li:1

invalid vote: zhuang Liao
登录后复制
输入样例2
2
liu yang
5
Liu liu YANG yang Liu
登录后复制
输出样例2
liu:3
yang:2

invalid vote:
登录后复制
关键逻辑说明

不区分大小写匹配通过将候选人和投票姓名统一转为小写实现，但输出保留原始格式[^3]。

废票处理若投票姓名无法匹配任何候选人，则记录原始输入内容[^2]。

排序规则先按票数降序，若票数相同则按输入顺序排列[^3]。