蓝桥杯Python刷题
目录
一 入门练习
1 A+B问题
2 序列求和
3 圆的面积
4 Fibonacci数列
二 基础练习
1 闰年判断
2 01字串
3 字母图形
4 数列特征
5 查找整数
6 杨辉三角形
7 特殊的数字
8 回文数
9 特殊回文数
10 十进制转换为十六进制
11 十六进制转十进制
12 十六进制转八进制
13 数列排序
14 时间转换
15 字符串对比
16 分解质因数
17 矩阵乘法
18 矩形面积交
19 完美的代价
20 数的读法
三、真题
1、高斯日记
2、排他平方数
3、振兴中华
一 入门练习
1 A+B问题
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
输入A、B，输出A+B。
说明：在“问题描述”这部分，会给出试题的意思，以及所要求的目标。
输入格式
输入的第一行包括两个整数，由空格分隔，分别表示A、B。
说明：“输入格式”是描述在测试你的程序时，所给的输入一定满足的格式。
做题时你应该假设所给的输入是一定满足输入格式的要求的，所以你不需要对输入的格式进行检查。多余的格式检查可能会适得其反，使用你的程序错误。
在测试的时候，系统会自动将输入数据输入到你的程序中，你不能给任何提示。比如，你在输入的时候提示“请输入A、B”之类的话是不需要的，这些多余的输出会使得你的程序被判定为错误。
输出格式
输出一行，包括一个整数，表示A+B的值。
说明：“输出格式”是要求你的程序在输出结果的时候必须满足的格式。
在输出时，你的程序必须满足这个格式的要求，不能少任何内容，也不能多任何内容。如果你的内容和输出格式要求的不一样，你的程序会被判断为错误，包括你输出了提示信息、中间调试信息、计时或者统计的信息等。
样例输入
12 45
说明：“样例输入”给出了一组满足“输入格式”要求的输入的例子。
这里给出的输入只是可能用来测试你的程序的一个输入，在测试的时候，还会有更多的输入用来测试你的程序。
样例输出
57
说明：“样例输出”给出了一组满足“输出格式”要求的输出的例子。
样例输出中的结果是和样例输入中的是对应的，因此，你可以使用样例的输入输出简单的检查你的程序。
要特别指出的是，能够通过样例输入输出的程序并不一定是正确的程序，在测试的时候，会用很多组数据进行测试，而不局限于样例数据。有可能一个程序通过了样例数据，但测试的时候仍只能得0分，可能因为这个程序只在一些类似样例的特例中正确，而不具有通用性，再测试更多数据时会出现错误。
比如，对于本题，如果你写一个程序不管输入是什么都输入57，则样例数据是对的，但是测试其他数据，哪怕输入是1和2，这个程序也输出57，则对于其他数据这个程序都不正确。
数据规模与约定
-10000 <= A, B <= 10000。
说明：“数据规模与约定”中给出了试题中主要参数的范围。
这个范围对于解题非常重要，不同的数据范围会导致试题需要使用不同的解法来解决。比如本题中给的A、B范围不大，可以使用整型(int)来保存，如果范围更大，超过int的范围，则要考虑其他方法来保存大数。
有一些范围在方便的时候是在“问题描述”中直接给的，所以在做题时不仅要看这个范围，还要注意问题描述。
'''
A = list(input().split())
print(int(A[0])+int(A[1]))2 序列求和
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
求1+2+3+...+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+...+n的值。
样例输入
4
样例输出
10
样例输入
100
说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。
一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。
样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
'''
n =int(input())
sum = (n+n**2)/2
print(int(sum))3 圆的面积
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。
对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。
实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
'''
PI = 3.14159265358979323
r = int(input())
print("%.7f"%(PI*r*r))4 Fibonacci数列
#试题 入门训练 Fibonacci数列
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。
'''
# #得分90的答案，超时
# N = int(input())
# F1 = 1
# F2 = 1
# i = 1
# while i<=N:
# if i<=2:
# F3 = 1
# else:
# F3 = F1 + F2
# F1 = F2
# F2 = F3
# i += 1
# print(F3%10007)
#利用余数的加法定理
'''
余数和定理（数论）：a与b的和除以c的余数，等于a,b分别除以c的余数之和再对c取余
'''
N = int(input())
F1 = 1
F2 = 1
i = 1
while i<=N:
if i<=2:
F3 = 1
else:
F3 = (F1%10007 + F2%10007)%10007
F1 = F2
F2 = F3
i += 1
print(F3)
二 基础练习
1 闰年判断
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1. 年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。
'''
n = int(input())
if ((n%4==0 and n%100!=0) or n%400==0):
print("yes")
else:
print("no")2 01字串
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。
输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>
'''
#直接转换即可
#bin()将10进制转换为2进制，舍掉0b，再填满5位
for i in range(32):
print(bin(i)[2:].zfill(5))3 字母图形
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。
'''
#ASCII码和字符转化
'''
chr() 将ASCII码转换为字符
ord() 将字符转化为ASCII码
'''
list1 = input().split()
list2 = []
#将字符转化为数字
for i in range(len(list1)):
list1[i]=int(list1[i])
#生成顺序字符串
for i in range(list1[0]):
for j in range(list1[1]):
if i>j:
list2.append(chr(ord('A')+i-j))
else:
list2.append(chr(ord('A')+j-i))
for k in range(len(list2)):
print(list2[k],end='')
print()
#print('\n') #注意这是两个换行
list2 = []
4 数列特征
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模与约定
1 <= n <= 10000。
'''
n = int(input())
list1=[] #空列表接收字符
list1 = input().split()
for i in range(n):
list1[i] = int(list1[i])
print(max(list1))
print(min(list1))
print(sum(list1))5 查找整数
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。
'''
def select_index():
for i in range(n):
if Num == list1[i]:
return i+1
if Num not in list1:
return -1
if __name__=='__main__':
n = int(input())
list1 = []
list1 = input().split()
Num = int(input())
for i in range(n):
list1[i] = int(list1[i]) #把字符转为整型数字
print(select_index())
6 杨辉三角形
'''
资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)^i的展开式的系数。
它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
下面给出了杨辉三角形的前4行：
1
1 1
1 2 1
1 3 3 1
给出n，输出它的前n行。
输入格式
输入包含一个数n。
输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1
数据规模与约定
1 <= n <= 34。
'''
# p =[1]
# print(p)
# p = [1] + [1] #这里的+相当于append操作
# print(p)
if __name__ == '__main__':
n = int(input())
list1 = [1] #初始化一个一行的杨辉三角
while n>0:
for i in range(len(list1)):
print(list1[i],end=' ') #先打印一行，再计算下一行
print() # print自带换行
list1 = [1] + [list1[j] + list1[j+1] for j in range(len(list1)-1)] +[1] #使用列表生成式，三角形中的每个数字等于它两肩上的数字相加
n -= 1
7 特殊的数字
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
'''
if __name__ == "__main__":
for i in range(100,1000,1):
bai = i // 100
shi = (i // 10) % 10
ge = i % 10
if (i == bai**3 + shi**3 + ge ** 3):
print(i)
8 回文数
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。
'''
if __name__ == "__main__":
for i in range(1000,10000,1):
str2=''
str1 = str(i)
for j in range(len(str1)):
a = str1[len(str1)-j-1]
str2 += a #向空字符串后拼接字符用+
if str1 == str2:
print(i)9 特殊回文数
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
1<=n<=54。
'''
# #下方法运行超时
# if __name__ == "__main__":
# n = int(input())
# for i in range(10000,1000000,1):
# str1 = str(i)
# str2 = ''
# num_sum = 0
# for j in range(len(str1)):
# a = str1[len(str1)-j-1]
# str2 += a
# num_sum += int(a)
# if (str1 == str2) and (num_sum == n):
# print(i)
# #下方法也会超时
# if __name__ == "__main__":
# n = int(input())
# for i in range(10000,1000000,1):
# str1 = str(i)
# str2 = str1[::-1] #快速实现字符串顺序颠倒
# num_sum = 0
# for j in range(len(str1)):
# num_sum += int(str1[j])
# if (str1 == str2) and (num_sum == n):
# print(i)
'''
这里借鉴某大佬，将功能封装为函数，结果就不超时了，没想通，请知道的大佬指点
'''
def is_Palindrome(num):
str1 = str(num)
str2 = str1[::-1] #快速实现字符串顺序颠倒
if str1 == str2:
return True
else:
return False
def num_sum(num):
num_sum = 0
str_num = str(num)
for i in range(len(str_num)):
num_sum += int(str_num[i])
return num_sum
if __name__ == "__main__":
n = int(input())
for num in range(10000,1000000,1):
if is_Palindrome(num) and num_sum(num)==n :
print(num)
10 十进制转换为十六进制
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
给出一个非负整数，将它表示成十六进制的形式。
输入格式
输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
输出格式
输出这个整数的16进制表示
样例输入
30
样例输出
1E
'''
num = int(input())
print(hex(num).upper()[2:])11 十六进制转十进制
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535
'''
num = input()
print(int(num,16))12 十六进制转八进制
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
【提示】
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
'''
#int()可以将字符串或数字按某种进制方式转换为10进制
n = int(input())
num_list = []
for i in range(n):
num = input()
num_list.append(int(num,16))
for i in range(n):
print(oct(num_list[i])[2:])13 数列排序
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9
'''
N = int(input())
list1=[]
list1 = input().split()
for i in range(len(list1)):
list1[i]=int(list1[i])
if len(list1) != N:
print("imput error")
list1.sort()
for i in range(N):
print(list1[i],end=' ')14 时间转换
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个以秒为单位的时间t，要求用“::”的格式来表示这个时间。表示时间，表示分钟，而表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
输入格式
输入只有一行，是一个整数t（0<=t<=86399）。
输出格式
输出只有一行，是以“::”的格式所表示的时间，不包括引号。
样例输入
0
样例输出
0:0:0
样例输入
5436
样例输出
1:30:36
'''
#把秒转换为小时制时间
if __name__ == "__main__":
sec = int(input())
h = sec // 3600
m = (sec - h*3600) // 60
s = sec - m*60 - h*3600
print('{}:{}:{}'.format(h,m,s)) 15 字符串对比
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
1：两个字符串长度不等。比如 Beijing 和 Hebei
2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
输入格式
包括两行，每行都是一个字符串
输出格式
仅有一个数字，表明这两个字符串的关系编号
样例输入
BEIjing
beiJing
样例输出
3
'''
def judgment(str1,str2):
if len(str1) != len(str2):
print(1)
elif str1 == str2 :
print(2)
elif str1.upper() == str2.upper():
print(3)
else:
print(4)
if __name__ == "__main__":
str1 = input()
str2 = input()
judgment(str1,str2)16 分解质因数
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
求出区间[a,b]中所有整数的质因数分解。
输入格式
输入两个整数a，b。
输出格式
每行输出一个数的分解，形如k=a1*a2*a3...(a1<=a2<=a3...，k也是从小到大的)(具体可看样例)
样例输入
3 10
样例输出
3=3
4=2*2
5=5
6=2*3
7=7
8=2*2*2
9=3*3
10=2*5
提示
先筛出所有素数，然后再分解。
数据规模和约定
2<=a<=b<=10000
'''
'''
解答思路：
借鉴https://blog.csdn.net/m0_37586991/article/details/79678043?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
'''
def is_prime(n): #判断数n是否是素数
for i in range(2,n):
if n % i == 0:
return False
return True
def decomposition(a,b):
for num in range(a,b+1,1):
if is_prime(num): #是素数就直接打印
print('{}={}'.format(num,num))
else: #否则就进行分解
print('{}='.format(num),end='')
while(num!=1):
for i in range(2,num+1):
if num % i == 0 : #满足则说明i是num的一个质因数
print('{}'.format(i),end='')
num = num // i
if num!=1:
print('*',end='')
break #跳出本层for循环，重新进入while循环从2开始查找质因数
print()
if __name__ == "__main__":
a,b = map(int, input().split()) #空格分割，map调整为整型
decomposition(a,b)
17 矩阵乘法
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
例如：
A =
1 2
3 4
A的2次幂
7 10
15 22
输入格式
第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值
输出格式
输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开
样例输入
2 2
1 2
3 4
样例输出
7 10
15 22
'''
'''
1 题目只测试矩阵的幂，方阵的幂的形状是不改变的
2 题目还测试了0次幂，方阵的0次幂是单位阵
'''
#接收数据 注 input()返回的实际是一维列表
def Receive_data(n,matrix):
for i in range(n):
row = input().split()
for j in range(n):
matrix[i].append(int(row[j]))
return matrix
#定义矩阵的幂
def matrix_power(matrix,n,m):
result_temp = matrix #临时存放每次相乘的数据
m -= 1
while m != 0:
result = [[0 for _ in range(n)] for _ in range(n)] #创建新的二维列表存放结果 注意不能创建空列表，否则会出现result列表index越界
for i in range(n):
for j in range(n):
for k in range(n):
result[i][j] += result_temp[i][k] * matrix[k][j]
m -= 1
result_temp = result
return result
if __name__ == "__main__":
n,m = map(int,input().split())
matrix = [[] for _ in range(n)] #创建二维列表
matrix = Receive_data(n,matrix)
if m!=0:
result = matrix_power(matrix,n,m)
else:
result = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
result[i][i] = 1
# print(matrix_power(matrix,n,m))
# 按照格式输出
for i in range(n):
for j in range(n):
print(result[i][j],end=' ')
print()18 矩形面积交
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。
输入格式
输入仅包含两行，每行描述一个矩形。
在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。
输出格式
输出仅包含一个实数，为交的面积，保留到小数后两位。
样例输入
1 1 3 3
2 2 4 4
样例输出
1.00
'''
'''
矩形交的条件
矩形1 对角坐标(x1,y1) (x2,y2)
矩形2 对角坐标(x3,y3) (x4,y4)
实际测试时坐标x1不一定比x2小并且两个矩形的相对位置也不知道，虽然可以分类但是麻烦
可以手画矩形相交图总结得出
如果 max(矩形1最小的横坐标 矩形2最小的横坐标) < min(矩形1最大的横坐标 矩形2最大的横坐标) 有横向相交可能性
如果 max(矩形1最小的纵坐标 矩形2最小的纵坐标) < min(矩形1最大的纵坐标 矩形2最大的纵坐标) 有纵向相交可能性
即 max(min(x1,x2),min(x3,x4)) < min(max(x1,x2),max(x3,x4)) 且 max(min(y1,y2),min(y3,y4)) < min(max(y1,y2),max(y3,y4)) 才能相交
则相交面积为 (min(x2,x4) - max(x1,x3)) * (min(y2,y4) - max(y1,y3))
'''
if __name__ == "__main__":
x1,y1,x2,y2 = map(float,input().split())
x3,y3,x4,y4 = map(float,input().split())
area = 0
if max(min(x1,x2),min(x3,x4)) < min(max(x1,x2),max(x3,x4)) and max(min(y1,y2),min(y3,y4)) < min(max(y1,y2),max(y3,y4)):
area = (min(max(x1,x2),max(x3,x4)) - max(min(x1,x2),min(x3,x4))) * (min(max(y1,y2),max(y3,y4)) - max(min(y1,y2),min(y3,y4)))
print('%.2f' % area)
else:
print('%.2f' % area)19 完美的代价
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
交换的定义是：交换两个相邻的字符
例如mamad
第一次交换 ad : mamda
第二次交换 md : madma
第三次交换 ma : madam (回文！完美！)
输入格式
第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
第二行是一个字符串，长度为N.只包含小写字母
输出格式
如果可能，输出最少的交换次数。
否则输出Impossible
样例输入
5
mamad
样例输出
3
'''
'''
判断有无可能是回文数
Impossible不可能是回文数的两种情况：
如果n是偶数，则每类字符应该出现偶数次
如果n是计数，则只能有一类字符出现次数为奇数
字符串自带count方法：用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置
count方法说明见 https://www.runoob.com/python/att-string-count.html
'''
def is_Palindrome(n,str1):
cnt = 0
if n%2 == 0:
for i in range(26): #依次统计字符串中a-z的出现次数
if str1.count(chr(ord('a')+i)) % 2 != 0: #当n是偶数 而 字母出现次数有奇数时
print("Impossible")
return False
return True
else:
for i in range(26):
if str1.count(chr(ord('a')+i)) % 2 != 0:
cnt += 1
if cnt != 1:
print("Impossible")
return False
else:
return True
'''
如果是回文数，需要计算最少移动步数
https://blog.csdn.net/u011506951/article/details/26382569?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control&dist_request_id=81a8cb98-fa29-46f0-94df-89d96ceda1cf&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.control
上面博客介绍了基本原理
移动次数最小原理相当于尽量保持原来的正向前一半的顺序
其实就是正向遍历字符串，当到某个字母的时候，同时再反向遍历字符串当相同的字母，将反向遍历的次数作为交换次数
这时的交换次数最少
这个博客图解适合理解 代码也容易理解
https://blog.csdn.net/bianxia123456/article/details/104388390
'''
def step(N,str1,str2):
step = 0
for i in range(N//2):
if str1[i:].count(str1[i]) != 1: #字符出现了两次及以上
# index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
# 可参考 https://www.runoob.com/python/att-list-index.html
temp = str2[:N - i].index(str1[i]) #得到索引位置
#pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
# 可参考 https://www.runoob.com/python/att-list-pop.html
str2.pop(temp)
step += temp
str1 = str2[::-1]
else: #只出现了一次
step += N//2 - i #将该字母移动到中间所需要的步数
return step
if __name__ == "__main__":
N = int(input())
str1 = list(input())
str2 = str1[::-1]
if is_Palindrome(N,str1):
print(step(N,str1,str2))20 数的读法
'''
资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。
比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。
所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：
十二亿三千四百五十六万七千零九
用汉语拼音表示为
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
这样他只需要照着念就可以了。
你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。
输入格式
有一个数字串，数值大小不超过2,000,000,000。
输出格式
是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。
样例输入
1234567009
样例输出
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
'''
'''
思路：佩服这博客，不知道他怎么想出来的
https://blog.csdn.net/bianxia123456/article/details/104366900
'''
def read_num(num_4):
num = list(map(int,num_4))
'''
千位上的数字处理
非0直接读数字和千，否则数字和千都不读
'''
if num[0] != 0:
temp.append(duyin1[num[0]])
temp.append("qian")
else:
pass
if num[1] != 0:
temp.append(duyin1[num[1]])
temp.append("bai")
# 不读百和百位上的0 的情况
# 1 千位百位都是0 如0023
# 2 千位不管，后三位是0 如1000或0000
elif (num[0] == 0 and num[1] == 0) or (num[1] == 0 and num[2] == 0 and num[3] == 0):
pass
# '''
# 其余情况不读百 但要读百位上的0 如1023
# '''
else:
temp.append(duyin1[num[1]])
# '''
# 十位上的数字处理
# 除开位0和1的两种情况，接直接读数字和十
# '''
if num[2] != 0 and num[2] != 1:
temp.append(duyin1[num[2]])
temp.append("shi")
# '''
# 10只能读十，不能读一十
# 12只能读十二，不能读一十二
# '''
elif num[2] == 1 and num[1] == 0 and num[0] == 0:
temp.append("shi")
# '''
# 如果百位和十位都为0 就不读 如1001 虽然读了一个0 但是这个0是读的百位上的0
# 如果十位和个位为0 也不读 如1100
# '''
elif (num[1] == 0 and num[2] == 0) or (num[2] == 0 and num[3] == 0):
pass
# '''
# 只读数字 不读十 如1101
# '''
else:
temp.append(duyin1[num[2]])
# '''
# 个位处理
# 为0不读
# 非0就读
# '''
if num[3] != 0:
temp.append(duyin1[num[3]])
else:
pass
return temp
if __name__ == "__main__":
num = input() #输入数字
l = len(num) #数字长度
duyin1 = ['ling','yi','er','san','si','wu','liu','qi','ba','jiu']
temp = [] #用来暂时存放4位读音
duyin = []
if 0 < l <= 4:
duyin = read_num(num.rjust(4,'0')) #不足4位先调整为4位再读
elif 4 < l <= 8:
new_num = num.rjust(8,'0')
read_num(new_num[:4])
temp.append('wan')
'''
4位非全0 且千位为0 就要读千位的0 弥补读数函数中千位为0的情况
'''
if new_num[4:] != '0000' and new_num[4:][0] == '0':
temp.append('ling')
duyin = read_num(new_num[4:])
elif 8 < l <= 10:
new_num = num.rjust(12,'0')
read_num(new_num[:4])
temp.append('yi')
if new_num[4:8] != '0000':
read_num(new_num[4:8])
temp.append('wan')
elif new_num[4:12] == '00000000':
pass
else:
temp.append('ling')
duyin = read_num(new_num[8:12])
for i in range(len(temp)):
print(duyin[i],end=' ')三、真题
1、高斯日记
y = 1777
m = 4
d = 30
def isleapyear(y):
return (y%4==0 and y%100 != 0) or y%400==0
for i in range(8112):
d += 1
if m==12 and d==32:
y += 1
m = 1
d = 1
continue
if (m==1 or m==3 or m==5 or m==7 or m==8 or m==10) and d==32:
m += 1
d = 1
continue
if (m==4 or m==6 or m==9 or m==11) and d==31:
m += 1
d = 1
continue
if (m==2 and isleapyear(y)) and d==30:
m += 1
d = 1
continue
if (m==2 and (not isleapyear(y))) and d==29:
m += 1
d = 1
continue
print("%d-%d-%d"%(y,m,d))2、排他平方数
def check(x,y): #检查y中是否有x的数字
for s in str(x):
if s in str(y):
return True #含有
return False #没有
for i in range(1,10):
for j in range(0,10):
if i != j:
for k in range(0,10):
if k!=j and k!=i:
for l in range(0,10):
if l!=i and l!=j and l!=k:
for m in range(0,10):
if m!=i and m!=j and m!=k and m!=l:
for n in range(0,10):
if n!=i and n!=j and n!=k and n!=l and n!=m:
num = i*100000+j*10000+k*1000+l*100+m*10+n
if not check(num,num**2):
print(num,num**2)3、振兴中华
def f(x,y):
if x==0 or y==0: #边界条件 f(i,j)表示(0,0)到(i,j)的走法
return 1
else:
return f(x-1,y) + f(x,y-1)
print(f(3,4))4、颠倒的价牌