蓝桥杯·寒假百校真题大联赛（大学B组）（第1期）python

刷题入口>>>

第一题 购物单（填空题）

问题描述

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供 100100 元面额的纸币。小明想尽可能少取些现金，够用就行了。 你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。

**** 180.90 88折
**** 10.25 65折
**** 56.14 9折
**** 104.65 9折
**** 100.30 88折
**** 297.15 半价
**** 26.75 65折
**** 130.62 半价
**** 240.28 58折
**** 270.62 8折
**** 115.87 88折
**** 247.34 95折
**** 73.21 9折
**** 101.00 半价
**** 79.54 半价
**** 278.44 7折
**** 199.26 半价
**** 12.97 9折
**** 166.30 78折
**** 125.50 58折
**** 84.98 9折
**** 113.35 68折
**** 166.57 半价
**** 42.56 9折
**** 81.90 95折
**** 131.78 8折
**** 255.89 78折
**** 109.17 9折
**** 146.69 68折
**** 139.33 65折
**** 141.16 78折
**** 154.74 8折
**** 59.42 8折
**** 85.44 68折
**** 293.70 88折
**** 261.79 65折
**** 11.30 88折
**** 268.27 58折
**** 128.29 88折
**** 251.03 8折
**** 208.39 75折
**** 128.88 75折
**** 62.06 9折
**** 225.87 75折
**** 12.89 75折
**** 34.28 75折
**** 62.16 58折
**** 129.12 半价
**** 218.37 半价
**** 289.69 8折

思路
作为填空题，总所周知，有一些题是可以采用Excel或者word这种小心思去解题。
但是，购物单这道题看第一眼，就知道怎么解，而且如果采用Excel的话还要一个一个的复制过去，复制错了更完蛋，那我还不如老老实实用python解，果不其然几分钟就可以做出来了。

sum = 0
while True:
    lists = list(map(str,input().strip().split()))
    # print(lists)
    if lists[2] != '半价':
        num = int(lists[2][0:-1])
        # print(num)
        if num < 10:
            num *= 10
        sum += float(lists[1]) * int(num) * 0.01
    else:
        sum += float(lists[1]) * 0.5
    if lists[1] == '289.69':    # 反正数字固定，那我就直接拿最后一个数字退出循环
        break
if sum % 100 != 0:     # 这个其实在正式比赛的时候可以不写，直接输出结果，然后再加到整百就好了
    sum = (sum // 100 + 1) * 100
print(sum)

第二题 等差素数列（填空题）

问题描述
2,3,5,7,11,13,… 是素数序列。 类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为 30，长度为 6。
2004 年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。 这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为 10 的等差素数列，其公差最小值是多少？

思路
既然是素数等差，那我找到第一个素数然后等差的递增上去，如果递增到的数字也是素数，连着10个，那么这个差值就是正确的，但是不是最小的呢？那就要找一个列表装起来，然后再比较。
这种属于暴力解法，在想不到其他方法的时候就可以用上。

# 只要抓到一个素数 完了就看他等差上去还是不是素数就完事
# 判断是否为素数
def f(n):
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    else:
        return True

num = []
for i in range(3, 1000, 2):
    for j in range(1, 1000):
        if f(i + j) and f(i + 2 * j) and f(i + 3 * j) and f(i + 4 * j) and f(i + 5 * j) and f(i + 6 * j) and f(i + 7 * j) and f(i + 8 * j) and f(i + 9 * j) and f(i):
            num.append(j)

print(min(num))

第三题 承压计算（填空题）

问题描述
X 星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。 金属材料被严格地堆放成金字塔形。
其中的数字代表金属块的重量（计量单位较大）。 最下一层的 XX 代表 3030 台极高精度的电子秤。
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
假设每块原料的重量都十分精确地平均落在下方的两个金属块上， 最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：20864582312086458231
请你推算出：读数最大的电子秤的示数为多少？

思路
这里的原题里数字是金字塔的形状，转换成这种直角三角形会更加清楚明了。
很明显，lists[0][0]的重量就会平分到lists[1][0]和lists[1][1]上面，也就是
lists[1][0] += lists[0][0]/2
lists[1][1] += lists[0][0]/2
而lists[1][0]和lists[1][1]又会把重量平分到lists[2][0]、lists[2][1]和lists[2][1]、lists[2][2]上面。
所以只要按照这个规律做一个循环，就能轻松得到答案！
这里还有一个小心机，就是题目中把计量单位给换了，这样的话，我们只需用2086458231/min(lists1)，就可以得知计量单位的大小，然后再*max(lists1)获得结果！

lists = []
for i in range(29):
    lists.append(list(map(int, input().strip().split())))
print(lists)
for i in range(28):
    for j in range(len(lists[i])):
        lists[i + 1][j] += lists[i][j] / 2
        lists[i + 1][j + 1] += lists[i][j] / 2
print(lists[28])
lists1 = [0 for i in range(30)]
for i in range(29):
    lists1[i] += lists[28][i]/2
    lists1[i+1] += lists[28][i]/2
print(2086458231/min(lists1)*max(lists1))

第四题 方格分割（填空题）

问题描述
6x6的方格，沿着格子的边线剪开成两部分。 要求这两部分的形状完全相同。
如下就是三种可行的分割法。
试计算：包括这 33 种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。

思路
这道题有点难了，我没做出来，最后参考了题解才懂。
题解采用了dfs算法。
我把注释都写在代码里了，哪里看不懂的可以评论告诉我窝

dx=[1,0,-1,0]      # 这里的dx和dy要合起来看 就是右一格 上一格 左一格 下一格
dy=[0,1,0,-1]
ans=0              # 计数
map=[[0 for i in range(7)] for _ in range(7)]  # 先把6*6画出来
def DFS(x,y):
    if x==0 or x==6 or y==0 or y==6:  # 走到头了说明完成了一次分割
        global ans           # 全局化计数器
        ans+=1               # 计数器+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


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

第五题 取位数（填空题）

问题描述
本题为代码补全填空题，请将题目中给出的源代码补全，并复制到右侧代码框中，选择对应的编译语言（C/Java）后进行提交。若题目中给出的源代码语言不唯一，则只需选择其一进行补全提交即可。复制后需将源代码中填空部分的下划线删掉，填上你的答案。提交后若未能通过，除考虑填空部分出错外，还需注意是否因在复制后有改动非填空部分产生错误。

求1个整数的第k位数字有很多种方法。 以下的方法就是一种。

请仔细分析源码，填写划线部分缺少的内容。

C语言源代码

#include <stdio.h>
// 求x用10进制表示时的数位长度
int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}

// 取x的第k位数字
int f(int x, int k){
if(len(x)-k==0) return x%10;
return _____________________; //填空
}

int main()
{
int x = 23574;
printf(“%d\n”, f(x,3));
printf(“%d\n”, f(893275,2));
}

Java源代码

import java.util.*;
public class Main
{
static int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
//取x的第k位数字
static int f(int x, int k){
if(len(x)-k==0) return x%10;
return ______________________; //填空
}

public static void main(String[] args)
{
int x = 23513;
//System.out.println(len(x));
System.out.println(f(x,3));
System.out.println(f(893275,2));
}
}

思路
这道题我就有点不李姐了，我的python哪去了？？

C语言

#include <stdio.h>
// 求x用10进制表示时的数位长度 
int len(int x){
    if(x<10) return 1;
    return len(x/10)+1;
}
    
// 取x的第k位数字
int f(int x, int k){
    if(len(x)-k==0) return x%10;
    return f(int(x/10),k);  //填空
}
    
int main()
{
    int x = 23574;
    printf("%d\n", f(x,3));
    printf("%d\n", f(893275,2));
}

第六题 最大公共子串 （填空题）

问题描述
最大公共子串长度问题就是： 求两个串的所有子串中能够匹配上的最大长度是多少。

比如：“abcdkkk” 和 “baabcdadabc”， 可以找到的最长的公共子串是"abcd",所以最大公共子串长度为 4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

思路
得 又没有python
这里使用的是dp算法
如图：

#include <stdio.h>
#include <string.h>

#define N 256
int f(const char* s1, const char* s2)
{
    int a[N][N];
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int i,j;
    
    memset(a,0,sizeof(int)*N*N);
    int max = 0;
    for(i=1; i<=len1; i++){
        for(j=1; j<=len2; j++){
            if(s1[i-1]==s2[j-1]) {
                a[i][j] = a[i-1][j-1]+1; 
                if(a[i][j] > max) max = a[i][j];
            }
        }
    }
    
    return max;
}

int main()
{
    printf("%d\n", f("abcdkkk", "baabcdadabc"));
    printf("%d\n", f("aaakkkabababa", "baabababcdadabc"));
    printf("%d\n", f("abccbaacbcca", "ccccbbbbbaaaa"));    
    printf("%d\n", f("abcd", "xyz"));
    printf("%d\n", f("ab", "ab"));
    return 0;
}

第七题 日期问题

问题描述
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在 1960 年 1 月 1 日至 2059 年 12 月 31 日。
令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。
更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如 02/03/04，可能是 2002 年 03 月 04 日、2004 年 02 月 03 日或 2004 年 03 月 02 日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？

思路
这个地方出现了多个相似的运算，为了防止冗余，要采用函数的形式去写。（可能也就我这种笨蛋才会忘记使用函数吧）一直写不出来，不用函数的话太绕，代码太长了，一个不小心就给绕进去了，后面是看了别人写的才想起来有函数这个好东西的。

下面是我根据别人的代码，进行去其糟粕取其精华，削微改改得来的新代码。

while True:
    a = list(map(int, input().split("/")))
    res = []


    def isRN(year):       # 闰年判断
        if year % 4 == 0 and year % 100 != 0:
            return True
        elif year % 400 == 0:
            return True
        else:
            return False

    def BigOrSmall(year,month,day):
        Month = [0,31,28,31,30,31,30,31,31,30,31,30,31]
        if day > Month[month]:
            return False

    def f(x, y, z):  # 默认年月日
        if x >= 0 and x <= 59:
            x += 2000
        elif x >= 60 and x <= 99:
            x += 1900
        if y <= 0 or y > 12:
            return False
        if z <= 0 or z > 31:
            return False

        if isRN(x) and y == 2 and z > 29:
            return False
        if isRN(x) == False and y == 2 and z > 28:
            return False
        if BigOrSmall(x,y,z) == False:
            return False
        else:
            res.append("{:d}-{:0>2d}-{:0>2d}".format(x,y,z))
            return

    f(a[0], a[1], a[2])
    f(a[2], a[0], a[1])
    f(a[2], a[1], a[0])
    for i in sorted(list(set(res))):
        print(i)

第八题 包子凑数

问题描述
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有 N种蒸笼，其中第 ii 种蒸笼恰好能放 Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。

每当有顾客想买 X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有 X个包子。比如一共有 3 种蒸笼，分别能放 3、4 和 5 个包子。当顾客想买 11 个包子时，大叔就会选 2 笼 3 个的再加 1 笼 5 个的（也可能选出 1 笼 3 个的再加 2 笼 4 个的）。

当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有 3 种蒸笼，分别能放 4、5 和 6 个包子。而顾客想买 7 个包子时，大叔就凑不出来了。

小明想知道一共有多少种数目是包子大叔凑不出来的。

思路
这道题之前我有出过一次类似的题目文章——买不到的数目
在做过那道题之后，我知道了这玩意是不会超过最小公倍数的！
然后就是dp算法了，如图：

但是，这个代码只拿到75分，没能拿100，没开会员也不知道错哪了，害

def Big(min1,min2):
    # 求最小公倍数先求最大公约数
    # 最大公约数 辗转相除法
    i = 1
    Big1 = min1
    Big2 = min2
    while i != 0:
        i = Big2 % Big1
        Big2 = Big1
        Big1 = i
    return Big2


n = int(input())
lists = []
for i in range(n):
    lists.append(int(input()))
min1 = min(lists)
lists.remove(min1)  # 这玩意不能赋值
min2 = min(lists)
lists.append(min1)
# print(min1,min2)
for i in range(1,len(lists)):
    big = Big(lists[i-1],lists[i])

if big == 1:
    # 有了最小公倍数 开始DP 0我们不要
    big1 = Big(min1,min2)
    small = min1*min2//big1
    lists1 = [0 for i in range(small+1)]
    lists1[0] = 1
    for i in range(1,len(lists1)):
        try:
            for j in lists:
                if lists1[i-j] == 1:
                    lists1[i] = 1
                    break
        except:
            pass
    # 这里要把list1[0]去掉
    print(lists1.count(0))

else:
    print('INF')

第九题 分巧克力

问题描述
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：

1. 形状是正方形，边长是整数
2. 大小相同

例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？ 输入 第一行包含两个整数N和K。(1 <= N, K <=100000) 以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。 输出 输出切出的正方形巧克力最大可能的边长。
样例输入
2 10
6 5
5 6
样例输出
2

思路
典型的二分法
二分法的题型做法比较统一，可以说是换汤不换药，大概思路就是：
根据题意，设置左边界、右边界，左右边界的设置最好是动态的，动态的话就不怕右边界设置太小或太大。
二分法嘛，精髓就是取得中间数，所以接下来就是(l+r)//2，如果这个数可以实现题目要求的话，那就说明答案在mid上面，所以把区间往上移动，l=mid+1。
直到l == r。

每道二分法的题目，不同的就只是在于fun函数，还有mid成立之后区间的上下移动。

如何判断一道题是否使用二分法：
答案为最大或最小就可以往二分法考虑。

# 二分法
def fun(mid):
    count = 0
    for i in num:
        count += (i[0] // mid) * (i[1] // mid)
    return count >= m


n,m = map(int,input().strip().split())
num = []
for i in range(n):
    num.append(list(map(int,input().strip().split())))
l = 1
lists = []
for i in range(n):
    lists.append(min(num[i]))
r = max(lists)
max = 0
while l <= r:
    mid = (l+r) // 2
    if fun(mid):
        max = mid
        l = mid + 1
    else:
        r = mid - 1
print(max)

第十题 k倍区间

问题描述
给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
输入格式
　　-----
　　第一行包含两个整数N和K。(1 <= N, K <= 100000)
　　以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)
输出格式
　　-----
　　输出一个整数，代表K倍区间的数目。

例如，
输入格式
　　5 2
　　1
　　2
　　3
　　4
　　5

程序应该输出：
　　6

n, m = map(int, input().strip().split())
lists = [0 for i in range(n + 1)]
count = 0
for i in range(n):
    lists[i + 1] = int(input()) % m + lists[i]
print(lists)
for i in range(n):
    for j in range(i, n):
        if (lists[j + 1] - lists[i]) % m == 0:
            count += 1
print(count)