Python蓝桥杯真题——基础练习（一）

Python蓝桥杯真题——基础练习（一）

• A+B问题
• 数列排序
• 十六进制转八进制
• 十六进制转十进制
• 十进制转十六进制
• 特殊回文数
• 回文数
• 特殊的数字
• 杨辉三角形
• 查找整数
• 数列特征
• 字母图形
• 01字串
• 闰年判断
• Fibonacci数列
• 圆的面积
• 序列求和

最近在刷蓝桥杯题目，按模块做一下笔记整理，顺便分享交流一下，有更好的解决方案欢迎大家共同提出探讨，以下源代码均为系统提交满分答案

A+B问题

问题描述

资源限制
Python时间限制：5.0s
问题描述
输入A、B，输出A+B。
输入格式
输入的第一行包括两个整数，由空格分隔，分别表示A、B。
输出格式
输出一行，包括一个整数，表示A+B的值。
样例输入
12 45
样例输出
57
数据规模与约定
-10000 <= A, B <= 10000。

源代码

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

问题分析

Python中输入单次只能输入一个变量，要实现单行输入多值，需要在input后添加split()，表示以空格分割输入的变量值。
注意直接添加后输入的变量为字符串，输入4 5会输出9，需要使用map(int,input().split())将变量转换为整型变量

测评结果

数列排序

问题描述

资源限制
Python时间限制：5.0s
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9

源代码

li_len = int(input())
li = list(map(int,input().split()))     #  将输入的字符串按空格分割并转换为整型存储到列表中
li.sort()   # 将列表排序（默认升序）
for i in range(li_len):         #  输出前li_len个数
    print(li[i],end=' ')

问题分析

利用list列表的原生sort方法实现排序。将输入的字符串利用split()进行分割，再利用map(int,iterator)将分割后的元素转为整型（这一步不可以省略，否则会扣分），最后使用list()创建列表，这样就可以使用sort()进行排序了

测评结果

十六进制转八进制

问题描述

资源限制
Python时间限制：5.0s
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0_{9、大写字母A}F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274

源代码

n = int(input())
li = []     #  创建列表
for i in range(n):
    li.append(input())		#  输入数据
for num in li:
    if len(num) <= 100000:		#  判断长度是否符合要求
            print(oct(int(num,16))[2:])		#  将元素转换为十进制后转换为八进制，从第三位开始取数并输出

问题分析

本题中将十六进制转换为八进制，考虑到需要将十六进制转为十进制，再转为八进制，int(num,16)表示将十六进制的数转换为十进制，如果不在后赘述16，直接使用int(num)表示将字符串转为整型，转换结果会出错，oct()表示将十进制数值转换为八进制，转换完成后八进制数前有0o前缀，使用[2：]从第三位开始取值，从而去掉0o

测评结果

十六进制转十进制

问题描述

资源限制
Python时间限制：5.0s
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535

源代码

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

问题分析

int(num,16)表示将十六进制的数转换为十进制，如果不在后赘述16，直接使用int(num)表示将字符串转为整型，转换结果会出错

测评结果

十进制转十六进制

问题描述

资源限制
Python时间限制：5.0s
问题描述
十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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())
if 0<=num<=2147483647:		#  判断数值是否符合范围
    print(hex(num)[2:].upper())		#  转换为十六进制，从第三位取数并将字母转为大写

问题分析

hex(num)表示将十进制的数转换为十六进制，转换完成后八进制数前有0x前缀，使用[2：]从第三位开始取值，从而去掉0x，此处需注意输出后的字母为大写，因此使用upper将字母转换为大写

测评结果

特殊回文数

问题描述

资源限制
Python时间限制：5.0s
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
1<=n<=54。

源代码

n = int(input())
for i in range(10000,100000):
    a1 = i % 10   #  个位数
    a2 = i // 10 % 10    #  十位数
    a3 = i // 100 % 10      #  百位数
    a4 = i // 1000 % 10      #  千位数
    a5 = i // 10000  # 万位数
    if a1+a2+a3+a4+a5 == n and a1 == a5 and a2 == a4:
        print(i)
for i in range(100000,1000000):
    a1 = i % 10   #  个位数
    a2 = i // 10 % 10    #  十位数
    a3 = i // 100 % 10      #  百位数
    a4 = i // 1000 % 10      #  千位数
    a5 = i // 10000 % 10  # 万位数
    a6 = i // 100000    #  十万位数
    if a1+a2+a3+a4+a5+a6 == n and a1 == a6 and a2 == a5 and a3 == a4:
        print(i)

问题分析

数值较小，直接进行枚举，暴力破解

测评结果

回文数

问题描述

资源限制
Python时间限制：5.0s
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。

源代码

for i in range(1000,10000):
    a1 = i % 10   #  个位数
    a2 = i // 10 % 10    #  十位数
    a3 = i // 100 % 10      #  百位数
    a4 = i // 1000      #  千位数
    if a1 == a4 and a2 == a3:
        print(i)

问题分析

数值较小，直接进行枚举，暴力破解

测评结果

特殊的数字

问题描述

资源限制
Python时间限制：5.0s
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
源代码

for i in range(100,1000):
    a1 = i % 10   #  个位数
    a2 = i // 10 % 10    #  十位数
    a3 = i // 100      #  百位数
    if a1*a1*a1+a2*a2*a2+a3*a3*a3 == i:
        print(i)

问题分析

数值较小，直接进行枚举，暴力破解

测评结果

杨辉三角形

问题描述

资源限制
Python时间限制：5.0s
问题描述
杨辉三角形又称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。

源代码

n = int(input())
#  创建二维数组
li = [[]for i in range(n)]
for i in range(n):
    for j in range(i+1):
        if j == 0:
            li[i].append(1)  # 第一个元素取1
        elif j < i:
            li[i].append(li[i - 1][j - 1] + li[i - 1][j])  # 非两边元素取肩值
        else:
            li[i].append(1)  # 最后一个元素取1
for i in range(n):
    print(" ".join(map(str,li[i])))     #  将每行列表值转换为字符串并输出

问题分析

本题难点在于二维数组的创建与列表-字符串的转换
二维数组通过[[]for i in range(n)]创建，其中n为一维数组的值，等于a[i][j]中的i，通过debug查看二维数组创建结果如下图（n=5）
列表-字符串的转换通过string.join(iterator)实现，其中string代表字符串的分割符，join只处理字符串，对于存在整型的列表，需要使用map(str,iterator)将其转换为字符串
对于杨辉三角形值的分析：每行i中右侧值数量为i+1个，因此j应当从0遍历到i+1，对于每一行具体的值，两侧值为1，中间数值为其肩上两数之和

测评结果

查找整数

问题描述

资源限制
Python时间限制：5.0s
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模和约定
1 <= n <= 1000。

源代码

n = int(input())
str_sp = input().split()
num = input()
tag = -1
for i in range(n):
    if str_sp[i] == num:
        tag = i+1
        break
print(tag)

问题分析

数值较小，遍历查找即可

测评结果

数列特征

问题描述

资源限制
Python时间限制：5.0s
问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模和约定
1 <= n <= 10000。

源代码

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

问题分析

Python中对于列表有原生的最值、求和处理方法，需注意仅列表元素为整型时可用，将输入的字符串利用split()进行分割，再利用map(int,iterator)将分割后的元素转为整型（这一步不可以省略，否则会出错），最后使用list()创建列表

测评结果

字母图形

问题描述

资源限制
Python时间限制：5.0s
问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模和约定
1 <= n <= 10000。

源代码

words = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
n,m = map(int,input().split())    #  n行m列
for i in range(n):
    word = words[i:0:-1]+words[0:m-i]	#  rear+front
    print(word[0:m])

问题分析

对于每一行数值，我们可以将其拆分成两部分前逆序部分rear和后顺序部分front
观察第i行（i从0开始）的rear部分可以发现rear为A后i个字母的逆序输出（不包括A），因此对于rear可以表示成words[i:0:-1]，i为A后的i个元素，0代表第0个元素A，由于切片查找的方式属于左闭右开区间，因此取不到0（即取不到A），-1代表步频step为-1，即逆序遍历查找（注意此处需要逆序遍历，因此i与0的位置不可交换，需要保持i始终>0）
对于front从0（A）遍历到m-i即可
对于某些特殊情况，例如列数m（每行值的数量）小于rear的数量，此时我们rear+front会出错。对此有两种解决方案：（1）对于特殊情况进行具体的分析与判断 （2）将每行rear+front求出，在输出时只输出前m个元素即可 。在此采用第二种方案，print(word[0:m])输出前m个元素

测评结果

01字串

问题描述

资源限制
Python时间限制：5.0s
问题描述
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。
输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>
源代码

for i in range(32):
    print(bin(i)[2:].zfill(5))

问题分析

通过对题目输出的分析，发现这是输出由0到31的五位二进制数，考虑使用for循环+bin()的方法解决，bin()将十进制数转换为二进制数，但转换后仍存在0b，如下图1，使用切片访问[2:]从第三位开始取值，从而删除0b前缀，删除前缀后发现前几位位数不足五位不显示0,如下图2，使用zfill()对二进制位数进行规定，不足补0

测评结果

闰年判断

问题描述

资源限制
Python时间限制：5.0s
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1.年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
样例输入
2013
样例输出
no
源代码

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

测评结果

Fibonacci数列

问题描述

资源限制
Python时间限制：5.0s
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
样例输入
10
样例输出
55
数据规模和约定
1 <= n <= 1,000,000。

源代码

li = [0,1,1]    #  0无意义，后两位1代表F1=F2=1
n = int(input())
for i in range(3,n+1):  #  从下标3开始计算
    li.append((li[i-1] + li[i-2]) % 10007)      #  将前两位数相加模运算后再赋值
print(str(li[-1:])[1:-1])

问题分析

本题正常思路为将目标数计算后进行模运算，当n足够大时，Fn也足够大，显然会导致超时，因此求值取模不可取。
本题应当使用迭代运算，突破点在于理解Fn%10007 = （Fn-1 + Fn-2）% 10007,即对于每次Fn计算可以使Fn-1和Fn-2相加后取模再赋值给Fn，这样便可保证每次Fn运算结果控制在10007内，能充分保证时间复杂度
计算完成后列表中最后一个数代表我们要求的数，使用切片逆序访问li[-1:]，代表最后一个元素开始到结束，但取出后的结果携带列表的花括号[num]，显然这不是我们要的结果,于是可以将其转为字符串再使用切片访问[1:-1]从1访问到-1（下标从0开始，左闭右开区间，[1：-1] 代表从第二位数到倒数第二位数）

测评结果

圆的面积

问题描述

资源限制
Python时间限制：5.0s
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
样例输入
4
样例输出
50.2654825
数据规模和约定
1 <= r <= 10000。
源代码

PI = 3.14159265358979323
r = int(input())
s = PI*r*r
print("{:.7f}".format(s))

问题分析

本题重点考察浮点数精度取值，还有一个比较不容易注意到的 PI的取值。
本题中要求保留七位数且四舍五入，r的取值最大为10000，由于s = PI * r * r，因此PI取值必须大于4 + 4 +（7+1）位，如果精度过小会导致最终取值不准确
精度的取值使用format()方法格式化，"{:.7f}".format(s)代表对s字符串进行格式化，保留七位小数（四舍五入）

测评结果

序列求和

问题描述

资源限制
Python时间限制：5.0s
问题描述
求1+2+3+…+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+…+n的值。
样例输入
4
样例输出
10
数据规模和约定
1 <= n <= 1,000,000,000。
说明：请注意这里的数据规模。
本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。
本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。
如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。

源代码

n = int(input())
print("{:.0f}".format((1+n)*n/2))

问题分析

题目中已经给出提示，暴力破解的方法会导致超时，由此这种等差数列的求和我们需要使用数学公式(n+1)*n/2来解决，"{:.0f}".format()代表输出0位小数、

测评结果