蓝桥杯-基础题python

蓝桥杯基础题题库连接：点我
需要题目的可以到题库里面去看看，或者直接在百度搜索题目名称

参加比赛的一些心得：感觉把比赛得那一门语言基础学会，输入输出（我写的python输入输出)，(C++的STL），熟练里面的数据结构，如数组，map等，主要还是基础。熟悉了后，可以在刷一下基础题，巩固哈学了的基础知识。把基础学好了，拿个奖是没问题的，正常发挥即可。想那个好的名词，就要看看相关的算法了，主要就是暴力的+优化，BFS,DFS，比较难的就是动态规划，得找转换方程。下面是当时参加比赛看的一些博客的链接，可参考：
蓝桥杯往年常考算法心得_蓝桥杯必考算法_不加冰可乐的博客-CSDN博客
蓝桥杯(简单算法模板)_蓝桥杯比赛电脑上可以存算法模版嘛_XDIGAS的博客-CSDN博客
蓝桥杯知识点总结【预备2020蓝桥杯】_Tanzq-blog的博客-CSDN博客
蓝桥杯及其搜索算法总结_蓝桥杯搜索算法_zhejiangjjw的博客-CSDN博客
蓝桥杯常用算法汇总_蓝桥杯必备算法_summerone123的博客-CSDN博客

0 python自带编译器使用

• 自动补全代码： Alt+/
• 加缩进： Ctrl+]
• 减缩进： Ctrl+[
• 加注释： Alt+3
• 去注释： Alt+4
• 调试：
  • 在编辑框右键设置断点(Set Breakpoint)
  • 点击Python Shell中的Debug->Debugger
  • 运行代码，Go运行到下一个断点，step一步一步运行

1 闰年判断

#basic-1 闰年判断
year = int(input())
if (year%4==0 and year%100!=0) or year%400==0:
	#闰年：能被四整除但不能被100整除，或者能被400整除
	print("yes")
else:
	print("no")

2 01字符串

#basic-2 01字符串
#1:0-32转二进制	
for i in range(0, 32):
    res = bin(i)
    res = int(res[2:])
    print("%05d" % res)

#2:直接以二进制输出
for i in range(0,32):
    print("{:05b}".format(i))

3 字母图形

#basic-3 字母图形
# chr(65) - A
#1 (有问题，这样只能row < col才可以)
row, col = map(int, input().split())
for i in range(0, row):
    for j1 in range(0,i):
        print(chr(65 + i - j1), end='')
    for j2 in range(i, col):
        print(chr(65 + j2 - i), end='')
    print()

#2
for i in range(0, row):
    for j in range(0, col):
        a = abs(i-j) #偏移
        print(chr(65 + a), end='')
    print()

4 数列特征

#basic-4 数列特征
n = int(input())
nums = list(map(int, input().split()))
res_sum = 0
res_max = -10001
res_min = 10001
if len(nums) == n:
    for i in range(0, n):
        res_sum += nums[i]
        res_max = max(res_max, nums[i])
        res_min = min(res_min, nums[i])
print(res_max)
print(res_min)
print(res_sum)

5 查找整数

#basic-5 查找整数
#1 调用列表自带函数index()获取出现第一个数字的下标
n = int(input())
nums = list(map(int, input().split()))
target = int(input())
if n == len(nums):
    try:
        #没有该目标的话会出现异常，用try..捕获
        res = nums.index(target)
        print(res + 1)
    except:
        print(-1)
        
#2 循环遍历查找
n = int(input())
nums = list(map(int, input().split()))
target = int(input())
def fun(nums, target):
    for i in range(0, len(nums)):
        if target == nums[i]:
            return i+1
    return -1
if n== len(nums):
    print(fun(nums, target))

6 杨辉三角

#basic-6 杨辉三角
n = int(input())
triangle = [[1],[1,1]]
for i in range(2,n):     #已经给出前两行，所以求剩余行
    cur = [1]            #定义每行第一个元素
    pre = triangle[i-1]  #上一行
    for j in range(i-1): #算几次
        cur.append(pre[j] + pre[j+1])
    cur.append(1)
    triangle.append(cur)
    
for i in range(n):
    for j in range(i+1):
        print(triangle[i][j], end = ' ')
    print()

7 特殊的数字

#basic-7 特殊的数字
for i in range(100, 1000):
    bai = i // 100
    shi = i // 10 % 10
    ge = i % 10
    if i == bai**3 + shi**3 + ge**3:
        print(i)

8 回文数

#basic-8 回文数
for i in range(1000, 10000):
    s = str(i)
    if s[0] == s[-1] and s[1] == s[-2]:
        print(i)

9 特殊回文数

#basic-9 特殊回文数
n = int(input())
sums = 0
for i in range(10000, 1000000):
    s = str(i)
    if (s[0]==s[-1]) and (s[1]==s[-2] and s[2]==s[-3]):
        for ch in s:
            sums += int(ch)
        if sums==n:
            print(i)   
        sums = 0

10 十进制转十六进制

#basic-10 十进制转(十六)进制
#1 除以十六
def _10to16(n, jinzhi = 16):
    if n == 0: return '0'
    res = []
    while n:
        num = n % jinzhi
        n = n // jinzhi
        if num > 9:
            res.append(chr(65 + num - 10))
        else:
            res.append(str(num))
        res = res[::-1]
    return ''.join(res)

n = int(input())  
print(_10to16(n))
#2
res = hex(n)
print(res[2:].upper())

11 十六进制转十进制

#basic-11 (十六)进制转十进制
#1
def _16to10(nstr, jinzhi = 16):
    res = 0
    for ch in nstr:
        if (ch > 'A' or ch == 'A') and (ch < 'Z' or ch == 'Z'):
            res = res*jinzhi + ord(ch) - ord('A') + 10
        else:
            res = res*jinzhi + ord(ch) - ord('0')
    return res
nstr = inpu t()
print(_16to10(nstr))
#2
dec = int(nstr, 16)
print(dec)

12 十六进制转八进制

#basic-12 十六进制转八进制
n = int(input())
while n:
    n = n - 1
    nstr = input()
    dec = int(nstr, 16) #十六进制转十进制
    res = oct(dec)[2:] #十进制转八进制
    print(res)

13 数列排序

#basic-13 数列排序
n = int(input())
nums = list(map(int, input().split()))
#1
nums.sort()
print(nums)

#2 快速排序
def point(nums, left, right, flag=0):
    n1 = nums[right] #选取最后一个作为主元素（可以随机选取，然后放到最右边一个）
    i = left #双指针的左指针，最后用来存n1,若flag=0,则i左边的都小于或等于n1,右边的都大于n1
    for j in range(left, right):
        if flag == 0: #默认升序
            if nums[j] < n1 or nums[j] == n1: #将比n1小或等于的移到左边
                nums[i], nums[j] = nums[j], nums[i]
                i = i + 1
        else:
            if nums[j] > n1 or nums[j] == n1: #将比n1大于或等于的移到左边
                nums[i], nums[j] = nums[j], nums[i]
                i = i + 1
    nums[i], nums[right] = nums[right], nums[i]
    return i;

def quicksort(nums, left, right):
    if left < right: #结束条件
        pos = point(nums, left, right) #找一个点，左边比这个数小，右边比这个数大
        quicksort(nums, left, pos-1) #对左边在排序
        quicksort(nums, pos+1, right) #对右边排序
        
quicksort(nums, 0, len(nums) - 1)
print(nums)

14 时间转换

#basic-14 时间转换
n=int(input())
shi = n // 3600
fen = n % 3600 // 60
miao = n % 60
print('{}:{}:{}'.format(shi, fen, miao))

15 字符串对比

#basic-15 字符串对比
str1 = input()
str2 = input()

if len(str1) != len(str2):
    print(1)
else:
    if str1 == str2:
        print(2)
    elif str1.lower() == str2.lower():
        print(3)
    else:
        print(4)

16 分解质因数

#basic-16 分解质因数
#先从2开始分解，2， 3， 5，7，，，，
def fun(n):
    flag = True
    i = 2
    print('{}='.format(n), end='')
    while n > 1:
        if n % i == 0:
            if flag:
                print(i, end='')
                flag = False
            else:
                print('*{}'.format(i), end='')
    
            n = n // i
        else:
            i += 1
    print()

a, b = map(int, input().split())
for i in range(a, b + 1):
    fun(i)

17 矩阵乘法

#basic-17 矩阵乘法
def mul(arr1, arr2):
    #计算两个矩阵的积
    length = len(arr1)
    res = [[0 for i in range(0, length)] for j in range(0, length)]
    for i in range(0, length):
        for j in range(0, length):
            for k in range(0, length):
                res[i][j] += arr1[i][k]*arr2[k][j]
    return res

def mul_m(arr, m):
    #计算矩阵的m次幂
    res = arr
    for i in range(1, m):
        res = mul(res, arr)
    return res

n, m = map(int, input().split())
arr =[[0 for i in range(0, n)] for j in range(0, n)]
for i in range(0, n):
    arr[i] = list(map(int, input().split()))

#判断m的情况，m为零则为单位矩阵，m为1为原矩阵
if m == 0:
    for i in range(0, n):
        for j in range(0, n):
            if i == j: print(1, end=' ')
            else: print(0, end=' ')
        print()

if m == 1:
    for i in range(0, n):
        for j in range(0, n):
            print(arr[i][j], end=' ')
        print()
else:
    res = mul_m(arr, m)
    for i in range(0, n):
        for j in range(0, n):
            print(res[i][j], end=' ')
        print()

18 矩形相交面积

#basic-18 矩形相交面积
x11, y11, x12, y12 = map(float, input().split())
x21, y21, x22, y22 = map(float, input().split())
#右上角的点
x31 = min(max(x11, x21), max(x12, x22))
y31 = min(max(y11, y21), max(y12, y22))
#左下角的点
x32 = max(min(x12, x22), min(x11, x21))
y32 = max(min(y12, y22), min(y11, y21))

if x31 > x32 and y31 > y32:
    res = (x31 - x32) * (y31 - y32)
    print('%.2f' % res)
else:
    print('0.00')

19 完美代价

#basic-19 完美的代价
#主要思想：因为从两边读要一样，则从两边开始找，固定左边，从右边开始寻找与左边字符相等的，
#然后左指针加1，右指针减一，然后在剩下的字符串中重复以上步骤（要注意出现奇数次的字符）
def fun(s):
    res = 0 #记录结果
    flag = False #用于判断字符串中单个字符为奇数的个数，因为该串中只能有一个出现奇数次的字符
    N = len(s)
    j = N - 1
    for i in range(N):
        #从前往后
        for k in range(j, i - 1, -1):
            #从后往前扫描
            if k == i:
                #扫描到一个出现奇数次的字符，如果原字符串长度为偶数，则直接退出程序
                #否则该字符串为奇数个字符，可以将该字符放到中间构成回文字串，这时将flag置为True
                #如果下次再扫描到一个出现奇数次的字符，也会直接退出程序
                if n % 2 == 0 or flag:
                    print("Impossible")
                    return 0
                flag = True
                #有一个奇数次出现的字符移动的代价，相当于从i位置移动到中间的位置，代价为N // 2 - i
                res = res + N // 2 - i
            elif s[i] == s[k]:
                #找到右边与左边匹配的了，然后从k位置一步一步移到j位置，每移动一次res加1
                for t in range(k, j):
                    res += 1
                    s[t], s[t+1] = s[t+1], s[t]
                j -= 1
                break
    print(res)
    return res

n = int(input())
s = list(input())
res = fun(s)

20 数的读法

#basic-20 数的读法
# https://blog.csdn.net/i6223671/article/details/104395716
#读数分为三种情况：
#为零：正好在万或者亿位上；零连续的情况
#开头为10 万亿
#一般情况：数字＋单位
def fun(nums):
    num = ["ling","yi","er","san","si","wu","liu","qi","ba","jiu"] #数字的拼音
    unit = [ "", "", "shi", "bai", "qian", "wan", "shi", "bai", "qian", "yi", "shi"] #单位的拼音

    n = len(nums)
    for i in range(n):
        x = int(nums[i])
        if x == 0:
            if n-i == 5 or n-i == 9:
                # 判断万和亿,在5或者9上面为零，需要将单位读出来
                print(unit[n-i], end=' ')
            if n-i != 1 and nums[i+1] != '0':
                # 判断连续的零，不是最后一个零，且该零后面不为零需要读零出来
                print('ling', end=' ')
        elif (n == 2 or n == 6 or n == 10) and x == 1 and i == 0:
            #1开头（10， 十万，十亿）
            print('shi', end=' ')
        else:
            #一般情况，数字＋单位
            print(num[x] + ' ' + unit[n-i], end=' ')

        
n = input()
res = fun(n)

21 Sine之舞

##basic-21 Sine之舞
##先表示An，在表示Sn，主要就是找规律
def An(n):
##    打印An
    for i in range(1, n+1):
        print('sin({}'.format(i), end='')
        if i == n: #打印结束括号
            print(i*')', end='')
        elif i&1: #奇数打印-
            print('-', end='')
        else: #偶数打印+
            print('+', end='')

def Sn(n):
##    打印Sn
    print((n-1)*'(', end='') #打印开始符号
    for i in range(1, n+1):
        An(i)
        #判断是否是最后一个，最后一个不需要右括号
        if i != n:
            print('+{})'.format(n-i+1), end='')
        else:
            print('+{}'.format(n-i+1), end='')
            
n = int(input())
Sn(n)

22 FJ的字符串

#basic-22 FJ的字符串
##假设数字为5，则是数字4对应的字串+E（第五个字符）+数字4对应的字串
##1 循环
def An(n):
    res = ['A']
    temp = []
    for i in range(1, n):
        #两个列表直接赋值，两个列表等价，一个变另外一个也要变
        temp = res.copy() #浅拷贝， 深拷贝在copy库中，new=copy.deepcopy(old)
        res.append(chr(ord('A')+i)) #转成ASCII码加i后在转成字符
        print (temp)
        print (res)
        res = res + temp
    res = ''.join(res) #将列表中字符连接成字符串
    print(res)
##2 递归
def An_r(n):
    if n == 1: #递归结束条件
        print('A', end='')
    else:
        An_r(n-1)#打印该数字前面的字符串
        print(chr(ord('A')+n-1), end='') #打印当前数字的对应的字符
        An_r(n-1)

n = int(input())
An_r(n)

23 芯片测试

#basic-23 芯片测试
#如果某一列的测试结果好的大于这一列的一半，则说明该芯片是好的
def fun(n, nums):
    judge = n // 2
    for i in range(n):
        summ = 0
        for j in range(n):
            summ += nums[j][i]
        if summ > judge:
                print(i+1, end=' ')   

n = int(input())
nums = []
for i in range(n):
    nums.append(list(map(int, input().split())))

fun(n, nums)

24 龟兔赛跑预测

#basic-24 龟兔赛跑预测
def fun(v1, v2, t, s, le):
    #兔子速度v1，乌龟速度v2，领先t米等s秒，总距离为l
    s1 = 0 #兔子的路程
    s2 = 0 #乌龟的路程
    time = 0 #计时
    stop = False #停止标志
    ts = 0 #计时停止时间
    while True:
        if s1 >= le or s2 >= le:
            if s1 >= le and s2 < le:
                print('R')
            elif s1 < le and s2 >= le:
                print('T')
            else:
                print('D')
            print(time)
            break
            
        time += 1
        s2 += v2
        if stop and ts != 0:
            ts -= 1
        else:
            stop = False
            s1 += v1
        if s1 - s2 >= t and not stop:
            ts = s
            stop = True

v1, v2, t, s, l = map(int, input().split())
fun(v1, v2, t, s, l)

25 回形取数

# basic-25 回形取数
def fun(nums, n, m):
    #确定循环的圈数，取行列最小的
    if n < m:
        c = n
    else:
        c = m
    if c & 1 == 0:
        c = c // 2
    else:
        c = c // 2 + 1
    for i in range(c):
        #外层圈数循环
        #左
        for j in range(i, n-i):
            #第一个数不打印空格，第二个数在前面打印空格，以满足最后不打印空格
            if i == 0 and j == 0:
                print(nums[j][i], end='')
            else:
                print(' ', nums[j][i], end='')
        #下
        for j in range(i+1, m-i):
            print(' ', nums[n-1-i][j], end='')
        #右
        for j in range(n-2-i, i-1, -1):
            #防止有奇数圈的最后一圈重复读，最后一圈仅为一行或一列
            if m % 2 != 0 and i == c-1: #在顺时针取数时，存在一些问题，可以判断打印的元素是否与矩阵的总元素是否相等来作为break条件，间leetcod 29
                break
            print(' ', nums[j][m-1-i], end='')
        #上
        for j in range(m-2-i, i, -1):
            #防止有奇数圈的最后一圈重复读，最后一圈仅为一行或一列
            if n % 2 != 0 and i == c-1:
                break
            print(' ', nums[i][j], end='')

nums = []
n, m = map(int, input().split())
for i in range(n):
    nums.append(list(map(int, input().split())))
fun(nums, n, m)

26 报时助手

#basic-26 报时助手
def fun(h, m):
    dic = {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'}
    dic1 = {2:'twenty', 3:'thirty', 4:'forty',5:'fifty'}
##    读小时
    if h <= 20:
        print(dic[h], end=' ')
    else:
        ge = h % 10
        print('twenty', dic[ge], end=' ')
##    读分钟
    if m == 0:
        print('o\'clock')
    elif m <= 20:
        print(dic[m], end=' ')
    else:
        ge = m % 10
        shi = m // 10
        print(dic1[shi], end=' ')
        if ge != 0:
              print(dic[ge])
        
h, m = map(int, input().split())
fun(h,m)

后面的不想做了，但还是贴上C++的代码

27 2n皇后问题

#include <string>
#include <iostream>
#include <cmath>

using namespace std;
/*int ans = 0, pos[21];

bool check(int col)
{//判断此列前面的
    for (int i = 1; i < col; i++)
    {
        if(pos[i] == pos[col] || abs(i - col) == abs(pos[i] - pos[col]))
            return false; // 如果有同行的，或则在对角的
    }
    return true;
}

void dfs(int col, int n)
{
    if (col == n + 1)
    {
        ans++;
    }
    for (int i = 1; i <= n; i++)
    {
        pos[col] = i;//将皇后放在col列，i行。
        if (check(col))//判断皇后放在这一列是否满足条件。
            dfs(col + 1, n);
    }

}

 题目：n个皇后，给出一个n*n的矩阵，输出n个皇后摆放的情况，不能在同行同列和对角线上。
 输入：n
 输出：情况
 注意：

int main()
{
	int n = 0;
	cin >> n;
	dfs(1, n);
	cout << ans << endl;

	return 0;
}
 */
 
 const int maxn = 10;  
int n;  
int map_Q[maxn][maxn];  
int posb[maxn]={0};  
int posw[maxn]={0};  
int ans;   
 
bool checkw( int cur) //检查函数
{  
    for( int i = 1; i < cur; i++)  
        if( posw[i] == posw[cur] || abs(i-cur) == abs(posw[i]-posw[cur]))  
            return false;  
    return true;  
}   
 
bool checkb( int cur)  //检查函数
{  
    for( int i = 1; i < cur; i++)  
        if( posb[i] == posb[cur] || abs(i-cur) == abs(posb[i]-posb[cur]))  
            return false;  
    return true;  
}  
 
void dfs_white( int cur)  
{  
    if( cur == n+1)  //白皇后也全部放完，次数+1
    {  
        ans++;  
      }
    for( int i = 1; i <= n; i++)  
    {  
        if( posb[cur] == i) //表示第cur列的第i行位置已经被黑皇后占用，
            continue;        //结束当前循环，i+1
        if( map_Q[cur][i] == 0)  //再判断前提条件是否成立
            continue;  
        posw[cur] = i;    //尝试把第cur列的白皇后放在第i行上
        if( checkw(cur))   //判断能否放置白皇后
            dfs_white(cur+1);  //递归
    }  
}  
  
void dfs_black( int cur)  
{  
    if( cur == n+1)  //当黑皇后处理完时，再处理白皇后
    {  
        dfs_white(1);  
    }  
    for( int i = 1; i <= n; i++)  
    {  
       if( map_Q[cur][i] == 0)  //如果第cur列第i行满足放皇后的前提条件即 mp[cur][i] == 1
            continue;  //如果不满足，则结束当前循环，进行下一次循环即i+1。
         posb[cur] = i;     //就尝试把第cur列的黑皇后放在第i行上
        if( checkb(cur))   //然后判断该尝试是否成立，如成立，则进行递归，如不成立，则尝试把当前列的黑皇后放在下一行(i+1行)上。
            dfs_black(cur+1);  //递归
    }  
}  
  
int main()  
{     
   cin>>n;
   for( int i = 1; i <= n; i++)   //定义棋盘
       for( int j = 1; j <= n; j++)  
           cin>>map_Q[i][j];    
   ans = 0;  
   dfs_black(1);    //先把黑皇后放在第一列
   cout<<ans<<endl; 
   
    return 0;  
}

28 Huffuman树

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int a[105];

 /*
 题目：Huffuman树， 找出最小的两个数，删除，然后将其和放入该数组中，费用为这两数和
 输入：n和n个数
 输出：一共的费用
 注意：无
 */
int main()
{
    int n, res = 0;
    cin >> n;

    for(int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    for (int i = n - 1; i > 0; i--)
    {
        sort(a, a + i + 1);
        a[0] = a[0] + a[1];
        for (int k = 1; k < i; k++)
        {
            a[k] = a[k + 1];
        }
        res += a[0];
    }
    cout << res << endl;


    return 0;
}

29 高精度加法

#include<iostream>
#include<cstring>
using namespace std;

int main()
{
    int i,alen,blen;
	char a[101], b[101];
	int c[102] = {0};
	//memset(c,0,sizeof(c));//清零
    scanf("%s%s", a, b);
    alen = strlen(a);
    blen = strlen(b);
    for (i = 0; i < alen || i < blen; i++)
    {
        if (i < alen)
            c[i] += a[alen-i-1] - '0';
        if (i < blen)
            c[i] += b[blen-i-1] - '0';
        if (c[i] >= 10)
        {
            c[i+1] = c[i] / 10;
            c[i] %= 10;
        }
    }
    if (alen < blen) alen = blen;
    if (c[alen] > 0) printf("%d", c[alen]);
    for (i = alen - 1; i >= 0; i--)
        printf("%d", c[i]);
    return 0;
}

30 阶乘计算

#include <iostream>
using namespace std;
 /*
 题目：大数阶乘
 输入：n <= 1000
 输出：n!
 注意：https://blog.csdn.net/qq_40663810/article/details/86599567
 */
int main()
{
    int n, len = 0;
    int a[10000];
    int s,c=0;
    a[0] = 1;
    cin >>n;
    for (int i = 2; i <= n; i++)
    {
        for (int j = 0; j <= len; j++)
        {
            s = a[j]*i+c;
            a[j] = s % 10; //保留个位
            c = s / 10; //进位数。
            //cout << s << " " << a[j] << " " << c << endl;
            if (c != 0 && j == len)
                len++;
        }
    }
     for(int i=len;i>=0;i--)    //逆序输出
    {
		cout<<a[i];
    }
}

00 致谢

谢谢来自互联网上各各大佬的资源分享，具体参考的那些，大多都不清楚啦，有部分留在注释里面。
** C++ 版本的源代码下载地址**