蓝桥杯系列4——python基础练习

零

如果时间比较紧，就功利一点，题目是为了手感服务的。
最基本的输入输出、杨辉三角（循环，if判断，递归）等等捡起来了，就可以直接刷真题了，这部分不需要浪费太多时间。

一 基础练习

BASIC-01 A+B问题

1.输入A、B，输出A+B。

输入格式:输入的第一行包括两个整数，由空格分隔，分别表示A、B。

a, b = map(int, input().split())
print(a + b)

12 34
46

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

12 34
46

BASIC-02 序列求和 入门 求和公式

问题描述
求1+2+3+…+n的值。

输入格式
输入包括一个整数n。

输出格式
输出一行，包括一个整数，表示1+2+3+…+n的值。

样例输入
4

样例输出
10

n=int(input())
sum1=0
for i in range(1,n+1):
    sum1=sum1+i
print(sum1)

4
10

# 直接循环 然后超时了
n=int(input())
sum2=n*(n+1)/2
print(int(sum2))

4
10

BASIC-03 圆的面积 入门 实数输出

问题描述
给定圆的半径r，求圆的面积。

输入格式
输入包含一个整数r，表示圆的半径。

输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。

对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。

实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。

样例输入
4

样例输出
50.2654825

import math
r=int(input())
s=math.pi*r*r
print('%.7f'%s)

44
6082.1233773

BASIC-04 Fibonacci数列 入门 数列 取模

问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。

当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

输入格式
输入包含一个整数n。

输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

样例输入
10

样例输出
55

n=int(input())
f=[1 for i in range(n)]
# print(f)
for i in range(n):
    if i >= 2:
        f[i]=(f[i-1]+f[i-2])%10007
print(f[n-1])

55
2091

BASIC-1 闰年判断 条件判断

问题描述
给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

1. 年份是4的倍数而不是100的倍数；

2. 年份是400的倍数。

其他的年份都不是闰年。

输入格式
输入包含一个整数y，表示当前的年份。

输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。

样例输入
2013

样例输出
no

y=int(input())
if (y%4 == 0 and y%100 !=0) or y%400 == 0:
    print("yes")
else:
    print("no")

2000
yes

BASIC-2 01字串

2.对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：

00000

00001

00010

请按从小到大的顺序输出这32种01串。
{0 : 0 > 3}
│ ││ │
│ ││ └─ Width of 3
│ │└─ Align Right
│ └─ Fill with ‘0’
└─ Element index

for i in range(32):
    # print(f"{bin(i)[2:].zfill(5)}")
    print("{0:0>5}".format(format(i, 'b')))

# zfill填充，不管结果多少位，都把他填充到5位数

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

for i in range(32):
    # print(f"{bin(i)[2:].zfill(5)}")
    print("{0:0>5}".format(format(i, 'b'))) # 'b'按位输出

# zfill填充，不管结果多少位，都把他填充到5位数

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

BASIC-3 字母图形 循环 字符串

问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式
输出n行，每个m个字符，为你的图形。

样例输入
5 7

样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

数据规模与约定
1 <= n, m <= 26。

n, m = map(int, input().split())

graph = [[0 for j in range(m)] for i in range(n)] # 空二维数组

for i in range(n):
    for j in range(m):
        if j >= i: # 数组中字母规律
            graph[i][j] = chr(ord('A') + j - i)
        else:
            graph[i][j] = chr(ord('A') + i - j)

for i in range(n): # 输出二维数组
    for j in range(m):
        print(graph[i][j], end='')
    print()

5 7
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

print(chr(ord('A') +1))
print(chr(ord('A') -1))

B
@

字符转ASCII码函数：ord(‘A’)->64
ASCII码转字符函数：chr(64)->A

BASIC-4 数列特征

给出n个数，找出这n个数的最大值，最小值，和。

输入格式
第一行为整数n，表示数的个数。

第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。

输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。

样例输入

5

1 3 -2 4 5

样例输出

5

-2

11

n=int(input())
arr=list(map(int,input().split()))
# print(arr)
print(max(arr))
print(min(arr))
print(sum(arr))

2
1 2
2
1
3

BASIC-5 查找整数 循环 判断

给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

输入格式

第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。

输出格式

如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。

样例输入

6

1 9 4 8 3 9

9

样例输出

2

n=int(input())
arr=list(map(int,input().split()))
a=int(input())
for i in range(len(arr)):
    if arr[i] == a:
        print(i+1)
        break
    elif i == len(arr)-1: #注意：n=len(arr)-1
        print(-1)

1
34
0
-1

BASIC-6 杨辉三角形 基础练习 二维数组

问题描述

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。

性质：三角形中的每个数字等于它两肩上的数字相加。

输入格式

输入包含一个数n。

输出格式

输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。

样例输入

4

样例输出
　　
1

1 1
　　
1 2 1
　　
1 3 3 1

n=int(input())

sanjiao=[]
for i in range(n): #定义空杨辉三角
    sanjiao.append([1 for j in range(i+1)])
#print(sanjiao)

for i in range(n):
    for j in range(i+1):
        if i >=2 and j >= 1 and j < i:
            # print("i,j",i,j)
            sanjiao[i][j] = sanjiao[i-1][j-1] + sanjiao[i-1][j]
        print(sanjiao[i][j],end=' ')
    print( )

3
1 
1 1 
1 2 1 

BASIC-7 特殊的数字 循环 判断 数位

问题描述

153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1 * 1 * 1+5 * 5 * 5+3 * 3 * 3。编程求所有满足这种条件的三位十进制数。

输出格式

按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。

for i in range(1,10):
    for j in range(0,10):
        for k in range(0,10):
            if (i*100+j*10+k) == (i**3+j**3+k**3):
                print(i*100+j*10+k)

153
370
371
407

BASIC-8 回文数 循环 判断 回文数

问题描述

1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。

输出格式

按从小到大的顺序输出满足条件的四位十进制数。

for i in range(1,10):
    for j in range(0,10):
        print(i*1001+j*110)

1001
1111
1221
1331
1441
1551
1661
1771
1881
1991
2002
2112
2222
2332
2442
2552
2662
2772
2882
2992
3003
3113
3223
3333
3443
3553
3663
3773
3883
3993
4004
4114
4224
4334
4444
4554
4664
4774
4884
4994
5005
5115
5225
5335
5445
5555
5665
5775
5885
5995
6006
6116
6226
6336
6446
6556
6666
6776
6886
6996
7007
7117
7227
7337
7447
7557
7667
7777
7887
7997
8008
8118
8228
8338
8448
8558
8668
8778
8888
8998
9009
9119
9229
9339
9449
9559
9669
9779
9889
9999

BASIC-9 特殊回文数 回文数 循环 条件语句

问题描述

123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n。

输入格式
输入一行，包含一个正整数n。

输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。

样例输入
52

样例输出
899998
989989
998899

n=int(input())
for i in range(1,10):
    for j in range(0,10):
        for k in range(0,10):
            if ((i+j)*2+k) == n:
                print(i*10001+j*1010+k*100)
for i in range(1,10):
    for j in range(0,10):
        for k in range(0,10):
            if (i+j+k)*2 == n:
                print(i*100001+j*10010+k*1100)

52
899998
989989
998899

n=int(input())	
for i in range(10000,1000000):
	a=str(i)
	if a[0]==a[-1] and a[1]==a[-2] and a[2] ==a[-3] and eval('+'.join(a))==n:
		print(i)

52
899998
989989
998899

BASIC-10 十进制转十六进制 循环 整除 求余 判断

问题描述

十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

a=int(input())
# print(hex(a)) # 0x1e
print(format(a, 'X')) # x 输出字母为小写 X 输出字母为大写

30
1E

BASIC-11 十六进制转十进制 进制转换 字符处理 判断

问题描述

从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。

注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

样例输入
FFFF

样例输出
65535

a=input()
print(int(a,16))

FFFF
65535

BASIC-12 十六进制转八进制 进制转换 字符 循环

问题描述
　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。

接下来n行，每行一个由0 ~ 9、大写字母A ~ F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式

输出n行，每行为输入对应的八进制正整数。

【注意】
　　输入的十六进制数不会有前导0，比如012A。

输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

n = int(input())
for i in range(n):
a = input()
ans = format(int(a,16),‘o’) #必须为小写o
print(ans)

BASIC-13 数列排序

给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

输入格式
　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。

输出格式
　　输出一行，按从小到大的顺序输出排序后的数列。

n = int(input())
arr = list(map(int, input().split()))
arr.sort()
for i in range(n):
    print(arr[i],end=' ') # end=' '输出' '后不换行

蓝桥杯对空格换行要求不高

BASIC-14 VIP试题 时间转换 取余 数字字符混合输出

问题描述
　　给定一个以秒为单位的时间t，要求用“< H > :< M>:< S>”的格式来表示这个时间。表示时间，< M > 表示分钟，而 < S > 表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。

输入格式
　　输入只有一行，是一个整数t（0<=t<=86399）。

输出格式
　　输出只有一行，是以“< H >:< M >:< S >”的格式所表示的时间，不包括引号。

样例输入
0

样例输出
0:0:0

样例输入
5436

样例输出
1:30:36

t=int(input())
H=t//3600
M=(t-H*3600)//60
S=t%60
print('%d:%d:%d'% (H, M, S))

5436
1:30:36

注意格式化print的写法：print(‘%d:%d:%d’% (H, M, S))

BASIC-15 VIP试题 字符串对比 字符串 大小写

问题描述
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：

1：两个字符串长度不等。比如 Beijing 和 Hebei

2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing

3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing

4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing

编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。

输入格式
　　包括两行，每行都是一个字符串

输出格式
　　仅有一个数字，表明这两个字符串的关系编号

样例输入
BEIjing
beiJing

样例输出
3

a=str(input())
b=str(input())
if len(a) != len(b):
    print("1")
elif a == b:
    print("2")
elif a.upper() == b.upper():
    print("3")
else:
    print("4")

BEIjing
beiJing
3

a='a'
a1=a.upper()
print(a1)
b='B'
b1=b.lower()
print(b1)

A
b

BASIC-16 VIP试题 分解质因数 质数分解 循环

问题描述
　　求出区间[a,b]中所有整数的质因数分解。

输入格式
　　输入两个整数a，b。

输出格式
　　每行输出一个数的分解，形如k=a1 * a2 * a3…(a1<=a2<=a3…，k也是从小到大的)(具体可看样例)

样例输入
3 10

样例输出
3=3
4=22
5=5
6=23
7=7
8=222
9=33
10=25

#import time

def is_prime(n):
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

a, b = map(int, input().split())
#start = time.time()
 
for i in range(a,b+1):
    if is_prime(i):  # 如果是素数，则等于它本身
        print(i, '=', i, sep='') # sep -- 用来间隔多个对象，默认值是一个空格。
# end -- 用来设定以什么结尾。默认值是换行符n，我们可以换成其他字符串。
    else:
        print(i, '=', sep='', end='')
        temp = i
        j = 2
        while j < i:
            if temp % j == 0: # 分解质因数，从j=2开始除,直到对i取余不为0时，才j += 1，保证每个j出现最多
                print(j,end='')
                temp=int(temp/j)
                if temp !=1:
                    print('*',end='')
            else:
                j=j+1
        print()
        
#print(time.time()-start)

3 10
3=3
4=2*2
5=5
6=2*3
7=7
8=2*2*2
9=3*3
10=2*5

temp=int(temp/j)比temp=temp/j所用时间更短，因为前者是整数运算，后者是浮点数运算。

BASIC-17 VIP试题 矩阵乘法 二维数组 循环 矩阵

问题描述
给定一个N阶矩阵A，输出A的M次幂（M是非负整数）

输入格式
第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值

输出格式
　　输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开

样例输入（N阶矩阵A）

2 2

1 2

3 4

样例输出（A的2次幂）

7 10

15 22

def multi(r_1,s_1,r_2,s_2): # 矩阵乘法函数
    if s_1[1] != s_2[0] : # 前提
        return
    else:
        r=[[0 for _ in range(s_1[0])] for _ in range(s_2[1])] # 初始化
        s=(s_1[0],s_2[1])
        for i in range(s_1[0]):
            for k in range(s_2[1]):
                for j in range(s_1[1]):
                    r[i][k] += r_1[i][j] * r_2[j][k]
        return r,s

# 读入数据，初始化
N,M = map(int,input().split())
r = [[] for _ in range(N) ]
# print(r) [[], []]
for i in range(N):
    arr = input().split()
    for j in range(N):
        r[i].append(int(arr[j]))
s=(N,N)
result,shape = r,s

# 计算矩阵
if M == 0 : # 单位矩阵,斜着的是1
    result = [[0 for _ in range(N)] for _ in range(N)]
    for i in range(N):
        result[i][i] = 1
else:
    for i in range(M-1):
        result,shape=multi(r,s,result,shape)

# 输出矩阵
for i in range(shape[0]):
    for j in range(shape[1]):
        print(result[i][j],end=' ')
    print()

2 2
1 2 
3 4
7 10 
15 22 

rect_ = [[0 for _ in range(1)] for _ in range(2)] #【【第一层循环】第二层循环】
print(rect_)

[[0], [0]]

幂==》递归算法 result,shape=multi(r,s,result,shape)

读入数据：先初始化一行，然后通过append函数添加这一行的数据

矩阵乘法：r[i][k] += r_1[i][j] * r_2[j][k]

BASIC-18 VIP试题 矩形面积交 判断 线段交

问题描述
　　平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。

输入格式
　　输入仅包含两行，每行描述一个矩形。
　　在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。

输出格式
　　输出仅包含一个实数，为交的面积，保留到小数后两位。

样例输入

1 1 3 3

2 2 4 4

样例输出

1.00

rect_1 = list(map(float, input().split()))
rect_2 = list(map(float, input().split()))

area = 0

x1 = max(min(rect_1[0], rect_1[2]), min(rect_2[0], rect_2[2]))
y1 = max(min(rect_1[1], rect_1[3]), min(rect_2[1], rect_2[3]))
x2 = min(max(rect_1[0], rect_1[2]), max(rect_2[0], rect_2[2]))
y2 = min(max(rect_1[1], rect_1[3]), max(rect_2[1], rect_2[3]))

if x1 < x2 and y1 < y2:
    area = (x2 - x1) * (y2 - y1)
    print('%.2f' % area)
else:
    print('%.2f' % area)

1 1 3 3
2 2 4 4 
1.00

矩阵交集条件：

max(矩阵A、B的最小横坐标) = x1 > min(最大横坐标) = x2

纵坐标同理

矩阵面积交：area=(x2 - x1) * (y2 - y1)

BASIC-19 VIP试题 完美的代价 贪心算法

问题描述

回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
　　
交换的定义是：交换两个相邻的字符
　　
例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)

输入格式

第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)

第二行是一个字符串，长度为N.只包含小写字母

输出格式

如果可能，输出最少的交换次数。

否则输出Impossible

样例输入

5

mamad

样例输出

3

n = int(input())
pal = list(input())

count = flag = 0  # count统计交换的次数，flag判断是否已经有一个单独的奇个数的字符了
m = n - 1 # 倒数第二个字符

for i in range(m):  # 从头遍历到倒数第二个字符
    for k in range(m, i - 1, -1):  # 从后面往前一直到i寻找和pal[i]相同的pal[k]
        if k == i:  # 如果找不到相同的
            if n % 2 == 0 or flag == 1:  # impossible的两种情况:
                # n为偶数，有一个字符出现次数为奇数；
                # n为奇数，if已存在字符是奇数，又有一个字符是奇数
                print('Impossible')
                exit()
            flag = 1
            count += int(n / 2) - i
        elif pal[k] == pal[i]:
            for j in range(k, m):  # 找到相同的，进行交换
                pal[j], pal[j + 1] = pal[j + 1], pal[j]
                count += 1  # 计数器加1
            m -= 1  # 最后排好序的不在进行比较
            break

print(count)

n = int(input())
pal = list(input())

count=0 #交换次数
flag =0 #存在单独奇数字符
m=n-1

for i in range(m):#从头到尾遍历
    for k in range(m,i-1,-1): #从尾到头遍历
        if k == i: #全部遍历了，但没找到相同的
            if n%2==0 or flag ==1:
                print("Impossible")
        

# BASIC-20	VIP试题 数的读法	判断 函数

二手写笔记