实用Python程序设计MOOC-OpenJudge

[TOC]

实用Python程序设计MOOC-OpenJudge

Python程序设计基础及实践(慕课版)教材题集(94题)

001:A+B问题

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  在一行输入两个整数，请输出它们的和。

• 输入
  一行，两个整数

• 输出
  两个整数的和

• 样例输入
  3 14

• 样例输出
  17

input = input();
print(int(input.split()[0])+int(input.split()[1]))

002:字符三角形

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定一个字符，用它构造一个底边长5个字符，高3个字符的等腰字符三角形。

• 输入
  输入只有一行， 包含一个字符。

• 输出
  该字符构成的等腰三角形，底边长5个字符，高3个字符。

• 样例输入

  *

• 样例输出

    *
   ***
  *****

• 提交代码

a = input()
print("  " + a)
print(" " + a*3)
print(a*5)

003:计算(a+b)*c的值

总时间限制: 1000ms 内存限制: 65536kB

-描述
给定3个整数a、b、c，计算表达式(a+b)*c的值。

• 输入
  输入仅一行，包括三个整数a、b、c, 数与数之间以一个空格分开。(-10,000< a,b,c <10,000)

• 输出
  输出一行，即表达式的值

• 样例输入

  2 3 5

• 样例输出

  25

• 提交代码

str = input()
a,b,c = int(str.split()[0]),int(str.split()[1]),int(str.split()[2])
print((a+b)*c)

004:反向输出一个三位数

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  将一个三位数反向输出。

• 输入
  一个三位数n。

• 输出
  反向输出n。

• 样例输入

  100

• 样例输出

  001

• 提交代码

n = int(input())
a = int(n/100)
b = int((n-a*100)/10)
c = (n-a*100-b*10)
print(str(c)+str(b)+str(a))

005:判断子串

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。

• 输入
  输入只有一行， 包含一个字符。

• 输出
  该字符构成的菱形。

• 样例输入

  *

• 样例输出

    *
   ***
  *****
   ***
    *

• 提交代码

str = input()
print(" " + " " + str)
print(" " + str + str + str)
print(str + str + str + str + str)
print(" " + str + str + str)
print(" " + " " + str)

005:字符菱形

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入两行字符串，要求判断第一行 字符串是不是第二行的子串

• 输入
  两行字符串。字符串长度不超过100。

• 输出
  如果第一行是第二行的子串，就输出 “YES”，否则输出”NO”。

• 样例输入

  hello world
  this is hello world, it is ok.

• 样例输出

  YES

• 提示
  python中每使用调用一次 input()，就输入一行的内容。输入内容有几行，就要用几次 input()。

• 提交代码

006:输出第二个整数

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入三个整数，把第二个输入的整数输出。

• 输入
  只有一行，共三个整数，整数之间由一个空格分隔。整数是32位有符号整数。

• 输出
  只有一行，一个整数，即输入的第二个整数。

• 样例输入

  123 456 789

• 样例输出

  456

• 提交代码

str = input()
print(str.split()[1])

007:求三个数的和

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入三个整数或小数，输出它们的和

如果结果是整数，就保留小数点后面一位的0(用python写则不用特别处理，程序自然会如此)

• 输入
  输入三个整数或小数

• 输出
  和

• 样例输入

  1 2.3 4.7

• 样例输出

  8.0

• 提交代码

  str = input()
  a,b,c = float(str.split()[0]),float(str.split()[1]),float(str.split()[2])
  print(a+b+c)

008:字符串交换

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入两个长度为4的字符串，交换这两个字符串的前两个字符后输出

• 输入
  两个长度为4的字符串

• 输出
  交换这两个字符串的前两个字符后输出

• 样例输入

  ABCD 
  1234

• 样例输出

  12CD
  AB34 

• 提交代码

str1,str2 = input(),input()
a,b,c,d = str1[0],str1[1],str1[2],str1[3]
e,f,g,h = str2[0],str2[1],str2[2],str2[3]
print(e+f+c+d)
print(a+b+g+h)

009:字符串中的整数求和

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入两个长度为3的字符串，每个串前两个字符是数字,后一个字符是字母。 求这两个串中的整数的和

• 输入
  一行，两个字符串

• 输出
  两个字符串中整数的和

• 样例输入

  12B 34D

• 样例输出

  46

• 提交代码

str = input()
a = int(str.split()[0][0]+str.split()[0][1])
b = int(str.split()[1][0]+str.split()[1][1])
print(a+b)

010:计算2的幂

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定非负整数n，求2^n。

• 输入
  一个整数n。0 <= n < 31。

• 输出
  一个整数，即2的n次方。

• 样例输入
  3

• 样例输出
  8

• 提交代码

inp = int(input())
print(2**inp)

011:计算多项式的值

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  对于多项式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位。

• 样例输入

  2.31 1.2 2 2 3

• 样例输出

  33.0838692

• 提交代码

str1 = input()
x,a,b,c,d = float(str1.split()[0]), float(str1.split()[1]), float(str1.split()[2]), float(str1.split()[3]), float(str1.split()[4])
print("%.7f" % float(a*x**3+b*x**2+c*x+d))

012:奇偶数判断

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定一个整数，判断该数是奇数还是偶数。

• 输入
  输入仅一行，一个大于零的正整数n。

• 输出
  输出仅一行，如果n是奇数，输出odd；如果n是偶数，输出even。

• 样例输入
  5

• 样例输出
  odd

• 提交代码

n = int(input())
if n % 2:
    print("odd")
else:
    print("even")

013:点和正方形的关系

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  有一个正方形，四个角的坐标（x,y)分别是（1，-1），（1，1），（-1，-1），（-1，1），x是横轴，y是纵轴。写一个程序，判断一个给定的点是否在这个正方形内（包括正方形边界）。

• 输入
  输入一行，包括两个整数x、y，以一个空格分开，表示坐标(x,y)。

• 输出
  输出一行，如果点在正方形内，则输出yes，否则输出no。

• 样例输入
  1 1

• 样例输出
  yes

• 提交代码

str1 = input()
x, y = int(str1.split()[0]), int(str1.split()[1])
if x>=-1 and x<=1 and y>=-1 and y<=1:
    print("yes")
else:
    print("no")

014:三角形判断

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定三个正整数，分别表示三条线段的长度，判断这三条线段能否构成一个三角形。

• 输入
  输入共一行，包含三个正整数，分别表示三条线段的长度，数与数之间以一个空格分开。

• 输出
  如果能构成三角形，则输出“yes” ，否则输出“no”。

• 样例输入
  3 4 5

• 样例输出
  yes

• 提交代码

str1 = input()
a, b, c = int(str1.split()[0]), int(str1.split()[1]), int(str1.split()[2])
if a+b>c and a+c>b and c+b>a:
    print("yes")
else:
    print("no")

015:计算邮资

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  根据邮件的重量和用户是否选择加急计算邮费。计算规则：重量在1000克以内(包括1000克), 基本费8元。超过1000克的部分，每500克加收超重费4元，不足500克部分按500克计算；如果用户选择加急，多收5元。

• 输入
  输入一行，包含整数和一个字符，以一个空格分开，分别表示重量（单位为克）和是否加急。如果字符是y，说明选择加急；如果字符是n，说明不加急。

• 输出
  输出一行，包含一个整数，表示邮费。

• 样例输入
  1200 y

• 样例输出
  17

• 提交代码

  str1 = input()
  a, b = int(str1.split()[0]), str1.split()[1]
  
  out = 0
  if a<=1000:
      out+=8
  elif a<=1500:
      out+=12
  elif a>1500:
      out+=12
      out+=(int((a-1500)//500)+1)*4
  
  if "y" == b:
      out+=5
  
  print(out)

016:分段函数

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  编写程序，计算下列分段函数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().split()[0])
  y = 0.0
  if x>=0 and x<5:
      y=-x+2.5
  elif x>=5 and x<10:
      y=2-1.5*(x-3)*(x-3)
  elif x>=10 and x<20:
      y=x/2-1.5
  print("%.3f" % y)

017:简单计算器

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  一个最简单的计算器，支持+, -, *, / 四种运算。仅需考虑输入输出为整数的情况(除法结果就是商，忽略余数）

• 输入
  输入只有一行，共有三个参数，其中第1、2个参数为整数，第3个参数为操作符（+,-,*,/）。

• 输出

输出只有一行，一个整数，为运算结果。然而：

1. 如果出现除数为0的情况，则输出：Divided by zero!
2. 如果出现无效的操作符(即不为+, -, *, / 之一），则输出：Invalid operator!

• 样例输入
  1 2 +

• 样例输出
  3

• 提交代码

str1 = input()
a, b, c = int(str1.split()[0]), int(str1.split()[1]), str1.split()[2]
if "+" == c:
    print(a+b)
elif "-" == c:
    print(a - b)
elif "*" == c:
    print(a * b)
elif "/" == c:
    if 0 == b:
        print("Divided by zero!")
    else:
        print(int(a/b))
else:
    print("Invalid operator!")

018:大象喝水

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。

• 输入
  输入有一行：包行两个整数，以一个空格分开，分别表示小圆桶的深h和底面半径r，单位都是厘米。

• 输出
  输出一行，包含一个整数，表示大象至少要喝水的桶数。

• 样例输入
  23 11

• 样例输出
  3

• 提示
  如果一个圆桶的深为h厘米，底面半径为r厘米，那么它最多能装Pi r r * h立方厘米的水。(设Pi=3.14159)1升 = 1000毫升，1毫升 = 1 立方厘米

• 提交代码

str1 = input()
a, b = int(str1.split()[0]), int(str1.split()[1])
print(int(20//(3.14159*b*b*a/1000))+1)

019:苹果和虫子2

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？

• 输入
  输入仅一行，包括n，x和y（均为整数）。

• 输出
  输出也仅一行，剩下的苹果个数

• 样例输入
  10 4 9

• 样例输出
  7

• 提交代码

str1 = input()
n, x, y = int(str1.split()[0]), int(str1.split()[1]), int(str1.split()[2])
if 0==y%x:
    print(int(n-y/x))
elif y//x>=10:
    print(0)
else:
    print(int(n-y//x-1))

020:求整数的和与均值

总时间限制: 1000ms内存限制: 65536kB

• 描述
  读入n (1 <= n <= 10000)个整数，求它们的和与均值。

• 输入

输入第一行是一个整数n，表示有n个整数。
第2~n+1行每行包含1个整数。每个整数的绝对值均不超过10000。

• 输出
  输出一行，先输出和，再输出平均值(保留到小数点后5位)，两个数间用单个空格分隔。

• 样例输入
  4
  344
  222
  343
  222

• 样例输出
  1131 282. 75000

• 提交代码

n = int(input())
a = 0
for i in range(n):
	a += int(input())
print(a, "%.5f" % a/n)

021:整数序列的元素最大跨度值

总时间限制: 1000ms，内存限制: 65536kB

• 描述
  给定一个长度为n的非负整数序列，请计算序列的最大跨度值(最大跨度值=最大值减去最小值)。

• 输入
  一共2行，第一行为序列的个数n (1 <= n <= 1000),第二行为序列的n个不超过1000的非负整数，整数之间以一个空格分隔。

• 输出
  输出一行，表示序列的最大跨度值。

• 样例输入
  6
  3 0 8 7 5 9

• 样例输出
  9

• 提交代码

n = int(input())
s = input().split()
a, b = int(s[0]), int(s[0])
for i in range(n):
	temp = int(s[i])
	if a >= temp:
		a = temp
	if b <= temp:
		b = temp
print(b - a)

022:奥运奖牌计数

总时间限制: 1000ms，内存限制: 65536kB

• 描述
  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())
a, b, c = 0, 0, 0
for i in range(n):
	temp = input().split()
	a += int(temp[0])
	b += int(temp[1])
	c += int(temp[2])
print(a, b, c, a+b+c)

023:鸡尾酒疗法

总时间限制: 1000ms内存限制: 65536kB

• 描述
  鸡尾酒疗法，原指“高效抗逆转录病毒治疗”(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
  9997
  23 98

• 样例输出
  same
  worse
  better
  same

• 提交代码

n = int(input())
a = input().split()
x = int(a[1]) / int(a[0])

for i in range(n-1):
	temp = input().split()
	y = int(temp[1]) / int(temp[0])
	res = x - y
	if res > 0.05:
		print("worse")
	elif res < -0.05:
		print("better")
	else:
		print("same")

024:角谷猜想

总时间限制: 1000ms，内存限制: 65536kB

• 描述
  所谓角谷猜想，是指对于任意一个正整数，如果是奇数，则乘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

• 提交代码

N = int(input())
while not(N == 1):
	if N % 2 == 0:
		print("%d/2=" % N, end="")
		N = N / 2
		print("%d" % N)
	else:
		print("%d*3+1=" % N, end="")
		N = N * 3 + 1
		print("%d" % N)
if N == 1:
	print("End")

025:正常血压

总时间限制: 1000ms内存限制: 65536kB

• 描述
  监护室每小时测量一次病人的血压， 若收缩压在90-140之间并且舒张压在60-90之间(包含端点值)则称之为正常，现给出某病人若干次测量的血压值，计算病人保持正常血压的最长小时数。

• 输入
  第一行为一个正整数n, n < 100
  后有n行，每行2个正整数，分别为一次测量的收缩压和舒张压，中间以一个空格分隔。

• 输出
  输出仅一行，血压连续正常的最长小时数。

• 样例输入
  4
  100 80
  90 50
  120 60
  140 90

• 样例输出
  2

• 提交代码

n = int(input())
x = 0
y = 0
for i in range(n):
	temp = input().split()
	a, b = int(temp[0]), int(temp[1])
	if (a >= 90 and a <= 140) and (b >= 60 and b <= 90):
		x += 1
		if x >= y:
			y = x
	else:
		x = 0
print(y)

026:数字反转

总时间限制: 1000ms内存限制: 65536kB

• 描述
  给定一个整数， 请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零(参见样例2)。

• 输入
  输入共1行，一个整数N。
  -1,000,000,000≤N≤1,0000000。

• 输出
  输出共1行，一个整数，示反转后的新数。

• 样例输入
  样例#1:
  123
  样例#2
  -380

• 样例输出
  样例#1:
  321
  样例#2:
  -83

• 提交代码

N = input()	#输入字符串
length1 = int(len(N))	#转为数组的长度
n = int(N)
res = 0	#最终结果
if n > 0:
	#print(">0")
	for i in range(length1):
		res += int(N[length1-i-1]) * 10**(length1-i-1)
elif n == 0:
	#print("=0")
	res = 0
else:
	#print("<0")
	for i in range(length1-1):
		res += int(N[length1 - i - 1]) * 10 ** (length1 - i - 2)
	res *= -1
print(res)

027:求特殊自然数

总时间限制: 1000ms，内存限制: 65536kB

• 描述
  一个十进制自然数，它的七进制与九进制表示都是三位数，且七进制与九进制的三位数码表示顺序正好相反。编程求此自然数,并输出显示。

• 输入
  无

• 输出
  三行:
  第一行是此自然数的十进制表示;
  第二行是此自然数的七进制表示;
  第三行是此自然数的九进制表示。

• 样例输入
  (无)

• 样例输出
  (不提供)

• 提交代码

#最小的三位数是九进制的100，对应十进制是1*9**2
#最大的三位数是七进制的666，对应十进制是6*7**2+6*7**1+6*7**0
a = 9**2  #循环左边界
b = 6 * 7**2 + 6 * 7**1 + 6 * 7**0    #循环右边界
for i in range(a, b + 1):
    #求取七进制
    lst = [0, 0, 0]
    lst[0] = i // (7**2)
    lst[2] = i - lst[0] * 7**2
    lst[1] = lst[2] // 7
    lst[2] -= lst[1] * 7

    #反推九进制和十进制对比
    if (9**2 * lst[2] + 9 * lst[1] + lst[0]) == i:
        print(i)
        print(lst[0], lst[1], lst[2], sep="")
        print(lst[2], lst[1], lst[0], sep="")

028:数字统计

总时间限制: 1000ms内存限制: 65536kB

• 描述
  请统计某个给定范围[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

• 提交代码

temp = input().split()
a, b = int(temp[0]), int(temp[1])
count = 0

for i in range(a, b + 1):
	temp2 = str(i)
	for j in range(len(temp2)):
		if 2 == int(temp2[j]):
			count += 1
print(count)

029:求最大公约数问题

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定两个正整数，求它们的最大公约数。

• 输入
  输入一行，包含两个正整数(<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。

• 提交代码

str1 = input()
int1, int2 = int(str1.split()[0]), int(str1.split()[1])

def fuc(a, b):
    if(0 == a % b):
        print(b)
    else:
        temp = b
        b = a % b
        a = temp
        fuc(a, b)

if(int1 >= int2):
    fuc(int1, int2)
else:
    fuc(int2, int1)

030:多少种取法

总时间限制: 2000ms 内存限制: 65536kB

• 描述
  给定三个正整数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时，只要m和s有一个不是0，ways(m,n,s)就应该返回0。

递归的时候，函数的参数会减少，如果会出现某个参数一直没完没了减少下去，那就不对了。因此,边界条件一定要考虑周全，确保递归可以终止。

边界条件可以有多种写法。

• 提交代码

t = int(input())

def ways(m, n, s):
    # 第一类，各种特殊情况
    if s < 0 or n < 0 or m <= 0:  # 当输入数据小于0时，取法为0
        return 0
    elif n == 0 and s == 0:  # 当n==0且s==0时，只有1种取法
        return 1
    elif n == 0 and s > 0:  # 当取0个，但是s>0时，取法为0
        return 0
    elif n == 1:  # 判断n=1的情况
        if m >= s:
            return 1  # 若m>=s,只有1种取法
        else:
            return 0  # 若m<s,则取法为0
    elif m >= n and s == 0:  # 当m>=n 并且 s=0时 ，只有1种取法
        return 1
    elif n > 1 and s == 1:  # 当n>1且s=0时 ，取法为0
        return 0

    # 第二类，讨论大类
    elif m > s:  # 当m>s时
        if n == s or n > s:
            return 0
        elif 1 < n < s:
            return ways(s - 1, n, s)
    elif m < s:  # 当m<s时
        return ways(m - 1, n - 1, s - m) + ways(m - 1, n, s)  # 当取m时与不取m时的和
    elif m == s:  # 当m=s时
        if n > m:
            return 0
        else:
            return ways(m - 1, n, s)

for i in range(t):
    str = input()
    m, n, s = int(str.split()[0]), int(str.split()[1]), int(str.split()[2])
    print(ways(m, n, s))

031:石头剪刀布

总时间限制：1000ms 内存限制：65536kB

• 描述
  石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。

一天，小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赢的轮数多。

• 提交代码

	0	2	5
0	平(0)	B(2)	A(5)
2	A(2)	平(4)	B(7)
5	B(5)	A(7)	平(10)

str1, strA, strB = input(), input(), input()

N, NA, NB = int(str1.split()[0]), int(str1.split()[1]), int(str1.split()[2])
A, B = strA.split(), strB.split()

countA, countB = 0, 0
for i in range(N):
    temp = int(A[i % NA]) + int(B[i % NB])
    if(0 == temp or 4 == temp or 10 == temp):
        countA += 1
        countB += 1
    elif(2 == temp or 7 == temp):
        if(A[i % NA] > B[i % NB]):
            countB += 1
        else:
            countA += 1
    elif(5 == temp):
        if (A[i % NA] > B[i % NB]):
            countA += 1
        else:
            countB += 1

if(countA > countB):
    print("A")
elif(countA < countB):
    print("B")
elif(countA == countB):
    print("draw")

032:统计数字字符个数

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入一行字符，统计出其中数字字符的个数。

• 输入
  一行字符串，总长度不超过255。

• 输出
  输出为1行，输出字符串里面数字字符的个数。

• 样例输入
  Peking University is set up at 1898.

• 样例输出
  4

• 提交代码

str1 = input()
count = 0
for i in range(len(str1)):
    if str1[i].isdigit():
        count += 1
print(count)

033:大小写字母互换

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  把一个字符串中所有出现的大写字母都替换成小写字母，同时把小写字母替换成大写字母。

• 输入
  输入一行：待互换的字符串。

• 输出
  输出一行：完成互换的字符串（字符串长度小于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.

• 提交代码

str1 = input()
str2 = ""
for i in range(len(str1)):
    if str1[i].islower():
        str2 += str1[i].upper()
    elif str1[i].isupper():
        str2 += str1[i].lower()
    else:
        str2 += str1[i]
print(str2)

034:过滤多余的空格

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  一个句子中也许有多个连续空格，过滤掉多余的空格，只留下一个空格。

• 输入
  一行，一个字符串（长度不超过200），句子的头和尾都没有空格。

• 输出
  过滤之后的句子。

• 样例输入

  Hello      world.This is    c language.

• 样例输出

  Hello world.This is c language.

• 提交代码

str1 = input().split()
str2 = str1[0]
for i in range(1, len(str1)):
    str2 += " "
    str2 += str1[i]
print(str2)

035:找第一个只出现一次的字符

总时间限制: 1000ms 内存限制：65536kB

• 描述
  给定一个只包含小写字母的字符串，请你找到第一个仅出现一次的字符。如果没有，输出no。

• 输入
  一个字符串，长度小于100000。

• 输出
  输出第一个仅出现一次的字符，若没有则输出no。

• 样例输入
  abcabd

• 样例输出
  c

• 提交代码

str1 = input()
int1 = 0
flag = True

for i in range(0, len(str1)):
    char1 = str1[i]
    flag = True
    for j in range(0, len(str1)):
        if str1[j] == str1[i] and i != j:
            flag = False
    if(flag):
        int1 = i
        break

if int1 == 0 and flag == False:
    print("no")
else:
    print(str1[int1])

036:判断字符串是否为回文

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入一个字符串，输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。

• 输入
  输入为一行字符串（字符串中没有空白字符，字符串长度不超过100）。

• 输出
  如果字符串是回文，输出yes；否则，输出no。

• 样例输入
  abcdedcba

• 样例输出
  yes

• 提交代码

str1 = input()
str2 = ""
for i in range(int(len(str1)/2)):
    str2 += str1[i]
flag = True
for i in range(len(str2)):
    if (str2[i] != str1[len(str1)-i-1]):
        flag = False

if(flag):
    print("yes")
else:
    print("no")

037:字符串最大跨距

总时间限制: 1000ms 内存限制: 65536kB

-描述
有三个字符串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

• 提交代码

str1 = input().split(",")
S, S1, S2 = str1[0], str1[1], str1[2]

StartS1, StartS2 = -1, -1
StartS1 = S.find(S1)
StartS2 = len(S) - S[::-1].find(S2[::-1]) - len(S2)

if StartS1 < 0 or StartS2 < 0 or StartS1 + len(S1) > StartS2:
    print("-1")
else:
    print(StartS2 - (StartS1 + len(S1)))

038:找出全部子串位置

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入两个串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()
    m = 0
    total = 0
    for j in s[0]:
        a = s[0].find(s[1],m)
        if a == -1:
            if total == 0:
                print('no',end='')
            break
        else:
            total += 1
            m = a + len(s[1])
            print(a,"",end='')
    print("")

039:万年历

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定年月日，求星期几。已知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 judge_week(year, month, day):
    lst1 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    lst2 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    date = days = 0

    lst_days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]

    if month in [1, 3, 5, 7, 8, 10, 12]:
        if day < 1 or day > 31:
            print('Illegal')
            return
    elif month == 2:
        if (year % 4 == 0) and (year % 100 != 0) or year % 400 == 0:
            if day < 1 or day > 29:
                print('Illegal')
                return
        else:
            if day < 1 or day > 28:
                print('Illegal')
                return
    elif month in [4, 6, 9, 11]:
        if day < 1 or day > 30:
            print('Illegal')
            return
    else:
        print('Illegal')
        return

    if year >= 1:  #1年1月1日为星期一
        for i in range(1, year):
            if (i % 4 == 0) and (i % 100 != 0) or i % 400 == 0:
                days += 366
            else:
                days += 365    #累加整年数
        if ((year % 4) == 0) and ((year % 100) != 0) or ((year % 400) == 0):
            for i in range(month - 1):
                date += lst1[i]
        else:
            for i in range(month-1):
                date += lst2[i]    #累加整月数
        total=date+day+days
        x=total % 7
        print(lst_days[x])
    else:
        for i in range(year + 1, 1):
            if (i % 4 == 0) and (i % 100 != 0) or i % 400 == 0:
                days += 366
            else:
                days += 365  # 累加整年数
        if ((year % 4) == 0) and ((year % 100) != 0) or ((year % 400) == 0):
            for i in range(month - 1,12):
                date += lst1[i]
        else:
            for i in range(month - 1,12):
                date += lst2[i]  # 累加整月数
        total = date - day + 1 + days
        x = total % 7
        print(lst_days[(8 - x)%7])

n = int(input())

for i in range(n):
    year, month, day = map(int, input().split())
    judge_week(year, month, day)

040:成绩排序

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给出班里某门课程的成绩单，请你按成绩从高到低对成绩单排序输出，如果有相同分数则名字字典序小的在前。

• 输入
  第一行为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())
student = []
for i in range(n):
    temp = input()
    temp1 = [str(temp.split()[0]), int(temp.split()[1])]
    student.append(temp1)

def f(x):
    return -x[1], x[0]
student.sort(key = f)

for i in range(n):
    print(student[i][0], student[i][1])

041:图像模糊处理

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定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

• 提交代码

  str1 = input()
  n, m = int(str1.split()[0]), int(str1.split()[1])
  #print(n,m)
  
  picture = []
  for i in range(n):
      str1 = input()
      temp = []
      for j in range(m):
          temp += [int(str1.split()[j])]
      picture.append(temp)
  #print(picture)
  #print(picture[0][1])
  
  import copy
  outpicture = copy.deepcopy(picture)
  
  for i in range(1, n-1):
      for j in range(1, m-1):
              temp = (picture[i-1][j] + picture[i+1][j] + picture[i][j] + picture[i][j-1] + picture[i][j+1]) / 5
              outpicture[i][j] = round(temp)
  #print(outpicture)
  
  for i in range(n):
      for j in range(m):
          print(outpicture[i][j], end=" ")
      print()

042:向量点积计算

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  在线性代数、计算几何中，向量点积是一种十分重要的运算。

给定两个n维向量 $a=(a_1, a_2, …, a_n)$ 和 $ b=(b_1, b_2, …, b_n) $，求点积$ a·b=a_1 b_1+a_2 b_2+…+a_n b_n $。

• 输入
  第一行是一个整数n。1 <= n <= 1000。
  第二行包含n个整数$ a_1, a_2, …, a_n $。
  第三行包含n个整数$ b_1, b_2, …, b_n $。
  相邻整数之间用单个空格隔开。每个整数的绝对值都不超过1000。

• 输出
  一个整数，即两个向量的点积结果。

• 样例输入
  3
  1 4 6
  2 1 5

• 样例输出
  36

• 提交代码

n = int(input())
stra = list(input().split())
strb = list(input().split())

result = 0
for i in range(n):
    result += int(stra[i]) * int(strb[i])

print(result)

043:病人排队

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  病人登记看病，编写一个程序，将登记的病人按照以下原则排出看病的先后顺序：

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

• 提交代码

  n = int(input())
  patient = []
  
  for i in range(n):
      temp = list(input().split())
      patient.append(temp)
  
  patientA, patientB = [], []
  for i in range(n):
      if int(patient[i][1]) >= 60:
          patientA.append(patient[i])
      else:
          patientB.append(patient[i])
  #print(patientA)
  #print(patientB)
  
  def f(x):
      return -int(x[1])
  patientA.sort(key = f)
  
  for i in range(len(patientA)):
      print(patientA[i][0])
  for i in range(len(patientB)):
      print(patientB[i][0])

044:矩阵乘法

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  计算两个矩阵的乘法。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

• 提交代码

  tempstr = input()
  n, m, k = int(tempstr.split()[0]), int(tempstr.split()[1]), int(tempstr.split()[2])
  
  A, B, C, CC = [], [], [], ''
  for i in range(n):
      temp = list(input().split())
      A.append(temp)
  for i in range(m):
      temp = list(input().split())
      B.append(temp)
  
  for i in range(n):
      D = []
      for j in range(k):
          d = 0
          for l in range(m):
             d += int(A[i][l]) * int(B[l][j])
          D.append(d)
      C = C + D
  
  for i in range(n*k):
      CC = CC + str(C[i])
      if (i+1) % k==0:
          CC += '\n'
      else:
          CC += ' '
  print(CC)

045:回文子串

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定一个字符串，输出所有长度至少为2的回文子串。

回文子串即从左往右输出和从右往左输出结果是一样的字符串，比如：abba，cccdeedccc都是回文字符串。

• 输入
  一个字符串，由字母或数字组成。长度500以内。

• 输出
  输出所有的回文子串，每个子串一行。
  子串长度小的优先输出，若长度相等，则出现位置靠左的优先输出。

• 样例输入

  123321125775165561

• 样例输出

  33
  11
  77
  55
  2332
  2112
  5775
  6556
  123321
  165561

• 提交代码

  str1 = input()
  for i in range(2, len(str1) + 1):
      for j in range(0, len(str1) + 1 - i):
          temp = str1[j:j + i]
          if temp == temp[::-1]:
              print(temp)

046:校园食宿预订系统

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  某校园为方便学生订餐，推出食堂预定系统。食宿平台会在前一天提供菜单，学生在开饭时间前可订餐。 食堂每天会推出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做，要用字典，
  如果用其它语言做，也要用类似的数据结构
  否则会超时
  名字长度范围没有给出，长度不会太离谱。请自己选用合适的办法确保这不是个问题

• 提交代码

  temp = input()
  n, m = int(temp.split()[0]), int(temp.split()[1])
  A, B, C = dict(), dict(), dict()
  # 菜谱A：{菜名:[售价,现在数量]}
  # 学生B：{学生编号:[菜名0,菜名1,菜名2]}
  # 菜谱C：{菜名:[售价,原始数量]}
  
  # 菜谱读入
  for i in range(m):
      temp = input()
      A.update({temp.split()[0]: [int(temp.split()[1]), int(temp.split()[2])]})
      C.update({temp.split()[0]: [int(temp.split()[1]), int(temp.split()[2])]})
  #print(A)
  
  # 学生选菜读入
  for i in range(n):
      temp = input()
      B.update({i: [str(temp.split()[0]), str(temp.split()[1]), str(temp.split()[2])]})
  #print(B)
  
  # 遍历学生点菜
  for i in B.values():
      if i[0] in A and A[i[0]][1] != 0:
          A[i[0]][1] += - 1
      if i[1] in A and A[i[1]][1] != 0:
          A[i[1]][1] += - 1
      if i[2] in A and A[i[2]][1] != 0:
          A[i[2]][1] += - 1
  #print(A)
  #print(C)
  
  sum = 0
  # 遍历菜谱计算价格
  for i in A.keys():
      if i in C:
          sum += (C[i][1] - A[i][1]) * C[i][0]
  print(sum)

047:找出所有整数

总时间限制: 1000ms 内存限制: 65536kB

• 描述

给一段文字，可能有中文，把里面的所有非负整数都找出来，不需要去掉前导0。如果碰到 “012.34”这样的就应该找出两个整数012和34，碰到0.050，就找出0和050

import re
// 在此处补充你的代码
while True:
    try:
        s = input()
        lst = re.findall(m, s)
        for x in lst:
            print(x)
    except:
        break

• 输入

一段文字

• 输出

按顺序输出所有整数，每个整数一行

• 样例输入

给一段文字,可能有中文,把里面的所有整数都找出来,不需要去掉前导0去。如果碰到 "012.34"这样的就应该找出两个整数012和34,碰到0.050,就找出0和050

• 样例输出

0
012
34
012
34
0
050
0
050

• 提交代码

m = '\d+'

048:找出所有整数和小数

总时间限制: 1000ms 内存限制: 65536kB

• 描述

给一段文字，可能有中文，把里面的所有非负整数和小数找出来，不需要去掉前导0或小数点后面多余的0， 然后依次输出

import re
// 在此处补充你的代码
while True:
    try:
        s = input()
        lst = re.findall(m,s)
        for x in lst:
            print(x)
    except:
        break

• 输入
  一段文字

• 输出
  按顺序输出所有整数和小数，每个整数一行

• 样例输入

给一段文字，可能有中文，把里面的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

• 提交代码

m = r'\d+\.\d+|\d+'

049:找出小于100的整数

总时间限制: 1000ms 内存限制: 65536kB

• 描述

有给定的两行输入，在每一行的输入中提取在[0,100)内的整数(不包括100)并依次输出。注意要排除负数

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:
			// 在此处补充你的代码

• 输入

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

• 样例输入

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

• 提交代码

print(x[1])

050:密码判断

总时间限制: 1000ms 内存限制: 65536kB

• 描述

用户密码的格式是： 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

• 样例输入

abdc
a223_b-cdef

• 样例输出

no
yes

• 提交代码

m = '^[a-zA-Z][\w-]{7,}$'

051:寻找h3

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  程序填空，输出指定结果

import re
m = \
// 在此处补充你的代码
for x in  re.findall(m,"cdef<h3>abd</h3><h3>bcK</h3><h3>123</h3>KJM"):
    print(x)

• 输入
  无

• 输出
  abd
  bcK
  123

• 样例输入
  无

• 样例输出

abd
bcK
123

• 提示

请注意，同一行的代码要在中间换行，在python 里的写法是加 “\”
如
x = \
3
即为
x = 3

• 提交代码

r"(?<=<h3>)\w+(?=</h3>)"

052:找 < > 中的数

总时间限制: 1000ms 内存限制: 65536kB

• 描述

输入一串字符，将输入中的，在 < > 里面的，没有前导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

m = '\<(0|[1-9]\d{0,2})\>'
n = int(input())
for i in range(n):
    s = input()
    lst = re.findall(m, s)
    if lst == []:
        print('NONE')
    else:
        print(*lst)

053:电话号码

总时间限制: 1000ms 内存限制: 65536kB

• 描述

在一串文字中抽取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重叠的情况。

• 样例输入

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

m = r'(<([a-z]+)>.+?</)\2>'
n = r'\((\d{1,2})\)-\d{3}(?=[^\d])'
x = int(input())

for i in range(x):
    falg1 = 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] + '>')
                falg1 = 1;

        if falg1 == 0:
            print("NONE")
    else:
        print("NONE")

054:时间处理

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  求从给定时刻开始过了给定时间后的时刻。

• 输入
  有若干组数据。
  每组数据有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
 
def getapm(s,ss): #这个函数作用主要是转换pm数据
    lt=s.split(':')
    if ss=='PM':
        s4=int(lt[0])+12
        s5=int(lt[1])
    else:
        s4 = int( lt[0] )
        s5 = int( lt[1] )
    return s4,s5
 
def getd(a): #这个函数作用是得到‘10-11-2000’这种日期（月-日-年）
    lt=a.split('-')
    lt.reverse()
    s1,s2,s3=int(lt[0]),int(lt[2]),int(lt[1]) #注意这里的位置
    return s1,s2,s3
 
def deter(a):
    if len(a)==3: #计算含有AMPM的数列
        s1,s2,s3=getd(a[0])
        s4, s5=getapm(a[1],a[2])
    else: #计算非AMPM数列
        s1,s2,s3,s4,s5=int(a[0]),int(a[1]),int(a[2]),int(a[3]),int(a[4])
    return s1,s2,s3,s4,s5
 
t=0
while t<5: #循环五次。
    a=input('').split() #给定时刻
    s1,s2,s3,s4,s5=deter(a) #调用函数判断格式，得到五个数据年、月、日、小时、分钟
    t1=datetime.datetime(s1,s2,s3,s4,s5) #转换为秒，得到t1
 
    n2=input('').split() #输入时间增量
    if len(n2)==1: #判断格式
        shu=int(n2[0])
    elif len(n2)==3: #如果是三个数值需要算出相应的秒
        shu=int(n2[0])*24*60*60+int(n2[1])*60*60+int(n2[2])*60
    newt=t1+datetime.timedelta(seconds=shu) #新的时间=t1+新的秒shu
    print(newt)
    t+=1

程序设计与算法（一）测验汇总(2022夏季)(63题)

001:输出第二个整数

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入三个整数，把第二个输入的整数输出。

• 输入
  只有一行，共三个整数，整数之间由一个空格分隔。整数是32位有符号整数。

• 输出
  只有一行，一个整数，即输入的第二个整数。

• 样例输入

  123 456 789

• 样例输出

  456

• 提交代码

  inputStr = input()
  print(inputStr.split()[1])

002:字符菱形

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。

• 输入
  输入只有一行， 包含一个字符。

• 输出
  该字符构成的菱形。

• 样例输入

  *

• 样例输出

    *
   ***
  *****
   ***
    *

• 提交代码

str = input()
print(" " + " " + str)
print(" " + str + str + str)
print(str + str + str + str + str)
print(" " + str + str + str)
print(" " + " " + str)

003:打印ASCII码

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入一个除空格以外的可见字符（保证在函数scanf中可使用格式说明符%c读入），输出其ASCII码。

• 输入
  一个除空格以外的可见字符。

• 输出
  一个十进制整数，即该字符的ASCII码。

• 样例输入

  A

• 样例输出

  65

• 提交代码

  a = input()
  print(ord(a))

004:打印字符

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  输入一个ASCII码，输出对应的字符。

• 输入
  一个整数，即字符的ASCII码，保证存在对应的可见字符。

• 输出
  一行，包含相应的字符。

• 样例输入

  65

• 样例输出

  A

• 提交代码

  a = input()
  print(chr(int(a)))

005:整型数据类型存储空间大小

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  分别定义int，short类型的变量各一个，并依次输出它们的存储空间大小（单位：字节）。

• 输入
  无。

• 输出
  一行，两个整数，分别是两个变量的存储空间大小，用一个空格隔开。

• 样例输入
  （无）

• 样例输出
  （不提供）

• 提示
  使用sizeof函数可以得到一个特定变量的存储空间大小。例如：对于int型变量x，sizeof(x)的值为4，即x的存储空间为4字节。

• 提交代码

import sys
a = int(1)
print(sys.getsizeof(a))

006:浮点型数据类型存储空间大小

总时间限制: 1000ms 内存限制: 65536kB

• 描述
  分别定义float，double类型的变量各一个，并依次输出它们的存储空间大小（单位：字节）。

• 输入
  无。

• 输出
  一行，两个整数，分别是两个变量的存储空间大小，用一个空格隔开。

• 样例输入
  （无）

• 样例输出
  （不提供）

• 提交代码

同上

程序设计与算法（二）测验汇总(2022夏季)(26题)

程序设计与算法（三）测验和作业题汇总(2022夏季)(45题)

练习(47题)