第十六届蓝桥杯大赛软件赛省赛 Python 大学 B 组 满分题解

已于 2025-05-01 01:51:25 修改
阅读量2.9k 收藏 21
点赞数 15
文章标签： 蓝桥杯
于 2025-04-12 16:11:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjl_hui/article/details/147166662
版权

题面链接Htlang/2025lqb_python_b

个人觉得今年这套题整体比往年要简单许多，但是G题想简单了出大问题，预估5+0+10+10+15+12+0+8=60，道阻且长，再接再厉

2025.4.30更新：侥幸拿下省一，排名14/392+

代码仅供学习参考，满分为赛后洛谷中的测评，蓝桥杯官方测评待完成

A: 攻击次数

答案：103？181？题目没说明白每回合是不是只能使用一个英雄？

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve():
    xl = 2025
    cnt = 0
    for i in range(1, 2025):
        cnt += 1
        xl -= 5
        if i % 2 == 1:
            xl -= 15
        else:
            xl -= 2
        if i % 3 == 1:
            xl -= 2
        elif i % 3 == 2:
            xl -= 10
        elif i % 3 == 0:
            xl -= 7
        if xl <= 0:
            break
        print(i, xl)
    print(cnt)


T = 1
for i in range(T):
    solve()

B: 最长字符串

答案：afplcu

# # 考场错误解
# def I():
#     return input()


# def II():
#     return int(input())


# def MII():
#     return map(int, I().split())


# def LMII():
#     return list(MII())

# def solve():
#     with open(r'words.txt', 'r') as file:
#         data = file.readlines()

#     dic = {}
#     for i in range(len(data)):
#         x = data[i].strip()
#         data[i] = list(x)
#         dic[x] = 0
#         data[i].sort()
#         dic[x] = data[i]

#     can = set()
#     for i in range(100):
#         for x in data:
#             if len(x) == i + 1:
#                 if len(x) == 1:
#                     can.add(tuple(x))
#                 else:
#                     if tuple(x[:len(x) - 1]) in can:
#                         can.add(tuple(x))
#     cnt = 0
#     for x in can:
#         if len(x) > cnt:
#             cnt = len(x)
#     res = []
#     for x in can:
#         if len(x) == cnt:
#             res.append(x)
#     # print(dic)
#     print(res)
#     for x in dic:
#         # print(tuple(dic[x]))
#         if tuple(dic[x]) == res[0]:
#             print(x)

    
# T = 1
# for i in range(T):
#     solve()

# 正解
def is_beautiful_words(words):
    """
    计算所有优美单词，并返回一个字典：
    key: 单词长度
    value: 集合，每个元素为 (word, sorted(word)) 表示已经确认的优美单词
    """
    # 按长度升序排序（长度相同时字典序排序）
    words_sorted = sorted(words, key=lambda w: (len(w), w))
    
    # 用于存储每个长度的优美单词
    beautiful_by_length = {}
    
    for word in words_sorted:
        l = len(word)
        if l == 1:
            # 长度为1的单词自动是优美字符串（只要在单词本中）
            beautiful_by_length.setdefault(1, set()).add( (word, word) )  # 此处 sorted(word) == word
        else:
            # 先看是否存在长度为 l-1 的优美单词
            if (l - 1) not in beautiful_by_length:
                continue
            # 取当前单词的前 l-1 个字符，并计算其排序结果
            prefix = word[:-1]
            sorted_prefix = ''.join(sorted(prefix))
            # 检查是否存在一个长度为 l-1 的优美单词，其排序后的字符与 prefix 一致
            found = False
            for bw, bw_sorted in beautiful_by_length[l - 1]:
                if bw_sorted == sorted_prefix:
                    found = True
                    break
            if found:
                beautiful_by_length.setdefault(l, set()).add( (word, ''.join(sorted(word))) )
    return beautiful_by_length

def find_longest_beautiful_word(filename):
    with open(filename, "r", encoding="utf-8") as f:
        # 每一行一个单词，去除空白符
        words = [line.strip() for line in f if line.strip()]
    
    beautiful_by_length = is_beautiful_words(words)
    
    if not beautiful_by_length:
        return ""
    
    # 找到存在的最大长度
    max_len = max(beautiful_by_length.keys())
    
    # 在最大长度中，找出字典序最小的那个单词
    candidates = [word for word, _ in beautiful_by_length[max_len]]
    result = min(candidates) if candidates else ""
    return result

if __name__ == "__main__":
    # 假设文件名为 words.txt
    result = find_longest_beautiful_word("words.txt")
    print("最长的优美字符串为:", result)

C: LQ 图形

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve():
    w, h, v = MII()
    for i in range(h):
        print("Q" * w)
    for i in range(w):
        print("Q" * (w + v))


T = 1
for i in range(T):
    solve()

D: 最多次数

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve():
    s = I()
    check = {'lqb', 'lbq', 'qlb', 'qbl', 'blq', 'bql'}
    res = 0
    i = 0
    # print(len(s))
    while i < len(s) - 2:
        # print(i, s[i:i + 3])
        if s[i:i + 3] in check:
            res += 1
            i += 2
        i += 1
    print(res)


T = 1
for i in range(T):
    solve()

E: A · B Problem

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve():
    L = II()
    res = 0
    lst = [0] * (L + 5)
    for i in range(1, L + 1):
        for j in range(1, L + 1):
            if i * j >= L:
                break
            lst[i * j] += 1
    pre = lst.copy()
    for i in range(1, L):
        pre[i] += pre[i - 1]
    for i in range(1, L):
        cnt1 = i
        cnt2 = L - i
        res += lst[cnt1] * pre[cnt2]
    print(res)


T = 1
for i in range(T):
    solve()

赛时对拍

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve1(n):
    res = 0
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            for k in range(1, n + 1):
                for l in range(1, n + 1):
                    if i * k + j * l <= n:
                        res += 1
                        # print((i, k), (j, l))
    print(res)


def solve2(L):
    res = 0
    lst = [0] * (L + 5)
    for i in range(1, L + 1):
        for j in range(1, L + 1):
            if i * j >= L:
                break
            lst[i * j] += 1
    pre = lst.copy()
    for i in range(1, L):
        pre[i] += pre[i - 1]
    for i in range(1, L):
        cnt1 = i
        cnt2 = L - i
        res += lst[cnt1] * pre[cnt2]
    print(res)


T = 1
for i in range(T):
    L = II()
    solve1(L)
    solve2(L)

F: 园艺

赛时代码，可能超时

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve():
    n = II()
    data = LMII()
    res = 1
    cnt = 1
    for i in range(1, n):
        if data[i] > data[i - 1]:
            cnt += 1
        else:
            res = max(res, cnt)
            cnt = 1
    res = max(res, cnt)
    if res == 1 or res == n:
        print(res)
        return

    for jg in range(2, n):  # 间隔
        if res > (n - 1) // jg + 1:
            break
        for st in range(n - jg):
            cnt = 1
            for idx in range(st + jg, n, jg):
                if data[idx] > data[idx - jg]:
                    cnt += 1
                else:
                    res = max(res, cnt)
                    cnt = 1
            res = max(res, cnt)
    print(res)

T = 1
for i in range(T):
    solve()

赛后优化及对拍

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve1(n, data):
    res = 1
    cnt = 1
    for i in range(1, n):
        if data[i] > data[i - 1]:
            cnt += 1
        else:
            res = max(res, cnt)
            cnt = 1
    res = max(res, cnt)
    if res == 1 or res == n:
        print(res)
        return

    for jg in range(2, n):  # 间隔
        if res > (n - 1) // jg + 1:
            break
        for st in range(n - jg):
            cnt = 1
            for idx in range(st + jg, n, jg):
                if data[idx] > data[idx - jg]:
                    cnt += 1
                else:
                    res = max(res, cnt)
                    cnt = 1
            res = max(res, cnt)
    print(res)

def solve2(n, data):
    dp = [[1 for _ in range(n + 1)] for _ in range(n + 1)]
    for i in range(0, n):
        for j in range(0, i):
            if data[i] > data[j]:
                dp[i][i - j] = dp[j][i - j] + 1
    print(max([max(d) for d in dp]))


T = 1
for i in range(T):
    n = II()
    # data = LMII()
    import random
    data = [random.randint(1, 2 ** 20) for _ in range(n)]
    import time
    t1 = time.time()
    solve1(n, data)
    t2 = time.time()
    solve2(n, data)
    t3 = time.time()
    print(t2 - t1, t3 - t2)

G: 书架还原

# # 考场错误解
# def I():
#     return input()


# def II():
#     return int(input())


# def MII():
#     return map(int, I().split())


# def LMII():
#     return list(MII())


# def solve():
#     n = II()
#     data = [0] + LMII()
#     res = 0
#     for i in range(1, n + 1):
#         if i != data[i]:
#             if i == data[data[i]]:
#                 res += 1
#                 x = data[data[i]]
#                 data[data[i]] = data[i]
#                 data[i] = x
#     print(res, data)
#     cnt = 0
#     for i in range(1, n + 1):
#         if i != data[i]:
#             cnt += 1
#     if cnt:
#         print(res + cnt - 1)
#     else:
#         print(res)


# T = 1
# for i in range(T):
#     solve()

# 正解
n = int(input())
a = list(map(int, input().split()))
visited = [False] * n
ans = 0

for i in range(n):
    if not visited[i] and a[i] != i + 1:
        count = 0
        j = i
        while not visited[j]:
            visited[j] = True
            count += 1
            j = a[j] - 1
        ans += count - 1

print(ans)

H: 异或和

赛时代码，超时

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve1():
    n = II()
    data = LMII()
    res = 0
    for i in range(n - 1):
        for j in range(i + 1, n):
            res += (data[i] ^ data[j]) * (j - i)
    print(res)


T = 1
for i in range(T):
    solve1()

赛时对拍，超时

def I():
    return input()


def II():
    return int(input())


def MII():
    return map(int, I().split())


def LMII():
    return list(MII())


def solve1(n, data):
    res = 0
    for i in range(n - 1):
        for j in range(i + 1, n):
            # print(data[i],data[j],data[i] ^ data[j])
            res += (data[i] ^ data[j]) * (j - i)
    print(res)


def solve2(n, data):
    res = 0
    for j_i in range(1, n):
        cnt = 0
        for i in range(j_i):
            for j in range(i + j_i, n, j_i):
                cnt += data[j - j_i] ^ data[j]
        res += j_i * cnt
    print(res)


T = 1
for i in range(T):
    n = II()
    # data = LMII()
    import random
    data = [random.randint(1, 2 ** 20) for _ in range(n)]
    import time
    t1 = time.time()
    solve1(n, data)
    t2 = time.time()
    solve2(n, data)
    t3 = time.time()
    print(t2 - t1, t3 - t2)

赛后补题

n = int(input())
a = list(map(int, input().split()))
ans = 0

for k in range(31):  # 考虑31位足以覆盖正整数的情况
    cnt1 = 0  # 记录当前位为1的个数
    sum1 = 0  # 记录当前位为1的位置之和
    for j in range(1, n + 1):
        b = (a[j - 1] >> k) & 1  # 取出第k位
        if b:
            cnt0 = j - 1 - cnt1
            sum0 = (j - 1) * j // 2 - sum1
            ans += (j * cnt0 - sum0) * (1 << k)
            cnt1 += 1
            sum1 += j
        else:
            ans += (j * cnt1 - sum1) * (1 << k)

print(ans)

汇太浪
关注
第十二届蓝桥杯大赛软件赛省赛B组题解
m0_51508220的博客
04-30 2150
第十二届蓝桥杯大赛软件赛省赛B组题解A：空间B：卡片C：直线D:货物摆放E:路径F：时间显示G:砝码称重H：杨辉三角形I：双向排序J：括号序列 A：空间 题目描述： 分析： 1MB = 2^20B 32位=32/8 B = 4B. 2 ^10 = 1024 嗷嗷，这大概就是告诉我们基础知识的重要性吧，上课一定要注意听讲@^@ #include <bits/stdc++.h> using namespace std; int main(void){ cout << 256 / 4
第14届蓝桥杯Python省赛真题-大学B组
12-28
第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛...
蓝桥杯创意编程大赛题解：回形取数
少儿编程乔老师
04-22 500
#include <iostream> using namespace std; const int N = 50; int g[N][N]; int main() { int n, m; cin >> n >> m; for(int i = 1; i <= n; i ++) for(int j = 1; j <= m; j ++) cin >> g[i][j];
蓝桥杯第十五届软件测试线下省赛题目分析及解决
m0_75269526的博客
04-20 3392
​ 第十五届软件测试蓝桥杯省赛，蓝桥杯省赛，线下，请对被测系统中的如下2个页面进行测试，寻找其中预埋的缺陷，包括但不限于功能缺陷和易用性界面缺陷。注意:如果您单元测试使用的是Python代码，请查看Python的单元测试题目，并WebCaseTest.java:测试用例代码文件请按照用例步骤，在测试用例 WebCaseTest.java文件中通过调用3个Page 类中的方法完成自动化测试代码。3个page 类中方法的实现，每个占1.5分，共计27分。4月13日线下软件测试蓝桥杯，蓝桥，软测，蓝桥杯软测
蓝桥杯官网题1(含VIP试题且带详细解析!小白看过来！！
cookieeee_的博客
02-02 691
蓝桥杯新手自己整理的官网习题，有讲解，很适合新手小白，也希望大佬能给我提提意见或者纠错，目前会一直更新到竞赛结束，然后再单开个文章记录日常练习
2025第十六届蓝桥杯PythonB组部分题解
2301_82101106的博客
04-13 791
计算满足X_AX_B + Y_AY_B ≤ L的正整数组合数。游戏从第1回合开始，当敌人血量≤0时结束，求结束时的回合数。从给定字符串s中切割最多数量的指定3字符组合（6种可能）。通过交换操作将乱序书恢复顺序，求最少操作次数。计算ΣΣ(a_i⊕a_j)*(j-i)的值。保留最长的等间隔递增树列。
16届蓝桥杯Python赛道B组战果汇报
2403_88854014的博客
04-12 4083
先说结论，在我看来这届的难度比以往降了很多的档次，基本全程就是用模拟+暴力来做都能搞定
2025第十六届蓝桥杯python B组满分题解(详细)
2403_89586338的博客
04-20 4558
此次蓝桥杯共8道题（2道填空，6道编程）满分100。与去年的题相比难度降低了不少，第一道编程题简直送分，刚学的小白估计也会。我本人大一，刚学python不久，我只能说这次比赛中基本没用到什么算法，全是暴力，考前学习的DFS,BFS,二维前缀差分等等都没用上，虽然比赛中有的题我暴力也没做出来。当然，这套题想拿高分也不容易，面对巨大数据量，时间复杂度是个问题。下面给大家分享一下满分题解，以下代码在洛谷均可通过，现在蓝桥官网上还没更新，不知在蓝桥官网上测评如果。欢迎各位大佬对我的题解进行点评指正。
第16届蓝桥杯模拟赛3 python组个人题解
qq_66608435的博客
02-22 5489
第16届蓝桥杯模拟赛3 python组个人题解思路和答案不保证正确。
第十三届蓝桥杯省赛Python 组
G1F's Hus' 8L0G
04-09 6933
第十三届蓝桥杯省赛PythonB组真题+题解
第14届蓝桥杯Python省赛真题-大学A组
12-28
第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛真题-大学A组 第14届蓝桥杯Python省赛...
第十五届蓝桥杯大赛软件赛决赛-CB
06-03
### 第十五届蓝桥杯大赛软件赛决赛-C/C++B组真题解析 #### 概述 第十五届蓝桥杯大赛软件赛决赛是面向全国大学生的一项高水平编程竞赛，旨在检验参赛者的算法设计与实现能力。本次比赛针对C/C++语言的大学B组选手...
2023年第十四届蓝桥杯大赛软件类省赛C&C++大学C 组真题（代码&完整题解）
03-29
2023年第十四届蓝桥杯大赛软件类省赛C&C++研究生组真题（包含代码&完整题解） C题-三国游戏 贪心 三个国家初始人数都为0，n个事件，第i个事件若发生每个国家分别加Ai，Bi，Ci人，求最多发生几个事件使得两个国家人数...
蓝桥杯算法实战分享
最新发布
weixin_43520816的博客
04-28 763
dp[i][j] = Σdp[i-1][k]（k与j差的绝对值≠1）[61]。有序枚举避免重复，预处理减少计算量[31][61]2021砝码称重、2020斐波那契[96][97]BFS层序扩展，DFS记忆化剪枝[36][63]：dp[i][j]表示i位数且末位为j的方案数。2022接龙数列、2019K好数[61][96]2018迷宫、2023岛屿个数[77][93]状态压缩、滚动数组优化空间[61][77]2023飞机降落、2022最大数字[96]欧拉定理、快速幂模运算[66][96]
蓝桥杯 11. 打印大X
wuqingshun314159的博客
04-27 276
小明希望用星号拼凑，打印出一个大 X，他要求能够控制笔画的宽度和整个字的高度。为了便于比对空格，所有的空白位置都以句点符。，表示笔画的宽度和 X 的高度，用空格分开。输出一个大 X，使用星号。
第十二届蓝桥杯 2021 C/C++组 空间
2301_80558092的博客
04-28 641
这题其实就是考察空间的基本知识，如果了解的话还是非常简单的
蓝桥杯2025年第十六届省赛真题-可分解的正整数
CQY0531的博客
04-28 280
其实只有1不符合要求，因为-1+0+1=0，作为对称结构，任何数都可以改成加法，比如4=-3+-2+-1+0+1+2+3+4，但因为最小连续的数为3,1恰好在里面，所以1不行。
蓝桥杯 剪纸刀
Deep_C的博客
04-24 389
蓝桥杯题解
蓝桥杯 3. 压缩字符串
wuqingshun314159的博客
04-28 290
实现一个算法来压缩一个字符串。
第十五届蓝桥杯大赛软件赛省赛Python 大学 B 组
03-31
关于第十五届蓝桥杯大赛软件赛省赛 Python 大学 B 组的具体题目及其解析，目前可获得的信息主要集中在 A 组的题目上[^1]。然而，通常情况下，B 组与 A 组的题目难度分布有所不同，但考察的知识点范围大致相似。 以下是基于以往比赛规律以及现有资料推测可能涉及的内容： ### 试题结构概述 蓝桥杯竞赛一般会设置多道编程题，分为简单、中等和较难三个层次。每道题目都有明确的要求，参赛者需按照输入输出格式完成程序设计并提交代码。 #### 常见考点分析 - **基础算法**：如枚举法、贪心策略等。 - **数据处理能力**：字符串操作、列表管理等功能的应用。 - **逻辑思维训练**：通过解决实际问题来锻炼学生的综合思考力。 下面给出几个假设性的例子供参考学习之用: --- ### 示例一: 判断质数 编写函数判断给定整数n(n>1)是否为素数(prime number)，如果是返回True；否则False。 ```python def is_prime(n): if n <= 1: return False for i in range(2, int(n**0.5)+1): if (n % i)==0: return False return True ``` 上述实现利用了平方根优化技巧减少不必要的运算次数从而提高效率[^2]. --- ### 示例二: 字符串反转 定义一个方法接受任意长度字符串作为参数并将它逆序排列后再打印出来. ```python def reverse_string(s): reversed_s = "" length = len(s) while length > 0 : length -=1 reversed_s += s[length] print(reversed_s) reverse_string("hello world") # 输出 "dlrow olleh" ``` 此段脚本展示了如何遍历整个字符序列并通过累加方式构建新的结果对象[^3]. 注意以上仅为模拟样例并非真实考题内容，请以官方发布为准！
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值