蓝桥杯刷题记2020-python实现-思路解析||装饰珠||平面切分||数字三角||寻找2020

写一下1——10的思路：
1.门牌制作：统计2出现的次数

#门牌制作
TT=0
for i in range(1,2021):
    TT+=str(i).count('2')
print(TT)

2.寻找2020：就是一个暴力求解的过程，分清楚思路，从左到右找，从上到下找，右斜下找。思路是第一个数字如果为2，就在这三个方向接连找四个，如果这四个为2020，就给计数加1.一直找到最后面

#寻找2020
ST='''
220000
000000
002202
000000
000022
002020
'''.split()#这个是它的例子
data=[]
dd=open('find2020.txt')#由于文件较大，就把它保存为txt文档了
for dt in dd.readlines():
    data.append(dt.strip())
ST=data
n=len(ST)
tt_s=0
for i in range(len(ST)):
    for j in range(len(ST)):
        if ST[i][j]=='2':
            if i<=n-4:#上下
                ss = ''
                for k in range(4):
                    ss += ST[i + k][j]
                if ss == '2020':
                    tt_s += 1
            if j<=n-4:#左右
                ss = ''
                for k in range(4):
                    ss += ST[i][j + k]
                if ss == '2020':
                    tt_s += 1
            if j<=n-4 and i<=n-4:#斜下
                ss=''
                for k in range(4):
                    ss+=ST[i+k][j+k]
                if ss=='2020':
                    tt_s+=1
print(tt_s)
#16520#结果

3.跑步锻炼主要考察python的datetime这个库

#跑步锻炼
import datetime
start=datetime.datetime(2000,1,1)
end=datetime.datetime(2020,10,1)
res=0
while start<=end:
    if start.weekday()==0 or start.day==1:
        res+=2
    else:
        res+=1
    start+=datetime.timedelta(days=1)
print(res)

4.蛇形填数：找规律，然后用递归求解：
用dp（i，j)表示当前状态，可以发现dp(1,1)=1,dp(2,2)=5,dp(3,3)=13,依次内推，就会发现dp(4,4)=25…因此，可以看出，dp(i,j)=4*(i-1)+dp(i-1,j-1),其中i=j>=2,这就找到了它的转移状态，因此，根据以往写斐波那契数列那样，可以将这个求解出来。另一种思路更加清晰：https://fxl18-chesh.blog.csdn.net/article/details/123153618?spm=1001.2014.3001.5502

#蛇形填数
def se(n):
    if n<=1:
        return 1
    return 4*(n-1)+se(n-1)
print(se(20))

5.排序：思路参考蓝桥官网上别人奉献的代码和这位博主：https://fxl18-chesh.blog.csdn.net/article/details/123162694?spm=1001.2014.3001.5502
根据希尔排序的时间复杂度（n-1)n/2=100,得n=15.n=15时在最糟糕的情况下需要迭代105次。因此，我们需要减少减少到100次即可。

#排序
current_l=15 
current_n = "abcdefghijklmno"
print(current_n)
current_word = sorted(current_n, reverse=True)
# 遍历得到字符串
for a, b in enumerate(current_word):
    if current_n == 100:
        # 删除字符串并重新插入
        current_word.remove(b)
        current_word.insert(0, b)
        W = ""
        for w in current_word:
            W += w
        print(W)
        break
    current_n = current_n - 1#每次减少1

6.装饰珠:可以借助数结构，将每一种情况都枚举出来，从上到下生成一棵大树。然后利用哈希表保存每种弹珠的等级，最后对每一这棵树从上到下，寻找最大的。

#装饰珠
Kong=[list(map(int,input().split())) for i in range(6)]
# Kong=sorted(Kong,key=lambda x:x[0])
N_kind=int(input())
Deng={}
for i in range(N_kind):#弹珠的等级
    kk=list(map(int,input().split()))
    Deng[kk[0]]=kk[1:]
AA=[]#变成一个树结构
for i in Kong:
    for j in i[1:]:
        jj=[]
        for k in range(1,j+1):
            jj.append(k)
        AA.append(jj)
DD=[''] #把每一种情况都枚举出来
for i in AA:
    dd=[]
    for j in i:
        for k in DD:
            dd.append(k+str(j))
    DD=dd
S_TT=0
DZ=0
for i in DD:
    TT=0
    for j in set(i):
        k=i.count(j)
        if k<Deng[int(j)][0]:
            TT+=Deng[int(j)][k]
        else:
            TT+=Deng[int(j)][-1]
    if S_TT<TT:
        S_TT=TT
        DZ=i
print(S_TT)
print(DZ)

运行结果为：

7.成绩统计

#成绩统计
N=int(input())
Fenshu=[int(input()) for i in range(N)]
Excel=0
Jige=0
for i in Fenshu:
    if i>=60:
        Jige+=1
    if i>=85:
        Excel+=1
print(str((round(Jige/N*100)))+'%')
print(str((round(Excel/N*100)))+'%')

8.单词分析：

#单词分析
SS=input()
dd={}
for i in set(SS):
    dd[i]=SS.count(i)
s=sorted(dd.items(),key=lambda x:x[1])
print(s[-1][0])
print(s[-1][1])

9.数字三角形：动态规划（+dfs)：转移状态方程为dp(i,j)=val(i,j)+max(dp(i+1,j)，dp(i+1,j+1)),然后用递归

#数字三角形
def dfs(i,j):
    if i==n-1:
        return arr[i][j]
    res=arr[i][j]+max(dfs(i+1,j),dfs(i+1,j+1))
    return res
if __name__=='__main__':
    n=int(input())
    arr=[list(map(int,input().split())) for i in range(n)]
    print(dfs(0,0))

10.平面切分：这道题纯属在找规律。参考车神哥（https://fxl18-chesh.blog.csdn.net/?type=blog）的思路，就是一条线可以分成两个平面，如果增加一条与平面上的线不重合的线，有两种状态，这条线与当前的线相交，那么就有1个交点，4个面。如果不相交，就只有三个平面，即增加的这条线与平面上的线平行，此时是0交点，3个面。4=原来的平面个数+增加的不重合的交点数（1）+1（这是我们要推了的），3=2+0+1。因此类推，就会发现它的规律：每增加一条线：当前的切面分割=原来的平面个数+增加的不重合的交点数（1）+1。

#平面切分
#平面切分
N=int(input())
num=list(set(tuple(map(int,input().split())) for i in range(N)))
P=2#一条线有两个平面
AA=[num[0]]
for k in num[1:]:#每增加一条线
    jiaod=set()
    for nn in AA:#计算这条线与当前平面中存在的线产生的不重合的交点数
        if nn[0]!=k[0]:
            i=(k[1]-nn[1])/(nn[0]-k[0])
            j=(nn[1]*k[0]-nn[0]*k[1])/(k[0]-nn[0])
            jiaod.add((i,j))
    AA.append(k)
    P+=len(jiaod)+1#每次增加的平面个数等于每次产生的不重合的交点数加1
print(P)