蓝桥杯题库

一、入门训练

1. 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取余数，直接计算余数往往比先算出原数再取余简单。

代码

1
2
3
4
5

n=int(input())#键盘读入
F1,F2=1,1
for i in range(3,n+1):
    F1,F2=F2%10007,(F1+F2)%10007#先取余再递推防止超时
print(F2)

2. 圆的面积

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

   ==============

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

   1 2 3 4

   import math #import导入math库函数 r=int(input()) #input()是获取键盘读入函数，int()是强制类型转换为整型 s=math.pi*r*r #math.pi是调用math库函数中的Π print('%.7f'%s)

3. 数列求和

   问题描述：
   求1+2+3+…+n的值。
   输入格式
   输入包括一个整数n。
   输出格式
   输出一行，包括一个整数，表示1+2+3+…+n的值。

   1 2 3 4 5 6 7 8 9 10 11

   n = int(input()) # s = 0 # for i in range(1,n+1): #s +=i #s = s +i # print(s) #注意这里不能直接迭代求和，一方面占用资源多，另一方面可能会超时。 #仔细分析问题发现是一道等差数列求和问题，直接用数学公式解决 sum = (1+n)*n/2 print(sum)

二、基础训练

1. 数列排序

   资源限制

   时间限制：1.0s 内存限制：512.0MB

   问题描述

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

   输入格式

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

   输出格式

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

   样例输入

   5
   8 3 6 4 9

   样例输出

   3 4 6 8 9

1
2
3
4
5
6

n = int(input())
if n>=1 and n<=200:
    lst = list(map(int,input().split()))
    lst.sort()
    for i in lst:
        print(i,end=" ")

2. 十六进制转换八进制

资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

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

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

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

　　【提示】
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

1
2
3
4
5
6
7
8
9
10
11
12

n =int(input())
if n >= 1 and n <= 10:
    lst = []
    for i in range(n):
        hex = input()
        if len(hex) <= 100000:
            s1 = int(hex,16)
            s2 = oct(s1)
            lst.append(s2[2:])

    for i in lst:
        print(i)

3. 十六进制转换十进制

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

样例输入

FFFF

样例输出

65535

1
2
3

n = input()
if len(n) <= 8:
    print(int(n,16))

4. 十进制转换十六进制

资源限制

时间限制：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

1
2
3
4

a = int(input())
if a >= 0 and a <= 2147483647:
    s = hex(a).upper()
    print(s[2:])

5. 特殊回文数

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输入格式

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

输出格式

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

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

1
2
3
4
5
6
7
8
9

n = int(input())
for i in range(10000,1000000):
    a = str(i)
    s = 0
    if a == a[::-1]:
        for j in a :
            s += int(j)
        if s == n:
            print(a)

6. 回文数

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输出格式

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

1
2
3
4
5

lst = []
for i in range(1000,10000):
    a = str(i)
    if a == a[::-1]:
        print(a)

7. 特殊的数字

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输出格式

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

1
2
3
4
5

for i in range(100,1000):
    a = str(i)
    s = pow(int(a[2]),3) + pow(int(a[1]),3) + pow(int(a[0]),3)
    if s == i:
        print(i)

8. 杨辉三角

资源限制

时间限制：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。

1
2
3
4
5
6
7
8
9
10
11

n=int(input())
nums=[[0]*n for i in range(n)]#初始化一个n*n的零阵
for i in range(n):
    for j in range(n):
        if j==0:
            nums[i][j]=1
        else:
            nums[i][j]=nums[i-1][j-1]+nums[i-1][j]
        if nums[i][j]!=0:
            print(nums[i][j],end=' ')
    print()

9. 查找整数

资源限制
时间限制：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。

1
2
3
4
5
6
7

n = int(input())
lst = list(map(int,input().split()))
a = int(input())
if a in lst:
    print(lst.index(a)+1)
else:
   print(-1)

10. 数列特征

资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给出n个数，找出这n个数的最大值，最小值，和。

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

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

输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模与约定
1 <= n <= 10000。

1
2
3
4
5
6
7

n = int(input())
lst = list(map(int,input().split()))
lst = sorted(lst,reverse=True)
print(lst[0])
lst = sorted(lst)
print(lst[0])
print(sum(lst))

11. 字母图形

资源限制
时间限制：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。

1
2
3
4
5
6
7
8
9

n,m = map(int,input().split())
for i in range(n):
    for j in range(m):
        print(chr(65 + abs(i - j)),end="")
    print("")
    
# ord（）函数就是用来返回单个字符的ascii值（0-255）或者unicode数值（）
# chr（）函数是输入一个整数[0，255]返回其对应的ascii符号，两个函数的作用刚好相反

12. 01字串

问题描述
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100

请按从小到大的顺序输出这32种01串。
输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>

1
2
3
4

for i in range(32):
    a = bin(i)[2:]
    a = '0000' + a
    print(a[-5:])

13. 闰年判断

资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
给定一个年份，判断这一年是不是闰年。

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

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

2. 年份是400的倍数。

其他的年份都不是闰年。

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

样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。

1
2
3
4
5

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

14. 斐波那契数列

资源限制
时间限制：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。

1
2
3
4
5

n = int(input())
F1 = F2 = 1
for i in range(3,n+1):
    F1,F2 = F2%10007,(F1+F2)%10007
print(F2)

15. 圆的面积

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

给定圆的半径r，求圆的面积。

输入格式

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

输出格式

输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。

说明：在本题中，输入是一个整数，但是输出是一个实数。

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

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

样例输入

4

样例输出

50.2654825

数据规模与约定

1 <= r <= 10000。

提示

本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。

1
2
3
4

import math      #import导入math库函数
r=int(input())    #input()是获取键盘读入函数，int()是强制类型转换为整型
s=math.pi*r*r     #math.pi是调用math库函数中的Π
print('%.7f'%s)

16. 序列求和

资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
求1+2+3+…+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+…+n的值。
样例输入
4
样例输出
10
样例输入
100
说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。

一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。

样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
说明：请注意这里的数据规模。

本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。

本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。

如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。

1
2
3
4
5
6
7
8
9
10
11

#第一种:
n = int(input())
s = (1+n)*n/2
print(int(s))

#第二种:
n=int(input())#input()是获取键盘读入函数
#注意这里不能直接迭代求和，一方面占用资源多，另一方面可能会超时。
#仔细分析问题发现是一道等差数列求和问题，直接用数学公式解决
sum=0.5*n*n+0.5*n
print(int(sum))

17. 阶乘计算

题目描述
输入一个正整数n，输出n!的值。
其中n!=123…n。
算法描述
n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。
输入
输入包含一个正整数n，n< =1000。
输出
输出n!的准确值。

python语言本身具有大数据和傅里叶乘法优化功能，具有无限精度的int类型。可以不通过数组存储阶乘位就能AC

1
2
3
4
5
6
7
8
9
10

# 方法一: 调用 math 库中的 factorial(阶乘)函数
import math
print(math.factorial(int(input())))

# 方法二: for 循环
n = int(input())
s = 1
for i in range(1,n+1):
    s *= i
print(s)

18. 高精度加法

题目描述
输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。
算法描述
由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
最后将C输出即可。
输入
输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。
输出
输出一行，表示a + b的值。
样例输入
20100122201001221234567890
2010012220100122
样例输出
20100122203011233454668012

1
2
3

a = int(input())
b = int(input())
print(a + b)

19. Huffuman树

题目描述
Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：

找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
重复步骤1，直到{pi}中只剩下一个数。
在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。
例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。
输入
输入的第一行包含一个正整数n（n< =100）。
接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
输出
输出用这些数构造Huffman树的总费用。

1
2
3
4
5
6
7
8
9
10
11
12
13

n = int(input())
s = 0
lst = list(map(int,input().split()))
if n == 1:
    print(lst[0])
lst.sort()
while len(lst) != 1:
    pa = lst.pop(0)
    pb = lst.pop(0)
    lst.append(pa + pb)
    s += (pa +pb)
    lst.sort()
print(s)

20. 报时助手

题目描述
给定当前的时间，请用英文的读法将它读出来。
时间用时h和分m表示，在英文的读法中，读一个时间的方法是：
如果m为0，则将时读出来，然后加上“o’clock”，如3:00读作“three o’clock”。
如果m不为0，则将时读出来，然后将分读出来，如5:30读作“five thirty”。
时和分的读法使用的是英文数字的读法，其中0~20读作：
0:zero, 1: one, 2:two, 3:three, 4:four, 5:five, 6:six, 7:seven, 8:eight, 9:nine, 10:ten, 11:eleven, 12:twelve, 13:thirteen, 14:fourteen, 15:fifteen, 16:sixteen, 17:seventeen, 18:eighteen, 19:nineteen, 20:twenty。
30读作thirty，40读作forty，50读作fifty。
对于大于20小于60的数字，首先读整十的数，然后再加上个位数。如31首先读30再加1的读法，读作“thirty one”。
按上面的规则21:54读作“twenty one fifty four”，9:07读作“nine seven”，0:15读作“zero fifteen”。
输入
输入包含两个非负整数h和m，表示时间的时和分。非零的数字前没有前导0。h小于24，m小于60。
输出
输出时间时刻的英文。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

h,m = input().split()
hour_list = ["zero","one","two","three","four","five",'"six"',"seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","ninteen","twenty","twenty one","twenty two","twenty three"]
min_list =["zero","one","two","three","four","five",'"six"',"seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","ninteen","twenty"]
mine_list = ["","","twenty","thirty","forty","fifty","sixty"]
# print(hour_list)
# print(min_list)
if len(h) ==1:
    if len(m) ==1 and int(m) != 0:      #eg: 2:08
        print(hour_list[int(h)] + " " + min_list[int(m)])
    elif len(m) == 1 and int(m) == 0:     # eg: 2:00
        print(hour_list[int(h)] + " " + "o’clock")
    elif len(m) == 2 and 10 <= int(m) <= 20:    # eg: 2:17
        print(hour_list[int(h)] + " " + min_list[int(m)])
    elif len(m) == 2 and int(m) >= 20:      #eg； 2:21
        print(hour_list[int(h)] + " " + mine_list[int(m[0])] + " " + min_list[int(m[1])])
if len(h) == 2:
    if len(m) ==1 and int(m) != 0:      #eg: 21:08
        print(hour_list[int(h)] + " " + min_list[int(m)])
    elif len(m) == 1 and int(m) == 0:     # eg: 21:00
        print(hour_list[int(h)] + " " + "o’clock")
    elif len(m) == 2 and 10 <= int(m) <= 20:    # eg: 21:17
        print(hour_list[int(h)] + " " + min_list[int(m)])
    elif len(m) == 2 and int(m) >= 20:      #eg； 21:21
        print(hour_list[int(h)] + " "+ mine_list[int(m[0])] +" "+ min_list[int(m[1])])