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

news2024/12/24 8:38:11

在这里插入图片描述

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

第1题：走出迷宫

当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。
假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。
时间限制：1000
内存限制：65536
输入
第一行是两个整数n和m(1<=n,m<=100)，表示迷宫的行数和列数。 接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符’.‘表示空地，’#'表示墙，'S’表示起点,'T’表示出口。
输出
输出从起点到出口最少需要走的步数。
样例输入
3 3
S#T
.#.
…
样例输出
6

以下是一个使用C语言编写的解决方案：

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

#define MAX_SIZE 100

typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point point;
    int distance;
} QueueNode;

typedef struct {
    QueueNode data[MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *queue) {
    queue->front = 0;
    queue->rear = 0;
}

int isQueueEmpty(Queue *queue) {
    return queue->front == queue->rear;
}

int isQueueFull(Queue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

void enqueue(Queue *queue, QueueNode node) {
    if (isQueueFull(queue)) {
        printf("Error: Queue is full.\n");
        return;
    }

    queue->data[queue->rear] = node;
    queue->rear = (queue->rear + 1) % MAX_SIZE;
}

QueueNode dequeue(Queue *queue) {
    if (isQueueEmpty(queue)) {
        printf("Error: Queue is empty.\n");
        QueueNode emptyNode = {{-1, -1}, -1};
        return emptyNode;
    }

    QueueNode node = queue->data[queue->front];
    queue->front = (queue->front + 1) % MAX_SIZE;
    return node;
}

int isValid(int x, int y, int n, int m) {
    return x >= 0 && x < n && y >= 0 && y < m;
}

int shortestPath(char maze[][MAX_SIZE], int n, int m, Point start, Point end) {
    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};

    Queue queue;
    initQueue(&queue);

    int visited[MAX_SIZE][MAX_SIZE] = {0};
    visited[start.x][start.y] = 1;

    QueueNode startNode = {start, 0};
    enqueue(&queue, startNode);

    while (!isQueueEmpty(&queue)) {
        QueueNode currentNode = dequeue(&queue);
        Point currentPoint = currentNode.point;
        int currentDistance = currentNode.distance;

        if (currentPoint.x == end.x && currentPoint.y == end.y) {
            return currentDistance;
        }

        for (int i = 0; i < 4; i++) {
            int newX = currentPoint.x + dx[i];
            int newY = currentPoint.y + dy[i];

            if (isValid(newX, newY, n, m) && maze[newX][newY] != '#' && !visited[newX][newY]) {
                visited[newX][newY] = 1;

                Point newPoint = {newX, newY};
                QueueNode newNode = {newPoint, currentDistance + 1};
                enqueue(&queue, newNode);
            }
        }
    }

    return -1; // 没有找到路径
}

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

    char maze[MAX_SIZE][MAX_SIZE];
    Point start, end;

    for (int i = 0; i < n; i++) {
        scanf("%s", maze[i]);

        for (int j = 0; j < m; j++) {
            if (maze[i][j] == 'S') {
                start.x = i;
                start.y = j;
            } else if (maze[i][j] == 'T') {
                end.x = i;
                end.y = j;
            }
        }
    }

    int shortestDistance = shortestPath(maze, n, m, start, end);
    printf("%d\n", shortestDistance);

    return 0;
}

在给定的示例输入下，该程序将产生以下输出：

6

该程序使用广度优先搜索（BFS）算法来找到从起点到出口的最短路径。它使用一个队列来保存待处理的节点，并使用一个二维数组来记录已访问的位置。

程序首先读取迷宫的行数和列数，然后读取迷宫的布局。通过遍历迷宫，找到起点和出口的位置。

接下来，程序使用BFS算法来搜索最短路径。它从起点开始，将起点入队，并将起点标记为已访问。然后，它进入一个循环，直到队列为空。请注意，在使用这个解决方案时，输入的迷宫地图必须符合以下要求：

  • 'S’表示起点，只能有一个。

  • 'T’表示出口，只能有一个。

  • '#'表示墙。

  • '.'表示空地。

此外，该程序假设迷宫是连通的，即从起点到出口存在至少一条路径。如果迷宫是不连通的，或者不存在从起点到出口的路径，程序将返回-1。

第2题：拯救公主

多灾多难的公主又被大魔王抓走啦！国王派遣了第一勇士阿福去拯救她。
身为超级厉害的术士，同时也是阿福的好伙伴，你决定祝他一臂之力。你为阿福提供了一张大魔王根据地的地图，上面标记了阿福和公主所在的位置，以及一些不能够踏入的禁区。你还贴心地为阿福制造了一些传送门，通过一个传送门可以瞬间转移到任意一个传送门，当然阿福也可以选择不通过传送门瞬移。传送门的位置也被标记在了地图上。此外，你还查探到公主所在的地方被设下了结界，需要集齐K种宝石才能打开。当然，你在地图上也标记出了不同宝石所在的位置。
你希望阿福能够带着公主早日凯旋。于是在阿福出发之前，你还需要为阿福计算出他最快救出公主的时间。
地图用一个R×C的字符矩阵来表示。字符S表示阿福所在的位置，字符E表示公主所在的位置，字符#表示不能踏入的禁区，字符$表示传送门，字符.表示该位置安全，数字字符0至4表示了宝石的类型。阿福每次可以从当前的位置走到他上下左右四个方向上的任意一个位置，但不能走出地图边界。阿福每走一步需要花费1个单位时间，从一个传送门到达另一个传送门不需要花费时间。当阿福走到宝石所在的位置时，就视为得到了该宝石，不需要花费额外时间。
时间限制：1000
内存限制：65536
输入
第一行是一个正整数T（1 <= T <= 10），表示一共有T组数据。 每一组数据的第一行包含了三个用空格分开的正整数R、C（2 <= R, C <= 200）和K，表示地图是一个R×C的矩阵，而阿福需要集齐K种宝石才能够打开拘禁公主的结界。 接下来的R行描述了地图的具体内容，每一行包含了C个字符。字符含义如题目描述中所述。保证有且仅有一个S和E。$的数量不超过10个。宝石的类型在数字0至4范围内，即不会超过5种宝石。
输出
对于每一组数据，输出阿福救出公主所花费的最少单位时间。若阿福无法救出公主，则输出“oop!”（只输出引号里面的内容，不输出引号）。每组数据的输出结果占一行。
样例输入
1
7 8 2
…
…S…#0.
.##…1…
.0#…
…1#…
…##E…
…1…
样例输出
11

以下是一个使用C语言编写的解决方案：

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

#define MAX_SIZE 200
#define INF 999999

typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point point;
    int distance;
} QueueNode;

typedef struct {
    QueueNode data[MAX_SIZE * MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *queue) {
    queue->front = 0;
    queue->rear = 0;
}

int isQueueEmpty(Queue *queue) {
    return queue->front == queue->rear;
}

int isQueueFull(Queue *queue) {
    return (queue->rear + 1) % (MAX_SIZE * MAX_SIZE) == queue->front;
}

void enqueue(Queue *queue, QueueNode node) {
    if (isQueueFull(queue)) {
        printf("Error: Queue is full.\n");
        return;
    }

    queue->data[queue->rear] = node;
    queue->rear = (queue->rear + 1) % (MAX_SIZE * MAX_SIZE);
}

QueueNode dequeue(Queue *queue) {
    if (isQueueEmpty(queue)) {
        printf("Error: Queue is empty.\n");
        QueueNode emptyNode = {{-1, -1}, -1};
        return emptyNode;
    }

    QueueNode node = queue->data[queue->front];
    queue->front = (queue->front + 1) % (MAX_SIZE * MAX_SIZE);
    return node;
}

int isValid(int x, int y, int r, int c) {
    return x >= 0 && x < r && y >= 0 && y < c;
}

int shortestRescueTime(char map[][MAX_SIZE], int r, int c, int k, Point start, Point end) {
    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};

    Queue queue;
    initQueue(&queue);

    int visited[MAX_SIZE][MAX_SIZE][1 << 5] = {0};
    visited[start.x][start.y][0] = 1;

    QueueNode startNode = {start, 0};
    enqueue(&queue, startNode);

    while (!isQueueEmpty(&queue)) {
        QueueNode currentNode = dequeue(&queue);
        Point currentPoint = currentNode.point;
        int currentDistance = currentNode.distance;

        if (currentPoint.x == end.x && currentPoint.y == end.y) {
            return currentDistance;
        }

        for (int i = 0; i < 4; i++) {
            int newX = currentPoint.x + dx[i];
            int newY = currentPoint.y + dy[i];

            if (isValid(newX, newY, r, c) && map[newX][newY] != '#' && !visited[newX][newY][0]) {
                int newMask = 0;
                if (map[newX][newY] >= '0' && map[newX][newY] <= '4') {
                    int gemType = map[newX][newY] - '0';
                    newMask = (1 << gemType);
                }

                for (int j = 0; j < (1 << k); j++) {
                    int nextMask = j | newMask;

                    if (!visited[newX][newY][nextMask]) {
                        visited[newX][newY][nextMask] = 1;

                        Point newPoint = {newX, newY};
                        QueueNode newNode = {newPoint, currentDistance + 1};
                        enqueue(&queue, newNode);
                    }
                }
            }
        }
    }

    return -1; // 无法救出公主
}

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

    while (t--) {
        int r, c, k;
        scanf("%d %d %d", &r, &c, &k);

        char map[MAX_SIZE][MAX_SIZE];
        Point start, end;

        for (int i = 0; i < r; i++) {
            scanf("%s", map[i]);

            for (int j = 0; j < c; j++) {
                if (map[i][j] == 'S') {
                    start.x = i;
                    start.y = j;
                } else if (map[i][j] == 'E') {
                    end.x = i;
                    end.y = j;
                }
            }
        }

        int shortestTime = shortestRescueTime(map, r, c, k, start, end);

        if (shortestTime == -1) {
            printf("oop!\n");
        } else {
            printf("%d\n", shortestTime);
        }
    }

    return 0;
}

在此解决方案中，我们使用了广度优先搜索（BFS）来寻找阿福救出公主的最短时间。我们使用一个队列来存储待处理的节点，并使用一个三维数组来记录已经访问过的位置和已经获得的宝石类型。通过遍历四个方向上的相邻位置，我们检查是否可以移动到该位置，如果可以移动，则将该位置加入队列，并更新已访问数组和距离数组。如果我们找到了公主的位置，我们返回当前的距离，表示成功救出公主。如果队列为空而且我们仍然没有找到公主的位置，则表示无法救出公主，返回-1。

请注意，此解决方案假设输入的地图是合法的，并且可以找到一条路径来救出公主。如果地图不合法或者无法救出公主，则输出"oop!"。

第3题：有多少种二叉树

输入n(1<n<13)，求n个结点的二叉树有多少种形态
时间限制：1000
内存限制：65536
输入
整数n
输出
答案
样例输入
3
样例输出
5

这是一个经典的动态规划问题，称为卡塔兰数（Catalan Number）。可以使用动态规划的方法来解决。

首先，我们可以观察到，对于一个二叉树来说，根节点的左子树和右子树的结点数量之和等于总结点数量减去1。因此，我们可以用一个递归的方式来计算二叉树的种类数量。

定义一个函数 countTrees(n)，表示 n 个结点的二叉树的种类数量。对于每一个 i，我们可以将其作为根节点，然后左子树的结点数量为 i-1，右子树的结点数量为 n-i。因此，可以得到递归关系式：

countTrees(n) = countTrees(0) * countTrees(n-1) + countTrees(1) * countTrees(n-2) + ... + countTrees(n-1) * countTrees(0)

初始条件为 countTrees(0) = 1，表示空树的一种形态。

下面是使用动态规划的 C 语言代码实现：

#include <stdio.h>

long long countTrees(int n) {
    long long dp[n+1];
    dp[0] = 1;

    for (int i = 1; i <= n; i++) {
        dp[i] = 0;
        for (int j = 0; j < i; j++) {
            dp[i] += dp[j] * dp[i-j-1];
        }
    }

    return dp[n];
}

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

    long long result = countTrees(n);
    printf("%lld\n", result);

    return 0;
}

在这个解决方案中，我们使用一个数组 dp 来存储计算过的结果，避免重复计算。我们使用两层循环，外层循环遍历结点数量，内层循环计算每个结点数量对应的二叉树种类数量。最后，输出 dp[n] 即为结果。

请注意，由于结果可能非常大，我们使用了 long long 类型来保存结果。

第4题：Sequence

给定m个数字序列，每个序列包含n个非负整数。我们从每一个序列中选取一个数字组成一个新的序列，显然一共可以构造出nm个新序列。接下来我们对每一个新的序列中的数字进行求和，一共会得到nm个和，请找出最小的n个和
时间限制：3000
内存限制：65536
输入
输入的第一行是一个整数T，表示测试用例的数量，接下来是T个测试用例的输入 每个测试用例输入的第一行是两个正整数m（0 < m <= 100）和n(0 < n <= 2000)，然后有m行，每行有n个数，数字之间用空格分开，表示这m个序列 序列中的数字不会大于10000
输出
对每组测试用例，输出一行用空格隔开的数，表示最小的n个和
样例输入
1
2 3
1 2 3
2 2 3
样例输出
3 3 4

这是一个简单的问题，可以使用优先队列（堆）来解决。我们可以遍历每个序列，将序列中的数字依次加入优先队列，保持队列的大小为 n。这样，优先队列中的元素就是最小的 n 个数。

下面是使用 C 语言编写的解决方案：

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

#define MAX_SIZE 2000

typedef struct {
    int value;
    int sequenceIndex;
    int numberIndex;
} Number;

typedef struct {
    Number *data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createMinHeap(int capacity) {
    MinHeap *heap = (MinHeap*) malloc(sizeof(MinHeap));
    heap->data = (Number*) malloc(sizeof(Number) * capacity);
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void destroyMinHeap(MinHeap *heap) {
    free(heap->data);
    free(heap);
}

void swap(Number *a, Number *b) {
    Number temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MinHeap *heap, int index) {
    while (index > 0) {
        int parentIndex = (index - 1) / 2;
        if (heap->data[index].value < heap->data[parentIndex].value) {
            swap(&heap->data[index], &heap->data[parentIndex]);
            index = parentIndex;
        } else {
            break;
        }
    }
}

void heapifyDown(MinHeap *heap, int index) {
    while (index < heap->size) {
        int leftChildIndex = 2 * index + 1;
        int rightChildIndex = 2 * index + 2;
        int smallestIndex = index;

        if (leftChildIndex < heap->size && heap->data[leftChildIndex].value < heap->data[smallestIndex].value) {
            smallestIndex = leftChildIndex;
        }

        if (rightChildIndex < heap->size && heap->data[rightChildIndex].value < heap->data[smallestIndex].value) {
            smallestIndex = rightChildIndex;
        }

        if (smallestIndex != index) {
            swap(&heap->data[index], &heap->data[smallestIndex]);
            index = smallestIndex;
        } else {
            break;
        }
    }
}

void insertNumber(MinHeap *heap, int value, int sequenceIndex, int numberIndex) {
    if (heap->size == heap->capacity) {
        if (value >= heap->data[0].value) {
            return;
        }

        heap->data[0].value = value;
        heap->data[0].sequenceIndex = sequenceIndex;
        heap->data[0].numberIndex = numberIndex;
        heapifyDown(heap, 0);
    } else {
        heap->data[heap->size].value = value;
        heap->data[heap->size].sequenceIndex = sequenceIndex;
        heap->data[heap->size].numberIndex = numberIndex;
        heapifyUp(heap, heap->size);
        heap->size++;
    }
}

void findSmallestSums(int m, int n, int sequences[][MAX_SIZE]) {
    MinHeap *heap = createMinHeap(n);

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            insertNumber(heap, sequences[i][j], i, j);
        }
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", heap->data[i].value);
    }
    printf("\n");

    destroyMinHeap(heap);
}

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

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

        int sequences[100][MAX_SIZE];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                scanf("%d", &sequences[i][j]);
            }
        }

        findSmallestSums(m, n, sequences);
    }

    return 0;
}

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

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

相关文章

BCSP-玄子Share-Java框基础_工厂模式/代理模式

BCSP-玄子Share-Java框基础_工厂模式/代理模式

三、设计模式 3.1 设计模式简介 软件设计中的三十六计是人们在长期的软件开发中的经验总结是对某些特定问题的经过实践检验的特定解决方法被广泛运用在 Java 框架技术中 3.1.1 设计模式的优点 设计模式是可复用的面向对象软件的基础可以更加简单方便地复用成功的设计和体系…
阅读更多...
【管理运筹学】第 7 章 | 图与网络分析（2，最小支撑树问题）

【管理运筹学】第 7 章 | 图与网络分析（2，最小支撑树问题）

文章目录 引言二、最小支撑树问题2.1 树的定义及其基本性质2.2 图的支撑树2.3 最小支撑树的定义及有关定理2.4 最小支撑树算法2.4.1 避圈法&#xff08;KRUSKAL算法&#xff09;2.4.2 反圈法&#xff08;PRIM算法&#xff09;2.4.3 破圈法 写在最后 引言 承接前文&#xff0c;…
阅读更多...
宠物电商Chewy第二季度销售额28亿美元，同比增长14.3%

宠物电商Chewy第二季度销售额28亿美元，同比增长14.3%

美国宠物电商Chewy公布2023年第二季度财报。报告显示&#xff0c;其Q2季度销售额同比增长14.3%至28亿美元&#xff0c;超出市场预期。 以下为Chewy期内业绩概要&#xff1a; 1.毛利率28.3%&#xff0c;同比增长20个基点 2.净利润有所收窄&#xff0c;同比下降15.2%至1890万美…
阅读更多...
QT连接数据库

QT连接数据库

目录 数据库 数据库基本概念 常用的数据库 SQLite3基础 SQLite特性&#xff1a; QT连接数据库 1.1 QT将数据库分为三个层次 1.2 实现数据库操作的相关方法 sql语句&#xff08;常用&#xff09; 1&#xff09;创建表格 2&#xff09;删除表格 3&#xff09;插入记录 …
阅读更多...
应急物资管理系统DW-S300|助力应急物资保障体系建设

应急物资管理系统DW-S300|助力应急物资保障体系建设

国务院新闻办公室于2023年7月25日举行国务院政策例行吹风会&#xff0c;介绍防汛抗旱工作情况&#xff0c;并答记者问。应急管理部副部长、水利部副部长王道席介绍&#xff0c;要推进应急物资保障体系建设。去年&#xff0c;应急管理部会同国家发展改革委、财政部、国家粮食和物…
阅读更多...
AIGC专栏5——EasyPhoto AI写真照片生成器 sd-webui插件介绍、安装与使用

AIGC专栏5——EasyPhoto AI写真照片生成器 sd-webui插件介绍、安装与使用

AIGC专栏5——EasyPhoto AI写真照片生成器 插件安装与使用 学习前言源码下载地址技术原理储备&#xff08;SD/Control/Lora&#xff09;StableDiffusionControlNetLora EasyPhoto插件简介EasyPhoto插件安装安装方式一&#xff1a;Webui界面安装 &#xff08;需要良好的网络&…
阅读更多...
Linux监测进程打开文件

Linux监测进程打开文件

分析问题过程中&#xff0c;追踪进程打开的文件可以在许多不同情况下有用&#xff0c;体现在以下几个方面&#xff1a; 故障排除和调试&#xff1a; 当程序出现问题、崩溃或异常行为时&#xff0c;追踪进程打开的文件可以帮助找出问题的根本原因。这有助于快速定位错误&#x…
阅读更多...
深入解析 curl：掌握命令行的网络传输利器

深入解析 curl：掌握命令行的网络传输利器

当我们使用 curl 进行网络请求时&#xff0c;了解如何有效地使用参数是非常重要的。curl 提供了许多参数&#xff0c;用于控制请求的行为和配置。在这篇博客文章中&#xff0c;我们将详细解释一些常用的 curl 参数&#xff0c;帮助你更好地理解如何利用这个强大的工具。 什么是…
阅读更多...
兵者多诡(HCTF2016)

兵者多诡(HCTF2016)

环境:https://github.com/MartinxMax/CTFer_Zero_one 题目简介 解题过程 登录首页 提交png图片上传抓包&#xff0c;可以看到是向upload文件提交数据 在fp参数中尝试伪协议读取home.php文件 http://127.0.0.1:88/HCTF2016-LFI/home.php?fpphp://filter/readconvert.base64…
阅读更多...
将YOLO数据集按照指定比例划分（训练集、验证集、测试集）的详细教程

将YOLO数据集按照指定比例划分（训练集、验证集、测试集）的详细教程

1.将训练集、验证集、测试集按照7:2:1随机划分 1.项目准备 1.在项目下新建一个py文件&#xff0c;名字就叫做splitDataset1.py 2.将自己需要划分的原数据集就放在项目文件夹下面 以我的为例&#xff0c;我的原数据集名字叫做hatDataXml 里面的JPEGImages装的是图片 Annota…
阅读更多...
【物联网】磁介质存储设备——机械硬盘

【物联网】磁介质存储设备——机械硬盘

磁介质存储设备是一种使用磁性材料作为存储介质的设备&#xff0c;用于存储和读取数据。常见的磁介质存储设备包括硬盘驱动器&#xff08;HDD&#xff09;、软盘驱动器和磁带。 文章目录 一、机械硬盘存储器的基本结构与分类1.1 基本结构1.2 分类 二、硬盘的信息分布三、机械硬…
阅读更多...
计算机网络的故事——HTTP报文内的HTTP信息

计算机网络的故事——HTTP报文内的HTTP信息

HTTP报文内的HTTP信息 文章目录 HTTP报文内的HTTP信息一、HTTP 报文二、请求报文及响应报文的结构三、编码提升传输速率 一、HTTP 报文 HTTP报文是由多行&#xff08;CRLF作换行符&#xff09;数据构成的字符串文本&#xff0c;HTTP报文可以分为报文首部和报文主体两部分&…
阅读更多...
Android ChatCPT集成

Android ChatCPT集成

准备工作 ChatGPT账号(openai) 集成好网络框架(默认使用Retrofit) 接入 选择modele 这里使用的是 「https://api.openai.com/v1/chat/completions」 创建API Keys 运行效果 POST https://api.openai.com/v1/chat/completions Content-Type: application/json Content-Length:…
阅读更多...
RHCA之路---EX280(8)

RHCA之路---EX280(8)

RHCA之路—EX280(8) 1. 题目 On master.lab.example.com using the template file in http://materials.example.com/exam280/gogs as a basis, install an application in the ditto project according to the following requirements: All of the registry entries must poi…
阅读更多...
AndroidTV端：酒店扫码认证投屏DLNA

AndroidTV端：酒店扫码认证投屏DLNA

被老板叼了几次了&#xff0c;最近实在忍不了&#xff0c;准备离职&#xff1b; 但是担心离职后长时间没有办法找到工作 就想贡献一套平时琢磨出来的程序&#xff0c;请各位有能力的话带我熬过这凛冽的寒冬。 目前写出来的&#xff0c;有三个端&#xff1a;安卓TV端&#xf…
阅读更多...
Kali之BurpSuite_pro安装配置

Kali之BurpSuite_pro安装配置

文章目录 配置jdk环境安装BurpSuitePro设置快捷方式启动方式 BurpSuite2021专业版本地址&#xff1a; 下载链接&#xff1a;https://pan.baidu.com/s/1PjzcukRDoc_ZFjrNxI8UjA 提取码&#xff1a;nwm7 我的安装工具都在/home/kali/tools/ 解压后我放在burpsuite_pro目录下 把j…
阅读更多...
Harbor 私人（企业）docker镜像仓库部署

Harbor 私人（企业）docker镜像仓库部署

目录 一、资源下载二、配置前准备三、配置harbor.yml文件四、安装五、上传镜像到Harbor docker镜像仓库 一、资源下载 在GitHub上可以找到相关的下载&#xff1a;https://github.com/goharbor/harbor/releases 或者Linux直接wget&#xff1a; ┌──(root㉿kali)-[~] └─# w…
阅读更多...
飞行动力学 - 第17节-航向静稳定性 之 基础点摘要

飞行动力学 - 第17节-航向静稳定性 之 基础点摘要

飞行动力学 - 第17节-航向静稳定性 之 基础点摘要 1. 航向静稳定性2. 航向静稳定性的组成3. 参考资料 1. 航向静稳定性 飞机受到侧滑扰动后&#xff0c;如果能产生使机头指向原来方向的力矩&#xff0c;抵消侧滑&#xff0c;则称为航向静稳定性。 2. 航向静稳定性的组成 飞机…
阅读更多...
vue3+ts+vite项目引入echarts

vue3+ts+vite项目引入echarts

概述 技术栈&#xff1a;Vue3 Ts Vite Echarts 简介&#xff1a; 图文详解&#xff0c;教你如何在Vue3项目中引入Echarts&#xff0c;封装Echarts组件&#xff0c;并实现常用Echarts图例 文章目录 概述一、先看效果1.1 静态效果1.2 动态效果 二、话不多数&#xff0c;引入 …
阅读更多...
三步搭建个人网站并发布上线【内网穿透】

三步搭建个人网站并发布上线【内网穿透】

三步搭建个人网站并发布上线【内网穿透】 文章目录 三步搭建个人网站并发布上线【内网穿透】前言一、在本地电脑上制作一个网站二、使用WordPress建立网站三、通过cpolar建立的数据隧道发布到公网上 前言 在这个个性飞扬的时代&#xff0c;每个人都希望拥有表现自我的平台&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023