一、编程基础之输入输出
1、Hello World
对于大部分编程语言来说，编写一个能够输出“Hello, World!”的程序往往是最基本、最简单的。因此，这个程序常常作为一个初学者接触一门新的编程语言所写的第一个程序，也经常用来测试开发、编译环境是否能够正常工作。
print("Hello,World!")2、输出输出练习之第二个数字
练习输入输出，这里会输入三个整数，要求只输出第二个数字来！
a,b,c = map(int,input().split())
print(b)3、输入输出练习之格式控制
依旧是输入三个整数，要求按照占8个字符的宽度，并且靠左对齐输出
两种方法
1.左对齐：'%-8d'%n 。不加-为右对齐（默认）
2.'{:<8d}'.format(n)。>为右对齐，d表示十进制。
a,b,c = map(int,input().split())
print('{:<8d}{:<8d}{:<8d}'.format(a,b,c))
print('%-8d''%-8d''%-8d'%(a,b,c))4、输入输出练习之精度控制1
输入一个单精度浮点数，输出保留三位小数输出
a = float(input())
print('%.3f'%a)5、输入输出练习之精度控制2
输入一个双精度浮点数，保留12位小数输出
a = float(input())
print('{:.12f}'.format(a))6、输入输出练习之精度控制3
输入一个字符，一个数字，一个单精度浮点数，一个双精度浮点数，按顺序输出它们四个
且数字指定占4个字符宽靠右对齐，单精度浮点数保留2位小数，双精度保留12位小数，占一行输出、空格分隔
a,b,c,d = map(str,input().split())
print('%c'%(a),end=' ')
print('%4d'%int(b),end=' ')
print('%.2f'%float(c),end=' ')
print('%.12f'%float(d),end=' ')7、数入输出练习之浮点数专题
输入一个双精度浮点数，输出这个浮点数的%f结果、保留5位小数的结果、%e、%g格式的结果
a = float(input())
print('%f'%(a))
print('%.5f'%(a))
print('%e'%(a))
print('%g'%(a))
输入:
3.14159265358
输出:
3.141593
3.14159
3.141593e+00
3.14159
8、输入输出练习之输出图案
输入一个字符，输出由这个字符组成等腰三角形
底为5个，高为3个。
a = input()
print(f' {a}')
print(f' {a*3}')
print(f'{a*5}')
9、字符菱形
给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。
* *** ***** *** *
a = input()
print(f' {a}')
print(f' {a*3}')
print(f'{a*5}')
print(f' {a*3}')
print(f' {a}')二、编程基础之算术表达式与顺序执行
1、A+B problem
输入两个自然数，输出他们的和。
a,b = map(int,input().split())
sum = a + b
print(sum)2、计算(a+b)*c的值
给定3个整数a、b、c，计算表达式(a+b)*c的值。
a,b,c = map(int,input().split())
sum = (a+b)*c
print(sum)3、计算(a+b)/c的值
给定3个整数a、b、c，计算表达式(a+b)/c的值，/是整除运算。
看清题目要求整除，python除法计算默认float类型。这里有个坑，整除运算根据题目给的信息是向下整除，但是使用//整除是过不了所有的测试点的。最后是使用int()强制类型转换才通过的。
a,b,c = map(int,input().split())
sum = (a+b)/c
print(int(sum))4、带余除法
给定被除数和除数，求整数商及余数。
此题中请使用默认的整除和取余运算，无需对结果进行任何特殊处理。看看程序运行结果与数学上的定义有什么不同？
a,b = map(int,input().split())
print(f'{a//b} {a%b}')5、计算分数的浮点数值
两个整数a和b分别作为分子和分母，既分数 a/b ，求它的浮点数值（双精度浮点数，保留小数点后9位）。
a,b = map(int,input().split())
print('%.9f'%(a/b))6、甲流疫情死亡率
甲流并不可怕，在中国，它的死亡率并不是很高。请根据截止2009年12月22日各省报告的甲流确诊数和死亡数，计算甲流在各省的死亡率。
输入格式
输入仅一行，有两个整数，第一个为确诊数，第二个为死亡数。
输出格式
输出仅一行，甲流死亡率，以百分数形式输出，精确到小数点后3位。
a,b = map(int,input().split())
p = (b*100)/a
print('%.3f%%'%(p))7、计算多项式的值
对于多项式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
x,a,b,c,d = map(float,input().split())
fx = a*x**3 + b*x**2 + c*x + d
print('%.7f'%(fx))8、[编程入门]温度转换
输入一个华氏温度，要求输出摄氏温度。公式为 c=5(F-32)/9，取位2小数。
F = float(input())
c = 5*(F-32)/9
print("c="'%.2f'%(c))9、与圆相关的计算
给出圆的半径，求圆的直径、周长和面积。
输入格式
输入包含一个实数r（0 < r <= 10,000），表示圆的半径。
输出格式
输出一行，包含三个数，分别表示圆的直径、周长、面积，数与数之间以一个空格分开，每个数保留小数点后4位。
样例输入
3.0
样例输出
6.0000 18.8495 28.2743
r = float(input())
pi = 3.14159
a = 2*r
b = 2*pi*r
c = pi*r*r
print('%.4f %.4f %.4f'%(a,b,c))10、计算并联电阻的阻值
对于阻值为r1和r2的电阻，其并联电阻阻值公式计算如下：
R = 1/(1/r1 + 1/r2)
r1,r2 = map(float,input().split())
R = 1/(1/r1 + 1/r2)
print('%.2f'%(R))11、计算浮点数相除的余数
计算两个双精度浮点数a和b的相除的余数，a和b都是正数的。这里余数（r）的定义是：a = k * b + r，其中 k是整数， 0 <= r < b。
注意：输出时小数尾部没有多余的0，可以用下面这种格式
printf("%g", x); 除去多余的0
a,b = map(float,input().split())
x = a%b
print('%g'%(x))12、计算球体积
根据输入的半径值，计算球的体积。
输入格式
输入数据有多组，每组占一行，每行包括一个实数，表示球的半径。
输出格式
输出对应的球的体积，对于每组输入数据，输出一行，计算结果保留三位小数。
样例输入
1
1.5
样例输出
4.189
14.137
import math
while True:
try:
r = float(input())
pi = math.pi
v = (4/3)*pi*(r**3)
print('%.3f'%(v))
except:
break13、三位数反转
输入一个三位数，分离出它的百位、十位和个位，反转后输出。
输入格式
有多组输入数据
输入测试数据占一行，一个数字n(100<=n<=999)
输出格式
输出三个整数占一行表示答案
样例输入
127
样例输出
721
方一:
while True:
try:
a = int(input())
print('%d%d%d'%(a%10,a%100//10,a//100))
except:
break
法二:
while True:
try:
n = input()
m = n[::-1]
print(m)
except EOFError:
break14、大象喝水
一只大象口渴了，要喝20升水才能解渴，但现在只有一个深h厘米，底面半径为r厘米的小圆桶(h和r都是整数)。问大象至少要喝多少桶水才会解渴。
import math
h,r = map(int,input().split())
pi = 3.14159
v = pi*r*r*h
n = math.ceil(20*1000/v)
print(n)15、苹果和虫子
你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？
import math
n,x,y = map(int,input().split())
a = n-math.ceil(y/x)
print(a)16、计算线段长度
题目描述
已知线段的两个端点的坐标A（Xa,Ya），B（Xb，Yb），求线段AB的长度。
输入格式
共两行。
第一行是两个实数Xa，Ya，即A的坐标。
第二行是两个实数Xb，Yb，即B的坐标。
输入中所有实数的绝对值均不超过10000。
输出格式
一个实数，即线段AB的长度，保留到小数点后3位。
题目没说清楚，可以一行输如4个数，也可以分两行输入，每行两个数
import math
number = list(map(float,input().split()))
if len(number) == 4:
x1,y1,x2,y2 = number[0],number[1],number[2],number[-1]
else:
x1,y1 = number[0],number[1]
x2,y2 = map(float,input().split())
n = math.sqrt((x1-x2)**2 + (y1-y2)**2)
print('%.3f'%(n))17、计算三角形面积
题目描述(用海伦公式)
平面上有一个三角形，它的三个顶点坐标分别为(x1, y1), (x2, y2), (x3, y3)，那么请问这个三角形的面积是多少。
输入格式
输入仅一行，包括6个单精度浮点数，分别对应x1, y1, x2, y2, x3, y3。
输出格式
输出也是一行，输出三角形的面积，精确到小数点后两位。
样例输入
0 0 4 0 0 3
样例输出
6.0
import math
x1,y1,x2,y2,x3,y3 = map(float,input().split())
a = math.sqrt((x1-x2)**2 + (y1-y2)**2)
b = math.sqrt((x1-x3)**2 + (y1-y3)**2)
c = math.sqrt((x2-x3)**2 + (y2-y3)**2)
p = (a+b+c)/2
s = math.sqrt(p*(p-a)*(p-b)*(p-c))
print('%.2f'%(s))18、等差数列末项计算
题目描述
给出一个等差数列的前两项a1，a2，求第n项是多少。
输入格式
一行，包含三个整数a1，a2，n。-100 <= a1,a2 <= 100，0 < n <= 1000。
输出格式
一个整数，即第n项的值。
样例输入
1 4 100
样例输出
298
动态规划解法
a1,a2,n = map(int,input().split())
dp = [0]*n
dp[0] = a1
dp[1] = a2
for i in range(1,n):
dp[i] = dp[i-1] + (a2-a1)
print(dp[-1])19、A*B问题
输入两个正整数A和B，求A*B。
a,b = map(int,input().split())
print(int(a*b))20、计算2的幂
给定非负整数n，求2^n
n = int(input())
print(2**n)三、编程基础之逻辑表达式与条件分支
1、判断数正负
给定一个整数N，判断其正负。
a = int(input())
if a > 0:
print('positive')
elif a < 0:
print('negative')
else:
print("zero")2、输出绝对值
输入一个浮点数，输出这个浮点数的绝对值。
import math
n = float(input())
print('%.2f'%(math.fabs(n)))3、奇偶数判断
给定一个整数，判断该数是奇数还是偶数。
n = int(input())
if n % 2 == 0:
print("even")
else:
print("odd")
4、奇偶ASCII值判断
任意输入一个字符，判断其ASCII是否是奇数，若是，输出YES，否则，输出NO。
例如，字符A的ASCII值是65，则输出YES，若输入字符B(ASCII值是66)，则输出NO。
n = input()
a = ord(n)
if a % 2 != 0:
print("YES")
else:
print("NO")5、整数大小比较
输入两个整数，比较它们的大小。
x,y = map(int,input().split())
if x > y:
print(">")
elif x < y:
print("<")
else:
print("=")6、判断是否为两位数
判断一个正整数是否是两位数（即大于等于10且小于等于99）。
n = int(input())
if n >=10 and n <= 99:
print("1")
else:
print("0")7、收集瓶盖赢大奖
某饮料公司最近推出了一个“收集瓶盖赢大奖”的活动：如果你拥有10个印有“幸运”、或20个印有“鼓励”的瓶盖，就可以兑换一个神秘大奖。
现分别给出你拥有的印有“幸运”和“鼓励”的瓶盖数，判断是否可以去兑换大奖。
a,b = map(int,input().split())
if a >= 10 or b >= 20:
print("1")
else:
print("0")8、判断一个数能否同时被3和5整除
判断一个数n能否同时被3和5整除。
n = int(input())
if n % 3 == 0 and n % 5 == 0:
print("YES")
else:
print("NO")9、判断能否被3、5、7整除
给定一个整数，判断它能否被3，5，7整除，并输出以下信息：
1、能同时被3，5，7整除（直接输出3 5 7，每个数中间一个空格）；
2、只能被其中两个数整除（输出两个数，小的在前，大的在后。例如：3 5或者 3 7或者5 7,中间用空格分隔）；
3、只能被其中一个数整除（输出这个除数）；
4、不能被任何数整除，输出小写字符‘n’,不包括单引号。
法一：
n = int(input())
if n % 3 == 0 and n % 5 == 0 and n % 7 == 0:
print("3 5 7")
elif n % 3 == 0 and n % 5 == 0 and n % 7 != 0:
print("3 5")
elif n % 3 == 0 and n % 5 != 0 and n % 7 == 0:
print("3 7")
elif n % 3 != 0 and n % 5 == 0 and n % 7 == 0:
print("5 7")
elif n % 3 == 0 and n % 5 != 0 and n % 7 != 0:
print("3")
elif n % 3 == 0 and n % 5 != 0 and n % 7 != 0:
print("3")
elif n % 3 != 0 and n % 5 == 0 and n % 7 != 0:
print("5")
elif n % 3 != 0 and n % 5 != 0 and n % 7 == 0:
print("7")
else:
print("n")
法二：
list,n = [3,5,7],int(input())
for i in list:
if n % i == 0:
print(i,end=' ')
if n % 3 != 0 and n % 5 != 0 and n % 7 != 0:
print('n')
10、有一门课不及格的学生
给出一名学生的语文和数学成绩，判断他是否恰好有一门课不及格（成绩小于60分）。
a,b = map(int,input().split())
if (a<=60 and b<=60) or (a>=60 and b>=60):
print("0")
else:
print(1)
score = list(map(int, input().split()))
if min(score) < 60:
if max(score) >= 60:
print(1)
else:
print(0)
else:
print(0)11、晶晶赴约会
晶晶的朋友贝贝约晶晶下周一起去看展览，但晶晶每周的1、3、5有课必须上课，请帮晶晶判断她能否接受贝贝的邀请，如果能输出YES；如果不能则输出NO。
a = int(input())
list = [1,3,5]
if a in list:
print("NO")
else:
print("YES")12、骑车与走路
在北大校园里,没有自行车,上课办事会很不方便.但实际上,并非去办任何事情都是骑车快,因为骑车总要找车、开锁、停车、锁车等,这要耽误一些时间.假设找到自行车,开锁并车上自行车的时间为27秒;停车锁车的时间为23秒;步行每秒行走1.2米,骑车每秒行走3.0米。请判断走不同的距离去办事,是骑车快还是走路快。
s = int(input())
w = s/1.2
b = s/3 + 50
if w>b:
print("Bike")
elif w<b:
print("Walk")
else:
print("All")13、分段函数
编写程序，计算下列分段函数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
x = float(input())
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))14、计算邮资
根据邮件的重量和用户是否选择加急计算邮费。计算规则：重量在1000克以内(包括1000克), 基本费8元。超过1000克的部分，每500克加收超重费4元，不足500克部分按500克计算；如果用户选择加急，多收5元。
import math
a,n = map(str,input().split())
b = int(a)
if n == 'n':
if b <= 1000:
print(f'{8}')
elif b > 1000:
print('%d'%(math.ceil((b-1000)/500)*4 + 8))
else:
if b <= 1000:
print(f'{8+5}')
elif b > 1000:
print('%d'%(math.ceil((b-1000)/500)*4 + 8 +5)) 15、[编程入门]三个数最大值
编写一个程序，输入a、b、c三个值，输出其中最大值。
num = list(map(int,input().split()))
num.sort()
print(num[-1])16、三角形判断
给定三个正整数，分别表示三条线段的长度，判断这三条线段能否构成一个三角形。
import math
num = list(map(int,input().split()))
num.sort()
if (num[0] + num[1] > num[2]) and (abs(num[2]-num[1]) < num[0]):
print("yes")
else:
print("no")17、[编程入门]宏定义之闰年判断
给年份year，定义一个宏，以判别该年份是否闰年。提示：宏名可以定义为LEAP_YEAR，形参为y，既定义宏的形式为 #define LEAP_YEAR(y) （读者设计的字符串）
a = int(input())
if (a % 4 == 0 and a % 100 != 0) or (a % 400 == 0):
print("L")
else:
print("N")
法二:
a = int(input())
def LEAP_YEAR(y):
if (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0):
print("L")
else:
print("N")
LEAP_YEAR(a)18 、点和正方形的关系
有一个正方形，四个角的坐标（x,y)分别是（1，-1），（1，1），（-1，-1），（-1，1），x是横轴，y是纵轴。写一个程序，判断一个给定的点是否在这个正方形内（包括正方形边界）。
x,y = map(float,input().split())
if (x >= -1 and x <= 1) and (y >= -1 and y <= 1):
print("yes")
else:
print("no")19、模拟计算器
使用Switch语句编写一个模拟简单计算器的程序。依次输入两个整数和一个字符，并用空格隔开。如果该字 符是一个“+”，则打印和；如果该字符是一个“-”，则打印差；如果该字符是一个“*”,则打印积；如果该字符是“/”，则打印商；如果该字符是一个 “%”，则打印余数。打印结果后输出一个空行。
x,y,s = map(str,input().split())
x = float(x)
y = float(y)
if s == '+':
print(int(x+y))
elif s == '-':
print(int(x-y))
elif s == '*':
print(int(x*y))
elif s == '/':
print(int(x/y))
elif s == '%':
print(int(x%y))
法二:
x,y,s = map(str,input().split())
x,y = int(x),int(y)
def switch(x,y,s):
switch={
'+':int(x+y),
'-':int(x-y),
'*':int(x*y),
'/':int(x/y),
'%':int(x%y)
}
return switch.get(s,'') #表示在字典 switch 中查找键为 symbol 的值，如果找到，则返回该值；如果找不到，则返回空字符串 ""。
print(switch(x,y,s))
20、[编程入门]自定义函数求一元二次方程
求方程 的根，用三个函数分别求当b^2-4ac大于0、等于0、和小于0时的根，并输出结果。从主函数输入a、b、c的值。
输入格式
a b c
输出格式
x1=? x2=?
样例输入
4 1 1
样例输出
x1=-0.125+0.484i x2=-0.125-0.484i
import math
a,b,c = map(float,input().split())
def solution(a,b,c):
t = b*b - 4*a*c
if t > 0:
x1 = (-b+math.sqrt(t))/(2*a)
x2 = (-b-math.sqrt(t))/(2*a)
print(f"x1={x1} x2={x2}")
elif t == 0:
x1 = x2 = (-b)/(2*a)
print(f"x1={x1} x2={x2}")
else:
a1 = (-b)/(2*a)
a2 = math.sqrt(-t)/(2*a)
print("x1={:.3f}+{:.3f}i x2={:.3f}-{:.3f}i".format(a1,a2,a1,a2))
solution(a,b,c)四、编程基础之循环控制
1、求平均年龄
班上有学生若干名，给出每名学生的年龄（整数），求班上所有学生的平均年龄，保留到小数点后两位。
输入格式
第一行有一个整数n（1<= n <= 100），表示学生的人数。第二行共有n个整数，表示每个学生的年龄，取值为15到25，空格分开。
输出格式
输出一行，该行包含一个浮点数，为要求的平均年龄，保留到小数点后两位。
样例输入
2
18 17
样例输出
17.50
n = int(input())
num = list(map(int,input().split()))
a = 0
for i in num:
a += i
print("{:.2f}".format(a/n))
2、财务管理
Larry今年毕业并找到了一份工作。他赚很多钱，但似乎总是不够。Larry认为他需要控制他的投资以解决自己的财务问题。Larry拿到了自己的银行账户详单，想看看自己有多少钱。请帮助Larry写一个程序，通过过去12个月中每月的月末结余，计算平均结余。
c = 0
num = [0]*12
for i in range(12):
num[i] = float(input())
for i in num:
c += i
print("${:.2f}".format(c/12))3、蓝桥杯算法训练VIP-整数平均值
编写函数，求包含n个元素的整数数组中元素的平均值。要求在函数内部使用指针操纵数组元素，其中n个整数从键盘输入，输出为其平均值。
（样例说明：5为输入数据的个数，3 4 0 0 2 是以空格隔开的5个整数）
n = int(input())
num = list(map(float,input().split()))
c=0
for i in num:
c+=i
print("{}".format(int(c/n)))4、求整数的和与均值
题目描述
读入n（1 <= n <= 10000）个整数，求它们的和与均值。
输入格式
输入第一行是一个整数n，表示有n个整数。
第2~n+1行每行包含1个整数。每个整数的绝对值均不超过10000。
输出格式
输出一行，先输出和，再输出平均值（保留到小数点后5位），两个数间用单个空格分隔。
#注意可能是一行输入或者是多行输入，分情况讨论
n = list(map(int,input().split()))
if len(n) == 1:
num = [0]*n[0]
c=0
for i in range(n[0]):
num[i] = int(input())
c+=num[i]
print("{} {:.5f}".format(c,c/n[0]))
else:
a = 0
c = 0
a = n[0]
n.pop(0)
for i in n:
c+=i
print("{} {:.5f}".format(c,c/a))5、最高的分数
孙老师讲授的《计算概论》这门课期中考试刚刚结束，他想知道考试中取得的最高分数。因为人数比较多，他觉得这件事情交给计算机来做比较方便。你能帮孙老师解决这个问题吗？
n = int(input())
num = list(map(int,input().split()))
print(max(num))6、整数序列的元素最大跨度值
给定一个长度为n的非负整数序列，请计算序列的最大跨度值（最大跨度值 = 最大值减去最小值）。
n = int(input())
num = list(map(int,input().split()))
print("{}".format(max(num)-min(num)))7、奥运奖牌计数
2008年北京奥运会，A国的运动员参与了n天的决赛项目(1≤n≤17)。现在要统计一下A国所获得的金、银、铜牌数目及总奖牌数。
输入格式
输入n＋1行，第1行是A国参与决赛项目的天数n，其后n行，每一行是该国某一天获得的金、银、铜牌数目，以一个空格分开。
输出格式
输出1行，包括4个整数，为A国所获得的金、银、铜牌总数及总奖牌数，以一个空格分开。
n = int(input())
a1,b1,c1=0,0,0
for i in range(n):
a,b,c = map(int,input().split())
a1 += a
b1 += b
c1 += c
print("{} {} {} {}".format(a1,b1,c1,a1+b1+c1))8、多边形内角和
在欧几里德几何中，n边形的内角和是(n-2)*180°。已知其中(n-1)个内角的度数，就能计算出剩下的一个未知内角的度数。请编写一个程序，来解决这个问题。
n = int(input())
num = list(map(int,input().split()))
a = (n-2)*180
c = 0
for i in num:
c += i
print("{}".format(a-c))9、奇数求和
计算非负整数 m 到 n（包括m 和 n ）之间的所有奇数的和，其中，m 不大于 n，且n 不大于300。例如 m=3, n=12, 其和则为：3+5+7+9+11=35。
m,n = map(int,input().split())
c = 0
for i in range(m,n+1):
if i % 2 != 0:
c += i
print("{}".format(c))10、满足条件的数累加
将正整数 m 和 n 之间（包括 m 和 n）能被 17 整除的数累加。其中，0 < m < n < 1000。
m,n = map(int,input().split())
c = 0
for i in range(m,n+1):
if i % 17 == 0:
c += i
print("{}".format(c))11、整数的个数
给定k（1 < k < 100）个正整数，其中每个数都是大于等于1，小于等于10的数。写程序计算给定的k个正整数中，1，5和10出现的次数。
n = int(input())
num = list(map(int,input().split()))
num1 = [1,5,10]
for i in num1:
print("{}".format(num.count(i)))12、与指定数字相同的数的个数
输出一个整数序列中与指定数字相同的数的个数。
输入格式
输入包含2行：
第1行为N和m，表示整数序列的长度(N <= 100)和指定的数字， 中间用一个空格分开；
第2行为N个整数，整数之间以一个空格分开。
输出格式
输出为N个数中与m相同的数的个数。
N,m = map(int,input().split())
num = list(map(int,input().split()))
print("{}".format(num.count(m)))13、乘方计算
给出一个整数a和一个整数n，求乘方a^n。
a,n = map(int,input().split())
print("{}".format(a**n))14、人口增长问题
我国现有x亿人口，按照每年0.1%的增长速度，n年后将有多少人？
x,n = map(int,input().split())
dp = [0]*(n+1)
dp[0] = x
for i in range(1,n+1):
dp[i] = dp[i-1]*(1+0.001)
print("{:.4f}".format(dp[-1]))15、银行利息
农夫约翰在去年赚了一大笔钱！他想要把这些钱用于投资，并对自己能得到多少收益感到好奇。已知投资的复合年利率为R（0到20之间的整数）。约翰现有总值为M的钱（100到1,000,000之间的整数）。他清楚地知道自己要投资Y年（范围0到400）。请帮助他计算最终他会有多少钱，并输出它的整数部分。数据保证输出结果在32位有符号整数范围内。
import math
R,M,Y = map(int,input().split())
dp = [0]*(Y+1)
dp[0] = M
for i in range(1,Y+1):
dp[i] = dp[i-1]*(1+R/100)
print("{}".format(math.floor(dp[-1])))16、买房子
某程序员开始工作，年薪N万，他希望在中关村公馆买一套60平米的房子，现在价格是200万，假设房子价格以每年百分之K增长，并且该程序员未来年薪不变，且不吃不喝，不用交税，每年所得N万全都积攒起来，问第几年能够买下这套房子？（第一年年薪N万，房价200万）
N,K = map(int,input().split())
c,n = 200,0
for i in range(1,20):
c *= 1+K/100
n = N*(i+1)
if n >= c:
print("{}".format(i+1))
break
if n < c:
print("Impossible")17、菲波那契数列
菲波那契数列是指这样的数列: 数列的第一个和第二个数都为1，接下来每个数都等于前面2个数之和。
给出一个正整数k，要求菲波那契数列中第k个数是多少。
k = int(input())
dp = [0]*k
if k == 1 or k == 2:
print(1)
else:
dp[0],dp[1] = 1,1
for i in range(2,k):
dp[i] = dp[i-2] + dp[i-1]
print("{}".format(dp[-1]))18、鸡尾酒疗法
鸡尾酒疗法，原指“高效抗逆转录病毒治疗”（HAART），由美籍华裔科学家何大一于1996年提出，是通过三种或三种以上的抗病毒药物联合使用来治疗艾 滋病。该疗法的应用可以减少单一用药产生的抗药性，最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，从而延缓病程进展，延长患者生 命，提高生活质量。人们在鸡尾酒疗法的基础上又提出了很多种改进的疗法。为了验证这些治疗方法是否在疗效上比鸡尾酒疗法更好，可用通过临床对照实验的方式 进行。假设鸡尾酒疗法的有效率为x，新疗法的有效率为y，如果y-x大于5%，则效果更好，如果x-y大于5%，则效果更差，否则称为效果差不多。下面给 出n组临床对照实验，其中第一组采用鸡尾酒疗法，其他n-1组为各种不同的改进疗法。请写程序判定各种改进疗法效果如何。
n = int(input())
num = []
for i in range(n):
a,b = map(int,input().split())
num.append(b/a)
for i in range(1,n):
if num[0] - num[i] > 0.05:
print("worse")
elif num[i] - num[0] > 0.05:
print("better")
else:
print("same")
19、救援
救生船从大本营出发，营救若干屋顶上的人回到大本营，屋顶数目以及每个屋顶的坐标
和人数都将由输入决定，求出所有人都到达大本营并登陆所用的时间。
在直角坐标系的原点是大本营，救生船每次从大本营出发，救了人之后将人送回大本营。坐标系中的点代表屋顶，每个屋顶由其位置坐标和其上的人数表 示。救生船每次从大本营出发，以速度50 米/分钟驶向下一个屋顶，达到一个屋顶后，救下其上的所有人，每人上船1 分钟，船原路返回，达到大本营，每人下船0.5 分钟。假设原点与任意一个屋顶的连线不穿过其它屋顶。
import math
n = int(input())
t1 = 0
for i in range(n):
x,y,p =map(int,input().split())
s = math.sqrt(x*x + y*y)
t = s/50*2 + (1+0.5)*p
t1 += t
print("{}".format(math.ceil(t1)))20、球弹跳高度的计算
一球从某一高度落下（整数，单位米），每次落地后反跳回原来高度的一半，再落下。
编程计算气球在第10次落地时，共经过多少米? 第10次反弹多高？
输入格式
输入一个整数h，表示球的初始高度。
输出格式
输出包含两行：
第1行：到球第10次落地时，一共经过的米数。
第2行：第10次弹跳的高度。
注意：结果可能是实数，结果用double类型保存。
提示：输出时不需要对精度特殊控制，用cout << ANSWER，或者printf("%g", ANSWER)即可。
h = int(input())
dp = [0]*11
dp[0] = h
s = h
for i in range(1,11):
dp[i] = dp[i-1]/2
if i < 10:
s += 2*dp[i]
print("{:g}".format(s))
print("{:g}".format(dp[-1]))21、C语言训练-角谷猜想
角谷猜想:
日本一位中学生发现一个奇妙的“定理”，请角谷教授证明，而教授无能为力，于是产生角谷猜想。猜想的内容是：任给一个自然数，若为偶数除以2，若为奇数则乘3加1，得到一个新的自然数后按照上面的法则继续演算，若干次后得到的结果必然为1。请编程验证。
n = int(input())
while n != 1:
if n % 2 == 0:
print("{}/2={:g}".format(int(n),n/2))
n=n/2
else:
print("{}*3+1={:g}".format(int(n),n*3+1))
n=n*3+122、津津的储蓄计划
津津的零花钱一直都是自己管理。每个月的月初妈妈给津津300元钱，津津会预算这个月的花销，并且总能做到实际花销和预算的相同。 为了让津津学习如何储蓄，妈妈提出，津津可以随时把整百的钱存在她那里，到了年末她会加上20％还给津津。因此津津制定了一个储蓄计划：每个月的月初，在得到妈妈给的零花钱后，如果她预计到这个月的月末手中还会有多于100元或恰好100元，她就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。 例如11月初津津手中还有83元，妈妈给了津津300元。津津预计11月的花销是180元，那么她就会在妈妈那里存200元，自己留下183元。到了11月月末，津津手中会剩下3元钱。 津津发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，津津手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，津津将不得不在这个月省吃俭用，压缩预算。 现在请你根据2004年1月到12月每个月津津的预算，判断会不会出现这种情况。如果不会，计算到2004年年末，妈妈将津津平常存的钱加上20％还给津津之后，津津手中会有多少钱。
输入格式
输入包括12行数据，每行包含一个小于350的非负整数，分别表示1月到12月津津的预算。
输出格式
输出包括一行，这一行只包含一个整数。如果储蓄计划实施过程中出现某个月钱不够用的情况，输出-X，X表示出现这种情况的第一个月；否则输出到2004年年末津津手中会有多少钱。
num = [0]*12
n = 0
s = 0
flag = 0
for i in range(12):
num[i] = int(input())
n += 300
if n - num[i] >= 100:
n -= num[i]
s = s + int(n/100)*100
n = n - int(n/100)*100
elif n - num[i] >= 0:
n -= num[i]
else:
print("-{}".format(i+1))
flag = 1
break
if flag == 0:
print("{:g}".format(s*(1+0.2)+n))
23、药房管理
随着信息技术的蓬勃发展，医疗信息化已经成为医院建设中必不可少的一部分。计算机可以很好地辅助医院管理医生信息、病人信息、药品信息等海量数据，使工作人员能够从这些机械的工作中解放出来，将更多精力投入真正的医疗过程中，从而极大地提高了医院整体的工作效率。
对药品的管理是其中的一项重要内容。现在药房的管理员希望使用计算机来帮助他管理。假设对于任意一种药品，每天开始工作时的库存总量已 知，并且一天之内不会通过进货的方式增加。每天会有很多病人前来取药，每个病人希望取走不同数量的药品。如果病人需要的数量超过了当时的库存量，药房会拒 绝该病人的请求。管理员希望知道每天会有多少病人没有取上药。
输入格式
共3行：
第一行是每天开始时的药品总量m；
第二行是这一天取药的人数n（0 < n <= 100）；
第三行共有n个数，分别记录了每个病人希望取走的药品数量（按照时间先后的顺序），两数之间以空格分隔。
输出格式
只有1行，为这一天没有取上药品的人数。
m = int(input())
n = int(input())
num = list(map(int,input().split()))
s = 0
for i in num:
if m >= i:
m-=i
else:
s+=1
print(s)24、正常血压
监护室每小时测量一次病人的血压，若收缩压在90 - 140之间并且舒张压在60 - 90之间（包含端点值）则称之为正常，现给出某病人若干次测量的血压值，计算病人保持正常血压的最长小时数。
输入格式
第一行为一个正整数n，n < 100。
其后有n行，每行2个正整数，分别为一次测量的收缩压和舒张压，中间以一个空格分隔。
输出格式
输出仅一行，血压连续正常的最长小时数。
n = int(input())
s = 0
num = []
for i in range(n):
a,b = map(int,input().split())
if (a>=90 and a<=140) and (b>=60 and b<=90):
s+=1
num.append(s)
else:
s=0
if len(num) == 0: #易错点，记得考虑没有输入数据时
print(0)
else:
print("{}".format(max(num)))25、求特殊自然数
一个十进制自然数,它的七进制与九进制表示都是三位数，且七进制与九进制的三位数码表示顺序正好相反。编程求此自然数,并输出显示。
输入格式
三行：
第一行是此自然数的十进制表示；
第二行是此自然数的七进制表示；
第三行是此自然数的九进制表示。
n = int(input())
a1 = input()
a2 = input()
def solution(n,a): #十进制转a进制
num=[]
while n>=a:
num.append(int(n%a))
n = int(n/2)
num.append(int(n))
num.reverse()
a = ''.join(map(str,num))
return(a)
b1 = solution(n,7)
b2 = solution(n,9)
if b1[::-1] == b2:
print(n)
法二:
for a in range(1,7):
for b in range(0,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(a+b*10+c*100)26、统计满足条件的4位数个数
给定若干个四位数，求出其中满足以下条件的数的个数：
个位数上的数字减去千位数上的数字，再减去百位数上的数字， 再减去十位数上的数字的结果大于零。
输入格式
输入为两行，第一行为四位数的个数n，第二行为n个的四位数，数与数之间以一个空格分开。(n <= 100)
输出格式
输出为一行，包含一个整数，表示满足条件的四位数的个数。
a = int(input())
num = map(str,input().split())
a1 = 0
for n in num:
g,s,b,q = int(n[3]),int(n[2]),int(n[1]),int(n[0])
if g-q-b-s > 0:
a1+=1
print(a1)27、级数求和
已知：Sn= 1＋1／2＋1／3＋…＋1／n。显然对于任意一个整数K，当n足够大的时候，Sn大于K。
现给出一个整数K（1<=k<=15），要求计算出一个最小的n；使得Sn＞K。
k = int(input())
s,n = 0,0
while s <= k:
n += 1
s += 1/n
print(n)28、分离整数的各个数位
给定一个整数，要求从个位开始分离出它的每一位数字。
n = int(input())
a = "".join(str(n))
a = a[::-1]
b = " ".join(a)
print(b)
法二：
print(" ".join(input()[::-1]))29、数字反转
给定一个整数，请将该数各个位上数字反转得到一个新数。新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例2）。
输入格式
输入共 1 行，一个整数N。
-1,000,000,000 ≤ N≤ 1,000,000,000。
输出格式
输出共 1 行，一个整数，表示反转后的新数。
n = input().strip()
if int(n) < 0:
a ='-' + n[::-1]
a = a.rstrip('-')
elif int(n) >= 0:
a = n[::-1]
for i in a:
if i == '-':
continue
elif i == '0':
a = a.replace('0','',1)
else:
break
print("{}".format(''.join(a)))
法二:
a = input()
a = a[::-1] # 字符串逆序
if a[len(a)-1] == '-': # 如果输入负数
a = int(a.strip('-')) # 去除字符串末尾负号,转整型去除最高位0
a *= -1
else:
a = int(a) # 转整型去除最高位0
print(a)30、含k个3的数
输入两个正整数 m 和 k，其中1 < m < 100000，1 < k < 5 ，判断 m 能否被19整除，且恰好含有k个3，如果满足条件，则输出YES，否则，输出NO。
例如，输入：
43833 3
满足条件，输出YES。
如果输入：
39331 3
尽管有3个3，但不能被19整除，也不满足条件，应输出NO。
m,k = map(int,input().split())
if m % 19 == 0 and str(m).count('3') == k:
print("YES")
else:
print("NO")31、开关灯
假设有N盏灯(N为不大于5000的正整数)，从1到N按顺序依次编号，初始时全部处于开启状态；有M个人(M为不大于N的正整数)也从1到M依次编号。
第一个人（1号）将灯全部关闭，第二个人（2号）将编号为2的倍数的灯打开，第三个人（3号）将编号为3的倍数的灯做相反处理（即，将打开的灯关闭，将关闭的灯打开）。依照编号递增顺序，以后的人都和3号一样，将凡是自己编号倍数的灯做相反处理。
请问：当第M个人操作之后，哪几盏灯是关闭的，按从小到大输出其编号，其间用逗号间隔。
N,M = map(int,input().split())
dict1 = {i : i*0 for i in range(1,N+1)} #0代表开灯，1代表关灯
dict2 = {i : i for i in range(1,M+1)}
s = []
for i in range(1,M+1):
for j in range(1,N+1):
if i == 1:
dict1[j] = 1
elif j % i == 0:
dict1[j] = ~dict1[j]
for i in range(1,N+1):
if dict1[i] == 1:
s.append(i)
print("{}".format(",".join(map(str,s))))32、求分数序列和
有一个分数序列 q1/p1,q2/p2,q3/p3,q4/p4,q5/p5,.... ,其中qi+1= qi+ pi, pi+1=qi, p1= 1, q1= 2。比如这个序列前6项分别是2/1,3/2,5/3,8/5,13/8,21/13。求这个分数序列的前n项之和。
n = int(input())
p,q = 1,2
a,sum = 0,2
for _ in range(n-1):
a = q
q = q + p
p = a
sum += q/p
print("{:.4f}".format(sum))33、计算分数加减表达式的值
编写程序，输入n的值，求 1/1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 + 1/7 - 1/8 + ... + (-1)n-1·1/n 的值。
n = int(input())
sum = 0
for i in range(1,n+1):
sum += pow(-1,i-1)/i
print("{:.4f}".format(sum))34、[编程入门]阶乘求和
求Sn=1!+2!+3!+4!+5!+…+n!之值，其中n是一个数字(n不超过20)。
import math
n = int(input())
sum = 0
for i in range(1,n+1):
sum += math.factorial(i)
if n == 0:
print(1)
else:
print(int(sum))
法二:
n = int(input())
s,sum = 1,0
for i in range(1,n+1):
s *= i
sum += s
print(sum)35、求出e的值
利用公式e = 1 + 1/1! + 1/2! + 1/3! + ... + 1/n! 求e 。
n = int(input())
s,sum = 1,1
for i in range(1,n+1):
s *= i
sum += 1/s
print("{:.10f}".format(sum))36、计算多项式的值
假定多项式的形式为xn+xn-1+…+x2+x+1，请计算给定单精度浮点数x和正整数n值的情况下这个多项式的值。
输入格式
输入仅一行，包括x和n，用单个空格隔开。x在float范围内，n <= 1000000。
输出格式
输出一个实数，即多项式的值，精确到小数点后两位。保证最终结果在float范围内。
样例输入
2.0 4
样例输出
31.00
x,n = input().split()
x = float(x)
n = int(n)
# 初始化result和item变量
result = 1.0
item = 1.0
# 使用for循环来计算幂和
for i in range(n):
item *= x
result += item
# 输出结果，保留两位小数
print("%.2f" % result)
注意精度问题，否则编译不完全通过38、雇佣兵
雇佣兵的体力最大值为M，初始体力值为0、战斗力为N、拥有X个能量元素。
当雇佣兵的体力值恰好为M时，才可以参加一个为期M天的战斗期，战斗期结束体力值将为0。在同一个战斗期内，雇佣兵每连续战斗n天，战斗力就会上升1点，n为当前战斗期开始时的战斗力。
一个战斗期结束后，雇佣兵需要用若干个能量元素使其体力恢复到最大值M，从而参加下一个战斗期。每个能量元素恢复的体力值不超过当前的战斗力。每个能量元素只能使用一次。
请问：雇佣兵的战斗力最大可以到达多少。
import math
M,N,X = map(int,input().split())
while X*N >= M: #剩余的总能量是否大于体力值
b = math.ceil(M/N) # 补满体力需要多少块元素
X -= b
a = M
while a >= N:
a -= N
N += 1
print(N)39、计算多项式的导函数
计算多项式的导函数是一件非常容易的任务。给定一个函数f(x)，我们用f'(x)来表示其导函数。我们用x^n来表示x的n次幂。为了计算多项式的导函数，你必须知道三条规则：
(1)、(C)' = 0 如果C是常量
(2)、(C*x^n)' = C*n*x^(n-1) 如果n >= 1且C是常量
(3)、(f1(x)+f2(2))' = f1'(x)+f2'(x)
容易证明，多项式的导函数也是多项式。
现在，请你编写一个程序，给定一个不包含负系数且已合并好同幂次项的多项式f(x)，计算出它的导函数。
输入格式
输入有两行。
第一行是一个整数n（0 <= n <= 100）表明多项式的最高次幂为n。
第二行包含n+1个非负整数，Cn ，Cn-1 ，Cn-2 ，Cn-3 ，Cn-4 ，… ，C1，C0（0 <= Ci <= 1000）且Cn != 0。Ci是幂次为i的项的系数。
输出格式
在一行内输出f'(x)的结果。
（1） 如果g(x) = 0那么直接输出0
（2） 如果g(x)形如Cm(x^m)+Cm-1(x^(m-1))+…+C0(Cm!=0)那么输出Cm…C0
（3） 相邻整数之间有单个空格。
n = int(input())
num = list(map(int,input().split()))
if n == 0:
print(0)
else:
for i in range(n):
num[i] = num[i]*(n-i)
print("{}".format(num[i]),end=' ')
40、与7无关的数
一个正整数,如果它能被7整除,或者它的十进制表示法中某一位上的数字为7,则称其为与7相关的数。现求所有小于等于n(n < 100)的与7无关的正整数的平方和。
n = int(input())
sum = 0
for i in range(n+1):
if i % 7 != 0 and '7' not in str(i):
sum += i*i
print(sum)41、数1的个数
给定一个十进制正整数n，写下从1到n的所有整数，然后数一下其中出现的数字“1”的个数。
例如当n=2时，写下1,2。这样只出现了1个“1”；当n=12时，写下1，2，3，4，5，6，7，8，9，10，11，12。这样出现了5个“1”。
n = int(input())
sum = 0
for i in range(1,n+1):
sum += str(i).count('1')
print(sum)42、数字统计
请统计某个给定范围[L, R]的所有整数中，数字2出现的次数。
比如给定范围[2, 22]，数字2在数2中出现了1次，在数12中出现1次，在数20中出现1次，在数21中出现1次，在数22中出现2次，所以数字2在该范围内一共出现了6次。
L,R = map(int,input().split())
sum = 0
for i in range(L,R+1):
sum += str(i).count('2')
print(sum)43、画矩形
输入一行，包括四个参数：前两个参数为整数，依次代表矩形的高和宽（高不少于3行不多于10行，宽不少于5列不多于10列）；第三个参数是一个字符，表示用来画图的矩形符号；第四个参数为1或0，0代表空心，1代表实心。
法一:列表法
a, b, c, d = map(str, input().split())
num = [[] * int(b) for _ in range(int(a))]
for i in range(int(a)):
for j in range(int(b)):
num[i].append(c)
for i in range(int(a)):
if d == '1':
print(''.join(num[i]))
elif d == '0':
if i == 0 or i == int(a)-1:
print(''.join(num[i]))
else:
s = ''.join(map(str,num[i]))
s = s[:1] + " "*(int(b)-2) + s[int(b)-1:] # s.replace()不好用
print("{}".format(s))
法二:直接画
h,w,c,flag=map(str,input().split())
h=int(h)
w=int(w)
flag=int(flag)
if flag==1:
for i in range(h):
print(f'{c*w}')
else:
print(f'{c*w}')
for i in range(1,h-1):
print(f'{c}{" "*(w-2)}{c}')
print(f'{c*w}')44、信息学奥赛一本通T1620-质因数分解
原题来自：NOIP 2012 普及组
已知正整数 n 是两个不同的质数的乘积，试求出较大的那个质数。
遍历就完事了，注意for-else结构，如果是for循环被break了，那么不执行else中的代码，如果遍历完了都没有触发break，那么执行else。
思路，先求出n以内所有质数，在判断
n = int(input())
num = []
num1 = []
for i in range(2, n):
for j in range(2,i):
if i % j == 0:
break
else:
num.append(i)
for i in range(len(num)):
for j in range(i+1,len(num)):
if n == num[i] * num[j]:
num1.append(num[i])
num1.append(num[j])
print(max(num1))
45、第n小的质数
输入一个正整数n，求第n小的质数。
法一:列出所有质数，求n的质数，但当n过大，占用时间和内存过多，18分
n = int(input())
num = []
for i in range(2,10001):
for j in range(2,i):
if i % j == 0:
break
else:
num.append(i)
print(num[n-1])
法二:，使用了埃拉托斯特尼筛法来生成第 n 个质数此代码只会计算生成第 n 个质数，而不需要生成范围在 [2, 10000] 内的所有质数
def is_prime(n):
num = []
m = 2
while(len(num) < n):
is_p =True
for i in num:
if i*i > m:
break
if m % i == 0:
is_p =False
break
if is_p:
num.append(m)
m += 1
return num[-1]
n = int(input())
print(is_prime(n))46、金币
国王将金币作为工资，发放给忠诚的骑士。第一天，骑士收到一枚金币；之后两天（第二天和第三天）里，每天收到两枚金币；之后三天（第四、五、六天）里，每天收到三枚金币；之后四天（第七、八、九、十天）里，每天收到四枚金币……这种工资发放模式会一直这样延续下去：当连续N天每天收到N枚金币后，骑士会在之后的连续N+1天里，每天收到N+1枚金币（N为任意正整数）。
你需要编写一个程序，确定从第一天开始的给定天数内，骑士一共获得了多少金币。
n = int(input())
sum,t,coin_per,p = 0,0,0,0
while n > p:
t += 1
coin_per += 1
for i in range(t):
if n == p:
break
sum += coin_per
p += 1
print(sum)五、编程基础之数组(元组)
1、与指定数字相同的数的个数
题目描述
输出一个整数序列中与指定数字相同的数的个数。
输入格式
输入包含三行：
第一行为N，表示整数序列的长度(N <= 100)；
第二行为N个整数，整数之间以一个空格分开；
第三行包含一个整数，为指定的整数m。
输出格式
输出为N个数中与m相同的数的个数。
n = int(input())
t = tuple(map(int,input().split()))
m = int(input())
print(t.count(m))
样例输入
3
2 3 2
2
样例输出
22、陶陶摘苹果
陶陶家的院子里有一棵苹果树，每到秋天树上就会结出10个苹果。苹果成熟的时候，陶陶就会跑去摘苹果。陶陶有个30厘米高的板凳，当她不能直接用手摘到苹果的时候，就会踩到板凳上再试试。
现在已知10个苹果到地面的高度，以及陶陶把手伸直的时候能够达到的最大高度，请帮陶陶算一下她能够摘到的苹果的数目。假设她碰到苹果，苹果就会掉下来。
输入格式
输入包括两行数据。第一行包含10个100到200之间（包括100和200）的整数（以厘米为单位）分别表示10个苹果到地面的高度，两个相邻的整数之间用一个空格隔开。第二行只包括一个100到120之间（包含100和120）的整数（以厘米为单位），表示陶陶把手伸直的时候能够达到的最大高度。
输出格式
输出包括一行，这一行只包含一个整数，表示陶陶能够摘到的苹果的数目。
h = tuple(map(int,input().split()))
hand_h = int(input())
sum = 0
for i in h:
if i <= hand_h + 30:
sum += 1
print(sum)
样例输入
100 200 150 140 129 134 167 198 200 111
110
样例输出
53、计算书费
下面是一个图书的单价表：
计算概论 28.9 元/本
数据结构与算法 32.7 元/本
数字逻辑 45.6元/本
C++程序设计教程 78 元/本
人工智能 35 元/本
计算机体系结构 86.2 元/本
编译原理 27.8元/本
操作系统 43 元/本
计算机网络 56 元/本
JAVA程序设计 65 元/本
给定每种图书购买的数量，编程计算应付的总费用。
输入格式
输入一行，包含10个整数(大于等于0，小于等于100)，分别表示购买的《计算概论》、《数据结构与算法》、《数字逻辑》、《C++程序设计教程》、《人工智能》、《计算机体系结构》、《编译原理》、《操作系统》、《计算机网络》、《JAVA程序设计》的数量（以本为单位）。每两个整数用一个空格分开。
输出格式
输出一行，包含一个浮点数f，表示应付的总费用。精确到小数点后一位。
num = tuple(map(int,input().split()))
price = (28.9,32.7,45.6,78,35,86.2,27.8,43,56,65)
sum = 0
for i in range(len(price)):
sum += num[i]*price[i]
print("{:.1f}".format(sum))
样例输入
1 5 8 10 5 1 1 2 3 4
样例输出
2140.24、数组逆序重放
将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。
输入格式
输入为两行：第一行数组中元素的个数n（1<n<100)，第二行是n个整数，每两个整数之间用空格分隔。
输出格式
输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。
n = int(input())
arr = list(map(int,input().split()))
arr.reverse()
print("{}".format(" ".join(map(str,arr))))
样例输入
5
8 6 5 4 1
样例输出
1 4 5 6 8
注意:
arr.reverse() 方法会原地修改列表，而不会返回修改后的结果，所以 arr.reverse() 返回的是 None，而不是反转后的列表。
arr = arr.reverse() 这行代码将 arr 变量重新赋值为 None，因为 arr.reverse() 的返回值是 None，而不是反转后的列表。5、年龄与疾病
某医院想统计一下某项疾病的获得与否与年龄是否有关，需要对以前的诊断记录进行整理，按照0-18、19-35、36-60、61以上（含61）四个年龄段统计的患病人数占总患病人数的比例。
输入格式
共2行，第一行为过往病人的数目n（0 < n <= 100)，第二行为每个病人患病时的年龄。
输出格式
按照0-18、19-35、36-60、61以上（含61）四个年龄段输出该段患病人数占总患病人数的比例，以百分比的形式输出，精确到小数点后两位。每个年龄段占一行，共四行。
n = int(input())
arr = list(map(int,input().split()))
num = [0]*4
for i in arr:
if 0 <= i <= 18:
num[0]+=1
elif 19 <= i <= 35:
num[1]+=1
elif 36 <= i <=60:
num[2]+=1
else:
num[3]+=1
for i in range(4):
print("{:.2f}%".format(num[i]*100/n))
样例输入
10
1 11 21 31 41 51 61 71 81 91
样例输出
20.00%
20.00%
20.00%
40.00%6、校门外的树
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。
由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。
输入格式
输入的第一行有两个整数L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。
输出格式
输出包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。
L,M = map(int,input().split())
tree = [1 for _ in range(L+1)] #定义一个列表，列表元素的个数为马路的宽度，将里面的元素赋值为1
for i in range(M):
x = list(map(int,input().split()))
for j in range(x[0],x[1]+1):
tree[j] = 0 #将区域范围内的列表元素值改为0
print(sum(tree)) #之后给列表中所有元素求和，即是剩余的树
样例输入
500 3
150 300
100 200
470 471
样例输出
2987、有趣的跳跃
一个长度为n（n>0）的序列中存在“有趣的跳跃”当前仅当相邻元素的差的绝对值经过排序后正好是从1到(n-1)。例如，1 4 2 3存在“有趣的跳跃”，因为差的绝对值分别为3,2,1。当然，任何只包含单个元素的序列一定存在“有趣的跳跃”。你需要写一个程序判定给定序列是否存在“有趣的跳跃”。
输入格式
一行，第一个数是n（0 < n < 3000），为序列长度，接下来有n个整数，依次为序列中各元素，各元素的绝对值均不超过1,000,000,000。
输出格式
一行，若该序列存在“有趣的跳跃”，输出"Jolly"，否则输出"Not jolly"。
# 注意，可以分一行或两行输入
choose = input().split()
if len(choose) == 1:
n = int(choose[0])
arr = list(map(int, input().split()))
arr2 = []
for i in range(n - 1):
if abs(arr[i] - arr[i + 1]) >= 1:
arr2.append(abs(arr[i] - arr[i + 1]))
arr2.sort()
for j in range(n - 1):
if arr2[j] == j + 1:
continue
else:
print("Not jolly")
quit()
print("Jolly")
else:
arr = list(map(int, choose))
arr2 = []
for i in range(1, arr[0]):
if abs(arr[i] - arr[i+1]) >= 1:
arr2.append(abs(arr[i] - arr[i+1]))
arr2.sort()
for j in range(arr[0] - 1):
if arr2[j] == j + 1:
continue
else:
print("Not jolly")
quit()
print("Jolly")
样例输入
4 1 4 2 3
样例输出
Jolly8、石头剪刀布
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。
一天，小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。
N, NA, NB = map(int, input().split())
numA = list(map(int, input().split()))
numB = list(map(int, input().split()))
num = []
numA1 = numA * (int(N / NA) + 1)
numB1 = numB * (int(N / NB) + 1)
n1, n2, n3 = 0, 0, 0
for i in range(N):
num.append((numA1[i],numB1[i]))
a, b = num[i]
if (a == 0 and b == 2) or (a == 2 and b == 5) or (a == 5 and b == 0):
n1 += 1
elif (a == 0 and b == 5) or (a == 2 and b == 0) or (a == 5 and b == 2):
n2 += 1
else:
n3 += 1
if n1 > n2:
print("A")
elif n1 < n2:
print("B")
else:
print("draw")
样例输入
10 3 4
0 2 5
0 5 0 2
样例输出
A9、向量点积计算
在线性代数、计算几何中，向量点积是一种十分重要的运算。
给定两个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。
输出格式
一个整数，即两个向量的点积结果。
n = int(input())
num1 = list(map(int,input().split()))
num2 = list(map(int,input().split()))
sum = 0
for i in range(n):
sum += num1[i]*num2[i]
print(sum)
样例输入
3
1 4 6
2 1 5
样例输出
3610、大整数加法
求两个不超过200位的非负整数的和。
输入格式
有两行，每行是一个不超过200位的非负整数，可能有多余的前导0。
输出格式
一行，即相加后的结果。结果里不能有多余的前导0，即如果结果是342，那么就不能输出为0342。
n1 = int(input())
n2 = int(input())
print("{}".format(int(n1+n2)))
样例输入
22222222222222222222
33333333333333333333
样例输出
5555555555555555555511、大整数减法
求两个大的正整数相减的差。
输入格式
共2行，第1行是被减数a，第2行是减数b(a > b)。每个大整数不超过200位，不会有多余的前导零。
输出格式
一行，即所求的差。
n1 = int(input())
n2 = int(input())
print("{}".format(int(n1-n2)))
样例输入
9999999999999999999999999999999999999
9999999999999
样例输出
999999999999999999999999000000000000012、计算2的N次方
任意给定一个正整数N(N<=100)，计算2的N次方的值。
输入格式
输入一个正整数N。
输出格式
输出2的N次方的值。
n = int(input())
print("{}".format(pow(2,n)))
样例输入
5
样例输出
3213、大整数的因子
已知正整数k满足2<=k<=9，现给出长度最大为30位的十进制非负整数c，求所有能整除c的k。
输入格式
一个非负整数c，c的位数<=30。
输出格式
若存在满足 c%k == 0 的k，从小到大输出所有这样的k，相邻两个数之间用单个空格隔开；若没有这样的k，则输出"none"。
c = int(input())
num = []
for k in range(2,10):
if c % k == 0:
num.append(k)
if len(num) == 0:
print("none")
else:
for i in num:
print("{}".format(i),end=" ")
法二:
n = int(input())
a = True
for i in range(2, 10):
if n % i == 0:
print(i,end=" ")
a = False
if a:
print("none")
样例输入
30
样例输出
2 3 5 6
14、求10000以内n的阶乘。
求10000以内n的阶乘。
输入格式
只有一行输入，整数n（0<=n<=10000）。
输出格式
一行，即n!的值。
n = int(input())
sum = 1
if n == 0:
print(0)
else:
for i in range(1,n+1):
sum *= i
print(sum)六、编程基础之字符串
1、统计数字字符个数
输入一行字符，统计出其中数字字符的个数。
输入格式
一行字符串，总长度不超过255。
输出格式
输出为1行，输出字符串里面数字字符的个数。
s = input()
sum = 0
for i in s:
if i.isdigit(): # 判断字符是否是数字
sum += 1
print(sum)
样例输入
Peking University is set up at 1898.
样例输出
42、找第一个只出现一次的字符
给定一个只包含小写字母的字符串，请你找到第一个仅出现一次的字符。如果没有，输出no。
输入格式
一个字符串，长度小于100000。
输出格式
输出第一个仅出现一次的字符，若没有则输出no
s = input()
for i in s:
if s.count(i) == 1:
print(i)
break
else:
print("no")
样例输入
abcabd
样例输出
c3、基因相关性
为了获知基因序列在功能和结构上的相似性，经常需要将几条不同序列的DNA进行比对，以判断该比对的DNA是否具有相关性。
现比对两条长度相同的DNA序列。首先定义两条DNA序列相同位置的碱基为一个碱基对，如果一个碱基对中的两个碱基相同的话，则称为相同碱基对。接着计算相同碱基对占总碱基对数量的比例，如果该比例大于等于给定阈值时则判定该两条DNA序列是相关的，否则不相关。
输入格式
有三行，第一行是用来判定出两条DNA序列是否相关的阈值，随后2行是两条DNA序列（长度不大于500）。
输出格式
若两条DNA序列相关，则输出“yes”，否则输出“no”。
法一:
n = float(input())
num1 = input()
num2 = input()
sum = 0
for a,b in zip(num1,num2): # 将num1,num2对应的元素打包成一个元组形式,如('T','T')
if a == b:
sum += 1
a = sum/len(num1)
if a >= n:
print("yes")
else:
print("no")
法二: 运行会出现运行错误，是访问字符串的方式有问题
n = float(input())
num1 = input()
num2 = input()
sum = 0
if len(num1) == 0:
print("no")
else:
for i in range(len(num1)):
if num1[i] == num2[i]:
sum += 1
if sum/len(num1) >= n:
print("yes")
else:
print("no")
样例输入
0.85
ATCGCCGTAAGTAACGGTTTTAAATAGGCC
ATCGCCGGAAGTAACGGTCTTAAATAGGCC
样例输出
yes4、石头剪子布
石头剪子布，是一种猜拳游戏。起源于中国，然后传到日本、朝鲜等地，随着亚欧贸易的不断发展它传到了欧洲，到了近现代逐渐风靡世界。简单明了的规则，使得石头剪子布没有任何规则漏洞可钻，单次玩法比拼运气，多回合玩法比拼心理博弈，使得石头剪子布这个古老的游戏同时用于“意外”与“技术”两种特性，深受世界人民喜爱。
游戏规则：石头打剪刀，布包石头，剪刀剪布。
现在，需要你写一个程序来判断石头剪子布游戏的结果。
输入格式
输入包括N+1行：
第一行是一个整数N，表示一共进行了N次游戏。1 <= N <= 100。
接下来N行的每一行包括两个字符串，表示游戏参与者Player1，Player2的选择（石头、剪子或者是布）：
S1 S2
字符串之间以空格隔开S1,S2只可能取值在{"Rock", "Scissors", "Paper"}（大小写敏感）中。
输出格式
输出包括N行，每一行对应一个胜利者（Player1或者Player2），或者游戏出现平局，则输出Tie。
N = int(input())
for i in range(N):
a,b = map(str,input().split())
if (a == 'Rock' and b == 'Scissors')or(a == 'Scissors' and b == 'Paper')or(a == 'Paper' and b=='Rock'):
print("Player1")
elif (a == 'Rock' and b == 'Paper')or(a == 'Scissors' and b == 'Rock')or(a == 'Paper' and b=='Scissors'):
print("Player2")
else:
print("Tie")
样例输入
3
Rock Scissors
Paper Paper
Rock Paper
样例输出
Player1
Tie
Player25、输出亲朋字符串
编写程序，求给定字符串s的亲朋字符串s1。
亲朋字符串s1定义如下：给定字符串s的第一个字符的ASCII值加第二个字符的ASCII值，得到第一个亲朋字符； 给定字符串s的第二个字符的ASCII值加第三个字符的ASCII值，得到第二个亲朋字符；依此类推，直到给定字符串s的倒数第二个字符。亲朋字符串的最 后一个字符由给定字符串s的最后一个字符ASCII值加s的第一个字符的ASCII值。
输入格式
输入一行，一个长度大于等于2，小于等于100的字符串。字符串中每个字符的ASCII值不大于63。
输出格式
输出一行，为变换后的亲朋字符串。输入保证变换后的字符串只有一行。
s = input()
num = []
for i in range(1,len(s)):
num.append(chr(ord(s[i])+ord(s[i-1])))
num.append(chr(ord(s[0])+ord(s[-1])))
print("{}".format(''.join(num)))
法二:
s = input()
s1 = ''
for i in range(len(s)):
s1 += chr(ord(s[i])+ord(s[(i+1)%len(s)]))
print(s1)
样例输入
1234
样例输出
cege6、合法C标识符
给定一个不包含空白符的字符串，请判断是否是C语言合法的标识符号（注：题目保证这些字符串一定不是C语言的保留字）。
C语言标识符要求：
1. 非保留字；
2. 只包含字母、数字及下划线（“_”）；
3. 不以数字开头。
输入格式
一行，包含一个字符串，字符串中不包含任何空白字符，且长度不大于20。
输出格式
一行，如果它是C语言的合法标识符，则输出yes，否则输出no。
法一:正则表达式
import re
s = input()
a = re.findall(r"\w*",s) #如果符合，返回列表形式，但会有一个空元素
b = re.match(r"^[a-zA-Z_]",s) #如果不符合，返回None
if len(a) == 2 and b != None:
print("yes")
else:
print("no")
法二:
s = input()
for i in s:
if s[0].isdigit():
print("no")
quit()
elif i.isalnum() or i == '_':
continue
else:
print("no")
quit()
print("yes")
样例输入
RKPEGX9R;TWyYcp
样例输出
no7、配对碱基链
脱氧核糖核酸（DNA）由两条互补的碱基链以双螺旋的方式结合而成。而构成DNA的碱基共有4种，分别为腺瞟呤（A）、鸟嘌呤（G）、胸腺嘧啶（T）和胞嘧啶（C）。我们知道，在两条互补碱基链的对应位置上，腺瞟呤总是和胸腺嘧啶配对，鸟嘌呤总是和胞嘧啶配对。你的任务就是根据一条单链上的碱基序列，给出对应的互补链上的碱基序列。
输入格式
一个字符串，表示一条碱基链。这个字符串只含有大写字母A、T、G、C，分别表示腺瞟呤、胸腺嘧啶、鸟嘌呤和胞嘧啶。字符串长度不超过255。
输出格式
一个只含有大写字母A、T、G、C的字符串，为与输入的碱基链互补的碱基链。
s = input()
num = []
for i in s:
if i == 'A':
num.append('T')
elif i == 'T':
num.append('A')
elif i == 'C':
num.append('G')
elif i == 'G':
num.append('C')
print("{}".format(''.join(num)))
样例输入
ATATGGATGGTGTTTGGCTCTG
样例输出
TATACCTACCACAAACCGAGAC8、字符替换
把一个字符串中特定的字符全部用给定的字符替换，得到一个新的字符串。
输入格式
只有一行，由一个字符串和两个字符组成，中间用单个空格隔开。字符串是待替换的字符串，字符串长度小于等于30个字符，且不含空格等空白符；
接下来一个字符为需要被替换的特定字符；
接下来一个字符为用于替换的给定字符。
输出格式
一行，即替换后的字符串。
n,a,b=map(str,input().split())
print(n.replace(a,b))
样例输入
hello-how-are-you o O
样例输出
hellO-hOw-are-yOu9、密码翻译
在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y，A-Y的字母用其后继字母替代，把z和Z用a和A替代，其他非字母字符不变，则可得到一个简单的加密字符串。
输入格式
输入一行，包含一个字符串，长度小于80个字符。
输出格式
输出每行字符串的加密字符串。
法一:91分，编译不完全通过
s = input()
num1 = "abcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWSY"
num = []
for i in s:
if i == 'z':
num.append('a')
elif i == 'Z':
num.append('A')
elif i in num1:
num.append(chr(ord(i)+1))
else:
num.append(i)
print("{}".format(''.join(num)))
法二：100 尽量在原字符串在修改，因为不知道结尾会漏掉什么
s = list(input())
for i in range(len(s)):
if s[i] == 'z':
s[i] = 'a'
continue
elif s[i] == 'Z':
s[i] = 'A'
continue
if 65 <= ord(s[i]) <= 89 or 97 <= ord(s[i]) <= 121:
s[i] = chr(ord(s[i]) + 1)
print(''.join(s))
样例输入
Hello! How are you!
样例输出
Ifmmp! Ipx bsf zpv!
10、简单密码
Julius Caesar曾经使用过一种很简单的密码。对于明文中的每个字符，将它用它字母表中后5位对应的字符来代替，这样就得到了密文。比如字符A用F来代替。如下是密文和明文中字符的对应关系。
密文
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
明文
V W X Y Z A B C D E F G H I J K L M N O P Q R S T U
你的任务是对给定的密文进行解密得到明文。
你需要注意的是，密文中出现的字母都是大写字母。密文中也包括非字母的字符，对这些字符不用进行解码。
输入格式
一行，给出密文，密文不为空，而且其中的字符数不超过200。
输出格式
输出一行，即密文对应的明文。
s = list(input())
for i in range(len(s)):
if 70 <= ord(s[i]) <= 90:
s[i] = chr(ord(s[i])-5)
elif 65 <= ord(s[i]) <= 69:
s[i] = chr(ord(s[i])-5+26)
print(''.join(s))
样例输入
NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX
样例输出
IN WAR, EVENTS OF IMPORTANCE ARE THE RESULT OF TRIVIAL CAUSES11、潜伏者(*)
R国和S国正陷入战火之中，双方都互派间谍，潜入对方内部，伺机行动。
历经艰险后，潜伏于S国的R国间谍小C终于摸清了S国军用密码的编码规则：
1、S国军方内部欲发送的原信息经过加密后在网络上发送，原信息的内容与加密后所的内容均由大写字母‘A’—‘Z’构成（无空格等其他字母）。
2、S国对于每个字母规定了对应的“密字”。加密的过程就是将原信息中的所有字母替换为其对应的“密字”。
3、每个字母只对应一个唯一的“密字”，不同的字母对应不同的“密字”。“密字”可以和原字母相同。
例如，若规定‘A’的密字为‘A’，‘B’的密字为‘C’（其他字母及密字略），则原信息“ABA”被加密为“ACA”。
现在，小C通过内线掌握了S国网络上发送的一条加密信息及其对应的原信息。小C希望能通过这条信息，破译S国的军用密码。小C的破译过程是这样的：扫描原信息，对于原信息中的字母x（代表任一大写字母），找到其在加密信息中的对应大写字母y，并认为在密码里y是x的密字。如此进行下去直到停止于如下的某个状态：
1、所有信息扫描完毕，‘A’—‘Z’所有26个字母在原信息中均出现过并获得了相应的“密字”。
2、所有信息扫描完毕，但发现存在某个（或某些）字母在原信息中没有出现。
3、扫描中发现掌握的信息里有明显的自相矛盾或错误（违反S过密码的编码规则）。例如某条信息“XYZ”被翻译为“ABA”就违反了“不同字母对应不同密字”的规则。
在小C忙得头昏脑胀之际，R国司令部又发来电报，要求他翻译另外一条从S国刚刚截取到的加密信息。现在请你帮助小C：通过内线掌握的信息，尝试破译密码。然后利用破译的密码，翻译电报中的加密信息。
输入格式
共3行，每行为一个长度在1到100之间的字符串。
第1行为小C掌握的一条加密信息。
第2行为第1行的加密信息所对应的原信息。
第3行为R国司令部要求小C翻译的加密信息。
输入数据保证所有字符串仅由大写字母‘A’—‘Z’构成，且第1行长度与第2行相等。
输出格式
共1行。
若破译密码停止时出现2，3两种情况，请你输出“Failed”（不含引号，注意首字母大写，其它小写）。
否则请输出利用密码翻译电报中加密信息后得到的原信息。
s1 = input().strip()
s2 = input().strip()
s3 = input().strip()
num = []
num1 = []
# 构建密码字典
dict = {}
for i in range(len(s1)):
dict.setdefault(s1[i],s2[i]) #创建字典
num.append((s1[i],s2[i]))
for i in range(len(s1)):
a1,b1 = num[i]
for j in range(len(s2)):
a2,b2 = num[j]
if a1 == a2 and b1 != b2: #判断是否一一对应，如果否，则退出
print("Failed")
quit()
if len(dict) != 26:
print("Failed")
quit()
# 执行上述代码没有退出，则有密码字典
for i in s3:
if i in dict.keys():
num1.append(dict.get(i))
print("{}".format("".join(num1)))
样例输入
AA
AB
EOWIE
样例输出
Failed12、加密的病历单
小英是药学专业大三的学生，暑假期间获得了去医院药房实习的机会。
在药房实习期间，小英扎实的专业基础获得了医生的一致好评，得知小英在计算概论中取得过好成绩后，主任又额外交给她一项任务，解密抗战时期被加密过的一些伤员的名单。
经过研究，小英发现了如下加密规律（括号中是一个“原文 -> 密文”的例子）
1. 原文中所有的字符都在字母表中被循环左移了三个位置（dec -> abz）
2. 逆序存储（abcd -> dcba ）
3. 大小写反转（abXY -> ABxy）
输入格式
一个加密的字符串。（长度小于50且只包含大小写字母）
输出格式
输出解密后的字符串。
s = input().strip()
s = s.swapcase()
s = list(s)
for i in range(len(s)):
if (65 <= ord(s[i]) <= 87) or (97 <= ord(s[i]) <= 119):
s[i] = chr(ord(s[i])+3)
elif (88 <= ord(s[i]) <= 90) or (120 <= ord(s[i]) <= 122):
s[i] = chr(ord(s[i])-26+3)
s.reverse()
print("{}".format("".join(s)))
样例输入
GSOOWFASOq
样例输出
Trvdizrrvj13、大小写转换
读入一些字符串，将其中的小写字母转成大写字母（其他字符不变）。
输入格式
输入为多行，每行为一个字符串，字符串只由字母和数字组成，长度不超过80。输入以“End of file”结束。
输出格式
对于每行输入，输出转换后的字符串
while True:
s = input().strip()
if s == "End of file":
quit()
print("{}".format(s.upper()))
样例输入
Hello
ICPC2004
12345abcde
样例输出
HELLO
ICPC2004
12345ABCDE14、蓝桥杯算法训练-大小写转换
编写一个程序，输入一个字符串（长度不超过20），然后把这个字符串内的每一个字符进行大小写变换，即将大写字母变成小写，小写字母变成大写，然后把这个新的字符串输出。
输入格式
输入一个字符串，而且这个字符串当中只包含英文字母，不包含其他类型的字符，也没有空格。
输出格式
输出经过转换后的字符串。
s = input()
s = s.swapcase()
print(s)
样例输入
AeDb
样例输出
aEdB15、整理药名
医生在书写药品名的时候经常不注意大小写，格式比较混乱。现要求你写一个程序将医生书写混乱的药品名整理成统一规范的格式，即药品名的第一个字符如果是字母要大写，其他字母小写。如将ASPIRIN、aspirin整理成Aspirin。
输入格式
第一行一个数字n，表示有n个药品名要整理，n不超过100。
接下来n行，每行一个单词，长度不超过20，表示医生手书的药品名。药品名由字母、数字和-组成。
输出格式
n行，每行一个单词，对应输入的药品名的规范写法。
n = int(input())
for _ in range(n):
s = input()
s = s.lower()
s = list(s)
for i in range(len(s)):
if s[0].isalpha():
s[0] = s[0].upper()
print("".join(s))
法二: 注意，字符串是不可变的，不能直接在原字符串上修改字符
n = int(input())
for _ in range(n):
s = input()
s = s.lower()
if s[0:1].isalpha():
s = s[0:1].upper() + s[1:]
print(s)
样例输入
4
AspiRin
cisapride
2-PENICILLIN
Cefradine-6
样例输出
Aspirin
Cisapride
2-penicillin
Cefradine-616、字符串判等
判断两个由大小写字母和空格组成的字符串在忽略大小写，且忽略空格后是否相等。
输入格式
两行，每行包含一个字符串。
输出格式
若两个字符串相等，输出YES，否则输出NO。
s1 = input().strip()
s2 = input().strip()
s1 = s1.lower()
s2 = s2.lower()
num1,num2 = [],[]
for i in s1:
if i.isspace():
continue
num1.append(i)
for i in s2:
if i.isspace():
continue
num2.append(i)
s1 = ''.join(num1)
s2 = ''.join(num2)
if s1 == s2:
print("YES")
else:
print("NO")
样例输入
a A bb BB ccc CCC
Aa BBbb CCCccc
样例输出
YES17、验证子串
输入两个字符串，验证其中一个串是否为另一个串的子串。
输入格式
输入两个字符串， 每个字符串占一行，长度不超过200且不含空格。
输出格式
若第一个串s1是第二个串s2的子串，则输出(s1) is substring of (s2)；
否则，若第二个串s2是第一个串s1的子串，输出(s2) is substring of (s1)；
否则，输出 No substring。
s1 = input().strip()
s2 = input().strip()
if s1 in s2:
print("{} is substring of {}".format(s1,s2))
elif s2 in s1:
print("{} is substring of {}".format(s2,s1))
else:
print("No substring")
样例输入
abc
dddncabca
样例输出
abc is substring of dddncabca18、字符串移位包含问题
对于一个字符串来说，定义一次循环移位操作为：将字符串的第一个字符移动到末尾形成新的字符串。
给定两个字符串s1和s2，要求判定其中一个字符串是否是另一字符串通过若干次循环移位后的新字符串的子串。例如CDAA是由AABCD两次移位后产生的新串BCDAA的子串，而ABCD与ACBD则不能通过多次移位来得到其中一个字符串是新串的子串。
输入格式
一行，包含两个字符串，中间由单个空格隔开。字符串只包含字母和数字，长度不超过30。
输出格式
如果一个字符串是另一字符串通过若干次循环移位产生的新串的子串，则输出true，否则输出false。
s = list(map(str,input().split()))
if len(s) == 2:
s1,s2 = s[0],s[1]
else:
s1 = s[0]
s2 = input()
n = 0
if len(s1) < len(s2): #确保s2是s1的字串
s1,s2 = s2,s1
while n < len(s1):
if s2 in s1:
print("true")
quit()
s1 = s1[1:] + s1[0:1]
n += 1
print("false")
样例输入
AABCD CDAA
样例输出
true
19、删除单词后缀
给定一个单词，如果该单词以er、ly或者ing后缀结尾， 则删除该后缀（题目保证删除后缀后的单词长度不为0）， 否则不进行任何操作。
输入格式
输入一行，包含一个单词（单词中间没有空格，每个单词最大长度为32）。
输出格式
输出按照题目要求处理后的单词。
s = input()
if (s[len(s)-2:] == "er") or (s[len(s)-2:] == "ly"):
s = s[:len(s)-2]
elif s[len(s)-3:] == 'ing':
s = s[:len(s)-3]
print(s)
法二:
s = input()
if s.endswith("er") or s.endswith("ly"):
s = s[:-2]
elif s.endswith("ing"):
s = s[:-3]
print(s)
样例输入
referer
样例输出
refer20、单词替换
输入一个字符串，以回车结束（字符串长度<=100）。该字符串由若干个单词组成，单词之间用一个空格隔开，所有单词区分大小写。现需要将其中的某个单词替换成另一个单词，并输出替换之后的字符串。
输入格式
输入包括3行，
第1行是包含多个单词的字符串 s;
第2行是待替换的单词a(长度 <= 100);
第3行是a将被替换的单词b(长度 <= 100)。
s, a, b 最前面和最后面都没有空格。
输出格式
输出只有 1 行，将s中所有单词a替换成b之后的字符串。
# 我服了，明明题目说a,b前后是没有空格的，但是去掉.strip()直接答案错误，只能说题目歧义很大，看来以后都得去一下前后空白符了
s = list(map(str,input().split()))
a = input().strip()
b = input().strip()
c = [b if a == i else i for i in s]
print(" ".join(c))
样例输入
You want someone to help you
You
I
样例输出
I want someone to help you21、紧急措施
近日，一些热门网站遭受黑客入侵，这些网站的账号、密码及email的数据惨遭泄露。你在这些网站上注册若干账号（使用的用户名不一定相同），但是注册时使用了相同的email。你此时拿到了那份泄露的数据，希望尽快将自己的密码更改。策略如下：根据email找到你的用户名和密码，然后更改密码。更改的规则为：小写和大写交换，非字母字符保持不变。
输入格式
第一行为你的email地址，长度不超过50个字符且只包含字母、数字和‘@’符号。
第二行为账号数N，N(0 < N < 10000)。
接下来N行，每行表示一个账号，格式为：
用户名 密码 email
它们之间用单个空格分开。用户名、密码、email均不含空格，且长度不超过50个字符。
输出格式
有若干行，每行为你的一个账号，包括：你的账号，修改后的密码（之间用单个空格分隔）。
如果没有你的账号，则输出empty。
s = input().strip()
n = int(input())
flag = 0
for i in range(n):
s1,s2,s3 = map(str,input().split())
if s3 == s:
s2 = s2.swapcase()
print("{} {}".format(s1,s2))
flag = 1
if flag == 0:
print("empty")
样例输入
abc@pku.edu.cn
5
helloKitty iLoveCats abc@pku.edu.cn
2012 maya2012 cplusplus@exam.com
KittyCat 5iKitty abc@pku.edu.cn
program password teacher@exam.com
whoAmi Feb.29$ abc@pku.edu.cn
样例输出
helloKitty IlOVEcATS
KittyCat 5IkITTY
whoAmi fEB.29$22、过滤多余的空格
一个句子中也许有多个连续空格，过滤掉多余的空格，只留下一个空格。
输入格式
一行，一个字符串（长度不超过200），句子的头和尾都没有空格。
输出格式
过滤之后的句子。
s = list(input().strip().split())
print(' '.join(s))
样例输入
Hello world.This is c language.
样例输出
Hello world.This is c language.23、单词的长度
输入一行单词序列，相邻单词之间由1个或多个空格间隔，请对应地计算各个单词的长度。
注意，如果有标点符号（如连字符，逗号），标点符号算作与之相连的词的一部分。没有被空格间开的符号串，都算作单词。
输入格式
一行单词序列，最少1个单词，最多300个单词，单词之间用至少1个空格间隔。单词序列总长度不超过1000。
输出格式
依次输出对应单词的长度，之间以逗号间隔。
s = list(map(str,input().strip().split()))
for i in range(len(s)):
s[i] = len(s[i])
print("{}".format(",".join(map(str,s)))) #别忘了join()用的是字符串类型数据
法二:
s = list(input().strip().split())
l = [str(len(i)) for i in s]
print(",".join(l))
样例输入
She was born in 1990-01-02 and from Beijing city.
样例输出
3,3,4,2,10,3,4,7,524、最长最短单词
输入1行句子（不多于200个单词，每个单词长度不超过100），包含字母、空格、逗号、引号等。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。
试输出第1个最长的单词和第1个最短单词。
输入格式
一行句子。
输出格式
两行输出：
第1行，第一个最长的单词。
第2行，第一个最短的单词。
法一: 91分
s = input().strip()
s = s.replace(","," ")
s = list(s.split())
s1 = [len(i) for i in s]
print("{}".format(s[s1.index(max(s1))]))
print("{}".format(s[s1.index(min(s1))]))
法二:100
"""
莫名其妙，输入I,am studying Programming language C in Peking University
应该是输出
Programming
I
而你这是输出
Programming
C
真搞不懂是咋通过的
"""
s = input().split() #split()会使分割后的字符以列表得形式存储
l = max(s,key = len)
s = min(s,key = len)
print(l)
print(s)
样例输入
I am studying Programming language C in Peking University
样例输出
Programming
I25、字符串最大跨距
有三个字符串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。
法一:100
S, S1, S2 = map(str, input().split(","))
if S.find(S1) == -1 or S.find(S2) == -1:
print(-1)
else:
print(len(S[S.find(S1) + len(S1):S.rfind(S2)]))
法二:78
n = list(input().split(","))
s,s1,s2 = n[0],n[1],n[2]
def find(string, substring):
indexes = []
start = 0
while True:
index = string.find(substring, start)
if index == -1:
break
indexes.append(index)
start = index + len(substring)
return indexes
num1 = find(s,s1)
num2 = find(s,s2)
if num2[-1] - num1[0] < len(s1):
print(-1)
else:
print(num2[-1] - num1[0] - len(s1))
输出格式
S1和S2在S最大跨距；若在S中没有满足条件的S1和S2，则输出-1。
样例输入
abcd123ab888efghij45ef67kl,ab,ef
样例输出
18
26、单词翻转
输入一个句子（一行），将句子中的每一个单词翻转后输出。
输入格式
只有一行，为一个字符串，不超过500个字符。单词之间以空格隔开。
输出格式
翻转每一个单词后的字符串，单词之间的空格需与原文一致。
s = list(input().split())
num = []
for i in s:
num.append(i[::-1])
print("{}".format(" ".join(num)))
样例输入
hello world
样例输出
olleh dlrow27、单词倒排
编写程序，读入一行英文(只包含字母和空格，单词间以单个空格分隔)，将所有单词的顺序倒排并输出，依然以单个空格分隔。
输入格式
输入为一个字符串（字符串长度至多为100）。
输出格式
输出为按要求排序后的字符串。
s = input().strip()
num = []
s = s[::-1]
s = s.split()
for i in s:
num.append(i[::-1])
print("{}".format(" ".join(num)))
样例输入
I am a student
样例输出
student a am I28、ISBN码
每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”就是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔符后的五位数字代表该书在该出版社的编号；最后一位为识别码。
识别码的计算方法如下：
首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，...,9,再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
你的任务是编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出你认为是正确的ISBN号码。
输入格式
输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。
输出格式
输出共一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。
法一：63，不知道哪里有问题,可能是输入时有识别码有10的，但是法二却没有相应的判断又可以通过，怪哉
while True:
try:
s = input().strip()
n,sum = 1,0
for i in s[:-1]:
if i.isdigit():
sum += int(i) * n
n += 1
if sum % 11 == int(s[-1]):
print("Right")
elif sum % 11 == 10:
print("{}".format(s[:-1] + "X"))
else:
print("{}".format(s[:-1] + str(sum%11)))
except:
break
法二:100
while True:
try:
raw = input()
s = ''.join(raw.split('-'))
id = 0
for i in range(len(s)-1):
id += int(s[i]) * (i + 1)
id %= 11
id = str(id)
if id == '10':
id = 'X'
if id == s[-1]:
print('Right')
else:
print(raw[:-1] + id)
except:
break
样例输入
0-670-82162-4
0-670-82162-0
样例输出
Right
0-670-82162-429、字符环
有两个由字符构成的环。请写一个程序，计算这两个字符环上最长连续公共字符串的长度。例如，字符串“ABCEFAGADEGKABUVKLM”的首尾连在一起，构成一个环；字符串“MADJKLUVKL”的首尾连在一起，构成一个另一个环；“UVKLMA”是这两个环的一个连续公共字符串。
输入格式
一行，包含两个字符串，分别对应一个字符环。这两个字符串之间用单个空格分开。字符串长度不超过255，且不包含空格等空白符。
输出格式
输出一个整数，表示这两个字符环上最长公共字符串的长度。
法一:36分
s1,s2 = map(str,input().split())
a = min(len(s1),len(s2))
if s1 == s2:
print(len(s1))
else:
s1 = s1 + s1
s2 = s2 + s2
start,sum = 0,0
num = []
for i in range(len(s1)):
for j in range(start,len(s2)):
if s1[i:i+1] == s2[j:j+1]:
sum += 1
start = j+1
break
else:
start = 0
num.append(sum)
sum = 0
if sum > a:
sum = a
num.append(sum)
print(max(num))
法二：100
l=list(input().split())
l1=l[0]+l[0]
l2=l[1]+l[1]#之前都不会这个，原来可以这样搞
la=len(l[0])
lb=len(l[1])
ans=0
mn=min(la,lb)
for i in range(la):
for j in range(lb):
x=i
y=j
le=1#这里要注意，++里面直接用x++y++直接等于零，这里用的多个条件下面，所以
while l1[x]==l2[y] and l1[x+1]==l2[y+1] and le<mn:
le+=1
x+=1#这里也是要自己+1才能自己往前
y+=1
if le>ans:#之前还以为计数的位置错了其实没有，最重要的其实就是上面这块
ans=le
print(ans)
样例输入
ABCEFAGADEGKABUVKLM MADJKLUVKL
样例输出
630、字符串p型编码（*）
给定一个完全由数字字符（'0','1','2',…,'9'）构成的字符串str，请写出str的p型编码串。例如：字符串122344111可被描述为"1个1、2个2、1个3、2个4、3个1"，因此我们说122344111的p型编码串为1122132431；类似的道理，编码串101可以用来描述1111111111；00000000000可描述为"11个0"，因此它的p型编码串即为110；100200300可描述为"1个1、2个 0、1个2、2个0、1个3、2个0"，因此它的p型编码串为112012201320。
输入格式
输入仅一行，包含字符串str。每一行字符串最多包含1000个数字字符。
输出格式
输出该字符串对应的p型编码串。
s = input().strip()
s1 = ''
t = 1
for i in range(len(s)-1):
if s[i] == s[i+1]:
t += 1
else:
s1 += str(t) + s[i]
t = 1
if i == len(s) - 2: # 最后一个字符手动添加
s1 += str(t) + s[i+1]
print(s1)
样例输入
122344111
样例输出
112213243131、行程长度编码
在数据压缩中，一个常用的途径是行程长度压缩。对于一个待压缩的字符串而言，我们可以依次记录每个字符及重复的次数。这种压缩，对于相邻数据重复较多的情况比较有效。 例如，如果待压缩串为"AAABBBBCBB"，则压缩的结果是(A,3)(B,4)(C,1)(B,2)。当然，如果相邻字符重复情况较少，则压缩效率就较低。
现要求根据输入的字符串，得到大小写不敏感压缩后的结果（即所有小写字母均视为相应的大写字母）。
输入格式
一个字符串，长度大于0，且不超过1000，全部由大写或小写字母组成。
输出格式
输出为一行，表示压缩结果，形式为：
(A,3)(B,4)(C,1)(B,2)
即每对括号内部分别为字符（都为大写）及重复出现的次数，不含任何空格。
s = input().strip()
s = s.upper()
num = []
t = 1
for i in range(len(s) - 1):
if s[i] == s[i+1]:
t += 1
else:
num.append((s[i],t))
t = 1
if i == len(s) - 2:
num.append((s[i+1],t))
for i in num:
a,b = i
print("({},{})".format(a,b),end = "")
样例输入
aAABBbBCCCaaaaa
样例输出
(A,3)(B,4)(C,3)(A,5)32、回文串
回文串是从左到右或者从右到左读起来都一样的字符串，试编程判别一个字符串是否为回文串。
输入格式
输入一个字符串。串长度<255.
输出格式
判别输入的字符串是否为回文串，是输出"Y",否则输出"N"。
s = input().strip()
if s == s[::-1]:
print("Y")
else:
print("N")
样例输入
abcba
样例输出
Y33、回文子串
给定一个字符串，输出所有长度至少为2的回文子串。
回文子串即从左往右输出和从右往左输出结果是一样的字符串，比如：abba，cccdeedccc都是回文字符串。
输入格式
一个字符串，由字母或数字组成。长度500以内。
输出格式
输出所有的回文子串，每个子串一行。
子串长度小的优先输出，若长度相等，则出现位置靠左的优先输出。
s = input().strip()
num,num1 = [],[]
n = 2
for i in range(len(s)):
for j in range(i,len(s)+1):
s1 = s[i:j]
if s1 == s1[::-1] and len(s1) >= 2:
num.append(s1)
while n < len(num):
for i in num:
if len(i) == n:
print(i)
n += 134、字符串展开
在初赛普及组的“阅读程序写结果”的问题中，我们曾给出一个字符串展开的例子：如果在输入的字符串中，含有类似于“d-h”或“4-8”的子串，我们就把它当作一种简写，输出时，用连续递增的字母或数字串替代其中的减号，即，将上面两个子串分别输出为“defgh”和“45678”。在本题中，我们通过增加一些参数的设置，使字符串的展开更为灵活。具体约定如下：
（1）遇到下面的情况需要做字符串的展开：在输入的字符串中，出现了减号“-”，减号两侧同为小写字母或同为数字，且按照ASCII码的顺序，减号右边的字符严格大于左边的字符。
（2）参数p1：展开方式。p1=1时，对于字母子串，填充小写字母；p1=2时，对于字母子串，填充大写字母。这两种情况下数字子串的填充方式相同。p1=3时，不论是字母子串还是数字子串，都用与要填充的字母个数相同的星号“*”来填充。
（3）参数p2：填充字符的重复个数。p2=k表示同一个字符要连续填充k个。例如，当p2=3时，子串“d-h”应扩展为“deeefffgggh”。减号两侧的字符不变。
（4）参数p3：是否改为逆序：p3=1表示维持原有顺序，p3=2表示采用逆序输出，注意这时仍然不包括减号两端的字符。例如当p1=1、p2=2、p3=2时，子串“d-h”应扩展为“dggffeeh”。
（5）如果减号右边的字符恰好是左边字符的后继，只删除中间的减号，例如：“d-e”应输出为“de”，“3-4”应输出为“34”。如果减号右边的字符按照ASCII码的顺序小于或等于左边字符，输出时，要保留中间的减号，例如：“d-d”应输出为“d-d”，“3-1”应输出为“3-1”。
输入格式
输入包括两行： 第1行为用空格隔开的3个正整数，依次表示参数p1，p2，p3。 第2行为一行字符串，仅由数字、小写字母和减号“-”组成。行首和行末均无空格。
输出格式
输出只有一行，为展开后的字符串。
看着好麻烦，不想写，摆烂七、编程基础之多维数组
1、矩阵交换行
给定一个5*5的矩阵（数学上，一个r×c的矩阵是一个由r行c列元素排列成的矩形阵列），将第n行和第m行交换，输出交换后的结果。
输入格式
输入共6行，前5行为矩阵的每一行元素,元素与元素之间以一个空格分开。
第6行包含两个整数m、n，以一个空格分开。（1 <= m,n <= 5）
输出格式
输出交换之后的矩阵，矩阵的每一行元素占一行，元素之间以一个空格分开。
num = [list(map(int,input().split())) for _ in range(5)]
m,n = map(int,input().split())
num[n-1],num[m-1] = num[m-1],num[n-1]
for i in num:
print(*i)
样例输入
1 2 2 1 2
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
3 0 8 2 4
1 5
样例输出
3 0 8 2 4
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
1 2 2 1 22、同行列对角线的格子
输入三个自然数N，i，j （1<=i<=N，1<=j<=N），输出在一个N*N格的棋盘中（行列均从1开始编号），与格子（i，j）同行、同列、同一对角线的所有格子的位置。
如：n=4，i=2，j=3表示了棋盘中的第二行第三列的格子，如下图：
同行列对角线的格子
当n=4，i=2，j=3时，输出的结果是：
(2,1) (2,2) (2,3) (2,4) 同一行上格子的位置
(1,3) (2,3) (3,3) (4,3) 同一列上格子的位置
(1,2) (2,3) (3,4) 左上到右下对角线上的格子的位置
(4,1) (3,2) (2,3) (1,4) 左下到右上对角线上的格子的位置
输入格式
一行，三个自然数N，i，j，相邻两个数之间用单个空格隔开。1 <= N <= 10。
输出格式
四行：
第一行：从左到右输出同一行格子位置；
第二行：从上到下输出同一列格子位置；
第三行：从左上到右下输出同一对角线格子位置；
第四行：从左下到右上输出同一对角线格子位置。
其中每个格子位置用如下格式输出：(x,y)，x为行号，y为列号，采用英文标点，中间无空格。
相邻两个格子位置之间用单个空格隔开。
"""
思路：
主对角线的规律是，两个坐标作差相等；
副对角线的规律是，两个坐标的和相等；
"""
N,x,y = map(int,input().split())
for j in range(1,N+1):
print("({},{})".format(x,j),end = " ")
print()
for i in range(1,N+1):
print("({},{})".format(i,y),end = " ")
print()
for i in range(1,N+1): #主对角线做差相等
for j in range(1,N+1):
if y - x == j - i:
print("({},{})".format(i,j),end = " ")
print()
for i in range(N,0,-1): #副对角线做和相等
for j in range(1,N+1):
if y + x == j + i:
print("({},{})".format(i,j),end = " ")
样例输入
4 2 3
样例输出
(2,1) (2,2) (2,3) (2,4)
(1,3) (2,3) (3,3) (4,3)
(1,2) (2,3) (3,4)
(4,1) (3,2) (2,3) (1,4)3、计算矩阵边缘元素之和
输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。
输入格式
第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。
接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
输出格式
输出对应矩阵的边缘元素和。
m,n =map(int,input().split())
num = [list(map(int,input().split())) for _ in range(m)]
sum = 0
for i in range(m):
for j in range(n):
if i == 0 or i == m-1:
sum += num[i][j]
elif j == 0 or j == n-1:
sum += num[i][j]
print(sum)
样例输入
3 3
3 4 1
3 7 1
2 0 1
样例输出
154、错误探测
给定n*n由0和1组成的矩阵，如果矩阵的每一行和每一列的1的数量都是偶数，则认为符合条件。
你的任务就是检测矩阵是否符合条件，或者在仅改变一个矩阵元素的情况下能否符合条件。
"改变矩阵元素"的操作定义为0变成1或者1变成0。
输入格式
输入n + 1行，第1行为矩阵的大小n(0 < n < 100)，以下n行为矩阵的每一行的元素，元素之间以一个空格分开。
输出格式
如果矩阵符合条件，则输出OK；
如果矩阵仅改变一个矩阵元素就能符合条件，则输出需要改变的元素所在的行号和列号，以一个空格分开。
如果不符合以上两条，输出Corrupt。
n = int(input())
num = [list(map(int,input().split())) for _ in range(n)]
row,col = [],[]
sum2 = 0
for i in range(n):
row.append(sum(num[i]) % 2) #每行存入的值确保只有0和1
for j in range(n):
sum2 += num[j][i] #每列之和
col.append(sum2 % 2)
sum2 = 0
if sum(row) == 0 and sum(col) == 0:
print("OK")
elif sum(row) == 1 and sum(col) == 1:
print("{} {}".format(row.index(1)+1,col.index(1)+1)) # 第i行第j列出现1的位置，即出现异端的行列位置
else:
print("Corrupt")
样例输入
4
1 0 1 0
0 0 0 0
1 1 1 1
0 1 0 1
样例输出
OK5、计算鞍点
给定一个5*5的矩阵，每行只有一个最大值，每列只有一个最小值，寻找这个矩阵的鞍点。
鞍点指的是矩阵中的一个元素，它是所在行的最大值，并且是所在列的最小值。
例如：在下面的例子中（第4行第1列的元素就是鞍点，值为8 ）。
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
输入格式
输入包含一个5行5列的矩阵。
输出格式
如果存在鞍点，输出鞍点所在的行、列及其值，如果不存在，输出"not found"。
num = [list(map(int,input().split())) for _ in range(5)]
row,col = [],[]
sum = float("inf") # 赋值为无穷大
for i in range(5):
row.append(max(num[i])) #取每行的最大值
for j in range(5):
sum = min(sum,num[j][i]) #取每列的最小值
col.append(sum)
sum = float("inf")
for i in row:
for j in col:
if i == j:
print("{} {} {}".format(row.index(i)+1,col.index(j)+1,i)) #它们的公共元素即为鞍点
quit()
print("not found")
样例输入
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
样例输出
4 1 86、图像相似度
给出两幅相同大小的黑白图像（用0-1矩阵）表示，求它们的相似度。
说明：若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像素点。两幅图像的相似度定义为相同像素点数占总像素点数的百分比。
输入格式
第一行包含两个整数m和n，表示图像的行数和列数，中间用单个空格隔开。1 <= m <= 100, 1 <= n <= 100。
之后m行，每行n个整数0或1，表示第一幅黑白图像上各像素点的颜色。相邻两个数之间用单个空格隔开。
之后m行，每行n个整数0或1，表示第二幅黑白图像上各像素点的颜色。相邻两个数之间用单个空格隔开。
输出格式
一个实数，表示相似度（以百分比的形式给出），精确到小数点后两位。
m,n = map(int,input().split())
num = [list(map(int,input().split())) for _ in range(2*m)]
count = 0
sum = m*n
for i in range(m):
for j in range(n):
if num[i][j] == num[i+m][j]:
count += 1
print("{:.2f}".format(count*100/sum))
样例输入
3 3
1 0 1
0 0 1
1 1 0
1 1 0
0 0 1
0 0 1
样例输出
44.447、矩阵归零消减序列和
给定一个n*n的矩阵（3 <= n <= 100，元素的值都是非负整数）。通过(n-1)次实施下述过程，可把这个矩阵转换成一个1*1的矩阵。每次的过程如下：
首先对矩阵进行行归零：即对每一行上的所有元素，都在其原来值的基础上减去该行上的最小值，保证相减后的值仍然是非负整数，且这一行上至少有一个元素的值为0。
接着对矩阵进行列归零：即对每一列上的所有元素，都在其原来值的基础上减去该列上的最小值，保证相减后的值仍然是非负整数，且这一列上至少有一个元素的值为0。
然后对矩阵进行消减：即把n*n矩阵的第二行和第二列删除，使之转换为一个(n-1)*(n-1)的矩阵。
下一次过程，对生成的(n-1)*(n-1)矩阵实施上述过程。显然，经过(n-1)次上述过程， n*n的矩阵会被转换为一个1*1的矩阵。
请求出每次消减前位于第二行第二列的元素的值。
输入格式
第一行是一个整数n。
接下来n行，每行有n个正整数，描述了整个矩阵。相邻两个整数间用单个空格分隔。
输出格式
输出为n行，每行上的整数为对应矩阵归零消减过程中，每次消减前位于第二行第二列的元素的值。
法一:18分
n = int(input())
num = [list(map(int,input().split())) for _ in range(n)]
def solution(arr):
a,b = 0,float("inf")
num = [[0]*len(arr) for _ in range(len(arr))]
num1 = [[0]*len(arr) for _ in range(len(arr))]
for i in range(len(arr)):
a = min(arr[i]) #每行的最小值
for j in range(len(arr[0])):
num[i].append(arr[i][j] - a) #每行减去最小值
for i in range(len(arr)):
for j in range(len(arr[0])):
b = min(b,num[j][i]) #每列的最小值
for i in range(len(arr)):
for j in range(len(arr[0])):
num1[j][i] = num[j][i] - b #每列减去最小值
del num1[1]
for row in num1:
del row[1]
return num1
print(num[1][1])
for i in range(n-2):
num = solution(num)
print(num[1][1])
print(num[1][1])
法二:77分
n = int(input())
num = [list(map(int, input().split())) for _ in range(n)]
def solution(arr):
# 找到每行的最小值
row_min = [min(row) for row in arr]
# 每行减去最小值
arr = [[value - row_min[i] for value in row] for i,row in enumerate(arr)]
# 找到每列的最小值
col_min = [min(col) for col in zip(*arr)]
# 每列减去最小值
arr = [[value - col_min[j] for j,value in enumerate(row)] for row in arr]
# 删除第二行和第二列
del arr[1]
for row in arr:
del row[1]
return arr
print(num[1][1])
for _ in range(n - 2):
num = solution(num)
print(num[1][1])
print(num[1][1])
法三:77
n = int(input())
num = [list(map(int, input().split())) for _ in range(n)]
def solution(arr):
# 找到每行的最小值
row_min = [min(row) for row in arr]
# 每行减去最小值
arr = [[value - row_min[i] if value - row_min[i] >= 0 else 0 for value in row] for i, row in enumerate(arr)]
# 找到每列的最小值
col_min = [min(col) for col in zip(*arr)]
# 每列减去最小值
arr = [[value - col_min[j] if value - col_min[j] >= 0 else 0 for j,value in enumerate(row)] for row in arr]
# 删除第二行和第二列
del arr[1]
for row in arr:
del row[1]
return arr
print(num[1][1])
for _ in range(n - 2):
num = solution(num)
print(num[1][1])
print(num[1][1])
样例输入
3
1 2 3
2 3 4
3 4 5
样例输出
3
0
0 8、矩阵加法
输入两个n行m列的矩阵A和B，输出它们的和A+B。
输入格式
第一行包含两个整数n和m，表示矩阵的行数和列数。1 <= n <= 100，1 <= m <= 100。
接下来n行，每行m个整数，表示矩阵A的元素。
接下来n行，每行m个整数，表示矩阵B的元素。
相邻两个整数之间用单个空格隔开，每个元素均在1~1000之间。
输出格式
n行，每行m个整数，表示矩阵加法的结果。相邻两个整数之间用单个空格隔开。
n,m = map(int,input().split())
num = [list(map(int,input().split())) for _ in range(2*n)]
num1 = [[0]*m for _ in range(n)]
for i in range(n):
for j in range(m):
num1[i][j] = num[i][j] + num[i+n][j]
for i in num1:
print(*i)
样例输入
3 3
1 2 3
1 2 3
1 2 3
1 2 3
4 5 6
7 8 9
样例输出
2 4 6
5 7 9
8 10 129、矩阵乘法
计算两个矩阵的乘法。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个整数，整数之间以一个空格分开。
n,m,k = map(int,input().split())
numA = [list(map(int,input().split())) for _ in range(n)]
numB = [list(map(int,input().split())) for _ in range(m)]
num = [[0]*k for _ in range(n)]
for i in range(n):
for j in range(k):
for a in range(m):
num[i][j] += numA[i][a] * numB[a][j]
for i in num:
print(*i)
样例输入
3 2 3
1 1
1 1
1 1
1 1 1
1 1 1
样例输出
2 2 2
2 2 2
2 2 210、矩阵转置
输入一个n行m列的矩阵A，输出它的转置AT。
输入格式
第一行包含两个整数n和m，表示矩阵A的行数和列数。1 <= n <= 100，1 <= m <= 100。
接下来n行，每行m个整数，表示矩阵A的元素。相邻两个整数之间用单个空格隔开，每个元素均在1~1000之间。
输出格式
m行，每行n个整数，为矩阵A的转置。相邻两个整数之间用单个空格隔开。
m,n = map(int,input().split())
num = [list(map(int,input().split())) for _ in range(m)]
num1 = [col for col in zip(*num)] #取每一列作为一个元组
for i in num1:
print(*i)
样例输入
3 3
1 2 3
4 5 6
7 8 9
样例输出
1 4 7
2 5 8
3 6 911、图像旋转
输入一个n行m列的黑白图像，将它顺时针旋转90度后输出。
输入格式
第一行包含两个整数n和m，表示图像包含像素点的行数和列数。1 <= n <= 100，1 <= m <= 100。
接下来n行，每行m个整数，表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开，每个元素均在0~255之间。
输出格式
m行，每行n个整数，为顺时针旋转90度后的图像。相邻两个整数之间用单个空格隔开。
m,n = map(int,input().split())
num = [list(map(int,input().split())) for _ in range(m)]
num1 = [list(col) for col in zip(*num)] #取每一列作为一个元组
for i in num1:
i.reverse() #倒叙
print(*i)
样例输入
3 3
1 2 3
4 5 6
7 8 9
样例输出
7 4 1
8 5 2
9 6 312、变幻的矩阵
有一个N x N（N为奇数，且1 <= N <= 10）的矩阵，矩阵中的元素都是字符。这个矩阵可能会按照如下的几种变幻法则之一进行变幻（只会变幻一次）。
现在给出一个原始的矩阵，和一个变幻后的矩阵，请编写一个程序，来判定原始矩阵是按照哪一种法则变幻为目标矩阵的。
1. 按照顺时针方向旋转90度；
如：
1 2 3 7 4 1
4 5 6 变幻为 8 5 2
7 8 9 9 6 3
2. 按照逆时针方向旋转90度；
如：
1 2 3 3 6 9
4 5 6 变幻为 2 5 8
7 8 9 1 4 7
3. 中央元素不变（如下例中的 5），其他元素（如下例中的3）与“以中央元素为中心的对应元素”（如下例中的7）互换；
如：
1 2 3 9 8 7
4 5 6 变幻为 6 5 4
7 8 9 3 2 1
4. 保持原始矩阵，不变幻；
5. 如果 从原始矩阵 到 目标矩阵 的变幻，不符合任何上述变幻，请输出5。
输入格式
第一行：矩阵每行/列元素的个数 N；
第二行到第N+1行：原始矩阵，共N行，每行N个字符；
第N+2行到第2*N+1行：目标矩阵，共N行，每行N个字符。
输出格式
只有一行，从原始矩阵到目标矩阵的所采取的变幻法则的编号。
n = int(input())
num_start = [list(map(str, input().split())) for _ in range(n)]
num_end = [list(map(str, input().split())) for _ in range(n)]
def shun_90(arr):
num1 = [list(col) for col in zip(*arr)]
for i in range(len(num1)):
num1[i].reverse()
return num1
def ni_90(arr):
num = [list(row) for row in arr] # 创建副本,以防在运行函数后将传递的参数改变
for i in range(len(num)):
num[i].reverse()
col = [list(col) for col in zip(*num)]
return col
def duichen(arr):
num = [list(row) for row in arr] # 创建副本
n, m = 0, len(num) - 1
for i in range(len(num)):
num[i].reverse()
while n < int(len(num) / 2):
num[n], num[m] = num[m], num[n]
n += 1
m -= 1
return num
def bubbian(arr):
num = [list(row) for row in arr] # 创建副本
return num
def compare_arr(arr1,arr2):
if len(arr1) != len(arr2):
return False
for row1, row2 in zip(arr1, arr2):
if row1 != row2:
return False
return True
a = shun_90(num_start[:]) #创建副本，避免修改num_start的值
b = ni_90(num_start[:])
c = duichen(num_start[:])
d = bubbian(num_start[:])
if compare_arr(a,num_end):
print(1)
elif compare_arr(b,num_end): # 修改此处
print(2)
elif compare_arr(c,num_end):
print(3)
elif compare_arr(d,num_end):
print(4)
else:
print(5)
样例输入
5
a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
y x w v u
t s r q p
o n m l k
j i h g f
e d c b a
样例输出
313、图像模糊处理
给定n行m列的图像各像素点的灰度值，要求用如下方法对其进行模糊化处理：
1. 四周最外侧的像素点灰度值不变；
2. 中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均（舍入到最接近的整数）。
输入格式
第一行包含两个整数n和m，表示图像包含像素点的行数和列数。1 <= n <= 100，1 <= m <= 100。
接下来n行，每行m个整数，表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开，每个元素均在0~255之间。
输出格式
n行，每行m个整数，为模糊处理后的图像。相邻两个整数之间用单个空格隔开。
14、扫雷游戏地雷数计算
扫雷游戏是一款十分经典的单机小游戏。它的精髓在于，通过已翻开格子所提示的周围格地雷数，来判断未翻开格子里是否是地雷。
现在给出n行m列的雷区中的地雷分布，要求计算出每个非地雷格的周围格地雷数。
注：每个格子周围格有八个：上、下、左、右、左上、右上、左下、右下。
输入格式
第一行包含两个整数n和m，分别表示雷区的行数和列数。1 <= n <= 100, 1 <= m <= 100。
接下来n行，每行m个字符，‘*’表示相应格子中是地雷，‘？’表示相应格子中无地雷。字符之间无任何分隔符。
输出格式
n行，每行m个字符，描述整个雷区。若相应格中是地雷，则用‘*’表示，否则用相应的周围格地雷数表示。字符之间无任何分隔符。
n,m = map(int,input().split())
num = [list(map(str,input())) for _ in range(n)]
num1 = [[0]*m for _ in range(n)]
direction = [(-1,-1),(-1,1),(-1,0),(0,1),(0,-1),(1,-1),(1,1),(1,0)] #八个方向
for i in range(n):
for j in range(m):
if num[i][j] == "*":
num1[i][j] = "*"
else:
count = 0
for dx,dy in direction:
x,y = i+dx,j+dy
if 0 <= x < n and 0 <= y < m and num[x][y] == "*":
count += 1
num1[i][j] = str(count)
for i in num1:
print("{}".format("".join(i)))
样例输入
3 3
*??
???
?*?
样例输出
*10
221
1*1
扫一扫
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
