蓝桥杯笔记(Python程序设计)

1. 二进制位数

问题描述
十进制整数 2 在十进制中是 1 位数，在二进制中对应 10 ，是 2 位数。
十进制整数 22 在十进制中是 2 位数，在二进制中对应 10110 ，是 5 位数。
请问十进制整数 2022 在二进制中是几位数？

答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

思路
这道题对于其他人来说，可能还稍微麻烦了，但是对于python说，几乎秒杀，只需要用python的bin函数，就可以迅速将十进制转成二进制，然后再减去首字母的两个0b即可。

参考答案
 

print(len(bin(2022))-2)

2. 晨跑

问题描述
小蓝每周六、周日都晨跑，每月的 1、11、21、31日也晨跑。其它时间不晨跑。
已知 2022年1月1日是周六，请问小蓝整个2022年晨跑多少天？

答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

参考答案

import datetime

start = datetime.datetime(year=2022,month=1,day=1) # 定义头为2022.1.1
end = datetime.datetime(year=2023,month=1,day=1) # 尾为2023.1.1
cnt = 0 # 计数
while start != end: # 当没到下一年的时候，也就是遍历2022全年
    if start.isoweekday() in [6,7] or start.day in [1,11,21,31]:
        cnt += 1  # 小蓝每周六、周日都晨跑，每月的 1、11、21、31日也晨跑。
    start += datetime.timedelta(days=1) # 下一天
    
print(cnt)

3. 调和级数

问题描述

小蓝特别喜欢调和级数 S(n)=1/1+1/2+1/3+1/4+…+1/n 。
请问，n 至少为多大时，S(n)>12 ？

参考答案

s = 0
i = 1
while s <= 12:
    s += 1.0/i
    i += 1 
print(i-1) # 不用加最后一次

4.贪心算法

问题描述

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
示例 1:
输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。
示例 2:
输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

题目解析：在这里采用贪心策略的思想，让孩子们按胃口大小排成队，胃口小的在前面，饼干按大小也摞好，小的在上面，每次给队头的孩子一个能满足他胃口且尽可能小的饼干（注：这个过程就是求局部最优解的过程），吃到饼干的队头孩子就离开队伍，直到饼干发完或者队伍没人即每个孩子都吃到饼干（注：这是通过局部最优解堆叠求得全局最优解）

参考答案：

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()#列表的排序命令，默认从小到大排序。将孩子按胃口大小排成队
        s.sort()#把饼干也从小到大摞起来
        child=0#统计吃到饼干的孩子数
        i=0;j=0;
        while i<len(g) or j<len(s):#设置循环结束条件
            if s[j]>=g[i]:#如果第j个饼干刚好可以满足第i个孩子
                child+=1
                i+=1
                j+=1
            else:#如果不能，换下一个饼干试试能不能满足这个孩子
                j+=1
        print(child)

5.穿越雷区（BFS）

参考答案：

n = int(input())
arr = [list(map(str, input().split())) for _ in range(n)]
ex, ey = 0, 0

# 找到起点 'A' 和终点 'B' 的坐标
for i in range(n):
    for j in range(n):
        if arr[i][j] == 'A':
            start = (i, j, '', 0)  # 将起点的坐标、前一步状态、步数添加到队列
        if arr[i][j] == 'B':
            ex, ey = i, j  # 记录终点的坐标

def bfs():
    dir = [(1, 0), (-1, 0), (0, 1), (0, -1)]  # 定义四个方向：下、上、右、左
    visited = set()  # 用集合存储已经访问过的位置
    q = [start]  # 使用列表作为队列，将起点添加进去

    while q:
        x, y, s, step = q.pop(0)  # 从队列中取出一个位置的坐标、前一步状态、步数

        for i, j in dir:
            dx, dy = x + i, y + j  # 计算新位置的坐标

            # 判断新位置是否在迷宫范围内，且没有被访问过，且不等于前一步状态
            if 0 <= dx < n and 0 <= dy < n and (dx, dy) not in visited and arr[dx][dy] != s:
                visited.add((dx, dy))  # 标记新位置为已访问

                # 如果新位置是终点，返回步数
                if dx == ex and dy == ey:
                    return step + 1

                # 将新位置的坐标、前一步状态、步数添加到队列
                q.append((dx, dy, arr[dx][dy], step + 1))

print(bfs())  # 打印最短路径的步数

6.穿越时空之门

【问题描述】
        随着 2024 年的钟声回荡，传说中的时空之门再次敞开。这扇门是一条神秘
的通道，它连接着二进制和四进制两个不同的数码领域，等待着勇者们的探索。
        在二进制的领域里，勇者的力量被转换成了力量数值的二进制表示中各数
位之和。
        在四进制的领域里，力量的转换规则相似，变成了力量数值的四进制表示
中各数位之和。
        穿越这扇时空之门的条件是严苛的：当且仅当勇者在二进制领域的力量等
同于四进制领域的力量时，他才能够成功地穿越。
国王选定了小蓝作为领路人，带领着力量值从 1 到 2024 的勇者们踏上了这
段探索未知的旅程。作为小蓝的助手，你的任务是帮助小蓝计算出，在这 2024
位勇者中，有多少人符合穿越时空之门的条件。

def check(a):
    jin_2, x2 = jin_s(a, 2)
    jin_4, x4 = jin_s(a, 4)
    print(a, x2, x4)
    if jin_2 == jin_4:
        return True
    return False
 
 
def jin_s(x, m):
    res = []
    while x:
        res.append(x%m)
        x //= m
    return sum(res), res
 
 
def main():
    res = 0
    for i in range(1, 2025):
        if check(i):
            res += 1
    print(res, '**************')
# 63
if __name__ == '__main__':
    main()

7.数字串个数

【问题描述】
小蓝想要构造出一个长度为 10000 的数字字符串，有以下要求：
        1) 小蓝不喜欢数字 0 ，所以数字字符串中不可以出现 0 ；
        2) 小蓝喜欢数字 3 和 7 ，所以数字字符串中必须要有 3 和 7 这两个数字。
请问满足题意的数字字符串有多少个？这个数字会很大，你只需要输出其
对 10 9 + 7 取余后的结果。

分析：

每个位置9种情况
一共9^10000种
没有3的有8^10000种
没有7的也有8^10000种
这两个多算了一份没有3和7的
最后加上一份同时没有3和7的
7^10000种
 

def ksm(a, b, mod):
    if b == 0:
        return 1
    t = ksm(a, b // 2, mod)
    t = (t * t) % mod
    if b & 1:
        t = (t * a) % mod
    return t % mod
##快速幂板子

mod = 10**9 + 7
ans = ksm(9, 10000, mod) - 2 * ksm(8, 10000, mod) + ksm(7, 10000, mod)
ans %= mod
print(ans)

8.迷宫问题

#maze表示迷宫
maze=[
[0,1,0,0,0],
[0,1,1,1,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,1,1,1,0]
]

#表示向四个方向移动坐标
dirs=[
	lambda x,y:(x+1,y),
	lambda x,y:(x-1,y),
	lambda x,y:(x,y+1),
	lambda x,y:(x,y-1)
]

def stack_path(x1,y1,x2,y2):
	#x1,y1:初始坐标；x2,y2:表示终点坐标
	stack=[]              #建一个空列表，当做一个栈
	stack.append((x1,y1))     #将初始坐标存起来
	while(len(stack)>0):      #栈内有元素就循环
		curNode=stack[-1]     #取当前坐标
		if curNode[0]==x2 and curNode[1]==y2:                #当前坐标等于终点坐标，路径找到，结束程序
			for p in stack:
				print("(%d,%d)" % (p[0],p[1]))
			return True

		for dir in dirs:                                #遍历四个方向
			nexNode=dir(curNode[0],curNode[1])
			if 0<= nexNode[0]<=x2 and 0<= nexNode[1]<= y2:           #坐标没有越界
				if maze[nexNode[0]][nexNode[1]] == 0:       
					stack.append(nexNode)                      #坐标等于0，就把他放入栈中，并标记为2
					maze[nexNode[0]][nexNode[1]] = 2
					break
			else:                            #坐标越界了，进入下轮循环，看其他方向
				continue
		else:                             #如果没有路可以走，回退，将当前节点出栈,如果for循环正常结束，else中语句执行。如果是break的，则不执行。
			stack.pop()
	else:
		return False
	
stack_path(0,0,4,4)