蓝桥杯真题训练6

蓝桥杯真题训练

1-特别数的和

小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。

请问，在 1 到 nn 中，所有这样的数的和是多少？

n = int(input())
count = 0
for i in range(1,n+1):
  m = str(i)
  for j in m:
    if(j in '2019'):
      count = count + i
      break
print(count)

解题思路：这个题就是把数字转为str类型找关键数字，然后两个for循环完事，暴力就可以。

2-明码

汉字的字形存在于字库中，即便在今天，1616 点阵的字库也仍然使用广泛。

1616 点阵的字库把每个汉字看成是 16 \times 1616×16 个像素信息。并把这些信息记录在字节中。

一个字节可以存储 88 位信息，用 3232 个字节就可以存一个汉字的字形了。 把每个字节转为 22 进制表示，11 表示墨迹，00 表示底色。每行 22 个字节，一共 1616 行，布局是：

第 1 字节，第 2 字节
第 3 字节，第 4 字节
....
第 31 字节, 第 32 字节

copy
这道题目是给你一段多个汉字组成的信息，每个汉字用 3232 个字节表示，这里给出了字节作为有符号整数的值。

题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形，从中看出题目的要求，并根据要求填写答案。

这段信息是（一共 1010 个汉字）：

4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4
4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64
16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128
0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0
2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0
1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0
0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0

# l = list(map(int, "4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0".split()))         九
# l = list(map(int, "16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16".split()))     的
# l = list(map(int, "4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 ".split()))             九
# l = list(map(int, "0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4".split()))        次
# l = list(map(int, "4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64".split()))           方
# l = list(map(int, "16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128".split()))    等
# l = list(map(int, "0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0".split()))               于
# l = list(map(int, "2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0".split()))       多
# l = list(map(int, "1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0 ".split()))        少
# l = list(map(int, "0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0".split()))   # ？

# 解码：“九的九次方等于多少？”

# def get_bin(n):
#     b = '{0:b}'.format(n)
#     return b
#
# def reshape(n):
#     if n >= 0:
#         if len(str(get_bin(n))) < 7:
#             return "0"+"0"*(7-len(str(get_bin(n)))) + str(get_bin(n))
#         else:
#             return "0" + str(get_bin(n))
#     else:
#         if len(str(get_bin(n))[1:]) < 7:
#             return "1"+"0"*(7-len(str(get_bin(n))[1:])) + str(get_bin(n))[1:]
#         else:
#             return "1" + str(get_bin(n))[1:]
#
# chara = []
# for i in range(0, 32, 2):
#     print(reshape(l[i])+reshape(l[i+1]))

print(9**9)

解题思路：引用了LOU69516717的代码，不太清楚这个的意思，找朋友研究之后再说。

3-汉诺塔

汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。

大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着 6464 片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上(可以借助第三根柱子做缓冲)。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

如下图所示是现代“山寨”版的该玩具。6464 个圆盘太多了，所以减为 77 个，金刚石和黄金都以木头代替了…但道理是相同的。

图片描述

据说完成大梵天的命令需要太多的移动次数，以至被认为完成之时就是世界末日！

你的任务是精确计算出到底需要移动多少次。

很明显，如果只有 22 个圆盘，需要移动 33 次。

圆盘数为 33，则需要移动 77 次。

那么 6464 个呢？

import math
print(pow(2,64)-1)

解题思路：这个汉诺塔问题有个规律就是移动的次数等于2的n次方-1，n为多少个圆盘。

4-方格分割

6x6的方格，沿着格子的边线剪开成两部分。 要求这两部分的形状完全相同。

如下就是1种可行的分割法。

试计算： 包括这 33 种分法在内，一共有多少种不同的分割方法。 注意：旋转对称的属于同一种分割法。

dx=[1,0,-1,0]
dy=[0,1,0,-1]
ans=0
map=[[0 for i in range(7)] for _ in range(7)]
def DFS(x,y):
    if x==0 or x==6 or y==0 or y==6:
        global ans
        ans+=1
        return
    for i in range(4):
        newx=x+dx[i]
        newy=y+dy[i]
        # print(newx,newy)
        if map[newx][newy]==0:
            map[newx][newy]=1#标记走过
            map[6-newx][6-newy]=1
            DFS(newx,newy)
            map[newx][newy]=0#搜索完后没走过
            map[6-newx][6-newy]=0

def main():
    map[3][3] = 1#从中心位置3,3开始
    DFS(3, 3)#深度搜索
    print(int(ans / 4))
if __name__=='__main__':
    main()

解题思路：引用了niu的代码，用的是dfs的想法，但是有个点很关键就是在一次的搜索（裁剪）后，把裁剪过的位置重新复位0，以便下一次以另一条线走，并且从中间开始走，更容易对称，最后除以四，是因为有如果同一个对称图形有四个方向的旋转对称。很nb的思路。

5-七段码

小蓝要用七段码数码管来表示一种特殊的文字。

上图给出了七段码数码管的一个图示，数码管中一共有 77 段可以发光的二 极管，分别标记为 a, b, c, d, e, f, ga,b,c,d,e,f,g。

小蓝要选择一部分二极管（至少要有一个）发光来表达字符。在设计字符 的表达时，要求所有发光的二极管是连成一片的。

例如：bb 发光，其他二极管不发光可以用来表达一种字符。

例如 cc 发光，其他二极管不发光可以用来表达一种字符。这种方案与上 一行的方案可以用来表示不同的字符，尽管看上去比较相似。

例如：a, b, c, d, ea,b,c,d,e 发光，f, gf,g 不发光可以用来表达一种字符。

例如：b, fb,f 发光，其他二极管不发光则不能用来表达一种字符，因为发光 的二极管没有连成一片。

请问，小蓝可以用七段码数码管表达多少种不同的字符？

data = [0,[2,7],[3,1,6],[2,4,6],[3,5],[4,6,7],[2,3,5,7],[1,6,5]]

s = []
def fun(d):
    
    if len(d) == 7:
        return
    for i in range(1,8):
        if len(d) == 0:
            D = d[:]
            D.append(i)
            fun(D)
            s.append(D)
        elif i not in d:
            for j in d:
                if i in data[j]:
                    D = d[:]
                    D.append(i)
                    if sorted(D) not in s:
                        fun(sorted(D))
                        s.append(sorted(D))
                    break
fun([])
print(len(s))

解题思路：这个题解引用了肖的代码。思想基本是dfs加上找集合的思路。先是用data讲abcd…相邻的字母用数字标识并整合到一个【】里面，再利用递归实现深度搜索，找出每个字符相邻字符可以连成的图示，但是注意的是可能会有重复，这里用sorted来避免重复，最后输出len（s）,便是答案。

勉励自己的话

加油，或许很难，但是坚持总会有收获！