【CSP】2023年12月真题练习(更新到202312-2)

试题编号:202312-1
试题名称:仓库规划
时间限制:1.0s
内存限制:512.0MB
问题描述:

问题描述

西西艾弗岛上共有 n 个仓库,依次编号为 1⋯n。每个仓库均有一个 m 维向量的位置编码,用来表示仓库间的物流运转关系。

具体来说,每个仓库 i 均可能有一个上级仓库 j ,满足:仓库 j 位置编码的每一维均大于仓库 i 位置编码的对应元素。比如编码为 (1,1,1) 的仓库可以成为 (0,0,0) 的上级,但不能成为 (0,1,0) 的上级。如果有多个仓库均满足该要求,则选取其中编号最小的仓库作为仓库 i 的上级仓库;如果没有仓库满足条件,则说明仓库 i 是一个物流中心,没有上级仓库。

现给定 n 个仓库的位置编码,试计算每个仓库的上级仓库编号。

输入格式

从标准输入读入数据。

输入共 n+1 行。

输入的第一行包含两个正整数 n 和 m,分别表示仓库个数和位置编码的维数。

接下来 n 行依次输入 n 个仓库的位置编码。其中第 i 行(1≤i≤n)包含 m 个整数,表示仓库 i 的位置编码。

输出格式

输出到标准输出。

输出共 n 行。

第 i 行(1≤i≤n)输出一个整数,表示仓库 i 的上级仓库编号;如果仓库 i 没有上级,则第 i 行输出 0。

样例输入

4 2

0 0

-1 -1

1 2

0 -1

样例输出

3

1

0

3

样例解释

对于仓库 2:(−1,−1) 来说,仓库 1:(0,0) 和仓库 3:(1,2) 均满足上级仓库的编码要求,因此选择编号较小的仓库 1 作为其上级。

子任务

50% 的测试数据满足 m=2;

全部的测试数据满足 0<m≤10、0<n≤1000,且位置编码中的所有元素均为绝对值不大于 10^{6} 的整数。

编译环境Dev-cpp(C语言)

#include <stdio.h>

int main() {
    int n=0,m=0;
	scanf("%d %d",&n,&m); 
	int a[1000][10]={0};
    int x=0,y=0;
    int value=0;
    int ans[10]={0};
    for(x=0;x<n;x++)
    {
    	for(y=0;y<m;y++)
    	{
    		scanf("%d",&value);
    		a[x][y]=value;
		}
	}
    int num=0;
    int flag=1;
    
    for(num=0;num<n;num++)
    {
    	int res=0;
    	for(x=0;x<n;x++)
    	{
    		if (x == num) {
                continue;  // 跳过当前仓库
            }
            flag=1;
    		for(y=0;y<m;y++)
    		{
    			if(a[x][y]<=a[num][y])
    			{
    				flag=0;
    				break;
				}
			}
			if(flag==1)
			{
				res=x+1;
				break;
			}
			
		}
		
		printf("%d\n",res);

	}
    return 0;
}

编译环境Dev-cpp(C++语言)

#include <stdio.h>
#include <stdlib.h>

int main() {
    int N = 0, M = 0;
    scanf("%d %d", &N, &M);
    
    int** warehouse = (int**)malloc((N + 1) * sizeof(int*));
    for (int i = 0; i <= N; i++) {
        warehouse[i] = (int*)malloc(M * sizeof(int));
    }
    
    for (int i = 1; i <= N; i++) {
        for (int j = 0; j < M; j++) {
            scanf("%d", &warehouse[i][j]);
        }
    }
    
    for (int i = 1; i <= N; i++) {
        int res = 0;
        for (int j = 1; j <= N; j++) {
            if (i != j) {
                int flag = 1;
                for (int k = 0; k < M; k++) {
                    if (warehouse[i][k] >= warehouse[j][k]) {
                        flag = 0;
                        break;
                    }
                }
                if (flag) {
                    res = j;
                    break;
                }
            }
        }
        printf("%d\n", res);
    }
    
    for (int i = 0; i <= N; i++) {
        free(warehouse[i]);
    }
    free(warehouse);
    
    return 0;
}
试题编号:202312-2
试题名称:因子化简
时间限制:2.0s
内存限制:512.0MB
问题描述:

题目背景

质数(又称“素数”)是指在大于 1 的自然数中,除了 1 和它本身以外不再有其他因数的自然数。

问题描述

小 P 同学在学习了素数的概念后得知,任意的正整数 n 都可以唯一地表示为若干素因子相乘的形式。如果正整数 n 有 m 个不同的素数因子 p_{1},p_{2},...,p_{m},则可以表示为:n=p_{1}^{​{t_{1}}}\times p_{2}^{​{t_{2}}}\times...\times p_{m}^{​{t_{m}}}

小 P 认为,每个素因子对应的指数 t_{i} 反映了该素因子对于 n 的重要程度。现设定一个阈值 k,如果某个素因子 p_{i} 对应的指数 t_{i} 小于 k,则认为该素因子不重要,可以将 p_{i}^{t_{i}} 项从 n 中除去;反之则将 p_{i}^{t_{i}} 项保留。最终剩余项的乘积就是 n 简化后的值,如果没有剩余项则认为简化后的值等于 1。

试编写程序处理 q 个查询:

  • 每个查询包含两个正整数 n 和 k,要求计算按上述方法将 n 简化后的值。

输入格式

从标准输入读入数据。

输入共 q+1 行。

输入第一行包含一个正整数 q,表示查询的个数。

接下来 q 行每行包含两个正整数 n 和 k,表示一个查询。

输出格式

输出到标准输出。

输出共 q 行。

每行输出一个正整数,表示对应查询的结果。

样例输入

3

2155895064 3

2 2

10000000000 10

样例输出

2238728

1

10000000000

样例解释

查询一:

  • n=2^{3}\times 3^{2}\times 23^{4}\times 107

  • 其中素因子 3 指数为 2,107 指数为 1。将这两项从 n 中除去后,剩余项的乘积为 2^{3}\times 23^{4}=2238728

查询二:

  • 所有项均被除去,输出 1。

查询三:

  • 所有项均保留,将 n 原样输出。

子任务

40% 的测试数据满足:n≤1000;

80% 的测试数据满足:n≤10^{5}

全部的测试数据满足:1<n≤1010 且 1<k,q≤10。

编译环境Dev-cpp(C++语言)

#include <stdio.h>

long long int simplifyValue(long long int n, int k) {
    long long int result = 1;
    int factor = 2;

    while (n > 1) { // 只要 n 大于 1,就继续进行素数因子的检查和处理
        if (n % factor == 0) { // 如果 factor 是 n 的因子
            int count = 0;
            while (n % factor == 0) { // 计算 factor 在 n 中的出现次数
                n /= factor;
                count++;
            }

            if (count >= k) { // 如果 factor 的指数大于等于阈值 k
                int i;
                for (i = 0; i < count; i++) { // 将 factor 乘以 count 次,累积到结果 result 中
                    result *= factor;
                }
            }
        }

        factor++; // 检查下一个因子
    }

    return result;
}

int main() {
    int q;
    scanf("%d", &q);

    int i;
    for (i = 0; i < q; i++) {
        long long int n;
        int k;
        scanf("%lld %d", &n, &k);

        long long int result = simplifyValue(n, k);
        printf("%lld\n", result);
    }

    return 0;
}
试题编号:202312-3
试题名称:树上搜索
时间限制:1.0s
内存限制:512.0MB
问题描述:

题目背景

西西艾弗岛大数据中心为了收集用于模型训练的数据,推出了一项自愿数据贡献的系统。岛上的居民可以登录该系统,回答系统提出的问题,从而为大数据中心提供数据。为了保证数据的质量,系统会评估回答的正确性,如果回答正确,系统会给予一定的奖励。

近期,大数据中心需要收集一批关于名词分类的数据。系统中会预先设置若干个名词类别,这些名词类别存在一定的层次关系。例如,“动物”是“生物”的次级类别,“鱼类”是“动物”的次级类别,“鸟类”是“动物”的次级类别,“鱼类”和“鸟类”是“动物”下的邻居类别。这些名词类别可以被按树形组织起来,即除了根类别外,每个类别都有且仅有一个上级类别。
并且所有的名词都可以被归类到某个类别中,即每个名词都有且仅有一个类别与其对应。一个类别的后代类别的定义是:若该类别没有次级类别,则该类别没有后代类别;否则该类别的后代类别为该类别的所有次级类别,以及其所有次级类别的后代类别。

下图示意性地说明了标有星号的类别的次级类别和后代类别。


次级类别与后代类别

系统向用户提出问题的形式是:某名词是否属于某类别,而用户可以选择“是”或“否”来回答问题。该问题的含义是:某名词是否可以被归类到某类别或其后代类别中。

例如,要确定名词“鳕鱼”的类别,系统会向用户提出“鳕鱼是否属于动物”,当用户选择“是”时,系统会进一步询问“鳕鱼是否属于鱼类”,当用户选择“是”时,即可确定“鳕鱼”可以被归类到“鱼类”这一类别。

此外,如果没有更具体的分类,某一名词也可以被归类到非叶子结点的类别中。例如,要确定“猫”的类别,系统可以向用户提出“猫是否属于动物”,当用户选择“是”时,系统会进一步分别询问“猫”是否属于“鱼类”和“鸟类”,当两个问题收到了否定的答案后,系统会确定“猫”的类别是“动物”。

大数据中心根据此前的经验,已经知道了一个名词属于各个类别的可能性大小。为了用尽量少的问题确定某一名词的类别,大数据中心希望小 C 来设计一个方法,以减少系统向用户提出的问题的数量。

问题描述

小 C 观察了事先收集到的数据,并加以统计,得到了一个名词属于各个类别的可能性大小的信息。具体而言,每个类别都可以赋予一个被称为权重的值,值越大,说明一个名词属于该类别的可能性越大。由于每次向用户的询问可以获得两种回答,小 C 联想到了二分策略。他设计的策略如下:

  1. 对于每一个类别,统计它和其全部后代类别的权重之和,同时统计其余全部类别的权重之和,并求二者差值的绝对值,计为 \omega _{\delta }
  2. 选择 \omega _{\delta } 最小的类别,如果有多个,则选取编号最小的那一个,向用户询问名词是否属于该类别;
  3. 如果用户回答“是”,则仅保留该类别及其后代类别,否则仅保留其余类别;
  4. 重复步骤 1,直到只剩下一个类别,此时即可确定名词的类别。

小 C 请你帮忙编写一个程序,来测试这个策略的有效性。你的程序首先读取到所有的类别及其上级次级关系,以及每个类别的权重。你的程序需要测试对于被归类到给定类别的名词,按照上述策略提问,向用户提出的所有问题。

输入格式

从标准输入读入数据。

输入的第一行包含空格分隔的两个正整数 n 和 m,分别表示全部类别的数量和需要测试的类别的数量。所有的类别从 1 到 n 编号,其中编号为 1 的是根类别。

输入的第二行包含 n 个空格分隔的正整数 \omega_{1},\omega_{2},...,\omega_{n},其中第 i 个数 \omega_{i} 表示编号为 i 的类别的权重。

输入的第三行包含 (n−1) 个空格分隔的正整数 p_{2},p_{3},...,p_{n},其中第 i 个数 p_{i+1} 表示编号为 (i+1) 的类别的上级类别的编号,其中 p_{i}\in [1,n]

接下来输入 m 行,每行一个正整数,表示需要测试的类别编号。

输出格式

输出 m 行,每行表示对一个被测试的类别的测试结果。表示按小 C 的询问策略,对属于给定的被测类别的名词,需要依次向用户提出的问题。

每行包含若干空格分隔的正整数,每个正整数表示一个问题中包含的类别的编号,按照提问的顺序输出。

样例1输入

5 2

10 50 10 10 20

1 1 3 3

5

3

样例1输出

2 5

2 5 3 4

样例解释

上述输入数据所表示的类别关系如下图所示,同时各个类别的权重也标注在了图上。


样例输入数据所表示的类别关系

对于归类于类别 5 的某个名词,按照上述询问策略,应当对于树上的每个节点,都计算 \omega _{\delta }的值,对于类别 1 至 5,得到的 \omega _{\delta } 分别为:100、0、20、80、60。因此首先就类别 2 提问。由于类别 5 不属于类别 2 的后代类别,因此用户回答“否”,此时去除类别 2 和其全部后代类别,仅保留类别 1、3、4、5。对于剩下的类别,计算 \omega _{\delta } 的值,得到的 \omega _{\delta } 分别为:50、30、30、10。因此再就类别 5 提问。由于类别 5 就是被提问的名词所属类别,因此用户回答“是”,此时仅保留类别 5 和其全部后代类别。我们发现,这个时候,只剩下类别 5,因此算法结束。上述过程如下图所示:


算法执行过程 1

对于归类于类别 3 的某个名词,按照上述询问策略,依次对类别 2、5 提问,过程与前述一致。但是由于类别 3 不属于类别 2 的后代类别,用户回答“否”,此时应当去掉类别 5 和其后代类别,仅保留类别 1、3、4。分别计算 \omega _{\delta } 得:30、10、10。此时应当选择编号较小的类别 3 提问。由于类别 3 就是被提问的名词所属类别,因此用户回答“是”,此时仅保留类别 3 和其全部后代类别。我们发现,这个时候,并非只剩下一个类别,因此算法还应继续进行。剩下的类别有 3、4,分别计算 \omega _{\delta } 得:20、0。因此再就类别 4 提问。由于类别 3 不属于类别 4 的后代类别,用户回答“否”,此时应当去掉类别 4 和其后代类别,仅保留类别 3。我们发现,这个时候,只剩下类别 3,因此算法结束。上述过程如下图所示:


算法执行过程 2

子任务

对 20% 的数据,各个类别的权重相等,且每个类别的上级类别都是根类别;

对另外 20% 的数据,每个类别的权重相等,且每个类别至多有一个下级类别;

对 60% 的数据,有 n≤100,且 m≤10;

对 100% 的数据,有 n≤2000,m≤100,且 \omega _{i}\leq 10^{7}

(待更)

试题编号:202312-4
试题名称:宝藏
时间限制:1.5s
内存限制:512.0MB
问题描述:

问题描述

西西艾弗岛上埋藏着一份宝藏,小 C 根据藏宝图找到了宝藏的位置。藏有宝藏的箱子被上了锁,旁边写着一些提示:

  • 给定 n 条指令,编号为 1∼n,其中每条指令都是对一个双端队列的操作,队列中的元素均为 2×2 的矩阵
  • 在某些时刻,某一条指令可能会改变;
  • 在某些时刻,密码可以由以下方式计算:对于给定的指令区间 \left [ l,r \right ],对初始为空的队列依次执行第 l∼r 条指令,将得到的队列里的所有矩阵从头到尾相乘,并将乘积矩阵中的所有元素对 998244353 取模,得到的矩阵即为密码;特别地,若队列为空,则密码为单位矩阵;如果能分别计算出这些时刻的密码,将能够打开箱子的锁,从而获得宝藏。

经过小 C 的观察,每条指令的形式均为以下三种之一:

  1. 给定 2×2 的矩阵 A,将 A 插入队列的头部;
  2. 给定 2×2 的矩阵 B,将 B 插入队列的尾部;
  3. 若队列非空,删除队列中最晚被插入的矩阵。

小 C 将所有的时刻发生的事件均记录了下来。具体地,共有 m 个时刻,每个时刻可能会发生两种事件:

  1. 第 i 条指令改变,改变后的指令仍为以上三种形式之一;
  2. 给定指令区间 \left [ l,r \right ],求依次执行第 l∼r 条指令得到的密码。

由于小 C 并不会这个问题,他向你发起了求助。你需要帮助小 C 求出所有类型为 2 的事件所对应的密码。

输入格式

从标准输入读入数据。

输入的第一行包含两个正整数 n,m。

接下来 n 行,按顺序给出初始时刻的每条指令:

  • 输入的第一个正整数 v 描述这条指令的形式,保证 v 为 1,2,3 中的一种。
  • 若 v=1,接下来给出四个非负整数 A_{1,1},A_{1,2},A_{2,1},A_{2,2},表示操作为将 2×2 的矩阵 A 插入队列的头部;
  • 若 v=2,接下来给出四个非负整数 B_{1,1},B_{1,2},B_{2,1},B_{2,2},表示操作为将 2×2 的矩阵 B 插入队列的尾部;
  • 若 v=3,表示操作为若队列非空,删除队列中最晚被插入的矩阵;

接下来 m 行,按顺序给出每个时刻发生的事件:

  • 输入的第一个正整数 v 描述这个事件的类型,保证 v 为 1,2 中的一种。
  • 若 v=1,接下来给出一个正整数 i 与一条指令,表示将第 i 条指令更新为当前输入的指令,指令的输入格式与初始时刻指令的输入格式相同。
  • 若 v=2,接下来给出两个正整数 l,r,你需要求出依次执行第 l∼r 条指令得到的密码。

输出格式

输出到标准输出。

对于所有类型为 2 的事件,输出一行四个非负整数 C_{1,1},C_{1,2},C_{2,1},C_{2,2},表示该时刻的密码 C

样例1输入

3 4

1 2 3 9 3

2 6 9 4 2

2 2 8 2 1

2 2 3

1 2 1 3 1 0 1

1 3 3

2 1 3

样例1输出

30 57 12 34

2 3 9 3

样例解释

第一次事件发生时,

  • 第 2 条指令为在序列尾部插入矩阵 \begin{bmatrix} 6 &9 \\ 4 & 2 \end{bmatrix}
  • 第 3 条指令为在序列尾部插入矩阵 \begin{bmatrix} 2 & 8\\ 2 & 1 \end{bmatrix}

依次执行第 2∼3 条指令,得到的队列为 \left \{ \begin{bmatrix} 6 & 9\\ 4& 2 \end{bmatrix} ,\begin{bmatrix} 2 & 8\\ 2 & 1 \end{bmatrix}\right \},则密码为

\begin{bmatrix} 6 & 9\\ 4& 2 \end{bmatrix}\times \begin{bmatrix} 2 & 8\\ 2& 1 \end{bmatrix}=\begin{bmatrix} 30 & 57\\ 12 & 34 \end{bmatrix}

第四次事件发生时,

  • 第 1 条指令为在序列头部插入矩阵 \begin{bmatrix} 2 & 3\\ 9 & 3 \end{bmatrix}
  • 第 2 条指令为在序列头部插入矩阵 \begin{bmatrix} 3 & 1\\ 0 & 1 \end{bmatrix}
  • 第 3 条指令为若队列非空,删除队列中最晚被插入的矩阵。

依次执行第 1∼3 条指令,得到的队列为 \left \{ \begin{bmatrix} 2 & 3\\ 9 & 3 \end{bmatrix} \right \},则密码为 \begin{bmatrix} 2 & 3\\ 9 & 3 \end{bmatrix}

样例2

见题目目录下的2.in 与2.ans。

该样例满足测试数据 1∼3 的限制。

样例3

见题目目录下的3.in 与3.ans。

该样例满足测试数据 4∼7 的限制。

样例4

见题目目录下的4.in 与4.ans。

该样例满足测试数据 8,9 的限制。

样例5

见题目目录下的5.in 与5.ans。

该样例满足测试数据 10,11 的限制。

样例6

见题目目录下的6.in 与6.ans。

该样例满足测试数据 12∼15 的限制。

样例7

见题目目录下的7.in 与7.ans。

该样例满足测试数据 16,17 的限制。

子任务

对于所有测试数据,满足 1≤n,m≤10^{5},0≤A_{i,j},B_{i,j}<998244353,1≤l≤r≤n。

测试点编号n,m≤特殊性质
1∼310^{2}
4∼710^{3}
8,95\times 10^{4}所有指令的形式均为 1
10,115\times 10^{4}所有指令的形式均为 1 或 2
12∼155\times 10^{4}所有事件的类型均为 2
16,175\times 10^{4}
18∼2010^{5}

(待更)

试题编号:202312-5
试题名称:彩色路径
时间限制:2.0s
内存限制:512.0MB
问题描述:

问题描述

西西艾弗岛的路线图可以看作是一个具有 N 个节点和 M 条有向边的图。
第 i 个节点(0≤i<N)有一个颜色标签 C[i]∈0,1,⋯,K−1,第 j 条边(0≤j<M)从节点 U[j] 指向节点 V[j],长度为 D[j]。

对于游客顿顿来说,理想的观光路线应满足以下条件:

  • 是一条从节点 0 到节点 N−1 的简单路径;

  • 是一条彩色路径,即路径上每个节点的颜色标签均不相同;

  • 并且包含的节点数小于或等于 L。

具体而言,理想的观光路线是一个节点序列,例如 (t_{0},t_{1},...,t_{q-1}),满足以下所有要求:

  • 对于每个 i(0≤i<q−1),存在一条从节点 t_{i} 到节点 t_{i+1} 的有向边。

  • t_{0}=0 且 t_{q-1}=N-1

  • 对于每对 i,j(0≤i<j<q),都有 C\left [ t_{i} \right ]\neq C\left [ t_{j}\right ]

  • q≤L

一条路径的长度定义为边的总长度。你的任务是找到满足游客顿顿所有要求的最长观光路线。

输入格式

从标准输入读入数据。

输入共五行。

输入的第一行包含四个正整数 N、M、L 和 K,分别表示图的节点数、边数、理想观光路线的节点数上限和颜色标签范围。

输入的第二行包含 N 个整数 C[0],C[1],...,C[N-1],表示图中每个节点的颜色标签。

接下来输入边的信息。

输入的第三行包含 M 个整数 U[0],U[1],...,U[M-1],表示每条有向边的起点;

输入的第四行包含 M 个整数V[0],V[1],...,V[M-1] ,表示每条有向边的终点;

输入的第五行包含 M 个整数 D[0],D[1],...,D[M-1],表示每条有向边的长度。

输入数据保证不存在起点终点相同的边,如 (u,u);每条有向边 (u,v) 仅会出现一次,但不排除 (u,v) 和 (v,u) 可能同时存在。

输出格式

输出到标准输出。

输出一个数,表示理想观光路线的最大长度。

样例输入

6 9 4 10

0 2 2 3 3 9

0 0 0 1 1 1 2 3 4

1 2 4 3 4 5 4 5 5

1 2 4 3 2 8 5 3 1

样例输出

9

样例解释

以下是示例图,其中黑色和红色数字分别表示节点编号和边的长度。

{{ img('example.pdf', size = 1.0, align = 'middle', inline = False, caption='样例解释', label='fig:sample') }}
样例解释

如下表所示,在不超过四个节点的限制下,共有五条从节点 0 到节点 5 的彩色路径。其中最长的一条是 (0,1,5),长度为 9。

彩色路径节点数长度
(0,1,3,5)47
(0,1,4,5)44
(0,2,4,5)48
(0,1,5)39
(0,4,5)35

子任务

20% 的测试数据满足:对于每个 i(0≤i<N−1),有 C[i]\leq C[i+1],以及对于每个 j(0≤j<M),有 U[j]<V[j]

另有 30% 测试数据满足:K≤15。

全部的测试数据满足:

  • 2≤N≤100

  • 1≤M≤5000

  • 2≤L≤9≤K≤30

  • c[0]=0 且 C[N-1]=K-1

  • 对于每个 i(1≤i≤N−2):
                                                  1\leq C[i]\leq K-2

  • 对于每个 j(0≤j<M):
                                                  0\leq U[j],V[j]<N

                                                       C[U[j]]\neq C[V[j]]

                                                          1\leq D[j]\leq 10^{6}

  • 至少存在一条从节点 0 到节点 N−1 的彩色路径,节点数不超过 L。

(待更)

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

汽车生产污废水处理需要哪些工艺设备

对于汽车生产过程中产生的污废水处理&#xff0c;需要运用一系列的工艺设备来实现有效的清洁和回收利用。下面让我们一起来探索一下吧&#xff01; 首先&#xff0c;汽车生产工艺设备中最常见的是物理处理设备。物理处理包括沉淀、过滤和吸附等过程。其中&#xff0c;沉淀操作可…

Angular系列教程之观察者模式和RxJS

文章目录 引言RxJS简介RxJS中的设计模式观察者模式迭代器模式 示例代码RxJS 在 Angular 中的应用总结 引言 在Angular开发中&#xff0c;我们经常需要处理异步操作&#xff0c;例如从后端获取数据或与用户的交互。为了更好地管理这些异步操作&#xff0c;Angular中引入了RxJS&…

Java、C#、Python间的Battle

一、编译原理和开发效率 编译速度&#xff1a; C# &#xff08;约大于等于&#xff09; JAVA > Python python的编译原理 前提&#xff1a;python 3.6 python不会直接编译源码 而是把源码直接扔给解释器&#xff0c;这种方式 使得python非常灵活&#xff0c;让它的开发效…

从零开始:生产环境如何部署 Bytebase

Bytebase 是面向研发和 DBA 的数据库 DevOps 和 CI/CD 协同平台。目前 Bytebase 在全球类似开源项目中 GitHub Star 数排名第一且增长最快。 Bytebase 的架构 Bytebase 是一个单体架构 (monolith)&#xff0c;前端是 Vue3 TypeScript&#xff0c;后端是 Go。前端利用 Go 1.6 …

好用的内外网快速传输大文件方法

在信息化时代&#xff0c;数据已经成为各行各业的关键资产&#xff0c;数据的传输和交换方式直接影响着数据价值的体现。在众多场景下&#xff0c;我们需要在不同的网络环境中进行文件传输&#xff0c;如同一个局域网内或者互联网上。这时涉及到内外网的概念。 内外网指的是在不…

UE5 nDisplay群集事件的发送和接收

注意&#xff1a; 1.只能在投屏模式下生效 2.需要监听的机器都要执行“1.打开监听”

创意无限!亲测可用的免费Photoshop素材网站大揭秘!

高质量的PS材料可以保证设计师设计作品的质量&#xff0c;但很多人不知道在哪里找到一些免费的材料&#xff0c;尤其是对初学者来说。那么&#xff0c;有没有质量好、免费的PS材料网站呢&#xff1f;别担心&#xff0c;现在就告诉你。 即时设计 被很多人视为免费的PS素材网站…

likeshop知识付费系统PHP版v1.4.0

✅ 新增功能 题库功能 ⚡ 功能优化 数据库检测优化 订单中心页优化 系统-登录时效优化 &#x1f41e; 功能修复 详情页佣金可见设置未生效 更新内容说明 1.题库 题库功能的引入&#xff0c;不仅仅是对学习方式的一次革新&#xff0c;更是为广大用户提供了更多更丰富的学…

【运维】WSL1如何升级到WSL2

升级WSL1到WSL2&#xff1a;简便快捷版 在这篇博客中&#xff0c;我们将研究如何通过一种更简便的方式&#xff0c;将WSL1迅速升级到WSL2&#xff0c;避免官方文档的繁冗步骤。如果你觉得官方方法太过冗长&#xff0c;那么这里提供的步骤可能更适合你。 官网的办法是&#xf…

GaussDB(DWS)查询优化技术大揭秘

GaussDB(DWS)查询优化技术大揭秘 大数据时代&#xff0c;数据量呈爆发式增长&#xff0c;经常面临百亿、千亿数据查询场景&#xff0c;当数据仓库数据量较大、SQL语句执行效率低时&#xff0c;数据仓库性能会受到影响。本文将深入讲解在GaussDB(DWS)中如何进行表结构设计&#…

Python进阶知识:整理6 -> 正则表达式

1 基础匹配用法 # 演示Python中正则表达式re模块的3个基础匹配方法 import re # 1. match()方法 从头匹配 string "hello world" result re.match("hello", string) # 如果头部没有匹配成功就直接失败了,后面就不会继续匹配了 print(result) print(r…

软件测试|Selenium StaleElementReferenceException 异常分析与解决

简介 Selenium 是一个流行的自动化测试工具&#xff0c;用于模拟用户与网页交互。然而&#xff0c;当我们在使用 Selenium 时&#xff0c;可能会遇到一个常见的异常&#xff0c;即 StaleElementReferenceException。这个异常通常在我们尝试与网页上的元素交互时抛出&#xff0…

牛客-寻找第K大、LeetCode215. 数组中的第K个最大元素【中等】

文章目录 前言牛客-寻找第K大、LeetCode215. 数组中的第K个最大元素【中等】题目及类型思路思路1&#xff1a;大顶堆思路2&#xff1a;快排二分随机基准点 前言 博主所有博客文件目录索引&#xff1a;博客目录索引(持续更新) 牛客-寻找第K大、LeetCode215. 数组中的第K个最大元…

pytest -- 进阶使用详解

pytest-html⽣成报告 Pytest-HTML 是⼀个插件&#xff0c;它可以⽣成漂亮且易于阅读的 HTML 测试报告。 pytest-html ⽣成报告的步骤 ① 安装 pytest-html 插件&#xff1a; pip install pytest-html ② 运⾏测试并⽣成报告&#xff1a; file name:main.pyimport pytest&qu…

苹果MAC怎么清理内存?苹果MAC清理内存的方法

很多使用苹果电脑的用户都喜欢在同时运行多个软件&#xff0c;不过这样会导致在运行一些大型软件的时候出现不必要的卡顿现象&#xff0c;这时候我们就可以去清理下内存&#xff0c;不过很多人可能并不知道正确的清内存方式&#xff0c;下面就和小编一起来看看吧。 苹果MAC清理…

opengauss-高斯数据库的安装部署及MySQL数据迁移实战.

目录 介绍 下载安装包 安装 1.设置SEMMNI 2.新建用户和用户组 3.下载安装包解压 4.安装数据库 5.修改配置 6.重启服务 数据库使用 gsql命令和常用sql 1.使用omm用户连接数据库-本地登陆无需输入密码&#xff1a; 2.查看用户信息 3.删除数据库 4.创建用户 5.创建…

SSL之mkcert构建本地自签名

文章目录 1. 什么是SSL2. mkcert&#xff1a;快速生成自签名证书2.1 mkcert的工作流程如下&#xff1a;2.2 window 本地实现自签证书2.2.1 下载安装2.2.2 下载,生成本地 SSL2.2.3 生成 pem 自签证书,可供局域网内使用其他主机访问。2.2.4 使用-psck12 生成*.p12 文件 2.3 Sprin…

【设计模式-06】Observer观察者模式

简要说明 事件处理模型 场景示例&#xff1a;小朋友睡醒了哭&#xff0c;饿&#xff01; 一、v1版本(披着面向对象的外衣的面向过程) /*** description: 观察者模式-v1版本(披着面向对象的外衣的面向过程)* author: flygo* time: 2022/7/18 16:57*/ public class ObserverMain…

Odoo14 动态过滤或联动domain

在 Odoo14 中最常用的动态过滤或联动domain的方法有两种 1. 使用 上下文 context 和 重写 _search() 或 _name_search() 方法 2. 使用 onchange() 装饰器 的 domain 返回值 示例&#xff1a; 这个图有字段&#xff1a;项目&#xff0c;上级任务&#xff0c;任务 要求&#…

论文笔记(四十)Goal-Auxiliary Actor-Critic for 6D Robotic Grasping with Point Clouds

Goal-Auxiliary Actor-Critic for 6D Robotic Grasping with Point Clouds 文章概括摘要1. 介绍2. 相关工作3. 学习 6D 抓握政策3.1 背景3.2 从点云抓取 6D 策略3.3 联合运动和抓握规划器的演示3.4 行为克隆和 DAGGER3.5 目标--辅助 DDPG3.6 对未知物体进行微调的后视目标 4. 实…