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.mzph.cn/web/63189.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

MongoDB-副本集

MongoDB-副本集

一、什么是 MongoDB 副本集&#xff1f; 1.副本集的定义 MongoDB 的副本集&#xff08;Replica Set&#xff09;是一组 MongoDB 服务器实例&#xff0c;它们存储同一数据集的副本&#xff0c;确保数据的高可用性和可靠性。副本集中的每个节点都有相同的数据副本&#xff0c;但…
阅读更多...
《数据结构》（408代码题）

《数据结构》（408代码题）

2009 单链表&#xff08;双指针&#xff09; 分析&#xff1a;首先呢&#xff0c;给我们的数据结构是一个带有表头结点的单链表&#xff0c;也不允许我们改变链表的结构。链表的长度不是直接给出的啊&#xff0c;所以这个倒数也很棘手。那我们该如何解决这个“k”呢&#xff0c…
阅读更多...
6.1 初探MapReduce

6.1 初探MapReduce

MapReduce是一种分布式计算框架&#xff0c;用于处理大规模数据集。其核心思想是“分而治之”&#xff0c;通过Map阶段将任务分解为多个简单任务并行处理&#xff0c;然后在Reduce阶段汇总结果。MapReduce编程模型包括Map和Reduce两个阶段&#xff0c;数据来源和结果存储通常在…
阅读更多...
Cad c#.net 一键修改标注dimension中的文本内容

Cad c#.net 一键修改标注dimension中的文本内容

本例为给标注加前缀&#xff0c;也可定制其他形式&#xff0c;效果如下&#xff1a; public class Demo{[CommandMethod("xx")]//public void Dim(){Document doc Application.DocumentManager.MdiActiveDocument;Database db doc.Database;Editor ed doc.Editor;…
阅读更多...
Scala的隐式类

Scala的隐式类

package hfd //隐式类 //任务&#xff1a;给之前的BaseUser添加新的功能&#xff0c;但是不要直接去改代码 //思路&#xff1a;把BaseUser通过隐式转换&#xff0c;改成一个新类型&#xff0c;而这个新类型中有这新的方法 //implicit class一个隐式转换函数类 //作用&#xff1…
阅读更多...
旅游系统旅游小程序PHP+Uniapp

旅游系统旅游小程序PHP+Uniapp

旅游门票预订系统&#xff0c;支持景点门票、导游产品便捷预订、美食打卡、景点分享、旅游笔记分享等综合系统 更新日志 V1.3.0 1、修复富文本标签 2、新增景点入驻【高级版本】3、新增门票核销【高级版】4、新增门票端口【高级版】
阅读更多...
MacOS系统 快速安装appium 步骤详解

MacOS系统 快速安装appium 步骤详解

在macOS系统上&#xff0c;你可以通过使用nvm&#xff08;Node Version Manager&#xff09;来管理Node.js的版本&#xff0c;并基于nvm安装的Node.js环境来快捷地安装Appium。以下是具体步骤&#xff1a; 一、安装nvm 下载nvm 访问nvm的GitHub仓库&#xff08;nvm GitHub&…
阅读更多...
模型训练中梯度累积步数（gradient_accumulation_steps）的作用

模型训练中梯度累积步数（gradient_accumulation_steps）的作用

模型训练中梯度累积步数&#xff08;gradient_accumulation_steps&#xff09;的作用 flyfish 在使用训练大模型时&#xff0c;TrainingArguments有一个参数梯度累积步数&#xff08;gradient_accumulation_steps&#xff09; from transformers import TrainingArguments梯…
阅读更多...
技术速递｜.NET 9 简介

技术速递｜.NET 9 简介

作者&#xff1a;.NET 团队 排版&#xff1a;Alan Wang 今天&#xff0c;我们非常激动地宣布 .NET 9的发布&#xff0c;这是迄今为止最高效、最现代、最安全、最智能、性能最高的 .NET 版本。这是来自世界各地数千名开发人员又一年努力的成果。这个新版本包括数千项性能、安全和…
阅读更多...
Vue项目打包部署到服务器

Vue项目打包部署到服务器

1. Vue项目打包部署到服务器 1.1. 配置 &#xff08;1&#xff09;修改package.json文件同级目录下的vue.config.js文件。 // vue.config.js module.exports {publicPath: ./, }&#xff08;2&#xff09;检查router下的index.js文件下配置的mode模式。   检查如果模式改…
阅读更多...
【jpa】springboot使用jpa示例

【jpa】springboot使用jpa示例

目录 1. 请求示例2. pom依赖3. application.yaml4.controller5. service6. repository7. 实体8. 启动类 1. 请求示例 curl --location --request POST http://127.0.0.1:8080/user \ --header User-Agent: Apifox/1.0.0 (https://apifox.com) \ --header Content-Type: applic…
阅读更多...
uniapp 常用的指令语句

uniapp 常用的指令语句

uniapp 是一个使用 Vue.js 开发的跨平台应用框架&#xff0c;因此&#xff0c;它继承了 Vue.js 的大部分指令。以下是一些在 uniapp 中常用的 Vue 指令语句及其用途&#xff1a; v-if / v-else-if / v-else 条件渲染。v-if 有条件地渲染元素&#xff0c;v-else-if 和 v-else 用…
阅读更多...
中企出海-德国会计准则和IFRS间的差异

中企出海-德国会计准则和IFRS间的差异

根据提供的网页内容&#xff0c;德国的公认会计准则&#xff08;HGB&#xff09;与国际会计准则&#xff08;IFRS&#xff09;之间的主要差异可以从以下几个方面进行比较&#xff1a; 财务报告的目的&#xff1a; IFRS&#xff1a;财务报告主要是供投资者做决策使用&#xff0c…
阅读更多...
NPU是什么？电脑NPU和CPU、GPU区别介绍

NPU是什么？电脑NPU和CPU、GPU区别介绍

随着人工智能技术的飞速发展&#xff0c;计算机硬件架构也在不断演进以适应日益复杂的AI应用场景。其中&#xff0c;NPU&#xff08;Neural Processing Unit&#xff0c;神经网络处理器&#xff09;作为一种专为深度学习和神经网络运算设计的新型处理器&#xff0c;正逐渐崭露头…
阅读更多...
使用skywalking，grafana实现从请求跟踪、 指标收集和日志记录的完整信息记录

使用skywalking，grafana实现从请求跟踪、 指标收集和日志记录的完整信息记录

Skywalking是由国内开源爱好者吴晟开源并提交到Apache孵化器的开源项目&#xff0c; 2017年12月SkyWalking成为Apache国内首个个人孵化项目&#xff0c; 2019年4月17日SkyWalking从Apache基金会的孵化器毕业成为顶级项目&#xff0c; 目前SkyWalking支持Java、 .Net、 Node.js、…
阅读更多...
纯CSS实现文本或表格特效(连续滚动与首尾相连)

纯CSS实现文本或表格特效(连续滚动与首尾相连)

纯CSS实现文本连续向左滚动首尾相连 1.效果图&#xff1a; 2.实现代码&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport" content"widthdevice-width, init…
阅读更多...
【LeetCode刷题之路】622.设计循环队列

【LeetCode刷题之路】622.设计循环队列

LeetCode刷题记录 &#x1f310; 我的博客主页&#xff1a;iiiiiankor&#x1f3af; 如果你觉得我的内容对你有帮助&#xff0c;不妨点个赞&#x1f44d;、留个评论✍&#xff0c;或者收藏⭐&#xff0c;让我们一起进步&#xff01;&#x1f4dd; 专栏系列&#xff1a;LeetCode…
阅读更多...
Node.js基础入门

Node.js基础入门

1.Node.js 简介 Node 是一个让 JavaScript (独立)运行在服务端的开发平台，它让 JavaScript 成为与PHP、Python、Perl、Ruby 等服务端语言平起平坐的脚本语言。 发布于2009年5月，由Ryan Dahl开发，实质是对Chrome V8引擎进行了封装。 简单的说 Node.js 就是运行在服务端的…
阅读更多...
#思科模拟器通过服务配置保障无线网络安全Radius

#思科模拟器通过服务配置保障无线网络安全Radius

演示拓扑图&#xff1a; 搭建拓扑时要注意&#xff1a; 只能连接它的Ethernet接口&#xff0c;不然会不通 MAC地址绑定 要求 &#xff1a;通过配置MAC地址过滤禁止非内部员工连接WiFi 打开无线路由器GUI界面&#xff0c;点开下图页面&#xff0c;配置路由器无线网络MAC地址过…
阅读更多...
docker 部署kafka集群

docker 部署kafka集群

docker run 部署 docker run -d --name zookeeper --restart always -p 2181:2181 wurstmeister/zookeeperdocker run -d --name kafka1 --restart always -p 9094:9092 \-e KAFKA_ADVERTISED_HOST_NAME182.54.14.45 \-e KAFKA_ZOOKEEPER_CONNECT182.54.14.45:2181 \-e KAFKA_…
阅读更多...
最新文章

Copyright @ 2022~2023