蓝桥杯python历届真题总结(持续更新)_蓝桥杯python往届考题及答案

输入描述
输入一行包含一个单词，单词只由小写英文字母组成。

对于所有的评测用例，输入的单词长度不超过 1000。

输出描述
输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪 个。如果有多个字母出现的次数相等，输出字典序最小的那个。

第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。

import os
import sys

list = [0]*200
st = input()
for i in st:
    column = ord(i)
    list[column] = list[column] + 1
print(chr(list.index(max(list))))
print(max(list))

1
2
3
4
5
6
7
8
9
10
11

Notes：
1. input()：输入字符串等
2. ord()：字符转ASCII码
3. list = [0]200：初始化数组
4. chr()：ASCII码转字符
5. max()：搜索最大list最大数值
6. 列表.index()：找出括号内的索引

成绩统计

题目描述
小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。

如果得分至少是 60 分，则称为及格。如果得分至少为 85 分，则称为优秀。

请计算及格率和优秀率，用百分数表示，百分号前的部分四舍五入保留整 数。

输入描述
输入的第一行包含一个整数 n\ (1 \leq n \leq 10^4)n (1≤n≤10 4 )，表示考试人数。

接下来 n 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。

输出描述
输出两行，每行一个百分数，分别表示及格率和优秀率。百分号前的部分 四舍五入保留整数。

import os
import sys

s = int(input())
p = 0
e =0

for i in range(s):
    score = int(input())
    if 60 <= score:
        p = p +1
    if 85 <= score <= 100:
        e = e+1

print('{:.0%}'.format(p/s))
print('{:.0%}'.format(e/s))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Notes:
1. int(input())：从键盘输入整型。先input()再int()也是没问题的。
2. range()：range() 函数返回的是一个可迭代对象（类型是对象）详细解释
3. {:.0%}：python3输出百分比详细解释

最短路

题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如下图所示，GG 是一个无向图，其中蓝色边的长度是 11、橘色边的长度是 22、绿色边的长度是 33。

则从 A 到 S 的最短距离是多少？
Notes：
1. 这是一道填空题，灵活变通很重要
2. 解决无向图最短路径的问题用Dijkstra算法，Dijkstra算法原理
3. 在这道题里，不建议使用Dijkstra算法计算全部节点，中间那一团太浪费时间了。
4. 我是取巧了，从下图直接算出来了，肉眼就只能看出这条最短，其实可以暴力解决这题，能找到更小的就舍弃小的就可以了。浪费太多时间在填空题不太值这个分值的。

回文日期

输入描述
输入包含一个八位整数 N，表示日期。

对于所有评测用例，10000101≤N≤89991231，保证 N 是一个合法日期的 8 位数表示。

输出描述
输出两行，每行 1 个八位数。第一行表示下一个回文日期，第二行表示下一个 ABABBABA 型的回文日期。

Notes：

1. 公历每年可以分为平年和非闰年，平年和闰年区别在于2月，闰年2月29天 ，平年2月28天。
2. 闰年共有366天（1月~12月分别为31天、29天、31天、30天、31天、30天、31天、31天、30天、31天、30天、31天）。
3. 平年共有365天（1月~12月分别为31天、28天、31天、30天、31天、30天、31天、31天、30天、31天、30天、31天）。
4. 速记口诀：1月大，2月小，3月大，4月小，5月大，6月小，7月大，8月大，9月小，10月大，11月小，12月大。
5. 1582年以来的置闰规则：普通闰年：公历年份是4的倍数，且不是100的倍数的（如2004年、2020年等就是闰年）。世纪闰年：公历年份是整百数的，必须是400的倍数才是闰年（如1900年不是闰年，2000年是闰年）。更多详情
6. 判断闰年需满足 “普通闰年”和“世纪闰年”。
7. 下面答案不全对，没有参考价值。

import os
import sys

# 普通回文数
h1 = 0
# ABABBABA回文数
h2 = 0

# 普通回文数
h3 = 0
# ABABBABA回文数
h4 = 0

time = input()
list = [31,29,31,30,31,30,31,31,30,31,30,31]

year = int(time[0]+time[1]+time[2]+time[3])
month = int(time[4]+time[5])
day = int(time[6]+time[7])
if ((int(time) % 4 == 0 and int(time) % 100 !=0) or (int(time) % 400 ==0)):
    list[1] = 28

if int(time) != int(time[0]+time[1]+time[2]+time[3]+time[3]+time[2]+time[1]+time[0]):
    if month == int(time[3]+time[2]):
        if day <= int(time[1]+time[0]) <= list[month]:
            if int(time[0]+time[1]) == int(time[2]+time[3]):
                h2 = 1
                h4 = int(time[0]+time[1]+time[2]+time[3]+time[3]+time[2]+time[1]+time[0])
            else :
                h1 = 1
                h3 = int(time[0]+time[1]+time[2]+time[3]+time[3]+time[2]+time[1]+time[0])
    if month < int(time[3]+time[2]) <= 12:
        if int(time[1]+time[0]) <= list[month]:
            if int(time[0]+time[1]) == int(time[2]+time[3]):
                h2 = 1
                h4 = int(time[0]+time[1]+time[2]+time[3]+time[3]+time[2]+time[1]+time[0])
            else :
                h1 = 1
                h3 = int(time[0]+time[1]+time[2]+time[3]+time[3]+time[2]+time[1]+time[0])
# print(h1,h2,h3,h4)
 
if not h1 or not h2:
    y = year
    while not h1 or not h2:
        y = int(y)
        y = y + 1
        list[1] = 29
        if (y % 4 == 0 and y % 100 !=0) or (y % 400 ==0):
            list[1] = 28
        y = str(y)
        if not h1:
            if int(y[0] + y[1]) != int(y[2] + y[3]):
                if 0 < int(y[3] + y[2]) <= 12:
                    if 0 < int(y[1] + y[0]) <= list[int(y[3] + y[2]) - 1]:
                        h1 = 1
                        h3 = int(y[0] + y[1] + y[2] + y[3] + y[3] + y[2] + y[1] + y[0])
                        # print(h1, h3)
        if not h2:
            # print(y)
            if int(y[0] + y[1]) == int(y[2] + y[3]):
                if 0 < int(y[3] + y[2]) <= 12:
                    if 0 < int(y[1] + y[0]) <= list[int(y[3] + y[2]) - 1] and int(y[0] + y[1]) == int(y[2] + y[3]):
                        h2 = 1
                        h4 = int(y[0] + y[1] + y[2] + y[3] + y[3] + y[2] + y[1] + y[0])
                        # print(h2, h4)
if h3 > int(time):
    print(h3)
else:
    print()
if h4 > int(time):
    print(h4)
else:
    print()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

购物单

填空题
取款机只能提供 100100 元面额的纸币。小明想尽可能少取些现金，够用就行了。 你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。

import os
import sys

print(180.90 * 0.88 +
10.25 * 0.65 +
56.14 * 0.9 +
104.65 * 0.9 +
100.30 * 0.88 +
297.15 * 0.5 +
26.75 * 0.65 +
130.62 * 0.5 +
240.28 * 0.58 +
270.62 * 0.8 +
115.87 * 0.88 +
247.34 * 0.95 +
73.21 * 0.9 +
101.00 * 0.5 +
79.54 * 0.5 +
278.44 * 0.7 +
199.26 * 0.5 +
12.97 * 0.9 +
166.30 * 0.78 +
125.50 * 0.58 +
84.98 * 0.9 +
113.35 * 0.68 +
166.57 * 0.5 +
42.56 * 0.9 +
81.90 * 0.95 +
131.78 * 0.8 +
255.89 * 0.78 +
109.17 * 0.9 +
146.69 * 0.68 +
139.33  * 0.65 +
141.16 * 0.78 +
154.74 * 0.8 +
59.42 * 0.8 +
85.44 * 0.68 +
293.70 * 0.88 +
261.79 * 0.65 +
11.30 * 0.88 +
268.27 * 0.58 +
128.29 * 0.88 +
251.03 * 0.8 +
208.39 * 0.75 +
128.88 * 0.75 +
62.06 * 0.9 +
225.87 * 0.75 +
12.89 * 0.75 +
34.28 * 0.75 +
62.16 * 0.58 +
129.12 * 0.5 +
218.37 * 0.5 +
289.69 * 0.8)
# print('5200')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

递增序列

填空题
对于一个字母矩阵，我们称矩阵中的一个递增序列是指在矩阵中找到两个字母，它们在同一行，同一列，或者在同一 45 度的斜线上，这两个字母从左向右看、或者从上向下看是递增的。

例如，如下矩阵中
LANN
QIAO
有LN、LN、AN、AN、IO、AO、LQ、AI、NO、NO、AQ、IN、AN等 13 个 递增序列。注意当两个字母是从左下到右上排列时，从左向右看和从上向下看 是不同的顺序。

对于下面的 30 行 50 列的矩阵，请问总共有多少个递增序列？

VLPWJVVNNZSWFGHSFRBCOIJTPYNEURPIGKQGPSXUGNELGRVZAG
SDLLOVGRTWEYZKKXNKIRWGZWXWRHKXFASATDWZAPZRNHTNNGQF
ZGUGXVQDQAEAHOQEADMWWXFBXECKAVIGPTKTTQFWSWPKRPSMGA
BDGMGYHAOPPRRHKYZCMFZEDELCALTBSWNTAODXYVHQNDASUFRL
YVYWQZUTEPFSFXLTZBMBQETXGXFUEBHGMJKBPNIHMYOELYZIKH
ZYZHSLTCGNANNXTUJGBYKUOJMGOGRDPKEUGVHNZJZHDUNRERBU
XFPTZKTPVQPJEMBHNTUBSMIYEGXNWQSBZMHMDRZZMJPZQTCWLR
ZNXOKBITTPSHEXWHZXFLWEMPZTBVNKNYSHCIQRIKQHFRAYWOPG
MHJKFYYBQSDPOVJICWWGGCOZSBGLSOXOFDAADZYEOBKDDTMQPA
VIDPIGELBYMEVQLASLQRUKMXSEWGHRSFVXOMHSJWWXHIBCGVIF
GWRFRFLHAMYWYZOIQODBIHHRIIMWJWJGYPFAHZZWJKRGOISUJC
EKQKKPNEYCBWOQHTYFHHQZRLFNDOVXTWASSQWXKBIVTKTUIASK
PEKNJFIVBKOZUEPPHIWLUBFUDWPIDRJKAZVJKPBRHCRMGNMFWW
CGZAXHXPDELTACGUWBXWNNZNDQYYCIQRJCULIEBQBLLMJEUSZP
RWHHQMBIJWTQPUFNAESPZHAQARNIDUCRYQAZMNVRVZUJOZUDGS
PFGAYBDEECHUXFUZIKAXYDFWJNSAOPJYWUIEJSCORRBVQHCHMR
JNVIPVEMQSHCCAXMWEFSYIGFPIXNIDXOTXTNBCHSHUZGKXFECL
YZBAIIOTWLREPZISBGJLQDALKZUKEQMKLDIPXJEPENEIPWFDLP
HBQKWJFLSEXVILKYPNSWUZLDCRTAYUUPEITQJEITZRQMMAQNLN
DQDJGOWMBFKAIGWEAJOISPFPLULIWVVALLIIHBGEZLGRHRCKGF
LXYPCVPNUKSWCCGXEYTEBAWRLWDWNHHNNNWQNIIBUCGUJYMRYW
CZDKISKUSBPFHVGSAVJBDMNPSDKFRXVVPLVAQUGVUJEXSZFGFQ
IYIJGISUANRAXTGQLAVFMQTICKQAHLEBGHAVOVVPEXIMLFWIYI
ZIIFSOPCMAWCBPKWZBUQPQLGSNIBFADUUJJHPAIUVVNWNWKDZB
HGTEEIISFGIUEUOWXVTPJDVACYQYFQUCXOXOSSMXLZDQESHXKP
FEBZHJAGIFGXSMRDKGONGELOALLSYDVILRWAPXXBPOOSWZNEAS
VJGMAOFLGYIFLJTEKDNIWHJAABCASFMAKIENSYIZZSLRSUIPCJ
BMQGMPDRCPGWKTPLOTAINXZAAJWCPUJHPOUYWNWHZAKCDMZDSR
RRARTVHZYYCEDXJQNQAINQVDJCZCZLCQWQQIKUYMYMOVMNCBVY
ABTCRRUXVGYLZILFLOFYVWFFBZNFWDZOADRDCLIRFKBFBHMAXX
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

NOTES：
1. 注意45°和135°的区别，题目只要45°方向的，不要135°方向的。
2. python存储多端字符串的手段：
如

b = 'abc'
d = 'def'
a = [] # 定义空列表
a.append(b) # a = [‘abc’]
a.append(d) # a = [‘abc’, ‘def’]
# 如果要调用d的值,可以通过列表下标索引，如a[0] 为‘abc’，a[0][0]为‘a’。
1
2
3
4
5
6

3. 要注意的是，一条线上的两个字母！45°一条线上的容易遗忘。

import os
import sys

list = ['VLPWJVVNNZSWFGHSFRBCOIJTPYNEURPIGKQGPSXUGNELGRVZAG',
        'SDLLOVGRTWEYZKKXNKIRWGZWXWRHKXFASATDWZAPZRNHTNNGQF',
        'ZGUGXVQDQAEAHOQEADMWWXFBXECKAVIGPTKTTQFWSWPKRPSMGA',
        'BDGMGYHAOPPRRHKYZCMFZEDELCALTBSWNTAODXYVHQNDASUFRL',
        'YVYWQZUTEPFSFXLTZBMBQETXGXFUEBHGMJKBPNIHMYOELYZIKH',
        'ZYZHSLTCGNANNXTUJGBYKUOJMGOGRDPKEUGVHNZJZHDUNRERBU',
        'XFPTZKTPVQPJEMBHNTUBSMIYEGXNWQSBZMHMDRZZMJPZQTCWLR',
        'ZNXOKBITTPSHEXWHZXFLWEMPZTBVNKNYSHCIQRIKQHFRAYWOPG',
        'MHJKFYYBQSDPOVJICWWGGCOZSBGLSOXOFDAADZYEOBKDDTMQPA',
        'VIDPIGELBYMEVQLASLQRUKMXSEWGHRSFVXOMHSJWWXHIBCGVIF',
        'GWRFRFLHAMYWYZOIQODBIHHRIIMWJWJGYPFAHZZWJKRGOISUJC',
        'EKQKKPNEYCBWOQHTYFHHQZRLFNDOVXTWASSQWXKBIVTKTUIASK',
        'PEKNJFIVBKOZUEPPHIWLUBFUDWPIDRJKAZVJKPBRHCRMGNMFWW',
        'CGZAXHXPDELTACGUWBXWNNZNDQYYCIQRJCULIEBQBLLMJEUSZP',
        'RWHHQMBIJWTQPUFNAESPZHAQARNIDUCRYQAZMNVRVZUJOZUDGS',
        'PFGAYBDEECHUXFUZIKAXYDFWJNSAOPJYWUIEJSCORRBVQHCHMR',
        'JNVIPVEMQSHCCAXMWEFSYIGFPIXNIDXOTXTNBCHSHUZGKXFECL',
        'YZBAIIOTWLREPZISBGJLQDALKZUKEQMKLDIPXJEPENEIPWFDLP',
        'HBQKWJFLSEXVILKYPNSWUZLDCRTAYUUPEITQJEITZRQMMAQNLN',
        'DQDJGOWMBFKAIGWEAJOISPFPLULIWVVALLIIHBGEZLGRHRCKGF',
        'LXYPCVPNUKSWCCGXEYTEBAWRLWDWNHHNNNWQNIIBUCGUJYMRYW',
        'CZDKISKUSBPFHVGSAVJBDMNPSDKFRXVVPLVAQUGVUJEXSZFGFQ',
        'IYIJGISUANRAXTGQLAVFMQTICKQAHLEBGHAVOVVPEXIMLFWIYI',
        'ZIIFSOPCMAWCBPKWZBUQPQLGSNIBFADUUJJHPAIUVVNWNWKDZB',
        'HGTEEIISFGIUEUOWXVTPJDVACYQYFQUCXOXOSSMXLZDQESHXKP',
        'FEBZHJAGIFGXSMRDKGONGELOALLSYDVILRWAPXXBPOOSWZNEAS',
        'VJGMAOFLGYIFLJTEKDNIWHJAABCASFMAKIENSYIZZSLRSUIPCJ',
        'BMQGMPDRCPGWKTPLOTAINXZAAJWCPUJHPOUYWNWHZAKCDMZDSR',
        'RRARTVHZYYCEDXJQNQAINQVDJCZCZLCQWQQIKUYMYMOVMNCBVY',
        'ABTCRRUXVGYLZILFLOFYVWFFBZNFWDZOADRDCLIRFKBFBHMAXX', ]
ans = 0

for x in range(0,30):
    for y in range(0,50):
        m = y
        n = x
        for w in range(m,50): # 列
            if ord(list[x][y]) < ord(list[x][w]):
                ans = ans + 1
        for w in range(n,30): # 行
            if ord(list[x][y]) < ord(list[w][y]):
                ans = ans + 1
        for i in range(0,50): # 从左下角到右上角和从右上角到左下角
            if 0 <= x - i < 30 and 0 <= y + i < 50:
                if ord(list[x - i][y + i]) != ord(list[x][y]):
                    ans = ans + 1
            if 0 <= x + i < 30 and 0 <= y + i < 50: # 从左上角到右下角
                if ord(list[x + i][y + i]) > ord(list[x][y]):
                    ans = ans + 1
print(ans)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

排序

填空题
小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。

小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 100 次交 换，可是他忘了吧这个字符串记下来，现在找不到了。

请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对 该串的字符排序，正好需要 100 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。

Notes：

1. 了解冒泡排序原理（这是原理）
2. 题目要求（1）最短字符串（2）最小字典序（3）100次交换
3. 完全逆序交换次数最多，字符串最短。
   公式：完全逆序交换次数 = n * ( n - 1 ) / 2，n为字符个数。
   套公式求得最小字符串长度为15，最小完全逆序交换次数为105。
4. 为满足“最小字典序”，a~o15个字符。
5. a交换15次，b交换14次，c交换13次，以此类推，将第6个（j）往前交换5次，换到o前面。即jonmlkihgfedcba。

成绩分析

题目描述
小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。
请计算这次考试的最高分、最低分和平均分。

输入描述
输入的第一行包含一个整数 n\ (1 ≤ n ≤ 10^4)n (1≤n≤10^4)，表示考试人数。
接下来 nn 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。

输出描述
输出三行。

第一行包含一个整数，表示最高分。

第二行包含一个整数，表示最低分。

第三行包含一个实数，四舍五入保留正好两位小数，表示平均分。

Notes：

1. 保留两位小数’{:.2f}’.format()。

import os
import sys

MAX = 0
MIN = 100
SUM = 0
nums = int(input())
for i in range(0,nums):
    L = int(input())
    SUM = SUM + L 
    if MAX < L:
        MAX = L
    if MIN > L:
        MIN = L
print(MAX)
print(MIN)
print('{:.2f}'.format(SUM/nums))            
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

棋盘放麦子

题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

你一定听说过这个故事。国王对发明国际象棋的大臣很佩服，问他要什么报酬，大臣说：请在第 11 个棋盘格放 11 粒麦子，在第 22 个棋盘格放 22 粒麦子，在第 33 个棋盘格放 44 粒麦子，在第 44 个棋盘格放 88 粒麦子，…后一格的数字是前一格的两倍，直到放完所有棋盘格（国际象棋共有 6464 格）。

请你借助计算机准确地计算，到底需要多少粒麦子。

import os
import sys

num = 1
nums = 1
for i in range(1,64):
    num = num*2
    nums = nums + num
print(nums)

1
2
3
4
5
6
7
8
9
10

长草

题目描述
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，
这四小块空地都将变为有草的小块。请告诉小明，k 个月后空地上哪些地方有草。

输入描述
输入的第一行包含两个整数 n,m。

接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。

接下来包含一个整数 k。

输出描述
输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。

输入输出样例
输入

4 5
.g...
.....
..g..
.....
2
1
2
3
4
5
6

输出

gggg.
gggg.
ggggg
.ggg.
1
2
3
4

Notes：

1. 了解BFS（宽搜）原理及过程并应用宽搜原理
2. 了解python输入多个数字以空格隔开
3. 了解python如何输入二维数组每行
4. 了解python分别输出二维数组每行

import os
import sys

# 输入行n和列m
n,m = map(int,input().split())
# 创建一个一维数组，用于存储初始化后的草坪中的草的坐标
lawn = []
# 创建一个队列，用于存储未访问过的草的坐标
queue = []
# 循环输入每行
for i in range(n):
    lawn.append(list(map(str,input())))
    # 存储每行草的坐标
    for j in range(len(lawn[i])):
        if lawn[i][j] == 'g':
            queue.append([i,j])
            
# 输入多少个月
k = int(input())

if k == 0:
    for l in lawn:
        for row in l:
            print(row,end='\n')

# 循环每个月草生长情况
for month in range(k):
    lens = len(queue)
    for q in range(lens):
        # 取队列队首
        temp = queue.pop(0)
        
        # 草左边的格子
        x = temp[0]
        y = temp[1]-1
        if 0 <= y < m and lawn[x][y] != 'g':
            queue.append([x,y])
            lawn[x][y] = 'g'
            
        # 草右边的格子
        y = temp[1]+1
        if 0 <= y < m and lawn[x][y] != 'g':
            queue.append([x,y])
            lawn[x][y] = 'g'
            
        # 草下方的格子
        x = temp[0]+1
        y = temp[1]
        if 0 <= x < n and lawn[x][y] != 'g':
            queue.append([x,y])
            lawn[x][y] = 'g'
            
        # 草上方的格子
        x = temp[0]-1
        if 0 <= x < n and lawn[x][y] != 'g':
            queue.append([x,y])
            lawn[x][y] = 'g'

for i in range(n):
    for j in range(m):
        print(lawn[i][j],end='')
    print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

寻扎2020

题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝有一个数字矩阵，里面只包含数字 0 和 2。小蓝很喜欢 2020，他想找 到这个数字矩阵中有多少个 2020 。 小蓝只关注三种构成 2020 的方式：

1. 同一行里面连续四个字符从左到右构成 2020。
2. 同一列里面连续四个字符从上到下构成 2020。
3. 在一条从左上到右下的斜线上连续四个字符，从左上到右下构成 2020。
   这是数据

Notes：
1. 暴力枚举

import os
import sys


# 数据格式
list = ['123','456','……',]
ans = 0
rows = len(list)
cols = len(list[0])
# print(row,col)
for i in range(rows):
    for j in range(cols):

        if j+3<rows:
            if int(str(list[i][j])+str(list[i][j+1])+str(list[i][j+2])+str(list[i][j+3])) == 2020:
                ans +=1
        if i+3<cols:
            if int(str(list[i][j])+str(list[i+1][j])+str(list[i+2][j])+str(list[i+3][j])) == 2020:
                ans +=1
        if i+3<rows and j+3<cols:
            if int(str(list[i][j]) + str(list[i + 1][j+1]) + str(list[i + 2][j+2]) + str(list[i + 3][j+3])) == 2020:
                ans +=1
print(ans)
# 16520

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

全球变暖

题目描述
你有一张某海域 NxN 像素的照片，".“表示海洋、”#"表示陆地，如下所示：

.......
.##....
.##....
....##.
..####.
...###.
.......
1
2
3
4
5
6
7

其中 上下左右 四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有 2 座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。

例如上图中的海域未来会变成如下样子：

.......
.......
.......
.......
....#..
.......
.......
1
2
3
4
5
6
7

请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。

输入描述
第一行包含一个整数 N(1≤N≤1000)。
以下 N 行 N 列代表一张海域照片。
照片保证第 1 行、第 1 列、第 N 行、第 N 列的像素都是海洋。
输出一个整数表示答案。

输入输出样例
示例
输入

7
.......
.##....
.##....
....##.
..####.
...###.
.......
1
2
3
4
5
6
7
8

输出
1

Notes：

1. 利用BFS宽搜的思想求解宽搜

import os
import sys


# 海域长宽
n = int(input())
# 存储字符
sea = []
# 标记有不会被淹没的小岛
land = 0
# 小岛数量
island = 0
# 没有被淹没的小岛数量
count = 0
# 创建队列
queue = []
# 输入每行字符
for _ in range(n):
    sea.append(list(map(str,input())))

for i in range(n):
    for j in range(n):
      # 初始化为0，表示已淹没
        land = 0
        # 找到一个小岛
        if sea[i][j] == '#':
            island += 1
            queue.append((i,j))
            # 已访问过的赋值为*
            sea[i][j] = '*'
            # 循环一个小岛上所有#
            while queue:
              # 取队首
                a,b = queue.pop(0)
                # 循环上下左右是否为#
                for x,y in [(0,-1),(0,1),(-1,0),(1,0)]:
                    temp_i = a + x
                    temp_j = b + y
                    if 0 <= temp_i < n and 0 <= temp_j < n:
                        if sea[temp_i][temp_j] == '#':
                          # 周围没有.，表示此小岛没有被淹没
                            if (0 <= temp_j - 1 < n and sea[temp_i][temp_j-1] != '.') and (0 <= temp_j + 1 < n and sea[temp_i][temp_j+1] != '.') and (0 <= temp_i - 1 < n and sea[temp_i-1][temp_j] != '.') and (0 <= temp_i + 1 < n and sea[temp_i+1][temp_j] != '.'):
                                land = 1
                            queue.append((temp_i,temp_j))
                            sea[temp_i][temp_j] = '*'
            # 没有被淹没的小岛数量加1
            if land == 1:
                count += 1
print(island-count)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50