2024第十六届蓝桥杯模拟赛（第二期）-Python

# 2024第十六届蓝桥杯模拟赛（第二期）-Python题解
# 自己改注释# -----------------------1------------------------
# def prime(x):
#     if x < 2:
#         return 0
#     for i in range(2, int(x ** 0.5) + 1):
#         if x % i == 0:
#             return 0
#     return 1
#
#
# res = 2
# for i in range(2, 2025):
#     if prime(i) and 2024 % i == 0:
#         res = i
# print(res)# -----------------------2------------------------
# import math
# print(2024*1024//math.gcd(2024, 1024))# -----------------------3------------------------
# n = 2024
# res = 0
# for i in range(1, n+1):
#     if i ^ n < n:
#         res += 1
# print(res)# -----------------------4------------------------
# n = 2024
# dp = [float('inf')] * (n + 1)
# dp[1] = 0
# for i in range(1, n):
#     if i + 1 <= n:
#         dp[i + 1] = min(dp[i + 1], dp[i] + 1)
#     if i + int(max(str(i))) <= n:
#         dp[i + int(max(str(i)))] = min(dp[i + int(max(str(i)))], dp[i] + 3)
#     if i * 2 <= n:
#         dp[i * 2] = min(dp[i * 2], dp[i] + 10)
# print(dp[n])# -----------------------5------------------------
# nums1 = [534, 386, 319, 692, 169, 338, 521, 713, 640, 692, 969, 362, 311, 349, 308, 357, 515, 140, 591, 216,
#          57, 252, 575, 630, 95, 274, 328, 614, 18, 605, 17, 980, 166, 112, 997, 37, 584, 64, 442, 495,
#          821, 459, 453, 597, 187, 734, 827, 950, 679, 78, 769, 661, 452, 983, 356, 217, 394, 342, 697, 878,
#          475, 250, 468, 33, 966, 742, 436, 343, 255, 944, 588, 734, 540, 508, 779, 881, 153, 928, 764, 703,
#          459, 840, 949, 500, 648, 163, 547, 780, 749, 132, 546, 199, 701, 448, 265, 263, 87, 45, 828, 634]
# nums1.sort()
# nums2 = [x % 24 for x in nums1]
# cnt = sum(nums1) % 24
# for i,x in enumerate(nums2):
#     if cnt == x:
#         print(sum(nums1) - nums1[i])
#         break# -----------------------6------------------------
# n = int(input())
# print((2024-1)//n+1)# -----------------------7------------------------
# n = int(input())
# data = list(map(int,input().split()))
# res = float('inf')
# for x in data:
#     if x % 2 == 0 and x < res:
#         res = x
# print(res)# -----------------------8------------------------
# s = input()
# find = "LANQIAO"
# cnt = 0
# for x in s:
#     if x == find[cnt]:
#         cnt += 1
#     if cnt == len(find):
#         print("YES")
#         break
# else:
#     print("NO")# -----------------------9------------------------
# n, m = map(int, input().split())
# data = []
# for i in range(n):
#     data.append(list(map(int, input().split())))
#
# res = 0
# for x1 in range(n):
#     for y1 in range(m):
#         L = min(n - x1, m - y1)
#         for l in range(1, L):
#             x2 = x1 + l
#             y2 = y1 + l
#             t = 0
#             # 左竖边 (x1, y1) 到 (x2, y1)
#             for x in range(x1, x2 + 1):
#                 t += data[x][y1]
#             # 上横边 (x1, y1) 到 (x1, y2)
#             for y in range(y1, y2 + 1):
#                 t += data[x1][y]
#             # 右竖边 (x2, y1) 到 (x2, y2)
#             for x in range(x1, x2 + 1):
#                 t += data[x][y2]
#             # 下横边 (x1, y2) 到 (x2, y2)
#             for y in range(y1, y2 + 1):
#                 t += data[x2][y]
#             # 减去重复的四个角点 (x1, y1), (x1, y2), (x2, y1), (x2, y2)
#             t -= data[x1][y1]
#             t -= data[x1][y2]
#             t -= data[x2][y1]
#             t -= data[x2][y2]
#
#             res = max(res, t)
# print(res)# -----------------------10------------------------
# directions = {"U": (-1, 0), "D": (1, 0), "L": (0, -1), "R": (0, 1)}  # 上下左右
# directions_change = {"U": {"F": "U", "R": "R", "L": "L"}, "D": {"F": "D", "R": "L", "L": "R"},
#                      "L": {"F": "L", "R": "U", "L": "D"}, "R": {"F": "R", "R": "D", "L": "U"}}
#
#
# def calculate_final_position(i, direction, pos):
#     for move in moves[i:]:
#         direction = directions_change[direction][move]
#         pos = (pos[0] + directions[direction][0], pos[1] + directions[direction][1])
#     return pos
#
#
# n = int(input())
# moves = list(input())
# final_positions = set()
# now_direction = "U"
# now_pos = (0, 0)
# for i in range(n):
#     original_move = moves[i]  # 保存原始步
#     for new_move in "FLR":  # 对每个步尝试变成 F, L, R
#         if new_move != original_move:
#             moves[i] = new_move  # 修改这一步
#             final_positions.add(calculate_final_position(i, now_direction, now_pos))  # 计算并记录最终位置
#     moves[i] = original_move  # 恢复原始步
#     now_direction = directions_change[now_direction][original_move]
#     now_pos = (now_pos[0] + directions[now_direction][0], now_pos[1] + directions[now_direction][1])
# print(len(final_positions))

一

【问题描述】

如果一个数 p 是个质数，同时又是整数 a 的约数，则 p 称为 a 的一个质因数。

请问， 2024 的最大的质因数是多少？

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案 23

def prime(x):if x < 2:return 0for i in range(2, int(x ** 0.5) + 1):if x % i == 0:return 0return 1res = 2
for i in range(2, 2025):if prime(i) and 2024 % i == 0:res = i
print(res)

二

【问题描述】

对于两个整数 a, b，既是 a 的整数倍又是 b 的整数倍的数称为 a 和 b 的公倍数。公倍数中最小的正整数称为 a 和 b 的最小公倍数。

请问， 2024 和 1024 的最小公倍数是多少？

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案 259072

import math
print(2024*1024//math.gcd(2024, 1024))

三

【问题描述】

两个数按位异或是指将这两个数转换成二进制后，最低位与最低位异或作为结果的最低位，次低位与次低位异或作为结果的次低位，以此类推。

例如，3 与 5 按位异或值为 6 。

请问，有多少个不超过 2024 的正整数，与 2024 异或后结果小于 2024 。

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案 2001

n = 2024
res = 0
for i in range(1, n+1):if i ^ n < n:res += 1
print(res)

四

【问题描述】

小蓝可以花费 10 的代价将整数变为原来的 2 倍。

例如，如果整数为 16，花费 3 将整数变为 22 。

又如，如果整数为 22，花费 1 将整数变为 23 。

又如，如果整数为 23，花费 10 将整数变为 46 。

请问，如果要将整数从初始值 1 变为 2024，请问最少需要多少代价？

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案 79

n = 2024
dp = [float('inf')] * (n + 1)
dp[1] = 0
for i in range(1, n):if i + 1 <= n:dp[i + 1] = min(dp[i + 1], dp[i] + 1)if i + int(max(str(i))) <= n:dp[i + int(max(str(i)))] = min(dp[i + int(max(str(i)))], dp[i] + 3)if i * 2 <= n:dp[i * 2] = min(dp[i * 2], dp[i] + 10)
print(dp[n])

五

【问题描述】

小蓝有以下 100 个整数：

534, 386, 319, 692, 169, 338, 521, 713, 640, 692, 969, 362, 311, 349, 308, 357, 515, 140, 591, 216, 57, 252, 575, 630, 95, 274, 328, 614, 18, 605, 17, 980, 166, 112, 997, 37, 584, 64, 442, 495, 821, 459, 453, 597, 187, 734, 827, 950, 679, 78, 769, 661, 452, 983, 356, 217, 394, 342, 697, 878, 475, 250, 468, 33, 966, 742, 436, 343, 255, 944, 588, 734, 540, 508, 779, 881, 153, 928, 764, 703, 459, 840, 949, 500, 648, 163, 547, 780, 749, 132, 546, 199, 701, 448, 265, 263, 87, 45, 828, 634

小蓝想从中选出一部分数求和，使得和是 24 的倍数，请问这个和最大是多少？

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案 49176

nums1 = [534, 386, 319, 692, 169, 338, 521, 713, 640, 692, 969, 362, 311, 349, 308, 357, 515, 140, 591, 216,57, 252, 575, 630, 95, 274, 328, 614, 18, 605, 17, 980, 166, 112, 997, 37, 584, 64, 442, 495,821, 459, 453, 597, 187, 734, 827, 950, 679, 78, 769, 661, 452, 983, 356, 217, 394, 342, 697, 878,475, 250, 468, 33, 966, 742, 436, 343, 255, 944, 588, 734, 540, 508, 779, 881, 153, 928, 764, 703,459, 840, 949, 500, 648, 163, 547, 780, 749, 132, 546, 199, 701, 448, 265, 263, 87, 45, 828, 634]
nums1.sort()
nums2 = [x % 24 for x in nums1]
cnt = sum(nums1) % 24
for i,x in enumerate(nums2):if cnt == x:print(sum(nums1) - nums1[i])break

六

【问题描述】

小蓝准备请自己的朋友吃饭。小蓝朋友很多，最终吃饭的人总数达 2024 人（包括他自己）。

请问如果每桌最多坐 n 人，最少要多少桌才能保证每个人都能吃饭。

【输入格式】

输入一行包含一个整数 n 。

【输出格式】

输出一行包含一个整数，表示最少的桌数。

【样例输入】

10

【样例输出】

203

【样例输入】

8

【样例输出】

253

【评测用例规模与约定】

对于所有评测用例，1 <= n <= 2024。

n = int(input())
print((2024-1)//n+1)

七

【问题描述】

小蓝有一个数组 a[1], a[2], ..., a[n] ，请求出数组中值最小的偶数，输出这个值。

【输入格式】

输入的第一行包含一个整数 n 。

第二行包含 n 个整数，相邻数之间使用一个空格分隔，依次表示 a[1], a[2], ..., a[n] 。

【输出格式】

输出一行，包含一个整数，表示答案。数据保证数组中至少有一个偶数。

【样例输入】

9
9 9 8 2 4 4 3 5 3

【样例输出】

2

【样例输入】

5
4321 2143 1324 1243 4312

【样例输出】

1324

【评测用例规模与约定】

对于 30% 的评测用例，1 <= n <= 100，0 <= a[i] <= 1000。

对于 60% 的评测用例，1 <= n <= 1000，0 <= a[i] <= 1000。

对于所有评测用例，1 <= n <= 10000，0 <= a[i] <= 1000000。

n = int(input())
data = list(map(int,input().split()))
res = float('inf')
for x in data:if x % 2 == 0 and x < res:res = x
print(res)

八

【问题描述】

一个字符串包含LANQIAO是指在字符串中能取出几个字符，将他们按照在原串中的位置顺序摆成一排后字符串为 LANQIAO 。即字符串包含 LANQIAO 是指 LANQIAO 是这个串的子序列。

例如：LLLLLANHAHAHAQLANIIIIALANO 中包含 LANQIAO 。

又如：OAIQNAL 中不包含 LANQIAO 。

给点一个字符串，判断字符串中是否包含 LANQIAO 。

【输入格式】

输入一行包含一个字符串。

【输出格式】

如果包含 LANQIAO ，输出一个英文单词 YES ，否则输出一个英文单词 NO 。

【样例输入】

LLLLLANHAHAHAQLANIIIIALANO

【样例输出】

YES

【样例输入】

OAIQNAL

【样例输出】

NO

【评测用例规模与约定】

对于所有评测用例，输入的字符串非空串，由大写字母组成，长度不超过 1000 。

s = input()
find = "LANQIAO"
cnt = 0
for x in s:if x == find[cnt]:cnt += 1if cnt == len(find):print("YES")break
else:print("NO")

九

【问题描述】

小蓝有一个 n 行 m 列的矩阵 a[i][j] ，他想在矩阵中找出一个“口”字形状的区域，使得区域上的值的和最大。

具体讲，一个“口”字形状的区域可以由两个坐标 (x1, y1) 和 (x2, y2) 确定，满足：

  • 1 <= x1 < x2 <= n ；
  • 1 <= y1 < y2 <= m ；
  • x2 - x1 = y2 - y1 。

对应的区域由满足以下条件之一的点 (x, y) 构成：

  • x1 <= x <= x2，且 y = y1 ，对应“口”的左边一竖；
  • y1 <= y <= y2，且 x = x1 ，对应“口”的上面一横；
  • x1 <= x <= x2，且 y = y2 ，对应“口”的右边一竖；
  • y1 <= y <= y2，且 x = x2 ，对应“口”的下面一横。

请注意有些点满足以上条件的多个，例如左上角的点 (x1, y1) ，在计算时算为一个点。

区域上的值是指对应区域的所有点的值，即“口”字的框上的值，不含框内和框外的值。

【输入格式】

输入的第一行包含两个整数 n, m ，分别表示行数和列数。

接下来 n 行，每行包含 m 个整数，相邻数之间使用一个空格分隔，依次表示矩阵的每行每列的值，本部分的第 i 行第 j 列表示 a[i][j] 。

【输出格式】

输出一行包含一个整数，表示最大的和。

【样例输入】

5 6
1 -1 2 -2 3 -3
-1 2 -2 3 -3 4
2 -2 3 -3 4 -4
-2 3 -3 4 -4 5
3 -3 4 -4 5 -5

【样例输出】

4

【样例说明】

取 (x1, y1) = (1, 1) ， (x2, y2) = (5, 5) 可得到最大值。

【评测用例规模与约定】

对于 30% 的评测用例，1 <= n, m <= 30 ，-1000 <= a[i][j] <= 1000 。

对于 60% 的评测用例，1 <= n, m <= 100 ，-1000 <= a[i][j] <= 1000 。

对于所有评测用例，1 <= n, m <= 300 ，-1000 <= a[i][j] <= 1000 。

n, m = map(int, input().split())
data = []
for i in range(n):data.append(list(map(int, input().split())))res = 0
for x1 in range(n):for y1 in range(m):L = min(n - x1, m - y1)for l in range(1, L):x2 = x1 + ly2 = y1 + lt = 0# 左竖边 (x1, y1) 到 (x2, y1)for x in range(x1, x2 + 1):t += data[x][y1]# 上横边 (x1, y1) 到 (x1, y2)for y in range(y1, y2 + 1):t += data[x1][y]# 右竖边 (x2, y1) 到 (x2, y2)for x in range(x1, x2 + 1):t += data[x][y2]# 下横边 (x1, y2) 到 (x2, y2)for y in range(y1, y2 + 1):t += data[x2][y]# 减去重复的四个角点 (x1, y1), (x1, y2), (x2, y1), (x2, y2)t -= data[x1][y1]t -= data[x1][y2]t -= data[x2][y1]t -= data[x2][y2]res = max(res, t)
print(res)

十（TLE）

【问题描述】

小蓝正在玩一个寻宝游戏。寻宝游戏在一个方格图上进行。方格图中的每一个格子都有一个坐标 (r, c)，其中越往北 r 越小，越往南 r 越大，越往东 c 越大，越往西 c 越小。南北相邻方格的 c 坐标相同，r 坐标差一。东西相邻方格的 r 坐标相同， c 坐标差一。

游戏开始时，小蓝站在 (0, 0) 处，面向北边。游戏区域无限大，且没有障碍。每一步，小蓝控制自己的角色走一步，他可以有如下三种选择：

  • 向前走：朝现在的方向前进到相邻的方格中，并保持当前的方向。
  • 向左走：向左转90度，并前进到相邻的方格中（即进入到原来左边的方格），面向的方向变为了原来的左边。
  • 向右走：向右转90度，并前进到相邻的方格中（即进入到原来右边的方格），面向的方向变为了原来的右边。

小蓝玩了一会儿，一共走了 n 步，他记录了自己的每一个动作。但是他没有找到宝藏。他怀疑前面的某一步出现了失误。他想知道，如果他改变之前的某一步，能到的位置有哪些。由于这个太复杂，他想知道最终到的位置（第 n 步后到的位置）有多少种。

【输入格式】

输入的第一行包含一个整数 n ，表示小蓝走了 n 步。

第二行包含一个长度为 n 的由大写字母组成的字符串，依次表示小蓝走的每一步。字母 F 、 L 、 R 分别表示对应的步是向前走、向左走、向右走。

【输出格式】

输出一行，包含一个整数，表示如果改变某一步，可以到的位置的种类数。

【样例输入】

3
FLR

【样例输出】

6

【样例说明】

如果不改变，三步依次走到：(-1, 0), (-1, -1), (-2, -1) ，最终位置为 (-2, -1) 。

如果第一步改成 L，三步依次走到：(0, -1), (1, -1), (1, -2) ，最终位置为 (1, -2) 。

如果第一步改成 R，三步依次走到：(0, 1), (-1, 1), (-1, 2) ，最终位置为 (-1, 2) 。

如果第二步改成 F，三步依次走到：(-1, 0), (-2, 0), (-2, 1) ，最终位置为 (-2, 1) 。

如果第二步改成 R，三步依次走到：(-1, 0), (-1, 1), (0, 1) ，最终位置为 (0, 1) 。

如果第三步改成 F，三步依次走到：(-1, 0), (-1, -1), (-1, -2) ，最终位置为 (-1, -2) 。

如果第三步改成 L，三步依次走到：(-1, 0), (-1, -1), (0, -1) ，最终位置为 (0, -1) 。

共有 6 种不同的最终位置。

【样例输入】

4
RRRR

【样例输出】

6

【样例说明】

有 8 种改变方法：

  1. 改为 FRRR ，最终位置为 (0, 0)；

  2. 改为 LRRR ，最终位置为 (0, 0)；

  3. 改为 RFRR ，最终位置为 (1, 1)；

  4. 改为 RLRR ，最终位置为 (0, 2)；

  5. 改为 RRFR ，最终位置为 (2, 0)；

  6. 改为 RRLR ，最终位置为 (2, 2)；

  7. 改为 RRRF ，最终位置为 (1, -1)；

  8. 改为 RRRL ，最终位置为 (2, 0)。

不同的最终位置共有 6 种。

【评测用例规模与约定】

对于 30% 的评测用例，1 <= n <= 20。

对于 60% 的评测用例，1 <= n <= 1000。

对于所有评测用例，1 <= n <= 100000。

directions = {"U": (-1, 0), "D": (1, 0), "L": (0, -1), "R": (0, 1)}  # 上下左右
directions_change = {"U": {"F": "U", "R": "R", "L": "L"}, "D": {"F": "D", "R": "L", "L": "R"},"L": {"F": "L", "R": "U", "L": "D"}, "R": {"F": "R", "R": "D", "L": "U"}}def calculate_final_position(i, direction, pos):for move in moves[i:]:direction = directions_change[direction][move]pos = (pos[0] + directions[direction][0], pos[1] + directions[direction][1])return posn = int(input())
moves = list(input())
final_positions = set()
now_direction = "U"
now_pos = (0, 0)
for i in range(n):original_move = moves[i]  # 保存原始步for new_move in "FLR":  # 对每个步尝试变成 F, L, Rif new_move != original_move:moves[i] = new_move  # 修改这一步final_positions.add(calculate_final_position(i, now_direction, now_pos))  # 计算并记录最终位置moves[i] = original_move  # 恢复原始步now_direction = directions_change[now_direction][original_move]now_pos = (now_pos[0] + directions[now_direction][0], now_pos[1] + directions[now_direction][1])
print(len(final_positions))

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/35147.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

模型案例：| 帐篷检测模型！

模型案例：| 帐篷检测模型！

导读 2023年以ChatGPT为代表的大语言模型横空出世&#xff0c;它的出现标志着自然语言处理领域取得了重大突破。它在文本生成、对话系统和语言理解等方面展现出了强大的能力&#xff0c;为人工智能技术的发展开辟了新的可能性。同时&#xff0c;人工智能技术正在进入各种应用领…
阅读更多...
实验日志——DETR

实验日志——DETR

DETR训练日志 1. 代码来源 代码源自作者的Github: https://github.com/facebookresearch/detr?tabreadme-ov-file 2. 数据来源 在DETR中只使用了COCO2017数据集&#xff0c;其中训练集有118288张图像&#xff0c;验证集有5001张数据&#xff0c;测试集有40671张数据&#…
阅读更多...
18、IO流：

18、IO流：

18、IO流&#xff1a; 这一章很枯燥无聊~ 文件&#xff1a; 什么是文件&#xff1a; 文件&#xff0c;对我们并不陌生&#xff0c;文件时保存数据的地方&#xff0c;比如我们经常使用的word文档&#xff0c;txt文档&#xff0c;excel文档…都是文件。它既可以保存一张图片&…
阅读更多...
24.两两交换链表中的节点 python

24.两两交换链表中的节点 python

两两交换链表中的节点 题目题目描述示例 1&#xff1a;示例 2&#xff1a;示例 3&#xff1a;提示&#xff1a;题目链接 题解解题思路python实现代码解读提交结果 题目 题目描述 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须…
阅读更多...
解决 git 报错 “fatal: unable to access ‘https://github.com/.../.git‘: Recv failure Connection was rese

解决 git 报错 “fatal: unable to access ‘https://github.com/.../.git‘: Recv failure Connection was rese

目录 前言 方法一&#xff1a;取消代理设置 方法二&#xff1a;设置系统代理&#xff08;推荐&#xff09; 方法三 方法四&#xff1a;不挂梯子时 前言 在使用 Git/Git小乌龟 进行代码管理的过程中&#xff0c;经常会遇到各种各样的问题&#xff0c;其中之一就是在执行 g…
阅读更多...
推荐8款自动化软件测试必备工具

推荐8款自动化软件测试必备工具

在现代软件测试开发领域&#xff0c;自动化测试工具的使用已经变得至关重要。 这些工具不仅提高了测试效率&#xff0c;还确保了软件质量和稳定性。 本文将向您介绍8款自动化软件测试必备工具&#xff0c;它们涵盖了各个层面的测试需求&#xff0c;从而助力测试团队更好地应对…
阅读更多...
MySQL聚合函数查询

MySQL聚合函数查询

【图书推荐】《MySQL 9从入门到性能优化&#xff08;视频教学版&#xff09;》-CSDN博客 《MySQL 9从入门到性能优化&#xff08;视频教学版&#xff09;&#xff08;数据库技术丛书&#xff09;》(王英英)【摘要 书评 试读】- 京东图书 (jd.com) MySQL9数据库技术_夏天又到了…
阅读更多...
Vue3 完结

Vue3 完结

组合式API - setup选项 组合式API可理解为一系列函数&#xff0c;通常需要调用这些函数去编写将来的组件逻辑&#xff1b; 而setup为组合式API的入口&#xff08;只有先写了setup才能往里写组合式API的函数&#xff09; setup选项的写法及执行时机 执行时机在beforeCreate之前…
阅读更多...
简洁的移动端登录注册界面

简洁的移动端登录注册界面

非常简洁的登录、注册界面模板&#xff0c;使用uni-app编写&#xff0c;直接复制粘贴即可&#xff0c;无任何引用&#xff0c;全部公开。 废话不多说&#xff0c;代码如下&#xff1a; login.vue文件 <template><view class"content"><view class&quo…
阅读更多...
2024NIPS | 在目标引导下利用强化学习范式进行图像冲印调优

2024NIPS | 在目标引导下利用强化学习范式进行图像冲印调优

文章标题&#xff1a;Goal Conditioned Reinforcement Learning for Photo Finishing Tuning 原文链接&#xff1a;RLPixTuner 本文是上海AI Lab联合香港中文大学&#xff08;薛天帆等人&#xff09;发表在2024NIPS上的论文。 1. Abstract 图像冲印调优旨在自动化对图像冲印管…
阅读更多...
【Spring】Cookie与Session

【Spring】Cookie与Session

一、Cookie是什么&#xff1f; Cookie的存在主要是为了解决HTTP协议的无状态性问题&#xff0c;即协议本身无法记住用户之前的操作。 “状态” 的含义指的是: 默认情况下 HTTP 协议的客端和服务器之间的这次通信&#xff0c;和下次通信之间没有直接的联系 但是实际开发中&…
阅读更多...
【最新】linux安装docker并配置加速源

【最新】linux安装docker并配置加速源

我这边之前本地创建了个虚拟机&#xff0c;linux系统的&#xff0c;用于部署服务器。有时安装一些常用工具或者中间件&#xff0c;还是用docker安装方便&#xff0c;而且docker还有编排服务等功能&#xff0c;实际使用中还是会省不少事的&#xff0c;这里记录下安装docker的过程…
阅读更多...
SpringBoot动态配置Nacos

SpringBoot动态配置Nacos

重要知识点 Nacos属性的简单使用将SpringBoot中的所有配置全部放入到Nacos中开发人创建单独的命名空间,修改互不影响Nacos经常变动的配置抽离到外部文件中 将项目中的所有配置全部放到到 1. 首先引入包 <!-- nacos 接入--><!-- https://mvnrepository.com/artifact…
阅读更多...
【每天一篇深度学习论文】轻量化自适应提取模块LAE

【每天一篇深度学习论文】轻量化自适应提取模块LAE

目录 论文介绍题目&#xff1a;论文地址&#xff1a; 创新点方法模型总体架构核心模块描述1. 轻量级自适应提取&#xff08;LAE&#xff09;模块&#xff1a;2. 多路径旁路特征匹配&#xff08;MSFM&#xff09;模块&#xff1a;3. RFABlock&#xff08;感受野注意力卷积&#…
阅读更多...
Linux中文件操作

Linux中文件操作

文件由文件内容和文件属性构成&#xff0c;因此对文件的操作就是对文件内容或文件属性的操作。所谓的“打开一个文件”就是将文件的属性或内容加载到内存中&#xff0c;而没有被打开的文件存在于磁盘上。打开的文件称作“内存文件”&#xff0c;未被打开的文件称作“磁盘文件”…
阅读更多...
hhdb数据库介绍(10-42)

hhdb数据库介绍(10-42)

安全 SQL防火墙 管理平台提供的SQL防火墙功能可为用户拦截高危SQL、误操作SQL等&#xff0c;提升系统安全性。 同时防火墙提供观测功能&#xff0c;可在开启新规则前&#xff0c;通过开启观测状态&#xff0c;判断新规则对业务的影响程度。开启观测状态后&#xff0c;计算节…
阅读更多...
白嫖VMware ESXi 8.0 U3新功能Live Patch、无需重启零中断修复漏洞

白嫖VMware ESXi 8.0 U3新功能Live Patch、无需重启零中断修复漏洞

哈喽大家好&#xff0c;欢迎来到虚拟化时代君&#xff08;XNHCYL&#xff09;&#xff0c;收不到通知请将我点击星标&#xff01;“ 大家好&#xff0c;我是虚拟化时代君&#xff0c;一位潜心于互联网的技术宅男。这里每天为你分享各种你感兴趣的技术、教程、软件、资源、福利…
阅读更多...
JavaSE学习心得（API与算法篇）

JavaSE学习心得（API与算法篇）

常用API和常见算法 前言 常用API Math System Runtime Object ​编辑浅克隆 深克隆 Objects Biginteger 构造方法 成员方法 底层存储方式 Bigdecimal 构造方法 Bigdecimal的使用 底层存储方式 ​编辑正则表达式 两个判断练习 两个爬取练习 贪婪爬取和非贪…
阅读更多...
如何开发高效的企业内训APP？教育培训系统源码搭建实战详解

如何开发高效的企业内训APP？教育培训系统源码搭建实战详解

本篇文章&#xff0c;小编将从教育培训系统的源码搭建、功能设计以及技术实现等方面&#xff0c;详细探讨如何开发一款高效的企业内训APP。 一、企业内训APP的需求分析 在开发企业内训APP之前&#xff0c;首先需要明确其基本需求。一个高效的企业内训APP应该具备以下几个核心…
阅读更多...
解释器模式的理解和实践

解释器模式的理解和实践

引言 解释器模式&#xff08;Interpreter Pattern&#xff09;是一种行为型设计模式&#xff0c;它在软件工程中用得相对较少&#xff0c;但在某些特定场景下非常有用。解释器模式提供了一种解释语言的语法或表达式的方式&#xff0c;它定义了一个表达式接口&#xff0c;并通过…
阅读更多...
最新文章

Copyright @ 2022~2023