目录
001:字符菱形
002:字符三角形
003:输出第二个整数
004:求三个数的和
005:判断子串
006:计算(a+b)*c的值
007:反向输出一个三位数
008:字符串交换
009:字符串中的整数求和
010:计算2的幂
011:计算多项式的值
012:奇偶数判断
013:点和正方形的关系
014:三角形判断
015:计算邮资
016:分段函数
017:简单计算器
018:大象喝水
019:苹果和虫子2
020:求整数的和与均值
021:整数序列的元素最大跨度值
022:奥运奖牌计数
023:鸡尾酒疗法
024:角谷猜想
025:正常血压
026:数字反转
027:求特殊自然数
028:数字统计
029:求最大公约数问题
030:多少种取法
031:石头剪刀布
032:统计数字字符个数
033:大小写字母互换
034:过滤多余的空格
035:找第一个只出现一次的字符
036:判断字符串是否为回文
037:字符串最大跨距
038:找出全部子串位置
039:万年历
040:成绩排序
041:图像模糊处理
042:向量点积计算
043:病人排队
044:矩阵乘法
045:回文子串
046:校园食宿预订系统
047:找出所有整数
048:找出所有整数和小数
049:找出小于100的整数
050:密码判断
051:寻找h3
052:找<>中的数
053:电话号码
054:时间处理文章来源：https://www.toymoban.com/news/detail-722984.html
001:字符菱形
给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。
样例输入
*
样例输出
*
***
*****
***
*文章来源地址https://www.toymoban.com/news/detail-722984.html
a=input()
print(" "+a)
print(" "+a+a+a)
print(a*5)
print(" "+a+a+a)
print(" "+a)002:字符三角形
给定一个字符，用它构造一个底边长5个字符，高3个字符的等腰字符三角形。
样例输入
*
样例输出
*
***
*****
a=input()
print(" "+a)
print(" "+a+a+a)
print(a*5)003:输出第二个整数
输入三个整数，把第二个输入的整数输出。
样例输入
123 456 789
样例输出
456
a=input().split()
print(a[1])004:求三个数的和
输入三个整数或小数，输出它们的和
如果结果是整数，就保留小数点后面一位的0
请注意：本题应该用float对三个数进行转换
样例输入
1 2.3 4.7
样例输出
8.0
s=input().split()
a,b,c=float(s[0]),float(s[1]),float(s[2])
print(a+b+c)005:判断子串
输入两行字符串，要求判断第一行字符串是不是第二行的子串
输入
两行字符串。字符串长度不超过100。
输出
如果第一行是第二行的子串，就输出 "YES"，否则输出"NO"
样例输入
hello world
this is hello world, it is ok.
样例输出
YES
a=input()
b=input()
if a in b:
print("YES")
else:
print("NO")006:计算(a+b)*c的值
给定3个整数a、b、c，计算表达式(a+b)*c的值。
输入
输入仅一行，包括三个整数a、b、c, 数与数之间以一个空格分开。
(－10,000 < a,b,c < 10,000)
输出
输出一行，即表达式的值
样例输入
2 3 5
样例输出
25
s=input().split()
a,b,c=int(s[0]),int(s[1]),int(s[2])
print((a+b)*c)007:反向输出一个三位数
将一个三位数反向输出。
输入
一个三位数n。
输出
反向输出n。
样例输入
100
样例输出
001
a=input()
b=a[2]+a[1]+a[0]
print(b)008:字符串交换
输入两个长度为4的字符串，交换这两个字符串的前两个字符后输出
样例输入
ABCD
1234
样例输出
12CD
AB34
s1=input()
s2=input()
print(s2[0]+s2[1]+s1[2]+s1[3])
print(s1[0]+s1[1]+s2[2]+s2[3])009:字符串中的整数求和
输入两个长度为3的字符串，每个串前两个字符是数字, 后一个字符是字母。 求这两个串中的整数的和
样例输入
12B 34D
样例输出
46
s=input().split()
a=int(s[0][0]+s[0][1])
b=int(s[1][0]+s[1][1])
print(a+b)010:计算2的幂
给定非负整数n，求2n。
输入
一个整数n。0 <= n < 31。
输出
一个整数，即2的n次方。
样例输入
3
样例输出
8
n=int(input())
print(2**n)011:计算多项式的值
对于多项式f(x) = ax3 + bx2 + cx + d 和给定的a, b, c, d, x，计算f(x)的值。
输入
输入仅一行，包含5个实数，分别是x，及参数a、b、c、d的值，
每个数都是绝对值不超过100的双精度浮点数。
数与数之间以一个空格分开。
输出
输出一个实数，即f(x)的值，保留到小数点后7位。
样例输入
2.31 1.2 2 2 3
样例输出
33.0838692
s=input().split()
x,a,b,c,d=float(s[0]),float(s[1]),float(s[2]),float(s[3]),float(s[4])
print("%.7f" % float(a*x**3+b*x**2+c*x+d))012:奇偶数判断
给定一个整数，判断该数是奇数还是偶数。
输入
输入仅一行，一个大于零的正整数n。
输出
输出仅一行，如果n是奇数，输出odd；如果n是偶数，输出even。
样例输入
5
样例输出
odd
n=int(input())
if n%2:
print("odd")
else:
print("even")013:点和正方形的关系
有一个正方形，四个角的坐标（x,y)分别是（1，-1），（1，1），（-1，-1），（-1，1），
x是横轴，y是纵轴。写一个程序，判断一个给定的点是否在这个正方形内（包括正方形边界）。
输入
输入一行，包括两个整数x、y，以一个空格分开，表示坐标(x,y)。
输出
输出一行，如果点在正方形内，则输出yes，否则输出no。
样例输入
1 1
样例输出
yes
s=input().split()
x,y=int(s[0]),int(s[1])
if -1<=x<=1 and -1<=y<=1:
print("yes")
else:
print("no")014:三角形判断
给定三个正整数，分别表示三条线段的长度，判断这三条线段能否构成一个三角形。
输入
输入共一行，包含三个正整数，分别表示三条线段的长度，数与数之间以一个空格分开。
输出
如果能构成三角形，则输出“yes” ，否则输出“no”。
样例输入
3 4 5
样例输出
yes
s=input().split()
a,b,c=int(s[0]),int(s[1]),int(s[2])
if a+b>c and a+c>b and b+c>a:
print("yes")
else:
print("no")015:计算邮资
根据邮件的重量和用户是否选择加急计算邮费。
计算规则：重量在1000克以内(包括1000克), 基本费8元。
超过1000克的部分，每500克加收超重费4元，不足500克部分按500克计算；
如果用户选择加急，多收5元。
输入
输入一行，包含整数和一个字符，以一个空格分开，分别表示重量（单位为克）和是否加急。
如果字符是y，说明选择加急；如果字符是n，说明不加急。
输出
输出一行，包含一个整数，表示邮费。
样例输入
1200 y
样例输出
17
s=input().split()
a,b=int(s[0]),s[1]
if b=="n":
if a<=1000:
print(8)
elif (a-1000)%500==0:
print(int(8+int((a-1000)/500)*4))
else:
print(int(8+(1+int((a-1000)/500))*4))
elif b=="y":
if a<=1000:
print(8+5)
elif (a-1000)%500==0:
print(int(8+int((a-1000)/500)*4+5))
else:
print(int(8+(1+int((a-1000)/500))*4+5))016:分段函数
编写程序，计算下列分段函数y=f(x)的值。
y=-x+2.5; 0 <= x < 5
y=2-1.5(x-3)(x-3); 5 <= x < 10
y=x/2-1.5; 10 <= x < 20
输入
一个浮点数N,0 <= N < 20
输出
输出N对应的分段函数值：f(N)。结果保留到小数点后三位。
样例输入
1.0
样例输出
1.500
x=float(input())
if 0<=x<5:
print("%.3f" % (-x+2.5))
elif 5<=x<10:
print("%.3f" % (2-1.5*(x-3)*(x-3)))
elif 10<=x<20:
print("%.3f" % (x/2-1.5))017:简单计算器
一个最简单的计算器，支持+, -, *, / 四种运算。
仅需考虑输入输出为整数的情况(除法结果就是商，忽略余数）
输入
输入只有一行，共有三个参数，其中第1、2个参数为整数，第3个参数为操作符（+,-,*,/）。
输出
输出只有一行，一个整数，为运算结果。然而：
1. 如果出现除数为0的情况，则输出：Divided by zero!
2. 如果出现无效的操作符(即不为 +, -, *, / 之一），则输出：Invalid operator!
样例输入
1 2 +
样例输出
3
s=input().split()
a,b,c=int(s[0]),int(s[1]),s[2]
if c in ['+','-','*','/']:
if b==0 and c=='/':
print("Divided by zero!")
else:
print(int(eval(s[0]+s[2]+s[1])))
else:
print("Invalid operator!")018:大象喝水
一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，
底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。
输入
输入有一行：包行两个整数，以一个空格分开，分别表示小圆桶的深h和底面半径r，单位都是厘米。
输出
输出一行，包含一个整数，表示大象至少要喝水的桶数。
样例输入
23 11
样例输出
3
提示
如果一个圆桶的深为h厘米，底面半径为r厘米，那么它最多能装Pi * r * r * h立方厘米的水。
(设Pi=3.14159)
1升 = 1000毫升
1毫升 = 1 立方厘米
s=input().split()
h,r=int(s[0]),int(s[1])
n=3.14159*r*r*h
print(int(20/n*1000)+1)019:苹果和虫子2
你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。
虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，
那么经过y小时你还有多少个完整的苹果？
输入
输入仅一行，包括n，x和y（均为整数）。
输出
输出也仅一行，剩下的苹果个数
样例输入
10 4 9
样例输出
7
提示
注意：是要求完整的苹果数。
s=input().split()
n,x,y=int(s[0]),int(s[1]),int(s[2])
if y/x>=n:
print(0)
elif y%x:
print(int(n-int(y/x)-1))
else:
print(int(n-y/x))020:求整数的和与均值
读入n（1 <= n <= 10000）个整数，求它们的和与均值。
输入
输入第一行是一个整数n，表示有n个整数。
第2~n+1行每行包含1个整数。每个整数的绝对值均不超过10000。
输出
输出一行，先输出和，再输出平均值（保留到小数点后5位），
两个数间用单个空格分隔。
样例输入
4
344
222
343
222
样例输出
1131 282.75000
n=int(input())
s=0
for i in range(n):
x=int(input())
s+=x
print(s,"%.5f" % float(s/n))021:整数序列的元素最大跨度值
给定一个长度为n的非负整数序列，请计算序列的最大跨度值
（最大跨度值 = 最大值减去最小值）。
输入
一共2行，第一行为序列的个数n（1 <= n <= 1000)，
第二行为序列的n个不超过1000的非负整数，整数之间以一个空格分隔。
输出
输出一行，表示序列的最大跨度值。
样例输入
6
3 0 8 7 5 9
样例输出
9
n=int(input())
s=input().split()
maxi=mini=int(s[0])
for i in s:
maxi=max(maxi,int(i))
mini=min(mini,int(i))
print(maxi-mini)022:奥运奖牌计数
2008年北京奥运会，A国的运动员参与了n天的决赛项目(1≤n≤17)。
现在要统计一下A国所获得的金、银、铜牌数目及总奖牌数。
输入
输入n＋1行，第1行是A国参与决赛项目的天数n，其后n行，
每一行是该国某一天获得的金、银、铜牌数目，以一个空格分开。
输出
输出1行，包括4个整数，为A国所获得的金、银、铜牌总数及总奖牌数，以一个空格分开。
样例输入
3
1 0 3
3 1 0
0 3 0
样例输出
4 4 3 11
n=int(input())
tg=ts=tb=0
for i in range(n):
s=input().split()
tg+=int(s[0])
ts+=int(s[1])
tb+=int(s[2])
print(tg,ts,tb,tg+ts+tb)023:鸡尾酒疗法
鸡尾酒疗法，原指“高效抗逆转录病毒治疗”（HAART），
由美籍华裔科学家何大一于1996年提出，
是通过三种或三种以上的抗病毒药物联合使用来治疗艾 滋病。
该疗法的应用可以减少单一用药产生的抗药性，
最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，
从而延缓病程进展，延长患者生 命，提高生活质量。
人们在鸡尾酒疗法的基础上又提出了很多种改进的疗法。
为了验证这些治疗方法是否在疗效上比鸡尾酒疗法更好，
可用通过临床对照实验的方式 进行。假设鸡尾酒疗法的有效率为x，
新疗法的有效率为y，如果y-x大于5%，则效果更好，
如果x-y大于5%，则效果更差，否则称为效果差不多。
下面给 出n组临床对照实验，其中第一组采用鸡尾酒疗法，
其他n-1组为各种不同的改进疗法。请写程序判定各种改进疗法效果如何。
输入
第一行为整数n（ 1 < n <= 20）；
其余n行每行两个整数，第一个整数是临床实验的总病例数(小于等于10000)，第二个疗效有效的病例数。
这n行数据中，第一行为鸡尾酒疗法的数据，其余各行为各种改进疗法的数据。
输出
有n-1行输出，分别表示对应改进疗法的效果：
如果效果更好，输出better；如果效果更差，输出worse；否则输出same
样例输入
5
125 99
112 89
145 99
99 97
123 98
样例输出
same
worse
better
same
n=int(input())
s=input().split()
a,b=int(s[0]),int(s[1])
x=float(b/a)
for i in range(n-1):
s=input().split()
a,b=int(s[0]),int(s[1])
y=float(b/a)
if y-x>0.05:
print("better")
elif x-y>0.05:
print("worse")
else:
print("same")024:角谷猜想
所谓角谷猜想，是指对于任意一个正整数，如果是奇数，则乘3加1，
如果是偶数，则除以2，得到的结果再按照上述规则重复处理，最终总能够得到1。
如，假定初始整数为5，计算过程分别为16、8、4、2、1。
程序要求输入一个整数，将经过处理得到1的过程输出来。
输入
一个正整数N(N <= 2,000,000)
输出
从输入整数到1的步骤，每一步为一行，每一部中描述计算过程。
最后一行输出"End"。如果输入为1，直接输出"End"。
样例输入
5
样例输出
5*3+1=16
16/2=8
8/2=4
4/2=2
2/2=1
End
提示
注意计算过程中中间值可能会超过int范围。
n=int(input())
while n!=1:
if n%2:
print(str(n)+"*3+1="+str(n*3+1))
n=n*3+1
else:
print(str(n)+"/2="+str(n//2))
n//=2
print("End")025:正常血压
监护室每小时测量一次病人的血压，
若收缩压在90 - 140之间并且舒张压在60 - 90之间（包含端点值）则称之为正常，
现给出某病人若干次测量的血压值，计算病人保持正常血压的最长小时数。
输入
第一行为一个正整数n，n < 100
其后有n行，每行2个正整数，分别为一次测量的收缩压和舒张压，
中间以一个空格分隔。
输出
输出仅一行，血压连续正常的最长小时数。
样例输入
4
100 80
90 50
120 60
140 90
样例输出
2
n=int(input())
m=t=0
for i in range(n):
s=input().split()
a,b=int(s[0]),int(s[1])
if 90<=a<=140 and 60<=b<=90:
t+=1
m=max(t,m)
else:
t=0
print(m)026:数字反转
给定一个整数，请将该数各个位上数字反转得到一个新数。
新数也应满足整数的常见形式，即除非给定的原数为零，
否则反转后得到的新数的最高位数字不应为零（参见样例2）。
输入
输入共 1 行，一个整数N。
-1,000,000,000 ≤ N≤ 1,000,000,000。
输出
输出共 1 行，一个整数，表示反转后的新数。
样例输入
样例 #1：
123
样例 #2：
-380
样例输出
样例 #1：
321
样例 #2：
-83
n=int(input())
x=0
a=1
if n<0:
a=-1
n*=a
while n!=0:
x=x*10+n%10
n//=10
x*=a
print(x)027:求特殊自然数
一个十进制自然数,它的七进制与九进制表示都是三位数，
七进制与九进制的三位数码表示顺序正好相反。编程求此自然数,并输出显示。
输入
无。
输出
三行：
第一行是此自然数的十进制表示；
第二行是此自然数的七进制表示；
第三行是此自然数的九进制表示。
for a in range(1,7):
for b in range(7):
for c in range(1,7):
if a*49+b*7+c==c*81+b*9+a:
print(a*49+b*7+c)
print(a*100+b*10+c)
print(c*100+b*10+a)028:数字统计
请统计某个给定范围[L, R]的所有整数中，数字2出现的次数。
比如给定范围[2, 22]，数字2在数2中出现了1次，在数12中出现1次，在数20中出现1次，在数21中出现1次，
在数22中出现2次，所以数字2在该范围内一共出现了6次。
输入
输入共 1 行，为两个正整数 L 和 R，之间用一个空格隔开。
输出
输出共 1 行，表示数字 2 出现的次数。
样例
样例 #1：
2 22
样例 #2：
2 100
样例输出
样例 #1：
6
样例 #2：
20
s=input().split()
L,R=int(s[0]),int(s[1])
t=0
for i in range(L,R+1):
for x in str(i):
if x=="2":
t+=1
print(t)029:求最大公约数问题
给定两个正整数，求它们的最大公约数。
输入
输入一行，包含两个正整数(<1,000,000,000)。
输出
输出一个正整数，即这两个正整数的最大公约数。
样例输入
6 9
样例输出
3
提示
求最大公约数可以使用辗转相除法：
假设a > b > 0，那么a和b的最大公约数等于b和a%b的最大公约数，
然后把b和a%b作为新一轮的输入。
由于这个过程会一直递减，直到a%b等于0的时候，b的值就是所要求的最大公约数。
比如：
9和6的最大公约数等于6和9%6=3的最大公约数。
由于6%3==0，所以最大公约数为3。
def f(x,y):
a=max(x,y)
b=min(x,y)
if a%b==0:
return b
else:
return f(b,a%b)
s=input().split()
a,b=int(s[0]),int(s[1])
print(f(a,b))030:多少种取法
给定三个正整数m,n,s问从1到m这m个数里面取n个不同的数，使它们和是s,有多少种取法
输入
多组数据
输入的第一行是整数t，表示有t组数据
此后有t行，每行是一组数据
每组数据就是三个正整数，m,n, s ( n <= 10,s <= 20)
输出
对每组数据，输出答案
样例输入
5
13 4 20
12 5 18
1 1 1
1 2 1
119 3 20
样例输出
22
3
1
0
24
提示
用函数ways(m,n,s)表示 从1到m这m个数里面取n个不同的数，使它们和是s的取法总数
显然，必须取m个数，不能不取(除非m == 0)
1) 考虑如果 m > s, 问题可以等价于什么？
2) 对于m<= s的情况，把所有的取法分成两类:
第一类： 取m。则取m后，剩下的问题变成什么？
第二类： 不取m，那么剩下的问题变成什么？
3) 注意边界条件（即递归终止条件，即不需要递归的条件）
边界条件一般是 n,m,s = 0, = 1 之类的情况。
例如：从 1-m这m个数里面，取0个数，使得它们的和是0，有几种取法? 答案是1。
从 1到m这m个数里面，取0个数，使得它们的和是s(s>0)，有几种取法? 答案是0。
无解对应的答案就是0.
当 m < n时，答案是0，因为没法取n个数
当 m = 0时，只要n和s有一个不是0，ways(m,n,s)就应该返回0。
递归的时候，函数的参数会减少，如果会出现某个参数一直没完没了减少下去，那就不对了。
因此,边界条件一定要考虑周全，确保递归可以终止。
边界条件可以有多种写法。
def ways(m,n,s):
if m<n or (m==0 and (n!=0 or s!=0)):
return 0
if m==1 and n==1 and s==1:
return 1
if n==0 and s==0:
return 1
if n==0 and s>0:
return 0
if m>s:
return ways(s,n,s)
else:
return ways(m-1,n-1,s-m)+ways(m-1,n,s)
n=int(input())
for i in range(n):
s=input().split()
m,n,s=int(s[0]),int(s[1]),int(s[2])
print(ways(m,n,s))031:石头剪刀布
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。
一天，小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的，
比如：“石头-布-石头-剪刀-石头-布-石头-剪刀……”，就是以“石头-布-石头-剪刀”为周期不断循环的。
请问，小A和小B比了N轮之后，谁赢的轮数多？
输入
输入包含三行。
第一行包含三个整数：N，NA，NB，分别表示比了N轮，小A出拳的周期长度，小B出拳的周期长度。
0 < N,NA,NB < 100。
第二行包含NA个整数，表示小A出拳的规律。
第三行包含NB个整数，表示小B出拳的规律。
其中，0表示“石头”，2表示“剪刀”，5表示“布”。相邻两个整数之间用单个空格隔开。
输出
输出一行，如果小A赢的轮数多，输出A；如果小B赢的轮数多，输出B；如果两人打平，输出draw。
样例输入
10 3 4
0 2 5
0 5 0 2
样例输出
A
提示
对于测试数据，猜拳过程为：
A：0 2 5 0 2 5 0 2 5 0
B：0 5 0 2 0 5 0 2 0 5
A赢了4轮，B赢了2轮，双方打平4轮，所以A赢的轮数多。
def result (a,b):
if a==b:
return 0
if a==5 and b==0:
return 1
if a==0 and b==5:
return -1
if a<b:
return 1
else:
return -1
s=input().split()
n,na,nb=int(s[0]),int(s[1]),int(s[2])
sa=input().split()
sb=input().split()
wina=winb=0
ptra=ptrb=0
for i in range(n):
r=result(int(sa[ptra]),int(sb[ptrb]))
if r==1:
wina+=1
elif r==-1:
winb+=1
ptra=(ptra+1)%na
ptrb=(ptrb+1)%nb
if wina>winb:
print("A")
elif wina<winb:
print("B")
else:
print("draw")032:统计数字字符个数
输入一行字符，统计出其中数字字符的个数。
输入
一行字符串，总长度不超过255。
输出
输出为1行，输出字符串里面数字字符的个数。
样例输入
Peking University is set up at 1898.
样例输出
4
s=input()
n=0
for i in s:
if 48<=ord(i)<=57:
n+=1
print(n)033:大小写字母互换
把一个字符串中所有出现的大写字母都替换成小写字母，同时把小写字母替换成大写字母。
输入
输入一行：待互换的字符串。
输出
输出一行：完成互换的字符串（字符串长度小于80）。
样例输入
If so, you already have a Google Account. You can sign in on the right.
样例输出
iF SO, YOU ALREADY HAVE A gOOGLE aCCOUNT. yOU CAN SIGN IN ON THE RIGHT.
s=input()
for c in s:
if 'a'<=c<='z':
print(chr(ord(c)-32),end="")
elif 'A'<=c<='Z':
print(chr(ord(c)+32),end="")
else:
print(c,end="")034:过滤多余的空格
一个句子中也许有多个连续空格，过滤掉多余的空格，只留下一个空格。
输入
一行，一个字符串（长度不超过200），句子的头和尾都没有空格。
输出
过滤之后的句子。
样例输入
Hello world.This is c language.
样例输出
Hello world.This is c language.
s=input().split(" ")
for i in s:
if i:
print(i,end=" ")035:找第一个只出现一次的字符
给定一个只包含小写字母的字符串，请你找到第一个仅出现一次的字符。如果没有，输出no。
输入
一个字符串，长度小于100000。
输出
输出第一个仅出现一次的字符，若没有则输出no。
样例输入
abcabd
样例输出
c
s=input()
a=0
for i in s:
n=s.count(i)
if n==1:
a+=1
if a==1:
print(i)
if a==0:
print("no")036:判断字符串是否为回文
输入一个字符串，输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。
输入
输入为一行字符串（字符串中没有空白字符，字符串长度不超过100）。
输出
如果字符串是回文，输出yes；否则，输出no。
样例输入
abcdedcba
样例输出
yes
s=input()
if s==s[::-1]:
print("yes")
else:
print("no")037:字符串最大跨距
有三个字符串S,S1,S2，其中，S长度不超过300，S1和S2的长度不超过10。
想检测S1和S2是否同时在S中出现，且S1位于S2的左边，并在S中互不交叉
（即，S1的右边界点在S2的左边界点的左侧）。计算满足上述条件的最大跨距
（即，最大间隔距离：最右边的S2的起始点与最左边的S1的终止点之间的字符数目）。
如果没有满足条件的S1，S2存在，则输出-1。
例如，S = "abcd123ab888efghij45ef67kl", S1="ab", S2="ef"，
其中，S1在S中出现了2次，S2也在S中出现了2次，最大跨距为：18。
输入
三个串：S, S1, S2，其间以逗号间隔（注意，S, S1, S2中均不含逗号和空格）；
输出
S1和S2在S最大跨距；若在S中没有满足条件的S1和S2，则输出-1。
样例输入
abcd123ab888efghij45ef67kl,ab,ef
样例输出
18
s=input().split(",")
s,s1,s2=s[0],s[1],s[2]
if s.find(s1)!=-1 and s.find(s2)!=-1:
if s.index(s1)+len(s1)<=s.rindex(s2):
print(s.rindex(s2)-s.index(s1)-len(s1))
else:
print(-1)
else:
print(-1)038:找出全部子串位置
输入两个串s1,s2，找出s2在s1中所有出现的位置
两个子串的出现不能重叠。例如'aa'在 aaaa 里出现的位置只有0,2
输入
第一行是整数n
接下来有n行，每行两个不带空格的字符串s1,s2
输出
对每行，从小到大输出s2在s1中所有的出现位置。位置从0开始算
如果s2没出现过，输出 "no"
行末多输出空格没关系
样例输入
4
ababcdefgabdefab ab
aaaaaaaaa a
aaaaaaaaa aaa
112123323 a
样例输出
0 2 9 14
0 1 2 3 4 5 6 7 8
0 3 6
no
n=int(input())
for i in range(n):
s=input().split()
s1,s2=s[0],s[1]
if s2 in s1:
a=0
while s1.find(s2,a)!=-1:
print(s1.find(s2,a),end=" ")
a=s1.find(s2,a)+len(s2)
else:
print("no",end="")
print("")039:万年历
给定年月日，求星期几。已知2020年11月18日是星期三。另外，本题有公元0年，这个和真实的纪年不一样
输入
第一行是n(n <=30)，表示有n组数据
接下来n行，每行是一组数据。
每行三个整数y,m,d，分别代表年，月，日。(-1000000<=y<=1000000)
若今年是2017年，则往前就是2016年，2015年....一直数到2年，1年，
再往前就是0年，-1年，-2年.....
输出
对每组数据，输出星期几，星期几分别用
"Sunday","Monday","Tuesday","Wednesday","Thursday", "Friday","Saturday" 表示
如果月份和日期不合法，输出"Illegal"
样例输入
6
2017 2 29
2017 13 2
0 1 1
-2 3 4
2017 10 18
2015 12 31
样例输出
Illegal
Illegal
Saturday
Wednesday
Wednesday
Thursday
def check(y, m, d):
if not 1 <= m <= 12:
print('Illegal')
return 0
if m in (1, 3, 5, 7, 8, 10, 12):
if not 1 <= d <= 31:
print('Illegal')
return 0
elif m == 2:
if y % 400 == 0 or y % 4 == 0 and y % 100 != 0:
if not 1 <= d <= 29:
print('Illegal')
return 0
else:
if not 1 <= d <= 28:
print('Illegal')
return 0
else:
if not 1 <= d <= 30:
print('Illegal')
return 0
n = int(input())
for i in range(n):
s = input().split()
y, m, d, days = int(s[0]), int(s[1]), int(s[2]), 0
monthDays = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
weekdays = ["Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
if y % 400 == 0 or y % 4 == 0 and y % 100 != 0:
monthDays[2] = 29
if check(y, m, d) == 0:
continue
if y < 2000:
c = -1
elif y > 2000:
c = 1
if y < 2000:
for i in range(y, 2000):
if i % 400 == 0 or i % 4 == 0 and i % 100 != 0:
days += 366
else:
days += 365
elif y > 2000:
for i in range(2000, y):
if i % 400 == 0 or i % 4 == 0 and i % 100 != 0:
days += 366
else:
days += 365
md = 0
for month in range(1, m):
md += monthDays[month]
if y < 2000:
days -= md
else:
days += md
if y < 2000:
days -= d - 1
days = - days
else:
days += (d - 1)
days %= 7
if days < 0:
print(weekdays[7 - days])
elif days >= 0:
print(weekdays[days])040:成绩排序
给出班里某门课程的成绩单，请你按成绩从高到低对成绩单排序输出，如果有相同分数则名字字典序小的在前。
输入
第一行为n (0 < n < 20)，表示班里的学生数目；
接下来的n行，每行为每个学生的名字和他的成绩, 中间用单个空格隔开。名字只包含字母且长度不超过20，成绩为一个不大于100的非负整数。
输出
把成绩单按分数从高到低的顺序进行排序并输出，每行包含名字和分数两项，之间有一个空格。
样例输入
4
Kitty 80
Hanmeimei 90
Joey 92
Tim 28
样例输出
Joey 92
Hanmeimei 90
Kitty 80
Tim 28
n=int(input())
a=[]
for i in range(n):
s=input().split()
a.append((s[0],int(s[1])))
a.sort(key=lambda x:(-x[1],x[0]))
for x in a:
print(x[0],x[1])041:图像模糊处理
给定n行m列的图像各像素点的灰度值，要求用如下方法对其进行模糊化处理：
1. 四周最外侧的像素点灰度值不变；
2. 中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均
（舍入到最接近的整数）。
输入
第一行包含两个整数n和m，表示图像包含像素点的行数和列数。1 <= n <= 100，1 <= m <= 100。
接下来n行，每行m个整数，表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开，
每个元素均在0~255之间。
输出
n行，每行m个整数，为模糊处理后的图像。相邻两个整数之间用单个空格隔开。
样例输入
4 5
100 0 100 0 50
50 100 200 0 0
50 50 100 100 200
100 100 50 50 100
样例输出
100 0 100 0 50
50 80 100 60 0
50 80 100 90 200
100 100 50 50 100
import copy
n,m=map(int,input().split())
a=[]
for i in range(n):
lst=list(map(int,input().split()))
a.append(lst)
b=copy.deepcopy(a)
for i in range(1,n-1):
for j in range(1,m-1):
b[i][j]=round((a[i][j]+a[i-1][j]+a[i+1][j]+a[i][j-1]+a[i][j+1])/5)
for i in range(0,n):
for j in range(0,m):
print(b[i][j],end=" ")
print("")042:向量点积计算
在线性代数、计算几何中，向量点积是一种十分重要的运算。
给定两个n维向量a=(a1,a2,...,an)和b=(b1,b2,...,bn)，求点积a·b=a1b1+a2b2+...+anbn。
输入
第一行是一个整数n。1 <= n <= 1000。
第二行包含n个整数a1,a2,...,an。
第三行包含n个整数b1,b2,...,bn。
相邻整数之间用单个空格隔开。每个整数的绝对值都不超过1000。
输出
一个整数，即两个向量的点积结果。
样例输入
3
1 4 6
2 1 5
样例输出
36
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
s=0
for i in range(n):
s+=a[i]*b[i]
print(s)043:病人排队
病人登记看病，编写一个程序，将登记的病人按照以下原则排出看病的先后顺序：
1. 老年人（年龄 >= 60岁）比非老年人优先看病。
2. 老年人按年龄从大到小的顺序看病，年龄相同的按登记的先后顺序排序。
3. 非老年人按登记的先后顺序看病。
输入
第1行，输入一个小于100的正整数，表示病人的个数；
后面按照病人登记的先后顺序，每行输入一个病人的信息，包括：
一个长度小于10的字符串表示病人的ID（每个病人的ID各不相同且只含数字和字母），
一个整数表示病人的年龄，中间用单个空格隔开。
输出
按排好的看病顺序输出病人的ID，每行一个。
样例输入
5
021075 40
004003 15
010158 67
021033 75
102012 30
样例输出
021033
010158
021075
004003
102012
def f(s):
if int(s[1])>=60:
return(-s[1])
else:
return -1
n=int(input())
a=[]
for i in range(n):
s=input().split()
a.append((s[0],int(s[1])))
a.sort(key=f)
for i in a:
print(i[0])044:矩阵乘法
计算两个矩阵的乘法。n*m阶的矩阵A乘以m*k阶的矩阵B得到的矩阵C 是n*k阶的，
且C[i][j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + …… +A[i][m-1]*B[m-1][j](C[i][j]
表示C矩阵中第i行第j列元素)。
输入
第一行为n, m, k，表示A矩阵是n行m列，B矩阵是m行k列，n, m, k均小于100
然后先后输入A和B两个矩阵，A矩阵n行m列，B矩阵m行k列，矩阵中每个元素的绝对值不会大于1000。
输出
输出矩阵C，一共n行，每行k个整数，整数之间以一个空格分开。
样例输入
3 2 3
1 1
1 1
1 1
1 1 1
1 1 1
样例输出
2 2 2
2 2 2
2 2 2
s=input().split()
n,m,k=int(s[0]),int(s[1]),int(s[2])
a=[]
b=[]
c=[]
for i in range(n):
a.append(list(map(int,input().split())))
for i in range(m):
b.append(list(map(int,input().split())))
for i in range(n):
d=[]
for j in range(k):
s=0
for t in range(m):
s+=a[i][t]*b[t][j]
d.append(s)
c.append(d)
for i in range(n):
for j in range(k):
print(c[i][j],end=" ")
print("")045:回文子串
给定一个字符串，输出所有长度至少为2的回文子串。
回文子串即从左往右输出和从右往左输出结果是一样的字符串，
比如：abba，cccdeedccc都是回文字符串。
输入
一个字符串，由字母或数字组成。长度500以内。
输出
输出所有的回文子串，每个子串一行。
子串长度小的优先输出，若长度相等，则出现位置靠左的优先输出。
样例输入
123321125775165561
样例输出
33
11
77
55
2332
2112
5775
6556
123321
165561
s=input()
ss=[]
for i in range(len(s)):
for j in range(i,len(s)):
t=s[i:j+1]
if t==t[::-1] and len(t)>1:
ss.append(t)
ss.sort(key=lambda x:len(x))
for i in ss:
print(i)046:校园食宿预订系统
某校园为方便学生订餐，推出食堂预定系统。食宿平台会在前一天提供菜单，学生在开饭时间前可订餐。
食堂每天会推出m个菜，每个菜有固定的菜价和总份数，售卖份数不能超过总份数。 假设共有n个学生点餐，
每个学生固定点3个菜，当点的菜售罄时, 学生就买不到这个菜了。
请根据学生预定记录，给出食堂总的预定收入 数据满足1 <= n <= 6000，3 <= m <= 6000，
单品菜价不大于1000元，每个菜的配额不超过3000
输入
第一行两个整数n和m，代表有n个学生订餐，共有m个可选的菜
下面m行，每行三个元素，分别是菜名、售价和可提供量，保证菜名不重合，菜价为整数
下面n行，每行三个元素，表示这个学生点的三个菜的菜名
输出
一个整数，表示食堂的收入
样例输入
5 5
yangroupaomo 13 10
jituifan 7 5
luosifen 16 3
xinlamian 12 20
juruo_milktea 999 1
yangroupaomo luosifen juruo_milktea
luosifen xinlamian jituifan
yangroupaomo jituifan juruo_milktea
jituifan xinlamian luosifen
yangroupaomo yangroupaomo yangroupaomo
样例输出
1157
提示
如果用python做，要用字典，
如果用其它语言做，也要用类似的数据结构
否则会超时
名字长度范围没有给出，长度不会太离谱。请自己选用合适的办法确保这不是个问题
**** p园食宿预订系统
1) 建一个字典，元素键是菜名，值是个列表，里面放价格和还剩余的份数
2) 每读入一个学生点的菜，就到字典里面去查这个菜剩的份数是否>0，如果是，就将其份数减1，
然后加其价格到总收入上
n,m=map(int,input().split())
dt={}
t=0
for i in range(m):
s=input().split()
dt[s[0]]=[int(s[1]),int(s[2])]
for i in range(n):
s=input().split()
for i in s:
if dt[i][1]>0:
dt[i][1]-=1
t+=dt[i][0]
print(t)047:找出所有整数
给一段文字，可能有中文，把里面的所有非负整数都找出来，不需要去掉前导0。
如果碰到 "012.34"这样的就应该找出两个整数 012和34,碰到 0.050,就找出 0和050
输入
一段文字
输出
按顺序输出所有整数，每个整数一行
样例输入
给一段文字，可能有中文，把里面的所有整数都找出来，不需要去掉前导0去。
如果碰到 "012.34"这样的就应该找出两个整数 012和34,碰到 0.050,就找出 0和050
样例输出
0
012
34
012
34
0
050
0
050
import re
m="\d+"
while True:
try:
s = input()
lst = re.findall(m,s)
for x in lst:
print(x)
except:
break048:找出所有整数和小数
给一段文字，可能有中文，把里面的所有非负整数和小数找出来，不需要去掉前导0或小数点后面多余的0， 然后依次输出
样例输入
给一段文字，可能有中文，把里面的0所有78..76数都.12找出来。0334.0000
如果碰到 "0012.3400"这样0的就24.23应该找出两个0.34400整数 00.00和00.4455340000,碰到 00.050
样例输出
0
78
76
12
0334.0000
0012.3400
0
24.23
0.34400
00.00
00.4455340000
00.050
import re
m="\d+\.?\d+|[0-9]"
while True:
try:
s = input()
lst = re.findall(m,s)
for x in lst:
print(x)
except:
break049:找出小于100的整数
有给定的两行输入，在每一行的输入中提取在[0,100)内的整数(不包括100)并依次输出。注意要排除负数
样例输入
12高兴-23大小256的数1234好啊24对的好0这个1这个2这个12这个134这个0123这个12
123高兴-23大小256的数1234好啊24对的23这
样例输出
12
24
0
1
2
12
12
24
23
import re
m = r"(^|[^0-9-])(\d{1,2})([^0-9]|$)"
for i in range(2):
s = input()
lst = re.findall(m,s)
for x in lst:
print(x[1])050:密码判断
用户密码的格式是： 1） 以大写或小写字母开头 2) 至少要有8个字符，最长不限 3) 由字母、数字、下划线或 '-' 组成 输入若干字符串，判断是不是符合密码的条件。如果是，输出 yes 如果不是，输出 no
样例输入
abdc
a223_b-cdef
样例输出
no
yes
import re
m="^[a-zA-Z]([a-zA-Z]+|\d+|((_|-)+)){7,}$"
while True:
try:
s = input()
if re.match(m,s) != None:
print("yes")
else:
print("no")
except:
break051:寻找h3
样例输入
无
样例输出
abd
bcK
123
提示
请注意，同一行的代码要在中间换行，在python 里的写法是加 “\"
如
x = \
3
即为
x = 3
import re
m = \
"<h3>(.*?)</h3>"
for x in re.findall(m,"cdef<h3>abd</h3><h3>bcK</h3><h3>123</h3>KJM"):
print(x)052:找<>中的数
输入一串字符，将输入中的，在<>里面的，没有前导0的少于4位的整数依次输出。单独的0也要输出。
输入
第一行是整数n，表示后面一共有n个字符串
接下来有n行字符串
输出
对每个字符串，输出题目要求的结果
样例输入
3
abc<123>cd<0456>,78,123<3554>1a<38>ab<08>,1<0>111cd<3>
<12>cd<77347>
<>
样例输出
123 38 0 3
12
NONE
import re
n=int(input())
for i in range(n):
s=input()
m="<([1-9]\d{0,2}|0)>"
lst=re.findall(m,s)
if lst:
for x in lst:
print(x,end=" ")
print("")
else:
print("NONE")053:电话号码
输入
有多组数据，每组一行
输出
对每组数据， 抽取出其中的tag及其包含的电话号码中的区号输出。每个tag输出为一行。tag外的电话号码不用理会。
如果找不到tag及其包含的电话号码， 则输出NONE
数据保证不会出现两个tag重叠的情况。
样例输入
2
<bb>(01)-123<a>bbb(02)-2784KK</a><xy>stk(1)-123(03)-345b</xy>(04)-123</xy><z>(05)-123</zz>zz<yy>(06)-123</yy>
<bb>(01)-123<a><k>1223</k><a>(01)-12</a>
样例输出
<xy>1,03</xy>
<yy>06</yy>
NONE
提示
1） tag中间可以有任何文字，比如 <ab>xddd</cd></ab>也是一个合法tag
2） 在分组的右边可以通过分组的编号引用该分组所匹配的子串
m = r'(((ab*)c)d)e\3' #要求 ab*cde后面跟着第三分组的内容
r = re.match(m,"abbbcdeabbbkfg") # 后面的bbb少一个b则不能匹配，因为第三分组是abbb
print(r.group(3)) # abbb
print(r.group()) # abbbcdeabbb
3) 如果一个正则表达式搞不定，可以先用一个正则表达式抽取某个中间结果，再在中间结果里面手工或者用另外的正则表达式进一步分析
import re
n=int(input())
for i in range(n):
s=input()
m="<([a-z]+)>(.*?)</\\1>"
lst=re.findall(m,s)
v = t = 0
if lst:
for x in lst:
s=x[1]
m0="(\((\d{1,2})\)-(\d{3,}))"
lst0=re.findall(m0,s)
l=len(lst0)
if lst0:
v=1
for i in range(l):
# print(lst0[i][2])
t=1
if len(lst0[i][2])!=3:
t=0
if t==1:
if l>1:
print("<" + x[0] + ">", end="")
for i in range(l-1):
print(lst0[i][1],end=",")
print(lst0[l-1][1],end="")
print("</" + x[0] + ">")
elif l==1:
print("<" + x[0] + ">"+lst0[0][1]+"</"+x[0]+">")
else:
v==0
if v==0 or t==0:
print("NONE")054:时间处理
求从给定时刻开始过了给定时间后的时刻。
输入
有若干组数据。
每组数据有2行，第一行是给定时刻，可能有两种格式
格式1) 年 月 日 时 分(时是24小时制)
格式2) 月-日-年 时:分 上下午 （时是12小时制,注意没有秒)
第二行是时间增量，也可能有两种格式
格式1) 一个整数，代表多少秒
格式2) 日 时 分
输出
对每组数据，输出给定时刻加上时间增量后的新时刻,24小时制
格式如： 1982-12-10 12:12:28
样例输入
1982 12 1 23 0
737848
1982 12 1 23 15
180 2 18
12-01-1982 1:23 AM
737848
样例输出
1982-12-10 11:57:28
1983-05-31 01:33:00
1982-12-09 14:20:28
import datetime
n=0
while n<5:
t=input()
s=input()
if "-" in t:
dt=datetime.datetime.strptime(t,"%m-%d-%Y %H:%M %p")
else:
dt=datetime.datetime.strptime(t,"%Y %m %d %H %M")
if " " in s:
s0=s.split()
d,h,m=int(s0[0]),int(s0[1]),int(s0[2])
delta=datetime.timedelta(days=d,hours=h,minutes=m)
else:
delta=datetime.timedelta(seconds=int(s))
newDate=dt+delta
print(newDate.strftime("%Y-%m-%d %H:%M:%S"))
n+=1到了这里，关于openjudge-实用Python程序设计测验题目1-54的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
