python 程序设计代码 1-4章
程序设计竞赛入门：python版 黄龙军 书籍算法代码
第一章
例1.5.1 a+b （处理T次）
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入两个整数a、b。
输出格式:
对于每组测试，输出一行，包含一个整数，表示a、b之和。
输入样例:
3
1 2
3 4
5 6
输出样例:
3
7
11
点击查看代码
T=int(input())
for i in range(T):
a,b=input().split()
c=int(a)+int(b)
print(c)
例1.5.2 a+b （处理到特值结束）
求两个整数之和。
输入格式:
测试数据有多组。每组测试输入两个整数a、b，当a、b同时为0时，表示输入结束。
输出格式:
对于每组测试，输出一行，包含一个整数，表示a、b之和。
输入样例:
1 2
3 4
5 6
0 0
输出样例:
3
7
11
点击查看代码
while True:
a,b=input().split()
if a=='0' and b=='0':
break
c=int(a)+int(b)
print(c)
例1.5.3 a+b （处理到文件尾）
求两个整数之和。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入两个整数a、b。
输出格式:
对于每组测试，输出一行，包含一个整数，表示a、b之和。
输入样例:
1 2
3 4
5 6
输出样例:
3
7
11
点击查看代码
try:
while True: #True要大写
a,b=input().split()
c=int(a)+int(b)
print(c)
except EOFError:pass
例1.6.1 输出乘法式子
输入两个整数，输出如输出样例所示的乘法式子。
输入格式:
输入两个整数a，b。
输出格式:
输出a*b=c，其中a，b是输入的整数，c是a与b的乘积。
输入样例:
2 5
输出样例:
2*5=10
点击查看代码
a,b=input().split()
a=int(a)
b=int(b)
c=a*b
print("%d*%d=%d"%(a,b,c))
例1.6.2 输出漏斗图形
输出如样例输出中所示的漏斗图形。
输入样例:
输出样例:
*********
*******
*****
***
*
***
*****
*******
*********
点击查看代码
n=int(5)
for i in range(2*n-1):
if i<n:
for j in range(i):
print(" ",end="")
for j in range(2*(n-i)-1):
print("*",end="")
print()
if i>=n:
for j in range(n-i+3):
print(" ",end="")
for j in range(2*(i-n)+3):
print("*",end="")
print()
第二章
例2.5.1 求矩形面积
已知一个矩形的长和宽，计算该矩形的面积。矩形的长和宽用整数表示，由键盘输入。
输入格式:
输入在一行中给出2个绝对值不超过1000的整数A和B，表示矩形的长和宽。
输出格式:
在一行中输出矩形的面积。
输入样例:
4 3
输出样例:
12
点击查看代码
a,b=map(int,input().split())
if abs(a)<1000 and abs(b)<1000:
print(a*b)
例2.5.2 求圆周长和面积
已知一个圆的半径，计算该圆的周长和面积，结果保留2位小数。半径用实数表示，由键盘输入。设圆周率等于3.14159。
输入格式:
输入在一行中给出1个实数r，表示圆的半径。
输出格式:
在一行中输出圆的周长和面积，结果保留2位小数。数据之间留一个空格。
输入样例:
3
输出样例:
18.85 28.27
点击查看代码
r=float(input())
pi=3.14159
c=2*pi*r
s=pi*r**2
print("%0.2f %0.2f"%(c,s))
例2.5.3 温度转换
输入一个华氏温度f（整数）,要求根据公式c=5(f-32)/9计算并输出摄氏温度，其中f由键盘输入，结果保留1位小数。
输入格式:
输入在一行中给出1个绝对值不超过1000的整数f，表示华氏温度。
输出格式:
在一行中输出摄氏温度，结果保留1位小数。
输入样例:
100
输出样例:
37.8
点击查看代码
f=int(input())
if abs(f)<1000:
c=float(5*(f-32)/9)
print("%0.1f"%c)
例2.5.4 反序显示一个四位数
从键盘上输入一个四位整数，将结果按反序显示出来。
输入格式:
输入在一行中给出1个四位整数a。
输出格式:
在一行中输出a的反序数。
输入样例:
1234
输出样例:
4321
点击查看代码
a=list(input())
a.reverse()
a="".join(a)
print(a)
例2.5.5 交换两实数的整数部分
输入两个实数，将其整数部分交换后输出，结果保留2位小数。
输入格式:
输入2个实数A和B。
输出格式:
输出交换整数部分之后的两个实数。数据之间以一个“,”分隔。
输入样例:
23.45 54.22
输出样例:
54.45,23.22
点击查看代码
a,b=map(float,input().split())
za=int(a)
zb=int(b)
la=a-za
lb=b-zb
fa=zb+la
fb=za+lb
print("%.2f,%.2f"%(fa,fb))
例2.5.6 英文字母的大小写转换
输入一个大写字母c1和一个小写字母c2，把c1转换成小写，c2转换成大写，然后输出。
输入格式:
输入在一行中给出2个字母，第1个是大写字母c1，第2个是小写字母c2。
输出格式:
在一行中输出把c1转换成小写，c2转换成大写后的结果。数据之间留一个逗号。
输入样例:
Y e
输出样例:
y,E
点击查看代码
a,b=input().split()
a=a.lower()
b=b.upper()
print("%s,%s"%(a,b))
习题2.2.1 4位整数的数位和
输入一个4位数的整数，求其各数位上的数字之和。
输入格式:
输入在一行中给出1个4位的正整数n。
输出格式:
在一行中输出n的各数位上的数字之和。
输入样例:
1234
输出样例:
10
点击查看代码
a=input()
sum=0
for i in range(len(a)):
a=int(a)
sum+=a%10
a=a//10
print(sum)
习题2.2.2 5门课的平均分
输入5门课程成绩（整数），求平均分（结果保留1位小数）。
输入格式:
输入在一行中给出5个整数，表示5门课成绩。
输出格式:
在一行中输出5门课的平均分（结果保留1位小数）。
输入样例:
66 77 88 99 79
输出样例:
81.8
点击查看代码
a,b,c,d,e=map(int,input().split())
avg=(a+b+c+d+e)/5
print("%0.1f"%avg)
习题2.2.3 打字
小明1分钟能打m字，小敏1分钟能打n字，两人一起打了t分钟，总共打了多少字。
输入格式:
输入3个整数m，n，t。
输出格式:
输出小明和小敏t分钟一共打的字数。
输入样例:
65 60 2
输出样例:
250
点击查看代码
m,n,t=map(int,input().split())
sum=m*t+n*t
print(sum)
习题2.2.4 欢迎信息
根据输入的姓名（可能包含空格，长度不超过12），输出欢迎信息，即在姓名之前添加“Hello,”。
输入格式:
输入在一行中给出1个字符串s（可能包含空格，长度不超过12），表示输入的姓名。
输出格式:
根据输入的姓名（可能包含空格，长度不超过12），输出欢迎信息，即在姓名s之前添加“Hello,”（参看样例输出）。
输入样例:
Jack
输出样例:
Hello,Jack
点击查看代码
# 二章习题 4
a=input()
print("Hello,"+a)
习题2.2.5 求串长
输入一个字符串（可能包含空格，长度不超过20），输出该串的长度。
输入格式:
输入在一行中给出1个长度不超过20的字符串s。
输出格式:
在一行中输出s的串长。
输入样例:
welcome to acm world
输出样例:
20
点击查看代码
s=input()
print(len(s))
习题2.2.6 求子串
输入一个字符串，输出该字符串的子串。
输入格式:
首先输入一个正整数k，然后是一个字符串s（可能包含空格，长度不超过20），k和s之间用一个空格分开。（k大于0且小于等于s的长度）
输出格式:
在一行中输出字符串s从头开始且长度为k的子串。
输入样例:
10 welcome to acm world
输出样例:
welcome to
点击查看代码
a=input().split()
k=int(a[0])
a=a[1:]
a=list(a)
a=" ".join(a)
a=str(a)
b=a[:k]
print(b)
习题2.2.7 查找字符串
在一行上输入两个字符串s和英文字符串t，要求在s中查找t。其中，字符串s，t均不包含空格，且长度均小于80。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入2个长度不超过80的字符串s和t（s和t都不包含空格）。
输出格式:
对于每组测试数据，若在s中找到t，则输出“Found!”，否则输出“not Found!”。引号不必输出。
输入样例:
2
dictionary lion
factory act
输出样例:
not Found!
Found!
点击查看代码
T=int(input())
for i in range(T):
s,t =input().split()
if t in s:
print('Found!')
else:
print('not Found!')
第三章
例3.2.4 成绩转换
百分制成绩转换为五级计分制时，90分以上为A，80～89分为B，70～79分为C，60～69分为D，0～59分为E。请把输入的百分之成绩转换为五级计分制输出。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个整数score。
输出格式:
对于每组测试，在一行上输出百分制成绩score对应的字符等级。若score超出百分制范围，则输出“error!”。引号不必输出。
输入样例:
1
61
102
输出样例:
E
D
error!
点击查看代码
try:
while True:
score=int(input())
if score>=90 and score<=100:
rank='A'
elif score>=80 and score<90 :
rank='B'
elif score>=70 and score<80 :
rank='C'
elif score>=60 and score<70 :
rank='D'
elif score>=0 and score<60:
rank='E'
else:
rank='error!'
print(rank)
except EOFError:pass
例3.2.5 求某月的天数
输入年份year、月份month，判断该月的天数。闰年：能被4整除但不能被100整除或者能被400整除的年份是闰年。
输入格式:
测试数据有多组，处理到文件尾。对于每组测试，输入两个整数，表示年份year和月份month。
输出格式:
对于每组测试，输出对应年月的天数。
输入样例:
2020 2
2020 4
输出样例:
29
30
点击查看代码
try:
while True:
year,month=map(int,input().split())
if month==2:
if year%4==0 and year%100!=0 or year%400==0:
days=29
else:
days=28
elif month==1 or month==3 or month==5 or month==7 or month==8 or month==10 or month==12:
days=31
elif month==4 or month==6 or month==9 or month==11:
days=30
print(days)
except EOFError:pass
例3.3.3 亲和数判断
古希腊数学家毕达哥拉斯在自然数研究中发现，220的所有真约数（即不是自身的约数）之和为：1+2+4+5+10+11+20+22+44+55+110＝284。而284的所有真约数为1、2、4、71、 142，加起来恰好为220。人们称这样的数对为亲和数。也就是说，若两个数中任何一个数都是另一个数的真约数之和，则它们就是亲和数。请判断输入的两个整数是否是亲和数。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入两个正整数a，b。
输出格式:
对于每组测试，若a，b是亲和数，是则输出“YES”，否则输出“NO”。引号不必输出。
输入样例:
220 284
输出样例:
YES
点击查看代码
try:
while True:
a,b=map(int,input().split())
na=0
for i in range(1,a//2+1):
if a%i==0:
na+=i
nb=0
for i in range(1,b//2+1):
if b%i==0:
nb+=i
if na==b and nb==a:
print('YES')
else:
print('NO')
except EOFError:pass
例3.3.4 星号三角形
输入整数n，显示星号构成的三角形。例如，n=6时，显示输出的三角形如样例输出所示。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个正整数n（0<n<41）。
输出格式:
对于每组测试，输出n行构成的三角形。
输入样例:
6
输出样例:
*
***
*****
*******
*********
***********
点击查看代码
try:
while True:
n=int(input())
for i in range(n):
for j in range(n-i-1):
print(' ',end='')
for j in range(2*i+1):
print('*',end='')
print()
except EOFError:pass
例3.3.5 百钱百鸡
百钱百鸡问题的白话版：100元钱买100只鸡，公鸡5元1只，母鸡3元1只，小鸡1元3只。问公鸡、母鸡、小鸡各多少只（某种鸡可以为0只）？
百钱百鸡的结果如输出样例所示。
现在把100改为n，即n元钱买n只鸡，各种鸡价格不变，结果又如何呢？
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个整数n（100<=n<=1000）。
输出格式:
对于每组测试，按公鸡、母鸡、小鸡的数量（按公鸡数从小到大的顺序）逐行输出各种买法（每行数据之间空一个空格）。
输入样例:
100
输出样例:
0 25 75
4 18 78
8 11 81
12 4 84
点击查看代码
try:
while True:
n=int(input())
for i in range(n//5+1):
for j in range(n//3+1):
k=n-i-j
if i*5+j*3+k/3==n:
print(i,j,k)
except EOFError:pass
例3.3.6 奇数的和
输入n，求[1，n]范围内的所有奇数之和。
输入格式:
测试数据有多组。每组测试数据输入一个整数n（0<n<1000）。若n=0，则输入结束。
输出格式:
对于每组测试，求[1，n]中的奇数之和。
输入样例:
10
9
0
输出样例:
25
25
点击查看代码
while True:
n=int(input())
if n==0:
break
sum=0
for i in range(1,n+1):
if i%2==1:
sum+=i
print(sum)
例3.3.7 数位之和
输入一个正整数，求其各个数位上的数字之和。例如，输入12345，输出15。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个正整数n（int范围内）。
输出格式:
对于每组测试，输出每个n对应的各位数字和。
输入样例:
12345
输出样例:
15
点击查看代码
try:
while True:
n=int(input())
s=0
while n>0:
s+=n%10 #取最后一位
n//=10 #去除最后一位
print(s)
except EOFError:pass
例3.3.8 数列求和
求下面数列的所有大于等于精度e的数据项之和，显示输出计算的结果（四舍五入保留6位小数）。
1/2，3/4，5/8，7/16，9/32……
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个实数e。
输出格式:
对于每组测试，输出数列中所有大于等于e的数据项之和。结果四舍五入保留6位小数。
输入样例:
0.000001
输出样例:
2.999998
点击查看代码
try:
while True:
e=float(input())
a=1
b=2
c=a/b
sum1=0
while c>=e:
a=a+2
b=b*2
sum1+=c
c=a/b
print("%.6f"%sum1)
except EOFError:pass
例3.3.10、例5.3.1 素数判断
输入一个正整数m，判断该数是否为素数。
输入格式:
首先输入测试组数T，然后输入T组测试数据。每组测试输入一个正整数m。
输出格式:
对于每组测试，若m为素数则输出“yes”；反之输出“no”。注意：引号不必输出。
输入样例:
3
9
3
7
输出样例:
no
yes
yes
点击查看代码
from math import sqrt
T=int(input())
for i in range(T):
n=int(input())
flag=True
if n<2:
flag=False
for i in range(2,int(sqrt(n))+1):
if n%i==0:
flag=False
break
if flag:
print('yes')
else:
print('no')
例3.4.1 平均值
在一行上输入若干整数，每个整数以一个空格分开，求这些整数的平均值。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个字符串（仅包含数字字符和空格）。
输出格式:
对于每组测试，输出以空格分隔的所有整数的平均值，结果保留一位小数。
输入样例:
1
1 2 3 4 5 6 7 8 9 10
输出样例:
5.5
点击查看代码
T=int(input())
for i in range(T):
a=input().split()
sum1=0
for i in range(len(a)):
sum1+=int(a[i])
avg=sum1/len(a)
print("%.1f"%avg)
例3.4.2 闰年判断
闰年是能被4整除但不能被100整除或者能被400整除的年份。请判断给定年份是否闰年。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入一个年份y。
输出格式:
对于每组测试，若y是闰年输出“YES”，否则输出“NO”。引号不必输出。
输入样例:
2
2008
1900
输出样例:
YES
NO
点击查看代码
T=int(input())
for i in range(T):
y=int(input())
if y%4==0 and y%100!=0 or y%400==0:
print('YES')
else:
print('NO')
例3.4.3、例5.4.1 求n!
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入一个正整数n（n≤12）。
输出格式:
对于每组测试，输出整数n的阶乘。
输入样例:
1
5
输出样例:
120
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
s=1
if n>0 and n<=12:
if n==0 and n==1:
res=1
else:
for i in range(1,n+1):
s=s*i
res=s
print(res)
例3.4.4 统计数字
输入一个字符串，统计其中数字字符的个数。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个仅由字母和数字组成的字符串（长度不超过80）。
输出格式:
对于每组测试，在一行上输出该字符串中数字字符的个数。
输入样例:
2
er520ac520
a1c2m3sdf
输出样例:
6
3
点击查看代码
T=int(input())
for i in range(T):
s=input()
n=0
for i in range(len(s)):
if s[i].isdigit():
n+=1
print(n)
例3.4.5 组合数
输入两个正整数n、m，要求输出组合数C(n,m)。
例如，当n=5、m=3时，组合数C(5,3)=(5×4×3)/(3×2×1)=10。
组合数可用以下公式计算：
zuheshu.jpg
输入格式:
测试数据有多组，处理到文件尾。每组测试输入两个整数n，m（0 < m ≤ n ≤ 20）。
输出格式:
对于每组测试，输出组合数。
输入样例:
5 3
20 12
输出样例:
10
125970
点击查看代码
def jiecheng(n):
if n==0 or n==1:
return 1
else:
s=1
for i in range(1,n+1):
s*=i
return s
try:
while True:
n,m=map(int,input().split()) #需要采用map形式
res=int(jiecheng(n)/(jiecheng(m)*jiecheng(n-m)))
print(res)
except EOFError:pass
例3.4.6 单词首字母大写
输入一个英文句子，要求将每个单词的首字母改成大写字母。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一行，包含一个长度不超过100的英文句子（仅包含大小写英文字母和空格），单词之间以一个空格间隔。
输出格式:
对于每组测试，输出按照要求改写后的英文句子。
输入样例:
I like acm
i want to get accepted
输出样例:
I Like Acm
I Want To Get Accepted
点击查看代码
try:
while True:
a=input().split()
for i in range(len(a)):
if i>0:
print(" ",end="")
print(a[i].capitalize(),end="")
print()
except EOFError:pass
例3.4.7、例4.1.1 列出完数
输入一个整数n，要求输出[1，n]范围内的所有完数。完数是一个正整数，该数恰好等于其所有不同真因子之和。例如，6、28是完数，因为6=1+2+3，28=1+2+4+7+14；而24不是完数，因为24≠1+2+3+4+6+8+12＝36。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据输入一个整数n（1≤n≤10000）。
输出格式:
对于每组测试，首先输出n和一个冒号“:”；然后输出所有不大于n的完数（每个数据之前留一个空格）；若[1，n]范围内不存在完数，则输出“NULL”。引号不必输出。具体输出格式参考输出样例。
输入样例:
100
5000
5
输出样例:
100: 6 28
5000: 6 28 496
5: NULL
点击查看代码
try:
while True:
n=int(input())
print(n,end=":")
if n<6:
print(" NULL")
elif n<28:
print(" 6")
elif n<496:
print(" 6 28")
elif n<8128:
print(" 6 28 496")
elif n<=10000:
print(" 6 28 496 8128")
except EOFError:pass
习题3.2.5 电费
某电价规定：月用电量在150千瓦时及以下部分按每千瓦时0.4463元收费，月用电量在151~400千瓦时的部分按每千瓦时0.4663元收费，月用电量在401千瓦时及以上部分按每千瓦时0.5663元收费。
请编写一个程序，根据输入的月用电量（单位以千瓦时计），按该电价规定计算出应缴的电费（单位以元计）。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。对于每组测试，输入一个整数n（0≤n≤10000），表示月用电量。
输出格式:
对于每组测试，输出一行，包含一个实数，表示应缴的电费。结果保留2位小数。
输入样例:
1
267
输出样例:
121.50
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
sum=0
if n>=0 and n<=10000:
if n<=150:
sum=0.4463*n
elif n<=400:
sum=0.4663*(n-150)+150*0.4463
elif n>400 :
sum=0.5663*(n-400)+250*0.4663+150*0.4463
print("%0.2f"%sum)
习题3.2.6 小游戏
有一个小游戏，6个人上台去算手中扑克牌点数之和是否5的倍数，据说是小学生玩的。这里稍微修改一下玩法，n个人上台，算手中数字之和是否同时是5，7，3的倍数。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试先输入1个整数n（1≤n≤15），再输入n个整数，每个都小于1000。
输出格式:
对于每组测试，若n个整数之和同时是5，7，3的倍数则输出“YES”，否则输出“NO”。引号不必输出。
输入样例:
2
3 123 27 60
3 23 27 60
输出样例:
YES
NO
点击查看代码
T=int(input())
for i in range(T):
a=input().split()
n=a[0]
a=a[1:]
sum1=0
for i in range(len(a)):
sum1+=int(a[i])
if sum1%3==0 and sum1%5==0 and sum1%7==0:
print('YES')
else:
print('NO')
习题3.2.7 购物
小明购物之后搞不清最贵的物品价格和所有物品的平均价格，请帮他编写一个程序实现。
输入格式:
测试数据有多组，处理到文件尾。每组测试先输入1个整数n（1≤n≤100），接下来的n行中每行输入1个英文字母表示的物品名及该物品的价格。测试数据保证最贵的物品只有1个。
输出格式:
对于每组测试，在一行上输出最贵的物品名和所有物品的平均价格，两者之间留一个空格，平均价格保留1位小数。
输入样例:
3
a 1.8
b 2.5
c 1.5
输出样例:
b 1.9
点击查看代码
try:
while True:
n=int(input())
s=[]
for i in range(n):
t=list(input().split())
s.append({"name":t[0],"price":float(t[1])})
max1=0
sum1=0
for i in range(n):
if s[i]['price']>max1:
max1=s[i]['price']
sum1+=s[i]['price']
for i in range(n):
if s[i]['price']==max1:
print(s[i]['name'],end=" ")
avg=0
avg=sum1/n
print("%.1f"%avg)
except EOFError:pass
习题3.2.8 等边三角形面积
对于等边三角形面积，请选择合适的方法计算之。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入1个实数表示等边三角形的边长。
输出格式:
对于每组测试，在一行上输出等边三角形的面积，结果保留2位小数。
输入样例:
1.0
2.0
输出样例:
0.43
1.73
点击查看代码
from math import sqrt
try:
while True:
a=float(input())
s=sqrt(3)/4*a**2
print("%0.2f"%s)
except EOFError:pass
习题3.2.9 三七二十一
某天，诺诺看到三七二十一（3721）数，觉得很神奇，这种数除以3余2，而除以7则余1。例如8是一个3721数，因为8除以3余2，8除以7余1。现在给出两个整数a、b，求区间[a，b]中的所有3721数，若区间内不存在3721数则输出“none”。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入两个整数a，b（1≤a<b<2000）。
输出格式:
对于每组测试，在一行上输出区间[a，b]中所有的3721数，每两个数据之间留一个空格。如果给定区间不存3721数，则输出“none”（引号不必输出）。
输入样例:
2
1 7
1 100
输出样例:
none
8 29 50 71 92
点击查看代码
T=int(input())
for i in range(T):
a,b=map(int,input().split())
num=0
for j in range(a,b+1):
if j%3==2 and j%7==1:
num+=1
if num>1:
print(" ",end="")
print(j,end="")
if num==0:
print('none')
else:
print()
习题3.2.10 胜者
Sg和Gs进行乒乓球比赛，进行若干局之后，想确定最后是谁胜（赢的局数多者胜）。
输入格式:
测试数据有多组，处理到文件尾。每组测试先输入一个整数n，接下来的n行中每行输入两个整数a，b（0≤a，b≤20），表示Sg与Gs的比分是a比b。
输出格式:
对于每组测试数据，若还不能确定胜负则输出“CONTINUE”，否则在一行上输出胜者“Sg”或“Gs”。引号不必输出。
输入样例:
3
3 11
13 11
11 9
输出样例:
Sg
点击查看代码
try:
while True:
n=int(input())
Sg=0
Gs=0
for i in range(n):
a,b=map(int,input().split())
if a>b:
Sg+=1
if b>a:
Gs+=1
if Sg>Gs:
print('Sg')
elif Gs>Sg:
print('Gs')
else:
print('CONTINUE')
except EOFError:pass
习题3.2.11 加密
信息安全很重要，特别是密码。给定一个5位的正整数n和一个长度为5的字母构成的字符串s，加密规则很简单，字符串s的每个字符变为它后面的第k个字符，其中k是n的每一个数位上的数字。第一个字符对应n的万位上的数字，最后一个字符对应n的个位上的数字。简单起见，s中的每个字符为ABCDE中的一个。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据在一行上输入非负的整数n和字符串s。
输出格式:
对于每组测试数据，在一行上输出加密后的字符串。
输入样例:
12345 ABCDE
输出样例:
BDFHJ
点击查看代码
try:
while True:
a,b=input().split()
for i in range(5):
c=chr(ord(b[i])+int(a[i]))
print(c,end='')
print()
except EOFError:pass
习题3.2.12 比例
某班同学在操场上排好队，请确定男、女同学的比例。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据输入一个以“.”结束的字符串，串中每个字符可能是“MmFf”中的一个，“m”或“M”表示男生，“f”或“F”表示女生。
输出格式:
对于每组测试数据，在一行上输出男、女生的百分比，结果四舍五入到1位小数。输出形式参照### 输出样例:。
输入样例:
FFfm.
MfF.
输出样例:
25.0 75.0
33.3 66.7
点击查看代码
try:
while True:
a=input()
a=a[:len(a)-1]
boy=0
girl=0
for i in range(len(a)):
if a[i]=='F' or a[i]=='f':
girl+=1
if a[i]=='M' or a[i]=='m':
boy+=1
b_percent=boy/len(a)*100
a_percent=girl/len(a)*100
print("%0.1f %0.1f"%(b_percent,a_percent))
except EOFError:pass
习题3.2.13 某校几人
某学校教职工人数不足n人，在操场排队，7个一排剩5人，5个一排剩3人，3个一排剩2人；请问该校人数有多少种可能？最多可能有几人？
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个整数n（1≤n≤10000）。
输出格式:
对于每组测试，输出一行，包含2个以一个空格间隔的整数，分别表示该校教职工人数的可能种数和最多可能的人数。
输入样例:
1000
输出样例:
9 908
点击查看代码
try:
while True:
n=int(input())
num=0
for i in range(n,1,-1):
if i%7==5 and i%5==3 and i%3==2:
num+=1
print(num,end=" ")
for i in range(n,1,-1):
if i%7==5 and i%5==3 and i%3==2:
print(i)
break
except EOFError:pass
习题3.2.14 昨天
例如：日期为2019-10-01，减去1天，则结果日期为2019-09-30。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入1个日期，日期形式为“yyyy-mm-dd”。保证输入的日期合法，而且输入的日期和计算结果都在[1000-01-01，9999-12-31]范围内。
输出格式:
对于每组测试，在一行上以“yyyy-mm-dd”的形式输出结果。
输入样例:
1
2019-10-01
输出样例:
2019-09-30
点击查看代码
T=int(input())
for i in range(T):
a=input().split("-")
y=int(a[0])
m=int(a[1])
d=int(a[2])
r=0
if y%400==0 or y%4==0 and y%100!=0:
r=1
d-=1
if d==0:
m-=1
if m>0 and m<7:
if m%2==1:
d=31
else:
if m==2:
if r==1:
d=29
else:
d=28
else:
d=30
else:
if m%2==0:
d=31
else:
d=30
if m==0:
m=12
y-=1
print("%d-%02d-%02d"%(y,m,d))
习题3.2.15 直角三角形面积
已知直角三角形的三边长，求该直角三角形的面积。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据输入3个整数a，b，c，代表直角三角形的三边长。
输出格式:
对于每组测试输出一行，包含一个整数，表示直角三角形面积。
输入样例:
2
3 4 5
3 5 4
输出样例:
6
6
点击查看代码
T=int(input())
for i in range(T):
a=input().split()
max1=0
for i in range(len(a)):
if int(a[i])>max1:
max1=int(a[i])
sum1=1
for i in range(len(a)):
if int(a[i])<max1:
sum1*=int(a[i])
res=sum1//2
print(res)
习题3.2.16 转向三角形
输入一个整数n，要求用数字1到n排列出一个转向三角形。例如，n=5时，转向三角形如输出样例所示。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入1个整数n（1≤n≤9）。
输出格式:
对于每组测试数据，输出一个有2n-1行的，由数字1…n…1组成的转向三角形（参看输出样例）。
输入样例:
1
5
输出样例:
1
22
333
4444
55555
4444
333
22
1
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
for i in range(1,2*n-1+1):
# print(i)
if i<=n:
for j in range(i):
print(i,end="")
print()
elif i>n:
for j in range(2*n-i):
print(2*n-i,end="")
print()
习题3.2.18 字符梯形
用从m到n的数字字符排列出一个字符梯形。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入2个整数m、n（1≤m≤n≤9）。
输出格式:
对于每组测试数据，输出一个有n-m+1行的，由数字m…n排列而成的梯形，每行的长度依次为：m，m+1，m+2，……，n，每行的数字依次是m，m+1，m+2，……，n。
输入样例:
1
3 6
输出样例:
333
4444
55555
666666
点击查看代码
T=int(input())
for i in range(T):
m,n=map(int,input().split())
for j in range(n-m+1):
for k in range(m+j):
print(m+j,end="")
print()
习题3.2.19 菱形
输入一个整数n，输出2n-1行构成的菱形，例如，n=5时的菱形如输出样例所示。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个整数n（3≤n≤20）。
输出格式:
对于每组测试数据，输出一个共2n-1行的菱形，具体参看输出样例。
输入样例:
5
输出样例:
*
***
*****
*******
*********
*******
*****
***
*
点击查看代码
try:
while True:
n=int(input())
if n>=3 and n<=20:
for i in range(1,2*n-1+1):
if i<=n:
for j in range(n-i):
print(' ',end="")
for z in range(2*i-1):
print('*',end="")
print()
else:
for j in range(i-n):
print(' ',end="")
for z in range(2*n-1-2*(i-n)): #2*5-1-2*(6-5)=10-1-2=7
print('*',end="")
print()
except EOFError:pass
习题3.2.17 求累加和
输入两个整数n和a，求累加和S=a+aa+aaa+…+aa…a（n个a）之值。
例如，当n=5，a=2时，S=2+22+222+2222+22222=24690。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入两个整数n和a（1≤n，a<10）。
输出格式:
对于每组测试，输出a+aa+aaa+…+aa…a（n个a）之值。
输入样例:
5 3
8 6
输出样例:
37035
74074068
点击查看代码
try:
while True:
n,a=map(int,input().split())
sum1=0
s=0
for i in range(n):
s=s*10+a
sum1+=s
print(sum1)
except EOFError:pass
习题3.2.20 水仙花数
输入两个3位的正整数m，n，输出[m，n]区间内所有的“水仙花数”。所谓“水仙花数”是指一个3位数，其各位数字的立方和等于该数本身。
输入格式:
测试数据由多组，处理到文件尾。每组测试输入两个3位的正整数m，n（100≤m<n≤999）。
输出格式:
对于每组测试，若[m，n]区间内没有水仙花数则输出“none”（引号不必输出），否则逐行输出区间内所有的水仙花数，每行输出的格式具体参看输出样例。
输入样例:
100 150
100 200
输出样例:
none
153=111+555+333
点击查看代码
try:
while True:
m,n=map(int,input().split())
flag=False
for i in range(m,n+1):
sum=0
a=i%10
b=i//10%10
c=i//100
sum=(i%10)**3+(i//10%10)**3+(i//100)**3
if sum==i:
flag=True
print("%d=%d*%d*%d+%d*%d*%d+%d*%d*%d"%(i,c,c,c,b,b,b,a,a,a))
if flag==False:
print("none")
except EOFError:pass
习题3.2.21 猴子吃桃
猴子第一天摘下若干个桃子，当即吃了2/3，还不过瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉2/3，又多吃了一个。以后每天早上都吃了前一天剩下的2/3再多一个。到第n天早上想再吃时，发现只剩下k个桃子了。求第一天共摘了多少桃子。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据输入2个正整数n，k（1≤n，k≤15）。
输出格式:
对于每组测试数据，在一行上输出第一天共摘了多少个桃子。
输入样例:
2
2 1
4 2
输出样例:
6
93
点击查看代码
#(重看) 从最后一天反向计算
T=int(input())
for i in range(T):
n,k=map(int,input().split())
if n>=1 and k<=15:
p=k
for j in range(n-1):
p=(p+1)*3
print(p)
习题3.2.22、例5.3.2 最小回文数
若一个数正向看和反向看等价，则称做回文数。例如：6，2552，12321均是回文数。
给出一个正整数n，求比n大的最小的回文数。（n和运算结果均不会超出int类型范围）
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入1个正整数n。
输出格式:
对于每组测试数据，输出比n大的最小回文数。
输入样例:
2
12
123456
输出样例:
22
124421
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
for j in range(n+1,2*n+1): #限制范围
flag=True
str1=str(j)
for k in range(len(str1)//2):
if str1[k]!=str1[len(str1)-k-1]:
flag=0
break
if flag:
print(j)
break
习题3.2.23 分解素因子
假设n是一个正整数，它的值不超过1000000，请编写一个程序，将n分解为若干个素数的乘积。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入一个正整数n（1< n ≤1000000）。
输出格式:
每组测试对应一行输出，输出n的素数乘积表示式，式中的素数从小到大排列，两个素数之间用一个“*”表示乘法。若输入的是素数，则直接输出该数。
输入样例:
2
9828
88883
输出样例:
22333713
88883
点击查看代码
from math import sqrt
T=int(input())
for i in range(T):
n=int(input())
flag=True
if n<2:
flag=False
for i in range(2,int(sqrt(n))+1):
if n%i==0:
flag=False
break
if flag:
print(n)
else:
k=2
while k<=n:
if n%k==0:
print(k,end="")
n=n//k
if n!=1:
print('*',end="")
else:
k+=1
print()
习题3.2.24 Fibonacci分数序列
求Fibonacci分数序列的前n项之和。Fibonacci分数序列的首项为2/1，后面依次是：3/2，5/3，8/5，13/8，21/13……
输入格式:
测试数据由多组，处理到文件尾。每组测试输入一个正整数n（2≤n≤20）。
输出格式:
对于每组测试，输出Fibonacci分数序列的前n项之和。结果保留6位小数。
输入样例:
3
8
15
输出样例:
5.166667
13.243746
24.570091
点击查看代码
try:
while True:
n=int(input())
sum=float(0)
a=1
b=2
for i in range(n):
sum+=b/a
c=a #先得保存a 重要
a=b
b=b+c
print("%0.6f"%sum)
except EOFError:pass
习题3.2.25 n马n担问题
有n匹马，驮n担货，大马驮3担，中马驮2担，两匹小马驮1担，问有大、中、小马各多少匹? （某种马的数量可以为0）
输入格式:
测试数据由多组，处理到文件尾。每组测试输入一个正整数n（8≤n≤1000）。
输出格式:
对于每组测试，逐行输出所有符合要求的大、中、小马的匹数。要求按大马数从小到大的顺序输出，每两个数字之间留一个空格。
输入样例:
20
输出样例:
1 5 14
4 0 16
点击查看代码
try:
while True:
n=int(input())
for i in range(n//3+1):
for j in range(n//2+1):
if 3*i+2*j+0.5*(n-i-j)==n:
print(i,j,n-i-j)
except EOFError:pass
习题3.2.26 打印沙漏
当n=5时，沙漏图形如输出样例所示。请观察并明确沙漏图形的规律。要求输入一个整数n，输出满足规律的沙漏图形。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个整数n（1<n<20）。
输出格式:
对于每组测试，输出满足规律的沙漏图形。
输入样例:
5
输出样例:
*********
*******
*****
***
*
***
*****
*******
*********
点击查看代码
try:
while True:
n=int(input())
i=2*n
# for i in range(2*n,1):
while i>1:
if i>n:
for j in range(2*n-i):
print(' ',end="")
for k in range(2*(i-n)-1):
print('*',end="")
print()
else:
for j in range(i-2):
print(' ',end="")
for k in range(2*n-2*i+3): #(2*n-1)-2(i-2)
print('*',end="")
print()
i-=1
except EOFError:pass
第四章
例4.1.1 均方差
求n个非负整数x1, x2 …… xn（xi为第i个元素）的均方差，公式如下：
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据先输入一个整数n（1≤n≤100），再输入n个整数xi（0≤xi≤1000）。
输出格式:
对于每组测试数据，在一行上输出均方差，结果保留5位小数。
输入样例:
2
4 6 7 8 9
10 6 3 7 1 4 8 2 9 11 5
输出样例:
1.11803
3.03974
点击查看代码
from math import sqrt
T=int(input())
for i in range (T):
a=list(map(int,input().split()))
n=a[0]
a=a[1:]
sum=0
for j in range(len(a)):
sum+=a[j]
avg=sum/len(a)
sum2=0
for j in range(len(a)):
sum2+=(a[j]-avg)**2
S=sqrt(sum2/n)
print("%0.5f"%S)
例4.2.1 逆序输出
输入n个数，然后把这n个数逆序输出。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据在一行上首先输入整数n，接着输入n（n<=40）个整数。
输出格式:
对于每组测试，逆序输出n个数，每两个数据之间留一个空格。每两组测试数据之间留一个空行。
输入样例:
5 1 2 3 4 5
3 1 2 3
输出样例:
5 4 3 2 1
3 2 1
点击查看代码
try:
k=0
while True:
a=input().split()
if a!=None:
k+=1
#print(k)
n=int(a[0])
a=a[1:]
a=list(a)
a.reverse()
if k>1:
print()
print(*a)
except EOFError:pass
例4.2.2 数位分离
输入一个正整数n，要求输出其位数，并分别以正序和逆序输出各位数字。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个整数n（int范围内）。
输出格式:
对于每组测试数据，输出n的位数，然后分别以正序和逆序输出各位数字，每两个数据之间用一个逗号“,”分隔。
输入样例:
2
12345
246
输出样例:
5,1,2,3,4,5,5,4,3,2,1
3,2,4,6,6,4,2
点击查看代码
T=int(input())
for i in range(T):
a=int(input())
b=[0]*10 #产生10个0构成的列表
i=0
while a>0:
b[i]=a%10 #数位分离
a=a//10
i+=1
print(i,end="")
for j in range(i-1,-1,-1):
print(",",b[j],sep='',end='') #输出逗号和数据，以空串为间隔符、结束符
for j in range(i):
print(",",b[j],sep='',end='')
print()
例4.2.3 约瑟夫环
有n个人围成一圈（编号为1～n），从第1号开始进行1、2、3报数，凡报3者就退出，下一个人又从1开始报数……直到最后只剩下一个人时为止。请问此人原来的位置是多少号?
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个整数n（5≤n≤100）。
输出格式:
对于每组测试，输出最后剩下那个人的编号。
输入样例:
10
28
69
输出样例:
4
23
68
点击查看代码
try:
while True:
n=int(input())
a=[True]*n
j=-1
cnt=0
m=n
while m>1:
j=(j+1)%n
if a[j]==False:
continue
cnt+=1
if cnt%3==0:
a[j]=False
m-=1
for i in range(n):
if a[i]==True:
print(i+1)
break
except EOFError:pass
例4.2.4 数组循环移位
输入两个整数n和m，再输入n个整数构成一个数列，把前m个数循环移位到数列的右边。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据第一行输入2个正整数n、m（1<=m，n<100），第二行输入n个整数。
输出格式:
对于每组测试数据, 在一行上输出把前m个数循环移位到数列的右边后的数列，每两个数据之间留一个空格。
输入样例:
5 3
1 2 3 4 5
输出样例:
4 5 1 2 3
点击查看代码
try:
while True:
a=list(map(int,input().split()))
b=list(map(int,input().split()))
n=a[0]
m=a[1]
for i in range(m):
x=b[0]
for j in range(1,n):
b[j-1]=b[j]
b[n-1]=x
print(*b)
except EOFError:pass
例4.2.5 小者靠前
输入n（1<n<100）个整数到一个数组中，使得其中最小的一个数成为数组的第一个元素（首元素）。若有多个最小者，则首元素仅与最早出现的最小者交换。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据的第一行输入n(1<n<100)，第二行输入n个整数。
输出格式:
对于每组测试，输出将这n个整数中最小的数与第一个数对换后的n个整数。
输入样例:
5
5 3 4 1 2
输出样例:
1 3 4 5 2
点击查看代码
try:
while True:
n=int(input())
a=list(map(int,input().split()))
a_min=min(a)
for i in range(len(a)):
if a[i]==a_min:
a[0],a[i]=a[i],a[0]
# b=a[0]
# a[0]=a[i]
# a[i]=b
print(*a)
except EOFError:pass
例4.2.6、例4.2.7 选择排序
输入数据个数n及n个整数构成整数序列，要求对该整数序列进行排序，使其按升序排列。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入两行，第一行输入n（1<n<100），第二行输入n个整数。
输出格式:
对于每组测试，在一行上按升序输出这n个整数，每两个数据之间留一个空格。
输入样例:
10
487 3633 410 4977 940 757 124 392 989 4228
输出样例:
124 392 410 487 757 940 989 3633 4228 4977
点击查看代码
#选择排序
try:
while True:
n=int(input())
a=list(map(int,input().split()))
for i in range(n-1):
for j in range(i+1,n):
if a[i]>=a[j]:
a[i],a[j]=a[j],a[i]
print(*a)
except EOFError:pass
例4.2.8 筛选法求素数
输入一个整数n，求n以内的素数。素数指的是除了1和它本身没有其他因子的整数；最小的素数是2，其余的素数都是奇数；素数序列为：2 3 5 7 11 13 17 19……
输入格式:
测试数据有多组，处理到文件尾。对于每组测试，输入一个整数n（1<n<2000）。
输出格式:
对于每组测试，输出n以内的素数。每两个素数之间留一个空格。
输入样例:
19
输出样例:
2 3 5 7 11 13 17 19
点击查看代码
from math import sqrt
try:
while True:
n=int(input())
cnt=0
for i in range(2,n+1):
for k in range(2,int(sqrt(i))+1):
if i%k==0:
flag=False
break
else:
flag=True
if flag:
cnt+=1
if cnt>1:
print(" ",end='')
print(i,end="")
print()
except EOFError:pass
例4.3.2 方阵转置
输入一个n×n的方阵，把其转置并输出。
输入格式:
测试数据有多组，处理到文件尾。对于每组测试，第一行输入一个整数n（n≤10），接下来的n行每行输入n个不超过2位的整数。
输出格式:
对于每组测试，输出这n×n矩阵的转置方阵，每行的每两个数据之间留一个空格。
输入样例:
5
5 51 96 80 45
51 57 77 45 47
72 45 58 83 21
0 28 42 72 42
91 61 7 73 66
输出样例:
5 51 72 0 91
51 57 45 28 61
96 77 58 42 7
80 45 83 72 73
45 47 21 42 66
点击查看代码
try:
while True:
n=int(input())
a=[[0]*n]*n
for i in range(n):
a[i]=list(map(int,input().split()))
for i in range(n):
for j in range(i):
a[i][j],a[j][i]=a[j][i],a[i][j]
for i in range(n):
print(*a[i])
except EOFError:pass
例4.3.3 杨辉三角
输入一个整数n，输出n行的杨辉三角形。例如，n=5，则杨辉三角如输出样例所示。
输入格式:
输入数据有多组，每组1个整数n(1≤n≤10)，一直处理到文件结束。
输出格式:
对于每个n，输出n行杨辉三角形。每个数据的输出为5个字符宽度，具体见输出样例。
输入样例:
5
输出样例:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
点击查看代码
try:
while True:
n=int(input())
a=[[1]*i for i in range(1,n+1)]
for i in range(2,n):
for j in range(1,i):
a[i][j]=a[i-1][j-1]+a[i-1][j]
for i in range(n):
for j in range(i+1):
print("%5d"%a[i][j],end="")
print()
except EOFError:pass
例4.3.4 两个矩阵之积
输入整数m、p、n，再输入一个m行p列的整数矩阵A和一个p行n列的整数矩阵B，求两个矩阵的乘积AB
输入格式:
测试数据有多组，处理到文件尾。每组测试数据的第一行输入n（1<m，p，n<10），接下来分别输入A矩阵和B矩阵。
输出格式:
对于每组测试，输出m行，每行n个整数，表示AB的结果，每行中每两个数据之间留一个空格。
输入样例:
4 3 2
5 2 4
3 8 2
6 0 4
0 1 6
2 4
1 3
3 2
输出样例:
24 34
20 40
24 32
19 15
点击查看代码
try:
while True:
m,p,n=map(int,input().split())
a=[]
for i in range(m):
t=list(map(int,input().split()))
a.append(t)
b=[]
for i in range(p):
t=list(map(int,input().split()))
b.append(t)
c=[[0]*n for i in range(m)]
for i in range(m):
for j in range(p):
for k in range(n):
c[i][k]+=a[i][j]*b[j][k]
for i in range(m):
print(*c[i])
except EOFError:pass
例4.3.5 蛇形矩阵
蛇形矩阵是由1开始的自然数依次排列成的一个上三角矩阵（参看 输出样例）。要求输入整数n，构造并输出蛇形矩阵。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个正整数N（N不大于100)。
输出格式:
对于每组测试，输出一个共有N行的蛇形矩阵。每行的每两个数字之间留一个空格。
输入样例:
在这里给出一组输入。例如：
1
5
输出样例:
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
a=[[0]*(n-i) for i in range(n)]
val=1
for i in range(n):
k=0
for j in range(i,-1,-1):
a[j][k]=val
val+=1
k+=1
for i in range(n):
print(*a[i])
例4.4.1、例5.5.9、例6.4.3 确定最终排名
某次程序设计竞赛时，最终排名采用的排名规则如下：
根据成功做出的题数（设为solved）从大到小排序，若solved相同则按输入顺序确定排名先后顺序（请结合输出样例）。请确定最终排名并输出。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试数据先输入1个正整数n（1 ≤ n ≤ 100），表示参赛队伍总数。然后输入n行，每行包括1个字符串s（不含空格且长度不超过50）和1个正整数d（0 ≤d ≤ 15），分别表示队名和该队的解题数量。
输出格式:
对于每组测试数据，输出最终排名。每行一个队伍的信息：排名、队名、解题数量。
输入样例:
1
8
Team22 2
Team16 3
Team11 2
Team20 3
Team3 5
Team26 4
Team7 1
Team2 4
输出样例:
1 Team3 5
2 Team26 4
3 Team2 4
4 Team16 3
5 Team20 3
6 Team22 2
7 Team11 2
8 Team7 1
点击查看代码
from functools import cmp_to_key
class S:
def __init__(self,id,name,solved):
self.id=id
self.name=name
self.solved=solved
def cmp(a,b):
if a.solved!=b.solved:
return b.solved-a.solved
if a.id!=b.id:
return a.id-b.id
T=int(input())
for i in range(T):
n=int(input())
a=[]
for i in range(n):
t=input().split()
a.append(S(i+1,t[0],int(t[1])))
a.sort(key=cmp_to_key(cmp))
for i in range(n):
print(i+1,a[i].name,a[i].solved)
例4.4.2、例5.5.8、例6.4.2 解题排行
解题排行榜中，按解题总数生成排行榜。假设每个学生信息仅包括学号、解题总数；要求先输入n个学生的信息；然后按“解题总数”降序排列，若“解题总数”相同则按“学号”升序排列。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试数据先输入1个正整数n（1 ≤ n ≤ 100），表示学生总数。然后输入n行，每行包括1个不含空格的字符串s（不超过8位）和1个正整数d，分别表示一个学生的学号和解题总数。
输出格式:
对于每组测试数据，输出最终排名信息，每行一个学生的信息：排名、学号、解题总数。每行数据之间留一个空格。注意，解题总数相同的学生其排名也相同。
输入样例:
1
4
0010 200
1000 110
0001 200
0100 225
输出样例:
1 0100 225
2 0001 200
2 0010 200
4 1000 110
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
a=[]
if n>=1 and n<=100:
for i in range(n):
card,solved=input().split()
a.append({"card":card,"solved":int(solved)})
for i in range(n-1):
for j in range(n-1-i):
if a[j]["solved"]<a[j+1]["solved"]:
a[j],a[j+1]=a[j+1],a[j]
elif a[j]["solved"]==a[j+1]["solved"]and a[j]["card"]>a[j+1]["card"]:
a[j],a[j+1]=a[j+1],a[j]
print(1,a[0]["card"],a[0]["solved"])
r=1
for i in range(1,n):
if a[i]["solved"]!=a[i-1]["solved"]:
r=i+1
print(r,a[i]["card"],a[i]["solved"])
例4.5.1 统计不同数字字符的个数
输入只包含数字字符的字符串，统计串中不同字符的出现次数。
输入格式:
测试数据有多组，处理到文件尾。对于每组测试，输入一个字符串（不超过80个字符）。
输出格式:
对于每组测试，按字符串中出现字符的ASCII码升序逐个输出不同的字符及其个数（两者之间留一个空格），每组输出之后空一行，输出格式参照输出样例。
输入样例:
12123
输出样例:
1 2
2 2
3 1
点击查看代码
try:
while True:
a=input()
s=[0]*10
for it in a:
s[int(it)]+=1
for i in range(len(s)):
if s[i]==0:
continue
print(i,s[i])
print()
except EOFError:pass
例4.5.2 判断双对称方阵
对于一个n阶方阵，请判断该方阵是否双对称，即既左右对称又上下对称。若是则输出“yes”，否则输出“no”。例如，样例中，以第2列为界则左右对称，以第2行为界则上下对称，因此输出“yes”。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据的第一行输入方阵的阶n（2≤n≤50），接下来输入n行，每行n个整数，表示方阵中的元素。
输出格式:
对于每组测试数据，若该方阵双对称，则输出“yes”，否则输出“no”。注意，引号不必输出。
输入样例:
2
3
1 2 1
3 5 3
1 4 1
3
1 2 1
3 5 3
1 2 1
输出样例:
no
yes
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
a=[]
for i in range(n):
t=list(map(int,input().split()))
a.append(t)
flag=True
for i in range(n//2):
for j in range(n):
if a[i][j]!=a[n-i-1][j]:
flag=False
break
if flag==False:
print('no')
continue
for j in range(n//2):
for i in range(n):
if a[i][j]!=a[i][n-j-1]:
flag=False
break
if flag:
print('yes')
else:
print('no')
例4.5.3 可重组相等
如果一个字符串通过字符位置的调整能重组为另一个字符串，就称这两个字符串“可重组相等”。给出两个字符串，请判断它们是否“可重组相等”。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入两字符串s和t。
输出格式:
对于每组测试，判断它们是否“可重组相等”，是则输出“Yes”，否则输出“No”。注意，引号不必输出。
输入样例:
1
Oh, yes!
y! O,seh
输出样例:
Yes
点击查看代码
T=int(input())
for i in range(T):
s=list(input())
t=list(input())
s.sort()
t.sort()
if s==t:
print('Yes')
else:
print('No')
例4.5.4 二分查找
对于输入的n个整数，先进行升序排序，然后进行二分查找。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据的第一行是一个整数n（1≤n≤100），第二行有n个各不相同的整数待排序，第三行是查询次数m（1≤m≤100），第四行有m个整数待查找。
输出格式:
对于每组测试，分2行输出，第一行是升序排序后的结果，每两个数据之间留一个空格；第二行是查找的结果，若找到则输出排序后元素的位置（从1开始），否则输出0，同样要求每两个数据之间留一个空格。
输入样例:
9
4 7 2 1 8 5 9 3 6
5
10 9 8 7 -1
输出样例:
1 2 3 4 5 6 7 8 9
0 9 8 7 0
点击查看代码
try:
while True:
n=int(input())
s=list(map(int,input().split())) #输入数据创建整型列表
s.sort() #列表排序
m=int(input())
t=list(map(int,input().split()))
print(*s) #输出排序结果
for k in range(m): #进行m次二分查找
if k>0:print(' ',end='')
x=t[k] #x暂存待查找的数据
low=0 #low指向查找区间的第一个数
high=n-1 #high指向查找区间的最后一个数
while low<=high:
mid=(low+high)//2 #注意用整除//
if s[mid]==x: #待查数据x等于中间数，查找成功
print(mid+1,end='')
break
elif x<s[mid]: #若待查找数据x小于中间数，则左半区间查找
high=mid-1
else: #若待查找数据x大于中间数，则右半区间查找
low=mid+1
else:
print(0,end='')
print()
except EOFError:pass
例4.5.5 马鞍点测试
如果矩阵A中存在这样的一个元素A[i][j]满足下列条件：A[i][j]是第i行中值最小的元素，且又是第j列中值最大的元素，则称之为该矩阵的一个马鞍点。请编写程序求出矩阵A的马鞍点。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
对于每组测试数据，首先输入2个正整数m、n（1 ≤ m，n ≤ 100），分别表示二维数组的行数和列数。
然后是二维数组的信息，每行数据之间用一个空格分隔，每个数组元素均在int型范围内。简单起见，假设二维数组的元素各不相同，且每组测试数据最多只有一个马鞍点。
输出格式:
对于每组测试数据，若马鞍点存在则输出其值，否则输出“Impossible”。注意，引号不必输出。
输入样例:
1
4 3
6 7 11
2 17 13
4 -2 3
5 9 88
输出样例:
6
点击查看代码
T=int(input())
for t in range(T):
m,n=map(int,input().split())
a=[]
for i in range(m):
t=list(map(int,input().split()))
a.append(t)
k=0
cnt=0
for i in range(m):
for j in range(n):
if a[i][j]<a[i][k]:
k=j
for j in range(m):
if a[j][k]>a[i][k]:
break
else:
print(a[i][k])
cnt+=1
break
if cnt==0:
print('Impossible')
# m,n=map(int,input().split())
# a=[]
# for i in range(m):
# t=list(map(int,input().split()))
# a.append(t)
# #print(a)
# cnt=0 #计数器清0
# for i in range(m): #找到每行数据的最小数，并记录下标到k中
# k=0
# for j in range(n):
# if a[i][j]<a[i][k]:
# k=j
# for j in range(m): #若该数不是列中的最大数，则结束循环
# if a[j][k]>a[i][k]:
# break
# else: #若上一条for语句未执行break，则找到马鞍点
# print(a[i][k])
# cnt+=1;
# break;
# if cnt==0: #若计数器为0，则不存在马鞍点
# print("Impossible")
##1
# cnt = 0
# for i in range(m):
# x = min(a[i])
# for j in range(n):
# if a[i][j] == x : #一行中可能会有多个最小值
# maxn = a[i][j]
# s = i
# for k in range(m):
# if a[k][j] > maxn:
# maxn = a[k][j]
# s = k
# if maxn == x:
# cnt += 1
# #print(s,j)
# print(x)
# if cnt == 0:
# print('impossible')
##2
# max1=[] #存储每列的最大值
# for i in range(n): #找到每行数据的最小数，并记录下标到k中
# max_l=a[0][i]
# for j in range(m):
# if a[j][i]>max_l:
# max_l=a[j][i]
# max1.append(max_l)
# t=False
# for i in range(n):
# for j in range(m):
# if a[j][i]==min(a[j]) and a[j][i]==max1[i]:
# print(a[j][i])
# t=True
# if t==False: #若计数器为0，则不存在马鞍点
# print("impossible")
# T=int(input())
# for t in range(T):
# m,n=map(int,input().split())
# a=[]
# for i in range(m):
# t=list(map(int,input().split()))
# a.append(t)
##3
# cnt=0 #计数器清0
# for h in a: #找到每行数据的最小数，并记录下标到k中
# k=min(h)
# l=h.index(k)
# if k>=max([hang[h.index(k)]for hang in a]):
# print(k)
# cnt+=1
# break
# if cnt==0: #若计数器为0，则不存在马鞍点
# print("impossible")
例4.5.6 骑士
在国际象棋中，棋盘的行编号为18，列编号为ah；马以“日”方式行走，根据马在当前棋盘上的位置，请问可以有几种合适的走法。如下图所示，设马（以H表示）在e4位置，则下一步可以走的位置是棋盘中粗体数字标注的8个位置：
1919.png
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入一个字符（ah）和一个整数（18），表示马所在的当前位置。
输出格式:
对于每组测试，输出共有几种走法。
输入样例:
1
e4
输出样例:
8
点击查看代码
# dir=[[2,1],[1,2],[-1,2],[-2,1],[-2,-1],[-1,-2],[1,-2],[2,-1]]
# T=int(input())
# for t in range(T):
# s=input() #包含两个字符的字符串
# row=int(s[1]) #行号转换为整数
# col=ord(s[0])-ord('a')+1 #列号（小写字母）转换为整数
# cnt=0 #计数器清0
# for i in range(len(dir)): #扫描方向数组的8个方向，检查可能走的位置是否在棋盘中
# newRow=row+dir[i][0] #计算可能走的新行号
# newCol=col+dir[i][1] #计算可能走的新列号
# if (newRow>=1 and newRow<=8) and (newCol>=1 and newCol<=8):
# cnt+=1 #若可能走的位置在棋盘内，则计数器增1
# print(cnt)
dir=[[1,2],[1,-2],[2,1],[2,-1],[-1,2],[-1,-2],[-2,1],[-2,-1]]
T=int(input())
for i in range(T):
s=input()
row=int(s[1])
col=ord(s[0])-ord('a')+1
cnt=0
for i in range(len(dir)):
newRow=row+dir[i][0]
newCol=col+dir[i][1]
if (newRow>=1 and newRow<=8) and (newCol>=1 and newCol<=8):
cnt+=1
print(cnt)
例4.5.8 气球升起来
程序设计竞赛时，赛场升起各色气球多么激动人心呀！志愿者送气球忙得不亦乐乎，观战的某人想知道目前哪种颜色的气球送出最多。
输入格式:
测试数据有多组，处理到文件尾。每组数据先输入一个整数n（0<n≤5000）表示分发的气球总数。接下来输入n行，每行一个表示颜色的字符串（长度不超过20且仅由小写字母构成）。
输出格式:
对于每组测试，输出出现次数最多的颜色。若出现并列的情况，则只需输出ASCII码值最小的那种颜色。
输入样例:
3
pink
red
pink
输出样例:
pink
点击查看代码
try:
while True:
n=int(input())
d={} #创建空字典
for i in range(n): #进行n次循环
s=input() #输入一个颜色字符串存放于s中
if s in d.keys(): #若已存在键s，则该键对应的值（出现次数）加1
d[s]+=1
else: #若原来不存在键s，则插入“键-值”对s:1
d[s]=1
maxNum=max(d.values()) #找出最大的值（出现次数）
res=max(d.keys()) #找出最大的键（颜色）
for it in d: #在字典中找值最大且字典序最小的键
if d[it]==maxNum and it<res:
res=it
print(res) #输出结果
except EOFError:pass
习题4.2.1 部分逆置
输入n个整数，把第i个到第j个之间的全部元素进行逆置，并输出逆置后的n个数。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试先输入三个整数n，i，j（0 < n <= 100，1 ≤ i < j ≤ n），再输入n个整数。
输出格式:
对于每组测试数据，输出逆置后的n个数，要求每两个数据之间留一个空格。
输入样例:
1
7 2 6 11 22 33 44 55 66 77
输出样例:
11 66 55 44 33 22 77
点击查看代码
T=int(input())
for k in range(T):
a=list(map(int,input().split()))
n=a[0]
i=a[1]-1
j=a[2]-1
a=a[3:]
while i<j:
a[i],a[j]=a[j],a[i]
i+=1
j-=1
print(*a)
习题4.2.2 保持数列有序
有n个整数，已经按照从小到大顺序排列好，现在另外给一个整数x，请将该数插入到序列中，并使新的序列仍然有序。
输入格式:
测试数据有多组，处理到文件尾。每组测试先输入两个整数n（1≤n≤100）和x，再输入n个从小到大有序的整数。
输出格式:
对于每组测试，输出插入新元素x后的数列（元素之间留一个空格）。
输入样例:
3 3 1 2 4
输出样例:
1 2 3 4
点击查看代码
try:
while True:
a=list(map(int,input().split()))
n=a[0]
x=a[1]
a=a[2:]
a.append(x) #x直接放在最后
a.sort()
print(*a)
except EOFError:pass
习题4.2.3 简单的归并
已知数组A和B各有m、n个元素，且元素按值非递减排列，现要求把A和B归并为一个新的数组C，且C中的数据元素仍然按值非递减排列。
例如，若A=(3，5，8，11)，B=(2，6，8，9，11，15，20)，
则C=(2，3，5，6，8，8，9，11，11，15，20)
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试数据输入两行，其中第一行首先输入A的元素个数m（1≤m≤100），然后输入m个元素。第2行首先输入B的元素个数n（1≤n≤100），然后输入n个元素。
输出格式:
对于每组测试数据。分别输出将A、B合并后的数组C的全部元素。输出的元素之间以一个空格分隔（最后一个数据之后没有空格）。
输入样例:
1
4 3 5 8 11
7 2 6 8 9 11 15 20
输出样例:
2 3 5 6 8 8 9 11 11 15 20
点击查看代码
T=int(input())
for i in range(T):
a=list(map(int,input().split()))
m=a[0]
b=list(map(int,input().split()))
n=b[0]
a=a[1:]
b=b[1:]
c=[0]*(m+n)
c=a+b
c.sort()
for i in range(m+n):
if i>0:
print(" ",end="")
print(c[i],end="")
print()
习题4.2.4 变换数组元素
变换的内容如下：
（1）将长度为10的数组中的元素按升序进行排序；
（2）将数组的前n个元素换到数组的最后面。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每行测试数据输入1个正整数n（0 < n < 10），然后输入10个整数。
输出格式:
对于每组测试数据，输出变换后的全部数组元素。元素之间以一个空格分隔（最后一个数据之后没有空格）。
输入样例:
1
2 34 37 98 23 24 45 76 89 34 68
输出样例:
34 34 37 45 68 76 89 98 23 24
点击查看代码
T=int(input())
for i in range(T):
a=list(map(int,input().split()))
n=a[0]
a=a[1:]
#print(a_n)
a.sort()
a_n=a[:n]
c=[0]*(n-1+10)
c=a[n:]+a_n
#print(c)
for i in range(len(c)):
if i>0:
print(" ",end="")
print(c[i],end="")
print()
习题4.2.5 武林盟主
在传说中的江湖中，各大帮派要选武林盟主了，如果龙飞能得到超过一半的帮派的支持就可以当选，而每个帮派的结果又是由该帮派帮众投票产生的，如果某个帮派超过一半的帮众支持龙飞，则他将赢得该帮派的支持。现在给出每个帮派的帮众人数，请问龙飞至少需要赢得多少人的支持才可能当选武林盟主？
输入格式:
测试数据有多组，处理到文件尾。每组测试先输入一个整数n（1≤n≤20），表示帮派数，然后输入n个正整数，表示每个帮派的帮众人数ai（0<ai≤100）。
输出格式:
对于每组数据输出一行，表示龙飞当选武林盟主至少需要赢得支持的帮众人数。
输入样例:
3 5 7 5
4 6 6 7 5
输出样例:
6
11
点击查看代码
try:
while True:
a=input().split()
#print(a)
n=a[0]
a=list(a[1:])
a.sort()
s=0
for i in range(int(n)//2+1):
s+=(int(a[i])//2+1)
print(s)
except EOFError:pass
习题4.2.6 集合A-B
求两个集合的差集。注意，同一个集合中不能有两个相同的元素。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入1行，每行数据的开始是2个整数n（0 < n ≤ 100）和m（0 < m ≤ 100），分别表示集合A和集合B的元素个数，然后紧跟着n+m个元素，前面n个元素属于集合A，其余的属于集合B。每两个元素之间以一个空格分隔。
输出格式:
针对每组测试数据输出一行数据，表示集合A-B的结果，如果结果为空集合，则输出“NULL”（引号不必输出），否则从小到大输出结果，每两个元素之间以一个空格分隔。
输入样例:
2
3 3 1 3 2 1 4 7
3 7 2 5 8 2 3 4 5 6 7 8
输出样例:
2 3
NULL
点击查看代码
T=int(input())
for i in range(T):
s=list(map(int,input().split()))
n=s[0]
m=s[1]
a=s[2:2+n]
b=s[2+n:2+n+m]
k=set(a)-set(b)
if len(k)==0:
print("NULL")
continue
k=list(k)
k.sort()
print(*k)
习题4.2.7 又见A+B
输入格式:
多组测试数据，处理到文件尾。每组测试输入两个英文单词表示的数字A、B（0≤A，B≤10）。
输出格式:
对于每组测试，在一行上输出A+B的结果，要求以英文单词表示。
输入样例:
ten ten
one two
输出样例:
twenty
three
点击查看代码
#使用字典
a={"zero":0,"one":1,"two":2,"three":3,"four":4,"five":5,"six":6,"seven":7,
"eight":8,"nine":9,"ten":10}
b={0:"zero",1:"one",2:"two",3:"three",4:"four",5:"five",6:"six",7:"seven",
8:"eight",9:"nine",10:"ten",11:"eleven",12:"twelve",13:"thirteen",
14:"fourteen",15:"fifteen",16:"sixteen",17:"seventeen",18:"eighteen",
19:"nineteen",20:"twenty"} #两个10以内的数相加之和的所有可能
try:
while True:
x,y=input().split()
s=a[x]+a[y]
print(b[s])
except EOFError:pass
习题4.2.8 简版田忌赛马
田忌与齐王赛马，双方各有n匹马参赛，每场比赛赌注为200两黄金，现已知齐王与田忌的每匹马的速度，并且齐王肯定是按马的速度从快到慢出场，请写一个程序帮助田忌计算他最多赢多少两黄金（若输，则用负数表示）。
简单起见，保证2n匹马的速度均不相同。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试数据输入3行，第一行是n（1≤n≤100) ，表示双方参赛马的数量，第2行n个正整数，表示田忌的马的速度，第3行n个正整数，表示齐王的马的速度。
输出格式:
对于每组测试数据，输出一行，包含一个整数，表示田忌最多赢多少两黄金。
输入样例:
3
3
92 83 71
95 87 74
2
20 25
21 12
10
1 2 3 24 5 6 7 8 9 12
11 13 15 19 22 34 14 21 44 99
输出样例:
200
400
-1200
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
max=a[0]+1 #保留田的最大值，给b,避多次比较
cnt=0 #计算赢的次数
for i in range(n):
for j in range(n):
if a[i]>b[j]: #如果田>齐
cnt+=1 #个数加1
b[j]=max #避免多次比较
break
print((cnt-(n-cnt))*200) #赢的次数-输的次数
习题4.2.9 魔镜
例如，对于字符串XY，若把Y端接触镜面，则魔镜会把这个字符串变为XYYX；若再用X端接触镜面，则会变成XYYXXYYX。对于一个最终得到的字符串（可能未接触魔镜），请输出没使用魔镜之前，该字符串最初可能的最小长度。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个字符串（长度小于100，且由大写英文字母构成）。
输出格式:
对于每组测试数据，在一行上输出一个整数，表示没使用魔镜前，最初字符串可能的最小长度。
输入样例:
XYYXXYYX
XYXX
输出样例:
2
4
点击查看代码
try:
while True:
s=input()
finish=False
while True:
n=len(s)
if n%2!=0: #排除奇数
break
for i in range(n): #排除不对称的
if s[i]!=s[n-1-i]: #有不相等，中断
finish=True
break
else:
s=s[:n//2] #对称的话，字符串减半
if finish==True: #如果没有这个，就会一直循环下去
break
print(n)
except EOFError:pass
习题4.2.10 并砖
工地上有n堆砖，每堆砖的块数分别是m1，m2，……mn，每块砖的重量都为1，现要将这些砖通过n-1次的合并（每次把两堆砖并到一起），最终合成一堆。若将两堆砖合并到一起消耗的体力等于两堆砖的重量之和，请设计最优的合并次序方案，使消耗的体力最小。
输入格式:
测试数据有多组，处理到文件尾。每组测试先输入一个整数n（1≤n≤100），表示砖的堆数；然后输入n个整数，分别表示各堆砖的块数。
输出格式:
对于每组测试，在一行上输出采用最优的合并次序方案后体力消耗的最小值。
输入样例:
7 8 6 9 2 3 1 6
输出样例:
91
点击查看代码
try:
while True:
s=list(map(int,input().split()))
n=s[0]
s=s[1:]
sum1=0
for i in range(1,n):
s.sort()
sum1+=s[0]+s[1]
s.append(s[0]+s[1])
s=s[2:]
print(sum1)
except EOFError:pass
习题4.2.11 判断回文串
若一个串正向看和反向看等价，则称做回文串。例如：t，abba，xyzyx均是回文串。
给出一个长度不超过60的字符串，判断是否是回文串。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每行输入一个长度不超过60的字符串（串中不包含空格）。
输出格式:
对于每组测试数据，判断是否是回文串，若是输出“Yes”，否则输出“No”。引号不必输出。
输入样例:
2
abba
abc
输出样例:
Yes
No
点击查看代码
T=int(input())
for i in range(T):
s=input()
n=len(s)
for i in range(n//2):
if s[i]!=s[n-1-i]:
print("No")
break #有不相等的就不再往下循环
else: #要在整个for循环上else
print("Yes")
习题4.2.12 统计单词
输入长度不超过80的英文文本，统计该文本中长度为n的单词总数（单词之间只有一个空格）。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组数据首先输入1个正整数n（1≤n≤50），然后输入1行长度不超过80的英文文本（只含英文字母和空格）。注意：不要忘记在输入一行文本前吸收换行符。
输出格式:
对于每组测试数据，输出长度为n的单词总数。
输入样例:
2
5
hello world
5
acm is a hard game
输出样例:
2
0
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
s=input().split()
sum1=0
for i in range(len(s)):
if len(s[i])==n:
sum1+=1
print(sum1)
习题4.2.13 删除重复元素
对于给定的数列，要求把其中的重复元素删去再从小到大输出。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据先输入一个整数n（1≤n≤100），再输入n个整数。
输出格式:
对于每组测试，从小到大输出删除重复元素之后的结果，每两个数据之间留一个空格。
输入样例:
1
10 1 2 2 2 3 3 1 5 4 5
输出样例:
1 2 3 4 5
点击查看代码
T=int(input())
for i in range(T):
a=list(map(int,input().split()))
n=a[0]
a=a[1:]
cnt=0
for i in sorted(set(a)):
cnt+=1
if cnt>1:
print(" ",end="")
print(i,end="")
print()
习题4.2.14 缩写期刊名
现对于给定的期刊名，要求按以下规则缩写：
（1）长度不超过4的单词不必缩写；
（2）长度超过4的单词仅取前4个字母，但其后要加“.”；
（3）所有字母都小写。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试输入一个包含大小写字母和空格的字符串（长度不超过85），单词由若干字母构成，单词之间以一个空格间隔。
输出格式:
对于每组测试，在一行上输出缩写后的结果，单词之间以一个空格间隔。
输入样例:
2
Ad Hoc Networks
IEEE Transactions on Nanotechnology
输出样例:
ad hoc netw.
ieee tran. on nano.
点击查看代码
T=int(input())
for i in range(T):
a=input().split()
for i in range(len(a)):
a[i]=a[i].lower()
if len(a[i])>4:
a[i]=a[i][0:4]+'.'
print(*a)
## 第二种书写方式
# a[i]=a[i].lower()
# if len(a[i])>4:
# a[i]=a[i][0:4]+"."
# print(*a)
习题4.2.15、例5.5.6 按长度排序
输入一个整数N及N个整数，要求对给定的N个整数进行排序：先按长度排（短的在前），如长度一样则按大小排（小的在前）。
输入格式:
测试数据有多组。每组测试数据的第一行输入一个整数N（0<N<100），接下来的N行每行输入一个非负整数（最多可达80位）。当N等于0时，输入结束。
输出格式:
对于每组测试，输出排序后的结果，每个数据占一行。每两组测试数据之间留一个空行。
输入样例:
3
123
12
3333
5
1111
2012123123123123122133333
1000
333333333
12
0
输出样例:
12
123
3333
12
1000
1111
333333333
2012123123123123122133333
点击查看代码
num=0
while True:
n=int(input())
if n==0:
break
num+=1
if num!=1:
print()
a=[]
for i in range(n):
s=int(input())
a.append(s)
a.sort()
for i in range(n):
print(a[i])
习题4.2.16 统计字符个数
输入若干的字符串，每个字符串中只包含数字字符和大小写英文字母，统计字符串中有出现的不同字符的出现次数。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个字符串（不超过80个字符）。
输出格式:
对于每组测试，按字符串中有出现的字符的ASCII码升序逐行输出不同的字符及其个数（两个数据之间留一个空格），每两组测试数据之间留一空行，输出格式参照输出样例。
输入样例:
12123
A1c1B
输出样例:
1 2
2 2
3 1
1 2
A 1
B 1
c 1
点击查看代码
try:
num=0
while True:
s=list(input())
num+=1
d={}
s.sort()
for i in range(len(s)):
if s[i] in d.keys():
d[s[i]]+=1
else:
d[s[i]]=1
if num>1:
print()
for i,v in d.items():
print(i,v)
except EOFError:pass
习题4.2.18 计算天数
根据输入的日期，计算该日期是该年的第几天。
输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个具有格式“Mon DD YYYY”的日期。其中，Mon是一个3个字母表示的月份，DD是一个2位整数表示的日份，YYYY是一个4位整数表示的年份。
提示：闰年则是指该年份能被4整除而不能被100整除或者能被400整除。1-12月份分别表示为：Jan，Feb，Mar，Apr，May，Jun，Jul，Aug，Sep，Oct，Nov，Dec。
输出格式:
对于每组测试，计算并输出该日期是该年的第几天。
输入样例:
Oct 26 2003
输出样例:
299
点击查看代码
month=['',"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
day=[0,31,28,31,30,31,30,31,31,30,31,30,31]
try:
while True:
s=input().split()
d=int(s[1])
m=month.index(s[0])
y=int(s[2])
days=d
for i in range(1,m):
days+=day[i]
if m>2 and (y%400==0 or y%4==0 and y%100!=0):
days+=1
print(days)
except EOFError:pass
习题4.2.19 判断对称方阵
输入一个整数n及一个n阶方阵，判断该方阵是否以主对角线对称，输出“Yes”或“No”。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据的第一行输入一个整数n（1<n<100），接下来输入n阶方阵（共n行，每行n个整数）。
输出格式:
对于每组测试，若该方阵以主对角线对称，则输出“Yes”，否则输出“No”。引号不必输出。
输入样例:
1
4
1 2 3 4
2 9 4 5
3 4 8 6
4 5 6 7
输出样例:
Yes
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
a=[]
flag=True
for i in range(n):
t=list(map(int,input().split()))
a.append(t)
for i in range(n): #判断是否按主对角线对称
for j in range(i):
if a[i][j]!=a[j][i]:
flag=False
break
if flag==False:
break
if flag:
print('Yes')
else:
print('No')
习题4.2.20 成绩排名
对于n个学生m门课程的成绩，按平均成绩从大到小输出学生的学号（不处理那些有功课不及格的学生），对于平均成绩相同的情况，学号小的排在前面。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据首先输入2个正整数n，m（1≤n≤50，1≤m≤5），表示有n个学生和m门课程，然后是n行m列的整数，依次表示学号从1到n的学生的m门课程的成绩。
输出格式:
对于每组测试，在一行内按平均成绩从大到小输出没有不及格课程的学生学号（每两个学号之间留一空格）。若无满足条件的学生，则输出“NULL”（引号不必输出）。
输入样例:
1
4 3
60 60 61
60 61 60
77 78 29
60 62 60
输出样例:
4 1 2
点击查看代码
from functools import cmp_to_key
class S:
def __init__(self,id1,avg):
self.id1=id1
self.avg=avg
def cmp(a,b):
if a.avg!=b.avg:
return b.avg-a.avg
else:
return a.id1-b.id1
T=int(input())
for i in range(T):
n,m=map(int,input().split())
a=[]
flag=True
for i in range(n):
t=list(map(int,input().split()))
s=0
for j in range(m):
if t[j]<60:
flag=False
break
s+=t[j]
else:
a.append(S(i+1,s/m))
a.sort(key=cmp_to_key(cmp))
for i in range(len(a)):
if i>0:
print(" ",end="")
print(a[i].id1,end="")
习题4.2.21 找成绩
给定n个同学的m门课程成绩，要求找出总分排列第k名（保证没有相同总分）的同学，并依次输出该同学的m门课程的成绩。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试包含两部分，第一行输入3个整数n、m和k（2≤n≤10，3≤m≤5，1≤k≤n）；接下来的n行，每行输入m个百分制成绩。
输出格式:
对于每组测试，依次输出总分排列第k的那位同学的m门课程的成绩，每两个数据之间留一空格。
输入样例:
1
7 4 3
74 63 71 90
98 68 83 62
90 55 93 95
68 64 93 94
67 76 90 83
56 51 87 88
62 58 60 81
输出样例:
67 76 90 83
点击查看代码
T=int(input())
for i in range(T):
a=list(map(int,input().split()))
n=a[0]
m=a[1]
k=a[2]
b=[]
for i in range(n):
t=list(map(int,input().split()))
b.append(t)
c=[]
for i in range(n):
s=0
for j in range(m):
s+=b[i][j]
else:
c.append({"id":i,"score":s})
#print(c)
for i in range(n-1): #冒泡排序
for j in range(n-1-i):
if (c[j]["score"]<c[j+1]["score"]): #从大到小排列
c[j],c[j+1]=c[j+1],c[j] #交换相邻的两个元素
#print(c)
id_k=c[k-1]["id"] #k是3,对应的坐标是2
for j in range(m):
if j>0:
print(" ",end="")
print(b[id_k][j],end="")
print()
习题4.2.22 最值互换
给定一个n行m列的矩阵，请找出最大数与最小数并交换它们的位置。若最大或最小数有多个，以最前面出现者为准（矩阵以行优先的顺序存放，请参照样例）。
输入格式:
测试数据有多组，处理到文件尾。每组测试数据的第一行输入2个整数n，m（1<n，m<20），接下来输入n行数据，每行m个整数。
输出格式:
对于每组测试数据，输出处理完毕的矩阵（共n行，每行m个整数），每行中每两个数据之间留一个空格。具体参看输出样例。
输入样例:
3 3
4 9 1
3 5 7
8 1 9
输出样例:
4 1 9
3 5 7
8 1 9
点击查看代码
try:
while True:
a=list(map(int,input().split()))
n=a[0]
m=a[1]
b=[]
for i in range(n):
t=list(map(int,input().split()))
b.append(t)
maxr=maxc=minr=minc=0
for i in range(n): #m范围小，在前，n范围大，在后，查找最大、最小数的位置
for j in range(m):
if b[i][j]>b[maxr][maxc]:
maxr,maxc=i,j
if b[i][j]<b[minr][minc]:
minr,minc=i,j
b[maxr][maxc],b[minr][minc]=b[minr][minc],b[maxr][maxc]
for i in range(n): #输出
print(*b[i])
except EOFError:pass
习题4.2.23 构造矩阵
当n=3时，所构造的矩阵如输出样例所示。观察该矩阵，相信你能找到规律。现在，给你一个整数n，请构造出相应的n阶矩阵。
输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入一个正整数n（n≤20）。
输出格式:
对于每组测试，逐行输出构造好的矩阵，每行中的每个数字占5个字符宽度。
输入样例:
1
3
输出样例:
4 2 1
7 5 3
9 8 6
点击查看代码
T=int(input())
for i in range(T):
n=int(input())
a=[[0]*n for i in range(n)]
val=1
for i in range(n-1,-1,-1): #从第一行的最后一列开始往右下侧填，再往左到第一列
col=i
for j in range(n-i):
a[j][col]=val
val+=1
col+=1
for i in range(1,n): #从第二行的第一列开始往右下侧填，再往下到最后一行
row=i
for j in range(n-i):
a[row][j]=val
val+=1
row+=1
for i in range(n):
for j in range(n):
print("%5d" % a[i][j],end='')
print()
