蓝桥杯python入门基础

最新推荐文章于 2024-04-14 10:16:50 发布

清忖灬

最新推荐文章于 2024-04-14 10:16:50 发布

阅读量1.6k

点赞数 2

分类专栏：蓝桥杯文章标签：蓝桥杯 python

本文链接：https://blog.csdn.net/m0_60964321/article/details/124563627

版权

蓝桥杯专栏收录该内容

1 篇文章 1 订阅

订阅专栏

一、字符串逆序

1.将一个字符串str的内容颠倒过来并输出

输入：包括一行。第一行输入字符串

输出：转换好的逆序字符串

例子：输入i am a boy 输出：yob a ma i

num = input('输入字符串：')
print（num[::-1]）

二、闰年

闰年能被4整除但不能被100整除

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

三、水仙花数

值等于其每一位数字的立方和

百位可以num // 100 ；十位 num //10 % 10 ；个位 num % 10

pow（a, 3）即 a*a*a

num = int(input('输入数字：'))
if num == pow(num//100,3) + pow(num%10,3) + pow(num//10%10,3):
    print('yes')
else:
    print('no')

四、a+b

map函数可以将输入的字符进行一系列操作，同时也可以转换成int

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

五、圆的面积

导入python中的math库；保留小数点后两位为{:.2f}

import math
r = int(input())
PI = math.pi
area = (r**2) * PI
print('{:.2f}'.format(area))

六、斐波那契数列

def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n-1) + f(n-2)
for i in range(1, 101):
    if f(i) <= 100:
        print(f(i))
    else:
        break

七、序列求和

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

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

八、字符串对比

问题描述
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
1、两个字符串长度不等。比如 Beijing 和 Hebei
2、两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
3、两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
4、两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。

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

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

样例输入
BEIjing
beiJing

样例输出
3

n1 = input()
n2 = input()
def n(n1, n2):
    if len(n1) != len(n2):
        print('1')
    elif len(n1) == len (n2) and n1 == n2 :
        print('2')
    elif len(n1) == len(n2) and n1.upper() == n2.upper():
        print('3')
    elif len(n1) == len(n2) and n1.upper() != n2.upper():
        print('4')
n(n1, n2)

九、芯片测试

问题描述
有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。
每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。
给出所有芯片的测试结果，问哪些芯片是好芯片。
输入格式
输入数据第一行为一个整数n，表示芯片个数。
第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。
输出格式
按从小到大的顺序输出所有好芯片的编号
样例输入
3
1 0 1
0 1 0
1 0 1
样例输出
1 3

n = int(input())

arry = [list(map(int, input().split())) for i in range(0, n)]
num = 0
for i in range(0, n):
    for j in range(0, n):
        if arry[i][j] == 1 or arry[i][j] == 0:
            num = num+1
            if num <= n and arry[i][j] == 1:
                print(n*i+j+1)

十、完美的代价

问题描述
　　回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
　　交换的定义是：交换两个相邻的字符
　　例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)
输入格式
　　第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
　　第二行是一个字符串，长度为N.只包含小写字母
输出格式
　　如果可能，输出最少的交换次数。
　　否则输出Impossible
样例输入
5
mamad
样例输出
3

N = int(input())
s = list(input())
count = 0  
flag = 0
i = 0
a = True
len = N - 1
while i < len:
    if a == False:
        break

    for j in range(len, i - 1, -1):
        if i == j:
           
            if N % 2 == 0 or flag == 1:  
                print('Impossible')
                a = False
                break
            flag = 1  
            count += N // 2 -i  
        elif s[i] == s[j]:
            for k in range(j, len):
                s[k], s[k + 1] = s[k + 1], s[k]
                count += 1
                
            len -= 1
            break
                
    i += 1
if a == True:
    print(count)

十一、矩形面积交

问题描述
　　平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。
输入格式
　　输入仅包含两行，每行描述一个矩形。
　　在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。
输出格式
　　输出仅包含一个实数，为交的面积，保留到小数后两位。
样例输入
1 1 3 3
2 2 4 4
样例输出
1.00

A = list(map(float, input().split()))
B = list(map(float, input().split()))
A1 = (min(A[0], A[2]), min(A[1], A[3]), max(A[0], A[2]),max(A[1], A[3]))
B1 = (min(B[0], B[2]), min(B[1], B[3]), max(B[0], B[2]),max(B[1], B[3]))
if A1[2]-B1[0] < 0 or A1[3]- B1[1] < 0:
    print('0')
else:
    height = A1[2]-B1[0]
    width = A1[3]-B1[1]
    area = height * width
    
    print('{:.2f}'.format(area))

十一、阶乘计算

题目描述

输入一个正整数n，输出n!的值。

其中n!=1*2*3*…*n。

算法描述

n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。

将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。

首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。

输入

输入包含一个正整数n，n< =1000。

输出

输出n!的准确值。

样例输入复制

10
样例输出复制

3628800

n = int(input())
s = 1
for i in range(2, n+1):
    s = s * i
print(s)

十二、矩阵的乘法

问题描述

　　给定一个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

n, m = list(map(int,input().split()))
matrix = [list(map(int,input().split())) for i in range(n)]

def multi(n, mat1, mat2):
    out = []
    for i in range(n):
        result = []
        for j in range(n):
            result0 = 0
            for k in range(n):
                result0 += mat1[i][k] * mat2[k][j]
            result.append(result0)
        out.append(result)
    return out



if m == 0:
   
    temp = [[0] * n for i in range(n)]
   
    for i in range(n):
       
        temp[i][i] = 1
else:
    temp = matrix
    for i in range(m-1):
        temp = multi(n, temp, matrix)
for i in range(n):
    for j in range(n):
        print(temp[i][j], end=' ')
    print(' ')

十三、哈夫曼树

问题描述
　　Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
　　给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
　　1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
　　2. 重复步骤1，直到{pi}中只剩下一个数。
　　在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
　　本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。

例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
　　1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
　　2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
　　3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
　　4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
　　5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。
输入格式
　　输入的第一行包含一个正整数n（n<=100）。
　　接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
输出格式
　　输出用这些数构造Huffman树的总费用。
样例输入
5
5 3 8 2 9
样例输出
59

n = int(input())
H = list(map(int, input().split()))
value = 0

for i in range(n-1):
    H = sorted(H)
    value = value + H[0] + H[1]
    value_list = H[0] + H[1]
    H.pop(0)
    if len(H) != 0:
        H.pop(0)
        H.append(value_list)
    else:break
    
print(value)

十四、时间转换

问题描述
　　给定一个以秒为单位的时间t，要求用“H:M:S”的格式来表示这个时间。表示时间，表示分钟，而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())
if t >= 3600:
    s = t % 3600 % 60
    m = t // 60 % 60
    h = t // 3600
    print("{}:{}:{}".format(h, m, s))
elif t < 3600 and t >= 60:
    s = t % 3600 % 60
    m = t // 60 % 60
    h = 0
    print("{}:{}:{}".format(h, m, s))
elif t < 60 and t >= 0:
    s = t % 3600 % 60
    m = 0
    h = 0
    print("{}:{}:{}".format(h, m, s))

十五、分解质因数

问题描述
　　求出区间[a,b]中所有整数的质因数分解。
输入格式
　　输入两个整数a，b。
输出格式
　　每行输出一个数的分解，形如k = a 1 ∗ a 2 ∗ a 3... k=a1*a2*a3...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

def sushu(x):
 
    for i in range(2, x // 2 + 1):
        if x % i == 0:
            return False
        else:
            continue
    return True

def fenjie(x):
    # yinshu = []
    for i in range(2, x+1):
        if x % i == 0 and sushu(i):
            return i
a, b = input().split()
num = []
for i in range(int(a), int(b)+1):
    num.append(i)
vis = [0] * len(num)
for i in range(len(num)):
    if sushu(num[i]):
        vis[i] = 1
for i in range(len(vis)):
    if vis[i] == 1:
        print('{0}={1}'.format(num[i], num[i]))
    else:
        temp = []
        x = num[i]
        while 1:
            m = fenjie(x)
            temp.append(m)
            x = x // m
            if x == 1:
                break
        print(num[i],'=',end='',sep='')
        for j in range(len(temp)):
            if j == len(temp) - 1:
                print(temp[j])
            else:
                print(temp[j],'*',end='',sep='')

十六、报时助手

问题描述
　　给定当前的时间，请用英文的读法将它读出来。
　　时间用时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。
输出格式
　　输出时间时刻的英文。
样例输入
0 15
样例输出
zero fifteen

h, m = map(int, input().split())
list = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight','nine','ten', 'eleven', 'twelve','thirteen', 'fourteen', 'fiveteen', 'sixteen', 'seventeen', 'eighteen','nineteen', 'twennty']
list_hour = [' ', ' ', ' ','thirty', 'forty', 'fivety']
if m == 0:
    print(list[h] + "o'clock")
else:
    if h <= 20:
        if m <= 20 :
            print('{} {}'.format(list[h], list[m]))

        elif m > 20 and m < 60:
            a = m // 10
            b = m % 10
            if b == 0:
                print('{} {}'.format(list[h], list_hour[a]))
            else:
                print('{} {}'.format(list[h], list_hour[a] + ' ' + list[b]))

    elif h > 20 and h < 24:
        if m <= 20 :
            c = h % 10
            print('{} {}'.format(list[20] + ' ' + list[c], list[m]))

        elif m > 20 and m < 60:
            a = m // 10
            b = m % 10
            c = h % 10
            if b == 0:
                print('{} {}'.format(list[20] + ' ' + list[c], list_hour[a]))
            else:
                print('{} {}'.format(list[20] + ' ' + list[c], list_hour[a] + ' ' + list[b]))

总结

这些题目前前后后大概花了一个星期（有时候做不出来就放在一边摆烂）作为蓝桥杯的入门基础，有几点还是想提醒大家。

1、python一些字符串的常见操作要熟悉，比如split().、upper().、字符串逆序[::-1]；

2、python的math库，比如绝对值abs()、x的y次幂pow(x, y)；注意range()左闭右开；

3、保留两位小数{:.2f}.format()；

4、进制转换，转十六hex()、转八oct()；

5、输入两个数要为整型a,b=map(int, input().split())、二维数组matrix = [list(map(int,input().split())) for i in range(n)]；

6、最后，想不出来就暴力，for while if~ 上面的题目有不明白的可以评论私信交流哦。根据我身边人的推断，省三大概一道填空一道大题（当然各个省份不一样），大家加油！

清忖灬

关注

2
点赞
踩
58

收藏

觉得还不错? 一键收藏
打赏
0
评论
蓝桥杯python入门基础

一、字符串逆序1.将一个字符串str的内容颠倒过来并输出输入：包括一行。第一行输入字符串输出：转换好的逆序字符串例子：输入i am a boy 输出：yob a ma inum = input('输入字符串：')print（num[::-1]）二、闰年闰年能被4整除但不能被100整除year = int(input())if year % 4 == 0 and year % 100 !=0: print('yes')else: print('no')
复制链接

扫一扫