目录
001：字符菱形
描述：给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。
输入：输入只有一行，包含一个字符。
输出：该字符构成的菱形。
输入样例1
*
输出样例1
* *** ***** *** *
char = input()
print(' ' * 2 + char)
print(' ' + char * 3)
print(char * 5)
print(' ' + char * 3)
print(' ' * 2 + char)002：输出第二个整数
描述：输入三个整数，把第二个输入的整数输出。
输入：输入只有一行，共三个整数，整数之间由一个空格分隔。整数时32为有符号整数。
输出：只有一行，一个整数，即输入的第二个整数。
输入样例1
123 456 789
输出样例1
456
# 读取输入的三个整数
a, b, c = map(int, input().split())
# 输出第二个整数
print(b)003：求三个数的和
描述：输入三个整数或小数，输出它们的和；如果结果是整数，就保留小数点后面一位的0；请注意：本题应该用float对三个数进行转换
输入：输入三个整数或小数
输出：和
输入样例 1
1 2.3 4.7
输出样例 1
8.0
num1, num2, num3 = map(float, input().split())
sum = num1 + num2 + num3
if sum.is_integer():
print(f'{sum:.1f}')
else:
print(sum)
004：字符串交换
描述：输入两个长度为4的字符串，交换这两个字符串的前两个字符后输出
输入：两个长度为4的字符串
输出：交换这两个字符串的前两个字符后输出
输入样例1
ABCD 1234
输出样例1
12CD AB34
a=input()
b=input()
c=b[:2]+a[2:]
d=a[:2]+b[2:]
print(c)
print(d)
005：字符串中的整数求和
描述：输入两个长度为3的字符串，每个串前两个字符是数字,后一个字符是字母。 求这两个串中的整数的和。
输入：一行，两个字符串
输出：两个字符串中整数的和
输入样例 1
12B 34D
输出样例 1
46
a,b=input().split()
c=int(a[:2])+int(b[:2])
print(c)006：字符三角形
描述：给定一个字符，用它构造一个底边长5个字符，高3个字符的等腰字符三角形。
输入：输入只有一行，包含一个字符。
输出：该字符构成的等腰三角形，底边长5个字符，高3个字符。
输入样例 1
*
输出样例 1
* *** *****
char = input()
print(' ' * 2 + char)
print(' ' + char * 3)
print(char * 5)
007： 计算（a+b）*c的值
描述：给定3个整数a、b、c，计算表达式(a+b)*c的值。
输入：输入仅一行，包括三个整数a、b、c, 数与数之间以一个空格分开。
(－10,000 < a,b,c < 10,000)
输出：输出一行，即表达式的值
输入样例 1
2 3 5
输出样例 1
25
a,b,c=map(int,input().split())
print((a+b)*c)008：反向输出一个三位数
描述：将一个三位数反向输出
输入：一个三位数n
输出：反向输出n
输入样例 1
100
输出样例 1
001
n = input()
a = n[::-1]
print(a)
009：判断子串
描述：输入两行字符串，要求判断第一行 字符串是不是第二行的子串
输入：两行字符串。字符串长度不超过100。
输出：如果第一行是第二行的子串，就输出 "YES"，否则输出"NO"
输入样例 1
hello world this is hello world, it is ok.
输出样例 1
YES
a=input()
b=input()
if a in b:
print("YES")
else:
print("NO")
010：计算2的幂
描述：给定非负整数n，求2^n。
输入：一个整数n。0 <= n < 31。
输出：一个整数，即2的n次方。
输入样例 1
3
输出样例 1
8
n=int(input())
if 0<=n<31:
a=2**n
print(a)011：计算多项式的值
描述：对于多项式f(x) = ax^3+ bx^2+ cx + d 和给定的a, b, c, d, x，计算f(x)的值。
输入：输入仅一行，包含5个实数，分别是x，及参数a、b、c、d的值，每个数都是绝对值不超过100的双精度浮点数。数与数之间以一个空格分开。
输出：输出一个实数，即f(x)的值，保留到小数点后7位。
输入样例 1
5 1.2 2.2 3.2 4.2
输出样例 1
225.2000000
x, a, b, c, d = map(float, input().split())
result = a*x**3 + b*x**2 + c*x + d
print("{:.7f}".format(result))012：点和正方形的关系
描述：有一个正方形，四个角的坐标（x,y)分别是（1，-1），（1，1），（-1，-1），（-1，1），x是横轴，y是纵轴。写一个程序，判断一个给定的点是否在这个正方形内（包括正方形边界）。
输入：输入一行，包括两个整数x、y，以一个空格分开，表示坐标(x,y)。
输出：输出一行，如果点在正方形内，则输出yes，否则输出no。
输入样例 1
1 1
输出样例 1
yes
# 输入坐标
x, y = map(int, input().split())
# 判断点是否在正方形内
if -1 <= x <= 1 and -1 <= y <= 1:
print("yes")
else:
print("no")013：奇偶数判断
描述：给定一个整数，判断该数是奇数还是偶数。
输入：输入仅一行，一个大于零的正整数n。
输出：输出仅一行，如果n是奇数，输出odd；如果n是偶数，输出even。
输入样例 1
5
输出样例 1
odd
n=int(input())
if n%2==0:
print("even")
else:
print("odd")014：计算邮资
描述：根据邮件的重量和用户是否选择加急计算邮费。计算规则：重量在1000克以内(包括1000克), 基本费8元。超过1000克的部分，每500克加收超重费4元，不足500克部分按500克计算；如果用户选择加急，多收5元。
输入：输入一行，包含整数和一个字符，以一个空格分开，分别表示重量（单位为克）和是否加急。如果字符是y，说明选择加急；如果字符是n，说明不加急。
输出：输出一行，包含一个整数，表示邮费。
输入样例 1
1200 y
输出样例 1
17
# 读取输入的重量和是否加急
weight, express = input().split()
weight = int(weight)
# 初始化基本费和超重费
basic_fee = 8
extra_fee_per_500g = 4
# 计算超重部分费用
if weight <= 1000:
total_fee = basic_fee
else:
extra_weight = weight - 1000
extra_fee = (extra_weight + 499) // 500 * extra_fee_per_500g
total_fee = basic_fee + extra_fee
# 如果加急，额外收取5元
if express == 'y':
total_fee += 5
# 输出结果
print(total_fee)015：分段函数
描述
编写程序，计算下列分段函数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
1.0
输出样例 1
1.500
N=float(input())
if 0<=N and N<5:
y=-N+2.5
elif 5<=N and N<10:
y=2-1.5*(N-3)*(N-3)
elif 10<=N and N<=20:
y=N/2-1.5
print("{:.3f}".format(y))016：三角形判断
描述
给定三个正整数，分别表示三条线段的长度，判断这三条线段能否构成一个三角形。
输入
输入共一行，包含三个正整数，分别表示三条线段的长度，数与数之间以一个空格分开。
输出
如果能构成三角形，则输出“yes” ，否则输出“no”。
输入样例 1
3 4 5
输出样例 1
yes
a,b,c=map(int,input().split())
if a+b>c and b+c>a and a+c>b:
print("yes")
else:
print("no")017：苹果和虫子
描述
你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？
输入
输入仅一行，包括n，x和y（均为整数）。
输出
输出也仅一行，剩下的苹果个数
输入样例 1
10 4 9
输出样例 1
7
提示
注意：是要求完整的苹果数
n,x,y=map(int,input().split())
if y%x==0:
a=n-y//x
print(a)
else:
a=n-1-y//x
print(a)018：简单计算器
描述
一个最简单的计算器，支持+, -, *, / 四种运算。仅需考虑输入输出为整数的情况(除法结果就是商，忽略余数）
输入
输入只有一行，共有三个参数，其中第1、2个参数为整数，第3个参数为操作符（+,-,*,/）。
输出
输出只有一行，一个整数，为运算结果。然而：
1. 如果出现除数为0的情况，则输出：Divided by zero!
2. 如果出现无效的操作符(即不为 +, -, *, / 之一），则输出：Invalid operator!
输入样例 1
1 2 +
输出样例 1
1 2 +
# 读取输入的三个参数
a, b, operator = input().split()
# 将参数a和b转换为整数
a = int(a)
b = int(b)
# 根据操作符进行相应的运算
if operator == '+':
result = a + b
elif operator == '-':
result = a - b
elif operator == '*':
result = a * b
elif operator == '/':
if b == 0:
result = 'Divided by zero!'
else:
result = a // b # 只保留商，忽略余数
else:
result = 'Invalid operator!'
# 输出结果
print(result)019：求整数的和与均值
描述
读入n（1 <= n <= 10000）个整数，求它们的和与均值。
输入
输入第一行是一个整数n，表示有n个整数。
第2~n+1行每行包含1个整数。每个整数的绝对值均不超过10000。
输出
输出一行，先输出和，再输出平均值（保留到小数点后5位），两个数间用单个空格分隔。
输入样例 1
4 344 222 343 222
输出样例 1
1131 282.75000
n=int(input())
sum=0
for i in range(n):
sum += int(input())
average=sum/n
print("%d %.5f" %(sum,average))020：整数序列的元素最大跨度值
描述
给定一个长度为n的非负整数序列，请计算序列的最大跨度值（最大跨度值 = 最大值减去最小值）。
输入
一共2行，第一行为序列的个数n（1 <= n <= 1000)，第二行为序列的n个不超过1000的非负整数，整数之间以一个空格分隔。
输出
输出一行，表示序列的最大跨度值。
输入样例 1
6 3 0 8 7 5 9
输出样例 1
9
n=int(input())
s=input().split()
Max=Min=int(s[0])
for i in range(len(s)):
Max=max(Max,int(s[i]))
Min=min(Min,int(s[i]))
m=Max-Min
print(m)021：奥运奖牌计数
描述
2008年北京奥运会，A国的运动员参与了n天的决赛项目(1≤n≤17)。现在要统计一下A国所获得的金、银、铜牌数目及总奖牌数。
输入
输入n＋1行，第1行是A国参与决赛项目的天数n，其后n行，每一行是该国某一天获得的金、银、铜牌数目，以一个空格分开。
输出
输出1行，包括4个整数，为A国所获得的金、银、铜牌总数及总奖牌数，以一个空格分开。
输入样例 1
3 1 0 3 3 1 0 0 3 0
输出样例 1
4 4 3 11
# 读取输入的天数
n = int(input())
# 初始化金牌、银牌、铜牌和总奖牌数
gold = silver = bronze = total = 0
# 循环读取每一天的奖牌数目并累加
for _ in range(n):
day_gold, day_silver, day_bronze = map(int, input().split())
gold += day_gold
silver += day_silver
bronze += day_bronze
total += day_gold + day_silver + day_bronze
# 输出结果
print(gold, silver, bronze, total)022：鸡尾酒疗法
描述
鸡尾酒疗法，原指“高效抗逆转录病毒治疗”（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
输入样例 1
5 125 99 112 89 145 99 99 97 123 98
输出样例 1
same worse better same
n=int(input())
a,b=input().split()
x=int(b)/int(a)
for i in range(1,n):
c,d=input().split()
y=int(d)/int(c)
if y-x>0.05:
print("better")
elif x-y>0.05:
print("worse")
else:
print("same")023：角谷猜想
描述
所谓角谷猜想，是指对于任意一个正整数，如果是奇数，则乘3加1，如果是偶数，则除以2，得到的结果再按照上述规则重复处理，最终总能够得到1。如，假定初始整数为5，计算过程分别为16、8、4、2、1。
程序要求输入一个整数，将经过处理得到1的过程输出来。
输入
一个正整数N(N <= 2,000,000)
输出
从输入整数到1的步骤，每一步为一行，每一部中描述计算过程。最后一行输出"End"。如果输入为1，直接输出"End"。
输入样例 1
5
输出样例 1
5*3+1=16 16/2=8 8/2=4 4/2=2 2/2=1 End
def A(n):
if n==1:
print("End")
return n
elif n%2==0:
a=n/2
b=n
n=a
print("%d/2=%d" % (b,a))
return A(n)
else:
a=n*3+1
b=n
n=a
print("%d*3+1=%d" % (b,a))
return A(n)
n=int(input())
A(n)
024：正常血压
描述
监护室每小时测量一次病人的血压，若收缩压在90 - 140之间并且舒张压在60 - 90之间（包含端点值）则称之为正常，现给出某病人若干次测量的血压值，计算病人保持正常血压的最长小时数。
输入
第一行为一个正整数n，n < 100
其后有n行，每行2个正整数，分别为一次测量的收缩压和舒张压，中间以一个空格分隔。
输出
输出仅一行，血压连续正常的最长小时数。
输入样例 1
4 100 80 90 50 120 60 140 90
输出样例 1
2
def calculate_normal_hours(n, measurements):
max_normal_hours = 0
current_normal_hours = 0
for i in range(n):
if 90 <= measurements[i][0] <= 140 and 60 <= measurements[i][1] <= 90:
current_normal_hours += 1
max_normal_hours = max(max_normal_hours, current_normal_hours)
else:
current_normal_hours = 0
return max_normal_hours
# 读取输入
n = int(input())
measurements = []
for _ in range(n):
measurement = list(map(int, input().split()))
measurements.append(measurement)
# 计算结果并输出
result = calculate_normal_hours(n, measurements)
print(result)
025：数字反转
描述
给定一个整数，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例2）。
输入
输入共 1 行，一个整数N。
-1,000,000,000 ≤ N≤ 1,000,000,000。
输出
输出共 1 行，一个整数，表示反转后的新数。
输入样例 1
样例 #1： 123 样例 #2： -380
输出样例 1
样例 #1： 321 样例 #2： -83
def reverse_integer(n):
sign = -1 if n < 0 else 1
reversed_num = sign * int(str(abs(n))[::-1])
return reversed_num
# 读取输入
n = int(input())
# 反转整数并输出结果
print(reverse_integer(n))026：数字统计
描述
请统计某个给定范围[L, R]的所有整数中，数字2出现的次数。
比如给定范围[2, 22]，数字2在数2中出现了1次，在数12中出现1次，在数20中出现1次，在数21中出现1次，在数22中出现2次，所以数字2在该范围内一共出现了6次。
输入
输入共 1 行，为两个正整数 L 和 R，之间用一个空格隔开。
输出
输出共 1 行，表示数字 2 出现的次数。
输入样例 1
样例 #1： 2 22 样例 #2： 2 100
输出样例 1
样例 #1： 6 样例 #2： 20
n=input().split()
L=int(n[0])
R=int(n[1])
count=0
for i in range(L,R+1):
count +=str(i).count('2')
print(count)027：求最大公约数问题
描述
给定两个正整数，求它们的最大公约数。
输入
输入一行，包含两个正整数(<1,000,000,000)。
输出
输出一个正整数，即这两个正整数的最大公约数。
输入样例 1
6 9
输出样例 1
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 gcd(a, b):
while b != 0:
a, b = b, a % b
return a
# 读取输入
a, b = map(int, input().split())
# 计算最大公约数并输出
print(gcd(a, b))028：递归复习法
描述
学渣复习期末考试，要用递归复习法，即当他复习知识点k的时候，他发现理解知识点k必须先理解知识点k-1和知识点k-2，于是他先去学习知识点k-1和知识点k-2，当他复习知识点k-1的时候，又发现理解知识点k-1必须先理解知识点k-2与知识点k-3，又得先去复习知识点k-2和知识点k-3。已知复习每个知识点所需的时间，问要多少时间才能复习完知识点n。
输入
输入：
第一行表示你要测试多少次后程序退出
后面每行输入一个正整数，表示复习知识点n
输出
输出：复习知识点n所需要的时间
输入样例 1
举例1：
5
1
2
3
4
5
举例2：
4
8
4
1
2
输出样例 1
举例1：
1
2
6
12
23
举例2：
120
12
1
2
提示
- 复习知识点 1 所需的时间是 1；
- 复习知识点 2 所需的时间是 2；
- 复习知识点 3 所需的时间是 3 + 复习知识点 2 所需的时间 + 复习知识点 1 所需的时间；
- 复习知识点 4 所需的时间是 4 + 复习知识点 3 所需的时间 + 复习知识点 2 所需的时间；
def Review(n):
if n==1:
return 1
elif n==2:
return 2
else:
return n+Review(n-1)+Review(n-2)
N=int(input())
for i in range(N):
print(Review(int(input())))
029：全排列
描
给定一个由不同的小写字母组成的字符串，输出这个字符串的所有全排列。 我们假设对于小写字母有'a' < 'b' < ... < 'y' < 'z'，而且给定的字符串中的字母已经按照从小到大的顺序排列。
输入
输入只有一行，是一个由不同的小写字母组成的字符串，已知字符串的长度在1到6之间，给定字符串的字母按照从小到大顺序排列。
输出
输出这个字符串的所有排列方式，每行一个排列。要求字母序比较小的排列在前面。字母序如下定义：
已知S = s1s2...sk, T = t1t2...tk，则S < T 等价于，存在p (1 <= p <= k)，使得
s1= t1, s2= t2, ..., sp - 1= tp - 1, sp< tp成立。（例如，英文单词 what 先于 why，因为第三个字母 a 先于 y )。
输入样例 1
abc
输出样例 1
abc acb bac bca cab cba
def permute(s):
if len(s) == 1:
return [s]
result = []
for i in range(len(s)):
first = s[i]
rest = s[:i] + s[i+1:]
for perm in permute(rest):
result.append(first + perm)
return result
# 读取输入
input_str = input().strip()
# 调用函数生成全排列
permutations = permute(input_str)
# 输出全排列
for perm in permutations:
print(perm)
030：石头剪刀布
描述
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。
一天，小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。
输入样例 1
10 3 4 0 2 5 0 5 0 2
输出样例 1
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赢的轮数多。
n = input().split()
N = int(n[0])
NA = int(n[1])
NB = int(n[2])
T1 = input().split()
T2 = input().split()
A_win = 0
B_win = 0
def game(a,b):
if (a == '0' and b == '2') or (a == '2' and b == '5') or (a == '5' and b == '0'):
return 'A'
elif a == b:
return
else:
return 'B'
for i in range(N):
a = T1[i % NA]
b = T2[i % NB]
result = game(a,b)
if result == 'A':
A_win += 1
elif result == 'B':
B_win += 1
if A_win > B_win:
print('A')
elif A_win < B_win:
print('B')
else:
print('draw')031：统计数字字符个数
描述:
输入一行字符，统计出其中数字字符的个数。
输入
一行字符串，总长度不超过255。
输出
输出为1行，输出字符串里面数字字符的个数。
输入样例 1
Peking University is set up at 1898.
输出样例 1
4
input_str = input()
digit_count = 0
for char in input_str:
if char.isdigit():
digit_count += 1
print(digit_count)032：大小写字母互换
描述
把一个字符串中所有出现的大写字母都替换成小写字母，同时把小写字母替换成大写字母。
输入
输入一行：待互换的字符串。
输出
输出一行：完成互换的字符串（字符串长度小于80）。
输入样例 1
If so, you already have a Google Account. You can sign in on the right.
输出样例 1
iF SO, YOU ALREADY HAVE A gOOGLE aCCOUNT. yOU CAN SIGN IN ON THE RIGHT.
def swap_case(s):
return s.swapcase()
input_str = input()
output_str = swap_case(input_str)
print(output_str)033：过滤多余的空格
描述
一个句子中也许有多个连续空格，过滤掉多余的空格，只留下一个空格。
输入
一行，一个字符串（长度不超过200），句子的头和尾都没有空格。
输出
过滤之后的句子。
输入样例 1
Hello world.This is c language.
输出样例 1
Hello world.This is c language.
def filter_spaces(s):
return ' '.join(s.split())
input_str = input()
output_str = filter_spaces(input_str)
print(output_str)034：找第一个只出现一次的字符
描述
给定一个只包含小写字母的字符串，请你找到第一个仅出现一次的字符。如果没有，输出no。
输入
一个字符串，长度小于100000。
输出
输出第一个仅出现一次的字符，若没有则输出no。
输入样例 1
abcabd
输出样例 1
c
def first_unique_char(s):
char_count = {}
for char in s:
char_count[char] = char_count.get(char, 0) + 1
for char in s:
if char_count[char] == 1:
return char
return "no"
input_str = input()
output_str = first_unique_char(input_str)
print(output_str)035：判断字符串是否为回文
描述
输入一个字符串，输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。
输入
输入为一行字符串（字符串中没有空白字符，字符串长度不超过100）。
输出
如果字符串是回文，输出yes；否则，输出no。
输入样例 1
abcdedcba
输出样例 1
yes
def is_palindrome(s):
return s == s[::-1]
input_str = input()
output_str = "yes" if is_palindrome(input_str) else "no"
print(output_str)036：字符串最大跨距
描述
有三个字符串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。
输入样例 1
abcd123ab888efghij45ef67kl,ab,ef
输出样例 1
18
def max_span(S, S1, S2):
if S1 not in S or S2 not in S:
return -1
indices_S1 = [i for i in range(len(S)) if S.startswith(S1, i)]
indices_S2 = [i for i in range(len(S)) if S.startswith(S2, i)]
max_span = -1
for start_S2 in indices_S2:
for start_S1 in indices_S1:
if start_S1 < start_S2:
span = start_S2 - (start_S1 + len(S1))
if span > max_span:
max_span = span
return max_span
037：找出全部子串位置
描述
输入两个串s1,s2，找出s2在s1中所有出现的位置
两个子串的出现不能重叠。例如'aa'在 aaaa 里出现的位置只有0,2
输入
第一行是整数n
接下来有n行，每行两个不带空格的字符串s1,s2
输出
对每行，从小到大输出s2在s1中所有的出现位置。位置从0开始算
如果s2没出现过，输出 "no"
如果输出结果不是no的行，在行末多输出一个空格
输入样例 1
4 ababcdefgabdefab ab aaaaaaaaa a aaaaaaaaa aaa 112123323 a
输出样例 1
0 2 9 14 0 1 2 3 4 5 6 7 8 0 3 6 no
def find_all_substring_positions(s1, s2):
positions = []
start = 0
while start < len(s1):
pos = s1.find(s2, start)
if pos == -1:
break
positions.append(pos)
start = pos + 1
return positions
n = int(input())
for _ in range(n):
s1, s2 = input().split()
positions = find_all_substring_positions(s1, s2)
if positions:
print(' '.join(map(str, positions)) + ' ')
else:
print('no')038：万年历
描述
给定年月日，求星期几。已知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"
输入样例 1
6 2017 2 29 2017 13 2 0 1 1 -2 3 4 2017 10 18 2015 12 31
输出样例 1
Illegal Illegal Saturday Wednesday Wednesday Thursday
def is_leap_year(year):
if year % 4 != 0:
return False
elif year % 100 != 0:
return True
elif year % 400 != 0:
return False
else:
return True
def is_valid_date(year, month, day):
days_in_month = [31, 29 if is_leap_year(year) else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
return 1 <= month <= 12 and 1 <= day <= days_in_month[month - 1]
def day_of_week(year, month, day):
if not is_valid_date(year, month, day):
return "Illegal"
if month < 3:
month += 12
year -= 1
known_year, known_month, known_day, known_weekday = 2020, 11, 18, 3
if known_month < 3:
known_month += 12
known_year -= 1
days_difference = 365 * (year - known_year) + (year - known_year) // 4 - (year - known_year) // 100 + (
year - known_year) // 400 + (306 * (month + 1)) // 10 + day - (
306 * (known_month + 1)) // 10 - known_day
days_difference -= ((year // 100) - (known_year // 100)) * 2 # Correction for Julian and Gregorian calendar
weekday = (known_weekday + days_difference) % 7
return ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][weekday]
n = int(input().strip())
for _ in range(n):
y, m, d = map(int, input().strip().split())
print(day_of_week(y, m, d))039：成绩排序
描述
给出班里某门课程的成绩单，请你按成绩从高到低对成绩单排序输出，如果有相同分数则名字字典序小的在前。
输入
第一行为n (0 < n < 20)，表示班里的学生数目；
接下来的n行，每行为每个学生的名字和他的成绩, 中间用单个空格隔开。名字只包含字母且长度不超过20，成绩为一个不大于100的非负整数。
输出
把成绩单按分数从高到低的顺序进行排序并输出，每行包含名字和分数两项，之间有一个空格。
输入样例 1
4 Kitty 80 Hanmeimei 90 Joey 92 Tim 28
输出样例 1
Joey 92 Hanmeimei 90 Kitty 80 Tim 28
n=int(input())
students=[]
for i in range(n):
name, score=input().split()
students.append((name,int(score)))
students.sort(key=lambda x: (-x[1],x[0]))
for student in students:
print(student[0], student[1])040：图像模糊处理
描述
给定n行m列的图像各像素点的灰度值，要求用如下方法对其进行模糊化处理：
1. 四周最外侧的像素点灰度值不变；
2. 中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均（舍入到最接近的整数）。
输入
第一行包含两个整数n和m，表示图像包含像素点的行数和列数。1 <= n <= 100，1 <= m <= 100。
接下来n行，每行m个整数，表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开，每个元素均在0~255之间。
输出
n行，每行m个整数，为模糊处理后的图像。相邻两个整数之间用单个空格隔开。输出每行末尾多一个空格。
输入样例 1
4 5 100 0 100 0 50 50 100 200 0 0 50 50 100 100 200 100 100 50 50 100
输出样例 1
100 0 100 0 50 50 80 100 60 0 50 80 100 90 200 100 100 50 50 100
n,m=input().split()
n=int(n)
m=int(m)
puts=[]
cputs=[]
for i in range(n):
cin=input().split()
for j in range(m):
cin[j]=int(cin[j])
puts.append(cin)
cputs=[row[:] for row in puts]
for i in range(1,n-1):
for j in range(1,m-1):
cputs[i][j]=round((puts[i-1][j]+puts[i][j-1]+puts[i][j]+puts[i][j+1]+puts[i+1][j])/5)
for i in cputs:
print(' '.join(map(str, i)) + ' ')041：向量点积计算
描述
在线性代数、计算几何中，向量点积是一种十分重要的运算。
给定两个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。
输出
一个整数，即两个向量的点积结果。
输入样例 1
3 1 4 6 2 1 5
输出样例 1
36
n=int(input())
a=input().split()
b=input().split()
result=0
for i in range(n):
x=int(a[i])
y=int(b[i])
result = x*y +result
print(result)042：病人排队
描述
病人登记看病，编写一个程序，将登记的病人按照以下原则排出看病的先后顺序：
1.老年人（年龄 >= 60岁）比非老年人优先看病。
2. 老年人按年龄从大到小的顺序看病，年龄相同的按登记的先后顺序排序。
3.非老年人按登记的先后顺序看病。
输入
第1行，输入一个小于100的正整数，表示病人的个数；
后面按照病人登记的先后顺序，每行输入一个病人的信息，包括：一个长度小于10的字符串表示病人的ID（每个病人的ID各不相同且只含数字和字母），一个整数表示病人的年龄，中间用单个空格隔开。
输出
按排好的看病顺序输出病人的ID，每行一个。
输入样例 1
5 021075 40 004003 15 010158 67 021033 75 102012 30
输出样例 1
021033 010158 021075 004003 102012
n=int(input())
line_1=[]
line_2=[]
for i in range(n):
ID,age=input().split()
ID,age=ID,int(age)
if (age>=60):
line_1.append((ID,age))
else:
line_2.append((ID,age))
line_1.sort(key=lambda x: (-x[1]))
line=line_1+line_2
for i in range(n):
print(line[i][0])
043：矩阵乘法
描述
计算两个矩阵的乘法。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个整数，整数之间以一个空格分开。输出每行末尾多一个空格。
输入样例 1
3 2 3 1 1 1 1 1 1 1 1 1 1 1 1
输出样例 1
2 2 2 2 2 2 2 2 2
n,m,k=input().split()
n,m,k=int(n),int(m),int(k)
A=[]
B=[]
C= [[0] * n for _ in range(k)]
for i in range(n):
a=input().split()
for j in range(m):
a[j]=int(a[j])
A.append(a)
for i in range(m):
b=input().split()
for j in range(k):
b[j]=int(b[j])
B.append(b)
for i in range(n):
for j in range(k):
for x in range(m):
C[i][j] += A[i][x] * B[x][j]
for i in C:
print(' '.join(map(str, i)) + ' ')044：回文子串
描述
给定一个字符串，输出所有长度至少为2的回文子串。
回文子串即从左往右输出和从右往左输出结果是一样的字符串，比如：abba，cccdeedccc都是回文字符串。
输入
一个字符串，由字母或数字组成。长度500以内。
输出
输出所有的回文子串，每个子串一行。
子串长度小的优先输出，若长度相等，则出现位置靠左的优先输出。
输入样例 1
123321125775165561
输出样例 1
33 11 77 55 2332 2112 5775 6556 123321 165561
def find_substrings(s):
substrings = []
for i in range(len(s)):
for j in range(i + 2, len(s) + 1):
substrings.append(s[i:j])
return substrings
input_string = input()
result = find_substrings(input_string)
n=len(input_string)-1
n=n*(n+1)/2
out_substrings=[]
for i in range(int(n)):
num=result[i]
if num==num[::-1]:
out_substrings.append(num)
def len_num(num):
return len(num)
out_substrings.sort(key=len_num)
for k in out_substrings:
print(k)045：校园食宿预订系统
描述
某校园为方便学生订餐，推出食堂预定系统。食宿平台会在前一天提供菜单，学生在开饭时间前可订餐。 食堂每天会推出m个菜，每个菜有固定的菜价和总份数，售卖份数不能超过总份数。 假设共有n个学生点餐，每个学生固定点3个菜，当点的菜售罄时, 学生就买不到这个菜了。 请根据学生预定记录，给出食堂总的预定收入 数据满足1 <= n <= 6000，3 <= m <= 6000，单品菜价不大于1000元，每个菜的配额不超过3000
输入
第一行两个整数n和m，代表有n个学生订餐，共有m个可选的菜
下面m行，每行三个元素，分别是菜名、售价和可提供量，保证菜名不重合，菜价为整数
下面n行，每行三个元素，表示这个学生点的三个菜的菜名
输出
一个整数，表示食堂的收入
输入样例 1
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
输出样例 1
1157
def calculate_revenue(n, m, menu, orders):
revenue = 0
menu_dict = {item[0]: [int(item[1]), int(item[2])] for item in menu}
for order in orders:
for item in order:
if menu_dict[item][1] > 0:
revenue += menu_dict[item][0]
menu_dict[item][1] -= 1
return revenue
# 读取输入
n, m = map(int, input().split())
menu = [input().split() for _ in range(m)]
orders = [input().split() for _ in range(n)]
# 计算并输出食堂的总预定收入
print(calculate_revenue(n, m, menu, orders))046：找出所有整数
描述
给一段文字，可能有中文，把里面的所有非负整数都找出来，不需要去掉前导0。如果碰到 "012.34"这样的就应该找出两个整数 012和34,碰到 0.050,就找出 0和050
输入
一段文字
输出
按顺序输出所有整数，每个整数一行
输入样例 1
给一段文字，可能有中文，把里面的所有整数都找出来，不需要去掉前导0去。如果碰到 "012.34"这样的就应该找出两个整数 012和34,碰到 0.050,就找出 0和050
输出样例 1
0 012 34 012 34 0 050 0 050
import re
text = input()
numbers = re.findall(r'\d+', text)
for number in numbers:
print(number)047：找出所有整数和小数
描述
给一段文字，可能有中文，把里面的所有非负整数和小数找出来，不需要去掉前导0或小数点后面多余的0， 然后依次输出
输入
一段文字
输出
按顺序输出所有整数和小数，每个整数一行
输入样例 1
给一段文字，可能有中文，把里面的0所有78..76数都.12找出来。0334.0000 如果碰到 "0012.3400"这样0的就24.23应该找出两个0.34400整数 00.00和00.4455340000,碰到 00.050
输出样例 1
0 78 76 12 0334.0000 0012.3400 0 24.23 0.34400 00.00 00.4455340000 00.050
import re
text = input()
numbers = re.findall(r'\d+\.\d+|\d+', text)
for number in numbers:
print(number)048：找出小于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
23
输入样例 1
12高兴-23大小256的数1234好啊24对的好0这个1这个2这个12这个134这个0123这个12 123高兴-23大小256的数1234好啊24对的23这
输出样例 1
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])
049：密码判断
描述
用户密码的格式是： 1） 以大写或小写字母开头 2) 至少要有8个字符，最长不限 3) 由字母、数字、下划线或 '-' 组成 输入若干字符串，判断是不是符合密码的条件。如果是，输出 yes 如果不是，输出 no
import re // 在此处补充你的代码 while True: try: s = input() if re.match(m,s) != None: print("yes") else: print("no") except: break
输入
若干行
输出
对每行输入，判断其是否符合密码格式，相应地输出 yes 或no
输入样例 1
abdc a223_b-cdef
输出样例 1
no yes
import re
m="^[a-zA-Z][a-zA-Z0-9_-]{7,}$"
while True:
try:
s = input()
if re.match(m, s) != None:
print("yes")
else:
print("no")
except:
break050：找<>中的数
描述
输入一串字符，将输入中的，在<>里面的，没有前导0的少于4位的整数依次输出。单独的0也要输出。
输入
第一行是整数n，表示后面一共有n个字符串
接下来有n行字符串
输出
对每个字符串，输出题目要求的结果，有数字的每行末尾多一个空格，输出为NONE的行末尾不要多空格。
输入样例 1
4 abc<123>cd<0456>,78,123<3554>1a<38>ab<08>,1<0>111cd<3> <12>cd<77347> <> <12>cd<773-47>qwedcsw
输出样例 1
123 38 0 3 12 NONE 12
import re
n = int(input())
pattern = r'<([1-9]\d{0,2}|0)>'
for _ in range(n):
s = input()
result = re.findall(pattern, s)
for num in result:
print(num, end=' ')
if not result:
print("NONE")
else:
print()051：电话号码
描述
在一串文字中抽取tag及其包含的电话号码的区号。
tag的定义：
"<X>"和它右边离他最近的那个"</X>"构成一个tag。"<X>"和"</X>"之间可以有任何文字。
X是一个任意长度不为0的字符串，由小写字母组成。"<X>"和"</X>"里面的X必须相同。比如：
<abc>this is ., ds</abc>
就是一个tag。但
<abc>this is ., ds</bc>
不是一个tag。
电话号码由括号里的1到2个数字（表示区号）加'-'再加3个数字构成。例如：
(01)-737
(1)-849
(20)-784
上面这些都是电话号码
注意，电话号码中最后一个数字的右边，不能是数字。如：
(10)-1234
不是电话号码，也不能认为其中的(10)-123是一个电话号码
给定一行文本，请抽取出其中的tag及其包含的电话号码种的区号。一个tag里面可能由多个电话号码，则输出时，tag里面的区号用逗号隔开。
输入
有多组数据，每组一行，第一行是数据的个数
输出
对每组数据， 抽取出其中的tag及其包含的电话号码中的区号输出。每个tag输出为一行。tag外的电话号码不用理会。
如果找不到tag及其包含的电话号码， 则输出NONE
数据保证不会出现两个tag重叠的情况。
输入样例 1
2 (02)-KK</a><xy>(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>
输出样例 1
<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
m=r'(<([a-z]+)>.+?</)\2>'
n=r'\((\d{1,2})\)-\d{3}(?=[^\d])'
i=int(input())
while i:
biaoji=0
s=input()
l1=re.findall(m,s)
if len(l1)!=0:
for l2 in l1:
l3=list(re.findall(n,l2[0]))
if len(l3)!=0:
time=len(l3)
print('<'+l2[1]+'>',end='')
print(l3[0],end='')
for x in range(1,time):
print(','+l3[x],end='')
print('</'+l2[1]+'>')
biaoji=1;
if biaoji==0:
print("NONE")
else:
print("NONE")
i-=1
052：时间处理
描述
求从给定时刻开始过了给定时间后的时刻。
输入
有若干组数据。
每组数据有2行，第一行是给定时刻，可能有两种格式
格式1) 年 月 日 时 分(时是24小时制)
格式2) 月-日-年 时:分 上下午 （时是12小时制,注意没有秒)
第二行是时间增量，也可能有两种格式
格式1) 一个整数，代表多少秒
格式2) 日 时 分
输出
对每组数据，输出给定时刻加上时间增量后的新时刻,24小时制
格式如： 1982-12-10 12:12:28
输入样例 1
1982 12 1 23 0 737848 1982 12 1 23 15 180 2 18 12-01-1982 1:23 AM 737848
输出样例 1
1982-12-10 11:57:28 1983-05-31 01:33:00 1982-12-09 14:20:28
import datetime
while True:
try:
dt = input()
if dt.count(" ") > 2:
year, month, day, hour, mini = map(int, dt.split())
nowtime = datetime.datetime(year, month,day, hour, mini)
else:
nowtime = datetime.datetime.strptime(dt,"%m-%d-%Y %I:%M %p")
# 由字符串生成
lst = input().split()
if len(lst) == 1:
delta = datetime.timedelta(seconds=int(lst[0]))
else:
day, hour, mini = map(int, lst)
delta = datetime.timedelta(days=day,hours=hour, minutes=mini)
newtime = nowtime + delta
print(newtime.strftime("%Y-%m-%d %H:%M:%S"))
except Exception as e:# print(e)
break
扫一扫
1072
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
