2022年12月 C/C++（六级）真题解析#中国电子学会#全国青少年软件编程等级考试

news2025/1/31 20:01:24

在这里插入图片描述

C/C++编程（1~8级）全部真题・点这里

第1题：区间合并

给定 n 个闭区间 [ai; bi]，其中i=1,2,…,n。任意两个相邻或相交的闭区间可以合并为一个闭区间。例如，[1;2] 和 [2;3] 可以合并为 [1;3]，[1;3] 和 [2;4] 可以合并为 [1;4]，但是[1;2] 和 [3;4] 不可以合并。
我们的任务是判断这些区间是否可以最终合并为一个闭区间，如果可以，将这个闭区间输出，否则输出no。
时间限制：1000
内存限制：65536
输入
第一行为一个整数n，3 ≤ n ≤ 50000。表示输入区间的数量。 之后n行，在第i行上（1 ≤ i ≤ n），为两个整数 ai 和 bi ，整数之间用一个空格分隔，表示区间 [ai; bi]（其中 1 ≤ ai ≤ bi ≤ 10000）。
输出
输出一行，如果这些区间最终可以合并为一个闭区间，输出这个闭区间的左右边界，用单个空格隔开；否则输出 no。
样例输入
5
5 6
1 5
10 10
6 9
8 10
样例输出
1 10

这个问题可以通过对输入的闭区间进行合并操作来解决。我们可以使用一个变量来追踪当前的合并区间范围，并根据每个输入的闭区间更新这个范围。

首先，我们可以将输入的闭区间按照左边界从小到大进行排序。

然后，我们可以使用两个变量start和end来表示当前的合并区间范围，初始值分别为第一个闭区间的左右边界。

接下来，我们可以遍历排序后的闭区间列表，对于每个闭区间，检查它是否与当前的合并区间相交或相邻。如果相交或相邻，则更新当前的合并区间范围，将start更新为当前闭区间的左边界，将end更新为当前闭区间的右边界。

最后，如果遍历完所有闭区间后，最终的合并区间范围等于输入的闭区间列表的最小和最大值，就说明这些区间可以最终合并为一个闭区间，输出这个闭区间的左右边界；否则输出"no"。

以下是一个用C语言实现的解答示例：

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

typedef struct {
    int left;
    int right;
} Interval;

int compare(const void *a, const void *b) {
    Interval *intervalA = (Interval *)a;
    Interval *intervalB = (Interval *)b;

    return intervalA->left - intervalB->left;
}

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

    Interval intervals[n];

    int i;
    for (i = 0; i < n; i++) {
        scanf("%d %d", &(intervals[i].left), &(intervals[i].right));
    }

    qsort(intervals, n, sizeof(Interval), compare);

    int start = intervals[0].left;
    int end = intervals[0].right;

    for (i = 1; i < n; i++) {
        if (intervals[i].left <= end) {
            if (intervals[i].right > end) {
                end = intervals[i].right;
            }
        } else {
            printf("no\n");
            return 0;
        }
    }

    if (start == intervals[0].left && end == intervals[n - 1].right) {
        printf("%d %d\n", start, end);
    } else {
        printf("no\n");
    }

    return 0;
}

该程序首先定义了一个表示闭区间的结构体（Interval），其中包括左边界和右边界属性。

在主函数中，首先读取区间的数量n，并创建用于存储所有闭区间的数组（intervals）。

然后，使用一个循环从输入中读取每个闭区间的左边界和右边界，并将其存储在对应的数组元素中。

接下来，使用qsort函数对闭区间数组进行排序，排序规则由compare函数定义。compare函数按照左边界从小到大的顺序进行排序。

然后，创建两个变量（start和end），并将它们的初始值设置为第一个闭区间的左边界和右边界。

使用一个循环遍历排序后的闭区间数组，对于每个闭区间，判断它是否与当前的合并区间相交或相邻。如果相交或相邻，则更新当前的合并区间范围，将start更新为当前闭区间的左边界，将end更新为当前闭区间的右边界。

最后，如果遍历完所有闭区间后，最终的合并区间范围的左边界等于闭区间数组的最小值，且右边界等于闭区间数组的最大值，就说明这些区间可以最终合并为一个闭区间，输出这个闭区间的左右边界；否则输出"no"。

注意：为了方便起见，该程序假设输入的闭区间已经按照左边界从小到大进行了排序。如果输入的闭区间没有排序，你可以在读取完所有闭区间后使用qsort函数进行排序。

另外，该程序使用了C标准库中的函数，因此需要包含相应的头文件（stdio.h和stdlib.h）。

第2题：电话号码

给你一些电话号码，请判断它们是否是一致的，即是否有某个电话是另一个电话的前缀。比如：
Emergency 911
Alice 97 625 999
Bob 91 12 54 26
在这个例子中，我们不可能拨通Bob的电话，因为Emergency的电话是它的前缀，当拨打Bob的电话时会先接通Emergency，所以这些电话号码不是一致的。
时间限制：1000
内存限制：65536
输入
第一行是一个整数t，1 ≤ t ≤ 40，表示测试数据的数目。 每个测试样例的第一行是一个整数n，1 ≤ n ≤ 10000，其后n行每行是一个不超过10位的电话号码。
输出
对于每个测试数据，如果是一致的输出“YES”，如果不是输出“NO”。
样例输入
2
3
911
97625999
91125426
5
113
12340
123440
12345
98346
样例输出
NO
YES

这个问题可以通过构建一个前缀树（Trie）来解决。前缀树是一种树状数据结构，用于存储一组字符串，并支持高效地查找字符串的前缀。

首先，我们可以定义一个前缀树节点的结构，包括一个布尔变量isEnd表示是否是一个字符串的结尾，以及一个指向子节点的指针数组。

然后，我们可以使用一个函数来构建前缀树。对于每个电话号码，我们从根节点开始，依次遍历号码的每一位数字。如果当前数字对应的子节点不存在，我们就创建一个新的节点，并更新当前节点的子节点指针。然后，将当前节点指向子节点，并继续遍历下一位数字。最后，将当前节点的isEnd标记设置为true，表示当前节点是一个电话号码的结尾。

接下来，我们可以使用另一个函数来判断一组电话号码是否一致。对于每个电话号码，我们从根节点开始，依次遍历号码的每一位数字。如果当前节点的isEnd标记为true，说明当前号码是另一个号码的前缀，返回"NO"。如果当前数字对应的子节点不存在，说明当前号码不是任何号码的前缀，返回"YES"。否则，将当前节点指向子节点，并继续遍历下一位数字。如果遍历完所有号码后都没有返回"NO"，则返回"YES"。

下面是一个用C语言实现的解答示例：

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

#define NUM_CHILDREN 10

typedef struct TrieNode {
    bool isEnd;
    struct TrieNode* children[NUM_CHILDREN];
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->isEnd = false;
    memset(node->children, 0, sizeof(node->children));
    return node;
}

void insert(TrieNode* root, char* phoneNumber) {
    TrieNode* curr = root;
    int len = strlen(phoneNumber);

    for (int i = 0; i < len; i++) {
        int index = phoneNumber[i] - '0';

        if (curr->children[index] == NULL) {
            curr->children[index] = createNode();
        }

        curr = curr->children[index];
    }

    curr->isEnd = true;
}

bool isConsistent(TrieNode* root, char* phoneNumber) {
    TrieNode* curr = root;
    int len = strlen(phoneNumber);

    for (int i = 0; i < len; i++) {
        int index = phoneNumber[i] - '0';

        if (curr->isEnd) {
            return false;
        }

        if (curr->children[index] == NULL) {
            return true;
        }

        curr = curr->children[index];
    }

    return true;
}

void freeTrie(TrieNode* root) {
    if (root == NULL) {
        return;
    }

    for (int i = 0; i < NUM_CHILDREN; i++) {
        freeTrie(root->children[i]);
    }

    free(root);
}

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

    while (t--) {
        int n;
        scanf("%d", &n);

        TrieNode* root = createNode();

        bool consistent = true;

        while (n--) {
            char phoneNumber[11];
            scanf("%s", phoneNumber);

            if (consistent) {
                if (!isConsistent(root, phoneNumber)) {
                    consistent = false;
                }

                insert(root, phoneNumber);
            }
        }

        if (consistent) {
            printf("YES\n");
        } else {
            printf("NO\n");
        }

        freeTrie(root);
    }

    return 0;
}

该程序首先定义了一个前缀树节点的结构体（TrieNode），其中包括一个布尔变量isEnd表示是否是一个字符串的结尾，以及一个指向子节点的指针数组。

第3题：扑克牌排序

假设这里有36张扑克牌，分别为A1A9,B1B9,C1C9,D1D9，其中A代表方片，B代表草花，C代表红桃，D代表黑桃，那么，设定如下的排序规则：
1.对于两张卡牌，X1Y1与X2Y2，X1与X2表示A～D，Y1与Y2表示1～9，如果X1与X2不同，那么依照D>C>B>A的方式进行排序
2.假如有X1与X2相同时，那么就比较Y1与Y2的大小。
例如，对于如下的四张牌，有如下的升序排序结果：
D3，C4，A4，C1
升序排序的结果为A4，C1，C4，D3
有人提出了如下的排序策略：
先建立9个队列，用于存放点数的大小，将卡牌依点数存放入各自的队列之中，然后再按队列1到队列9依次出队。
例如，对于上面的结果，依次进队后，结果如下：
队列1：C1；队列3：D3，队列4：C4，A4
将其依次出队后，结果为C1，D3，C4，A4
然后，再建立4个队列，用于存放花色。将卡牌依花色A～D存放入队列1～4中，然后再按队列1到队列4依次出队。
例如，对于上面刚刚出队的序列C1，D3，C4，A4，将其依次进队，结果如下：
队列1：A4；队列3：C1，C4；队列4：D3
将其依次出队后，结果为A4，C1，C4，D3，排序结束。
请根据上面的算法，编写一个用队列对扑克牌排序的程序，要求依照上面的排序规则，根据先花色后点数的方法进行排序。
时间限制：1000
内存限制：65536
输入
输入分为两行，第一行为一个整数n，表示一共有n张牌（1<=n<=100） 第二行用XY的形式表示每一张牌，其中X为A～D，Y为1～9
输出
输出三个部分 第一个部分为第一次进队出队的结果，用Queue1:…表示，共9行，结果用空格分隔，下同 第二部分为第二次进队出队的结果，用QueueA:…表示，共4行 第三部分为一行，即将卡牌排序后的结果（升序排序）
样例输入
8
D8 A6 C3 B8 C5 A1 B5 D3
样例输出
Queue1:A1
Queue2:
Queue3:C3 D3
Queue4:
Queue5:C5 B5
Queue6:A6
Queue7:
Queue8:D8 B8
Queue9:
QueueA:A1 A6
QueueB:B5 B8
QueueC:C3 C5
QueueD:D3 D8
A1 A6 B5 B8 C3 C5 D3 D8
提示
第二次入队出队时，可以复用第一次时9个队列中的4个。所以其实只需要开辟9个队列即可。

下面是用C语言编写的扑克牌排序程序，使用队列实现：

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

#define MAX_CARDS 100
#define MAX_QUEUE_SIZE 9

// 定义扑克牌结构体
typedef struct {
    char suit; // 花色
    int number; // 点数
} Card;

// 定义队列结构体
typedef struct {
    Card cards[MAX_CARDS];
    int front;
    int rear;
} Queue;

// 初始化队列
void initQueue(Queue *queue) {
    queue->front = 0;
    queue->rear = -1;
}

// 判断队列是否为空
int isQueueEmpty(Queue *queue) {
    return queue->front > queue->rear;
}

// 入队
void enqueue(Queue *queue, Card card) {
    queue->rear++;
    queue->cards[queue->rear] = card;
}

// 出队
Card dequeue(Queue *queue) {
    Card card = queue->cards[queue->front];
    queue->front++;
    return card;
}

// 按花色入队
void enqueueBySuit(Queue *queues, char suit, Card card) {
    int index;
    switch (suit) {
        case 'A':
            index = 0;
            break;
        case 'B':
            index = 1;
            break;
        case 'C':
            index = 2;
            break;
        case 'D':
            index = 3;
            break;
        default:
            return;
    }
    enqueue(&queues[index], card);
}

// 按花色出队
void dequeueBySuit(Queue *queues, char suit, Queue *resultQueue) {
    int index;
    switch (suit) {
        case 'A':
            index = 0;
            break;
        case 'B':
            index = 1;
            break;
        case 'C':
            index = 2;
            break;
        case 'D':
            index = 3;
            break;
        default:
            return;
    }
    while (!isQueueEmpty(&queues[index])) {
        Card card = dequeue(&queues[index]);
        enqueue(resultQueue, card);
    }
}

// 比较两张牌的大小
int compareCards(Card card1, Card card2) {
    if (card1.suit != card2.suit) {
        switch (card1.suit) {
            case 'D':
                return -1;
            case 'C':
                if (card2.suit == 'D')
                    return 1;
                else
                    return -1;
            case 'B':
                if (card2.suit == 'D' || card2.suit == 'C')
                    return 1;
                else
                    return -1;
            case 'A':
                if (card2.suit == 'D' || card2.suit == 'C' || card2.suit == 'B')
                    return 1;
                else
                    return -1;
        }
    } else {
        return card1.number - card2.number;
    }
    return 0;
}

// 扑克牌排序
void sortCards(Card *cards, int n) {
    Queue queues[MAX_QUEUE_SIZE]; // 9个队列
    Queue resultQueue; // 结果队列
    Card sortedCards[MAX_CARDS]; // 排序后的牌
    int i, j;

    // 初始化队列
    for (i = 0; i < MAX_QUEUE_SIZE; i++) {
        initQueue(&queues[i]);
    }
    initQueue(&resultQueue);

    // 第一次进队出队，按点数入队
    for (i = 0; i < n; i++) {
        enqueueBySuit(queues, cards[i].suit, cards[i]);
    }

    printf("Queue1:");
    while (!isQueueEmpty(&queues[0])) {
        Card card = dequeue(&queues[0]);
        printf(" %c%d", card.suit, card.number);
        enqueue(&resultQueue, card);
    }
    printf("\n");

    // 第二次进队出队，按花色入队
    for (i = 0; i < MAX_QUEUE_SIZE; i++) {
        dequeueBySuit(queues, 'A' + i, &resultQueue);
    }

    printf("QueueA:");
    for (i = 0; i < MAX_QUEUE_SIZE; i++) {
        while (!isQueueEmpty(&queues[i])) {
            Card card = dequeue(&queues[i]);
            printf(" %c%d", card.suit, card.number);
            enqueue(&resultQueue, card);
        }
    }
    printf("\n");

    // 排序后的结果
    printf("Result:");
    i = 0;
    while (!isQueueEmpty(&resultQueue)) {
        sortedCards[i] = dequeue(&resultQueue);
        printf(" %c%d", sortedCards[i].suit, sortedCards[i].number);
        i++;
    }
    printf("\n");
}

int main() {
    int n;
    scanf("%d", &n);
    Card cards[MAX_CARDS];
    int i;

    // 读取扑克牌
    for (i = 0; i < n; i++) {
        char suit;
        int number;
        scanf(" %c%d", &suit, &number);
        cards[i].suit = suit;
        cards[i].number = number;
    }

    // 扑克牌排序
    sortCards(cards, n);

    return 0;
}

使用上述代码，你可以输入扑克牌的数量和每张牌的花色与点数，然后程序将按照给定的排序规则进行排序，并输出进队出队的结果和排序后的结果。

第4题：现代艺术

在对二维艺术作品感到厌烦之后，伟大的艺术牛Picowso决定从事创作一项更为小众的艺术形式，一维画。
尽管目前她的画作可以用一个由颜色组成的长度为N(1100000)的数组表示，但她的创作风格依然保持不变：从一张空白的矩形画布上，不断地画上一些矩形，在一维的情况下，这些矩形就只是一个区间。她用N种颜色，颜色编号为1N进行创作，每种颜色只使用一次，之后使用的颜色可以完全的覆盖之前在相同位置上的颜色。
令Picowso感到十分沮丧的是，她的竞争对手Moonet似乎弄明白了如何复制她的这些一维画作，Moonet会画一些不相交的间隔，等待这些颜色晾干，然后再画另外的一些间隔，直到画完。Moonet每次每种颜色最多只能画一个间隔，但是他可以一次画不同颜色不相交的多个间隔，只要这些间隔没有重叠部分。之后Moonet再进行下一轮绘制。请计算Moonet为了复制一幅画需要画几个回合。
时间限制：10000
内存限制：65536
输入
第一行是一个整数N，之后N行包含了N个整数，范围0到N表示纸带每个格点的颜色，0表示没有涂色。
输出
输出一行，需要复制这幅画作的最少回合数，如果这幅画不可能是Picowso的画作输出-1（比如说这幅画不可能是通过一次在一条上画一层的方法进行创作的）
样例输入
7
0
1
4
5
1
3
3
样例输出
2
提示
在这个样例中，第一轮涂成0111133，第二轮涂成0145133，所以共需两轮。

下面是解决这个问题的C语言代码：

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

int main() {
    int N;
    scanf("%d", &N);
    
    int *colors = (int *)malloc((N+1) * sizeof(int));
    int *visited = (int *)calloc((N+1), sizeof(int));
    
    for (int i = 1; i <= N; i++) {
        scanf("%d", &colors[i]);
    }
    
    int rounds = 0;
    int maxIndex = 0;
    
    while (maxIndex < N) {
        int nextMaxIndex = maxIndex;
        
        for (int i = 1; i <= N; i++) {
            if (!visited[i] && colors[i] == maxIndex + 1) {
                visited[i] = 1;
                nextMaxIndex = i;
            }
        }
        
        if (nextMaxIndex == maxIndex) {
            printf("-1\n");
            free(colors);
            free(visited);
            return 0;
        }
        
        maxIndex = nextMaxIndex;
        rounds++;
    }
    
    printf("%d\n", rounds);
    
    free(colors);
    free(visited);
    
    return 0;
}

该程序首先读取输入的整数N，表示颜色的数量。然后，它使用动态内存分配来创建两个数组：colors和visited。colors数组用于存储每个格点的颜色，visited数组用于跟踪已经访问的格点。

接下来，程序使用循环读取N行输入，并将每个颜色存储在colors数组中。

然后，程序开始模拟Moonet复制画作的过程。它使用一个循环来找到当前未被访问的、具有最大颜色值（maxIndex + 1）的格点，并将其标记为已访问。然后，它更新maxIndex为该格点的索引，并增加回合数。

如果在某个回合中找不到未访问的、具有最大颜色值的格点，则说明无法复制Picowso的画作，程序输出-1并结束。

最后，程序输出回合数，并释放动态分配的内存。

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

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

相关文章

腾讯云网站备案详细流程_审核时间说明

腾讯云网站备案详细流程_审核时间说明

腾讯云网站备案流程先填写基础信息、主体信息和网站信息&#xff0c;然后提交备案后等待腾讯云初审&#xff0c;初审通过后进行短信核验&#xff0c;最后等待各省管局审核&#xff0c;前面腾讯云初审时间1到2天左右&#xff0c;最长时间是等待管局审核时间&#xff0c;网站备案…
阅读更多...
Python入门教程 - 判断语句（二）

Python入门教程 - 判断语句（二）

目录 一、布尔类型 二、比较运算符 三、if判断语句 一、布尔类型 True False result1 10 > 5 result2 10 < 5 print(result1) print(result2) print(type(result1)) True False <class bool> 二、比较运算符 ! > < > < 比较运算的结果是布尔…
阅读更多...
8. 摆平积木

8. 摆平积木

题目&#xff1a; 小明很喜欢玩积木。一天&#xff0c;他把许多积木块组成了好多高度不同的堆&#xff0c;每一堆都是一个摞一个的形式。然而此时&#xff0c;他又想把这些积木堆变成高度相同的。但是他很懒&#xff0c;他想移动最少的积木块来实现这一目标&#xff0c; 你能帮…
阅读更多...
DevEco Studio 配置

DevEco Studio 配置

首先,打开deveco studio 进入首页 …我知道你们想说什么,我也想说 汉化配置 没办法,老样子,先汉化吧,毕竟母语看起来舒服 首先,点击软件左下角的configure,在配置菜单里选择plugins 进入到插件页面, 输入chinese,找到汉化插件,(有一说一写到这我心里真是很不舒服) 然后点击o…
阅读更多...
2023年05月 C/C++（六级）真题解析#中国电子学会#全国青少年软件编程等级考试

2023年05月 C/C++（六级）真题解析#中国电子学会#全国青少年软件编程等级考试

C/C编程&#xff08;1~8级&#xff09;全部真题・点这里 第1题&#xff1a;字符串插入 有两个字符串str和substr&#xff0c;str的字符个数不超过10&#xff0c;substr的字符个数为3。&#xff08;字符个数不包括字符串结尾处的’\0’。&#xff09;将substr插入到str中ASCII码…
阅读更多...
百万级并发IM即时消息系统（4）Swagger

百万级并发IM即时消息系统（4）Swagger

golang swagger注解说明_go swagger 注释_mctlilac的博客-CSDN博客 Gin(十):集成 Swagger - 掘金 (juejin.cn) 手把手详细教你如何使用go-swagger文档 - 掘金 (juejin.cn) 08_Swagger&Logger复盘整理_哔哩哔哩_bilibili 1.配置swagger 1&#xff09;swagger ginSwag…
阅读更多...
kafka详解一

kafka详解一

kafka详解一 1、消息引擎背景 根据维基百科的定义&#xff0c;消息引擎系统是一组规范。企业利用这组规范在不同系统之间传递语义准确的消息&#xff0c;实现松耦合的异步式数据传递. 即&#xff1a;系统 A 发送消息给消息引擎系统&#xff0c;系统 B 从消息引擎系统中读取 A…
阅读更多...
[dasctf]misc04

[dasctf]misc04

与他不说一模一样吧也差不多 第三届红明谷杯CTF-【MISC】-阿尼亚_keepb1ue的博客-CSDN客flag.zip需要解压密码&#xff0c;在图片中发现一串密文。一串乱码&#xff0c;尝试进行字符编码爆破。获取到密码&#xff1a;简单的编码。https://blog.csdn.net/qq_36618918/article/d…
阅读更多...
IE浏览器攻击：MS11-003_IE_CSS_IMPORT

IE浏览器攻击：MS11-003_IE_CSS_IMPORT

目录 概述 利用过程 漏洞复现 概述 MS11-003_IE_CSS_IMPORT是指Microsoft Security Bulletin MS11-003中的一个安全漏洞&#xff0c;影响Internet Explorer&#xff08;IE&#xff09;浏览器。这个漏洞允许攻击者通过在CSS文件中使用import规则来加载外部CSS文件&#xff0…
阅读更多...
【Locomotor运动模块】攀爬

【Locomotor运动模块】攀爬

文章目录 一、攀爬主体“伪身体”1、“伪身体”的设置2、“伪身体”和“真实身体”&#xff0c;为什么同步移动3、“伪身体”和“真实身体”&#xff0c;碰到墙时不同步的原因①现象②原因③解决 二、攀爬1、需要的组件&#xff1a;“伪身体”、Climbing、Climbable及Interacto…
阅读更多...
QT实现任意阶贝塞尔曲线绘制

QT实现任意阶贝塞尔曲线绘制

bezier曲线在编程中的难点在于求取曲线的系数&#xff0c;如果系数确定了那么就可以用微小的直线段画出曲线。bezier曲线的系数也就是bernstein系数&#xff0c;此系数的性质可以自行百度&#xff0c;我们在这里是利用bernstein系数的递推性质求取&#xff1a; 简单举例 两个…
阅读更多...
爬楼梯【动态规划】

爬楼梯【动态规划】

爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢&#xff1f; class Solution {public int climbStairs(int n) {if (n < 2) return n;//特殊情况处理int dp[] new int[n 1];dp[1] 1;//因为数组索…
阅读更多...
20个不可错过的VScode神级插件

20个不可错过的VScode神级插件

VS Code 是我们打发时间时最常用的代码编辑器之一&#xff0c;它是一个多功能伴侣&#xff0c;重新定义了我们软件开发的方式。其轻量级的界面与强大的功能相结合&#xff0c;使其成为全球程序员的首选。但是&#xff0c;普通 VS Code 用户与熟练开发人员的区别在于通过扩展充分…
阅读更多...
11. Junit

11. Junit

我们主要学习的是 Junit5. 1. selenium 和 Junit 之间的关系 selenium 和 Junit 之间的关系 就像 Java 和 JavaScript 之间的关系&#xff0c;也就是没有关系。 为什么学习了 selenium 还要学习 Junit 呢&#xff1f; 举个例子&#xff0c;如果 Selenium 编写的自动化测试用…
阅读更多...
【图像分割】实战篇（1）传统图像分割

【图像分割】实战篇（1）传统图像分割

聚类图像分割 K均值聚类是一种常用的聚类算法&#xff0c;它将图像像素分为K个不同的群集&#xff0c;以使每个群集内的像素具有相似的颜色或强度。这可以用于分割具有不同颜色或亮度的对象。 import numpy as np import matplotlib.pyplot as plt from sklearn.cluster impo…
阅读更多...
单片机-控制按键点亮LED灯

单片机-控制按键点亮LED灯

1、按键电路图 定义四个按键引脚 1、按键按下 为 输入为低电平 2、按键不按下 IO有上拉电阻&#xff0c;为高电平 // 定义 按键的 管教 sbit KEY1 P3^1; sbit KEY2 P3^0; sbit KEY3 P3^2; sbit KEY4 P3^3; 2、LED灯电路图 LED 输出高电平为亮 // 定义LED灯 管教 sbit LED1…
阅读更多...
基于SpringBoot2的后台业务管理系统

基于SpringBoot2的后台业务管理系统

概述 SpringBoot-Plus 是一个适合大系统拆分成小系统的架构&#xff0c;java快速开发平台&#xff0c;或者是一个微服务系统。其中加入了Thymeleaf数据模板语言代替了之前的JSP页面方式。页面展示采用Layui前端框架&#xff0c;包含了用户管理&#xff0c;角色管理&#xff0c…
阅读更多...
获取Linux内核源码

获取Linux内核源码

在嵌入式平台上做Linux开发的时候&#xff0c;我们用的kernel都是芯片厂家移植到自家平台上的&#xff0c;但是最初的原生Linux内核的源码是从哪里来的呢&#xff1f;下面我们介绍一下怎么获取原生的Linux源码。 从Linux社区获取内核kernel源码 Linux社区的官方网站是 https:…
阅读更多...
【Day-26慢就是快】代码随想录-二叉树-对阵二叉树

【Day-26慢就是快】代码随想录-二叉树-对阵二叉树

给定一个二叉树&#xff0c;检查它是否是镜像对称的。 —————————————————————————————————————————— 分析&#xff1a; 需要比较的是根节点的左右子树&#xff0c;且是两个子树的里侧和外侧的元素是否相等。 根据后序遍历算法&…
阅读更多...
Modbus通信协议

Modbus通信协议

Modbus通信协议 一、概述 Modbus通信协议是一种工业现场总线协议标准&#xff0c;常用的Modbus协议有以下三种类型&#xff1a;Modbus TCP、Modbus RTU、Modbus ASCll。 Modbus通信协议解决了通过串行线路在电子设备之间发送信息的问题。该协议在遵循该协议的体系结构中实现主…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023