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

news2025/7/19 1:31:54

在这里插入图片描述

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

第1题：字符串插入

有两个字符串str和substr，str的字符个数不超过10，substr的字符个数为3。（字符个数不包括字符串结尾处的’\0’。）将substr插入到str中ASCII码最大的那个字符后面，若有多个最大则只考虑第一个。
时间限制：1000
内存限制：65536
输入
输入包括若干行，每一行为一组测试数据，格式为 str substr
输出
对于每一组测试数据，输出插入之后的字符串。
样例输入
abcab eee
12343 555
样例输出
abceeeab
12345553

下面是使用C语言编写的示例代码，实现将substr插入到str中ASCII码最大的字符后面：

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

void insertSubstring(char *str, const char *substr) {
    int maxIndex = 0;
    int maxAscii = str[0];

    // 找到ASCII码最大的字符的索引
    for (int i = 1; str[i] != '\0'; i++) {
        if (str[i] > maxAscii) {
            maxAscii = str[i];
            maxIndex = i;
        }
    }

    // 在最大字符后面插入substr
    int strLen = strlen(str);
    int substrLen = strlen(substr);
    for (int i = strLen; i > maxIndex + 1; i--) {
        str[i + substrLen] = str[i];
    }
    for (int i = 0; i < substrLen; i++) {
        str[maxIndex + 1 + i] = substr[i];
    }
}

int main() {
    char str[11];
    char substr[4];

    while (scanf("%s %s", str, substr) != EOF) {
        insertSubstring(str, substr);
        printf("%s\n", str);
    }

    return 0;
}

代码中的insertSubstring函数用于将substr插入到str中ASCII码最大的字符后面。它首先遍历str找到ASCII码最大的字符的索引，然后将substr插入到该索引后面。插入操作分两步：首先将原来的字符依次向后移动，然后将substr插入到空出的位置。

在main函数中，我们使用scanf读取输入的每一组测试数据，然后调用insertSubstring函数进行处理，并输出结果。

第2题：机器翻译

VariantF的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。
假设内存中有M 个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过M，软件会将新单词存入一个未使用的内存单元；若内存中已存入M 个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。
假设一篇英语文章的长度为N 个单词。给定这篇待译文章，翻译软件需要去外存查找多少次词典？假设在翻译开始前，内存中没有任何单词。
时间限制：1000
内存限制：262144
输入
第一行为两个正整数M 和N，代表内存容量和文章的长度。 第二行为N 个非负整数，按照文章的顺序，每个数（大小不超过1000000）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。 对于50%的数据，1<=N、M<=1000； 对于100%的数据，1<=N、M<=1000000。
输出
一个整数，为软件需要查词典的次数。
样例输入
3 7
1 2 1 5 4 4 1
样例输出
5
提示
整个查字典过程如下：每行表示一个单词的翻译，冒号前为本次翻译后的内存状况: 空：内存初始状态为空。 1． 1：查找单词1 并调入内存。 2． 1 2：查找单词2 并调入内存。 3． 1 2：在内存中找到单词1。 4． 1 2 5：查找单词5 并调入内存。 5． 2 5 4：查找单词4 并调入内存替代单词1。 6． 2 5 4：在内存中找到单词4。 7． 5 4 1：查找单词1 并调入内存替代单词2。 共计查了5 次词典。

下面是使用C语言编写的示例代码，实现计算翻译软件需要查词典的次数：

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

typedef struct {
    int word;
    int translation;
} MemoryUnit;

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

    int* words = (int*)malloc(N * sizeof(int));
    for (int i = 0; i < N; i++) {
        scanf("%d", &words[i]);
    }

    MemoryUnit* memory = (MemoryUnit*)malloc(M * sizeof(MemoryUnit));
    int memoryCount = 0;
    int dictionaryCount = 0;

    for (int i = 0; i < N; i++) {
        int currentWord = words[i];
        int found = 0;

        for (int j = 0; j < memoryCount; j++) {
            if (memory[j].word == currentWord) {
                found = 1;
                break;
            }
        }

        if (!found) {
            if (memoryCount < M) {
                memory[memoryCount].word = currentWord;
                memory[memoryCount].translation = 0;
                memoryCount++;
            } else {
                memory[0].word = currentWord;
                memory[0].translation = 0;
                dictionaryCount++;
            }
        }
    }

    printf("%d\n", dictionaryCount);

    free(words);
    free(memory);

    return 0;
}

代码中，我们使用动态数组words保存待翻译文章中的单词，使用动态数组memory保存内存中的词典单元。memory数组的每个元素是一个MemoryUnit结构体，包含word和translation字段，分别表示单词和译义。

我们使用memoryCount变量记录当前内存中已存入的单词数，使用dictionaryCount变量记录查词典的次数。

对于每个待翻译的单词，我们遍历内存中的词典单元，检查是否存在该单词，如果找到则表示无需查词典，如果未找到则需要进行查词典的操作。

当内存未满时，我们将新单词存入一个未使用的内存单元，并增加memoryCount；当内存已满时，我们将最早进入内存的单词替换为新单词，并增加dictionaryCount。

最后，我们输出dictionaryCount作为结果，表示翻译软件需要查词典的次数。

第3题：栈基本操作

依次读入序列元素1,2,…,n进栈，每进一个元素，机器可要求下一个元素进栈或弹栈，如此进行。给定一个输入序列，判断栈空时弹出的元素构成的序列是否可能等于给定的序列，如果是则输出栈的操作过程，否则输出“NO”。
时间限制：1000
内存限制：65535
输入
输入分两行 第一行为n的值（即序列元素个数） 第二行为给定的输入序列（序列元素均为整型）
输出
如果输入序列能够由题目规定的操作得到，则输出对栈的操作过程 否则直接输出“NO”
样例输入
7
4 5 3 6 2 7 1
样例输出
PUSH 1
PUSH 2
PUSH 3
PUSH 4
POP 4
PUSH 5
POP 5
POP 3
PUSH 6
POP 6
POP 2
PUSH 7
POP 7
POP 1
提示
给定序列中有可能有不在1…n之间的数字

下面是使用C语言编写的示例代码，实现栈的基本操作和判断输入序列是否可以通过栈操作得到：

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

typedef struct {
    int* elements;
    int top;
} Stack;

void initStack(Stack* stack, int size) {
    stack->elements = (int*)malloc(size * sizeof(int));
    stack->top = -1;
}

void push(Stack* stack, int element) {
    stack->top++;
    stack->elements[stack->top] = element;
}

int pop(Stack* stack) {
    int element = stack->elements[stack->top];
    stack->top--;
    return element;
}

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

    int* sequence = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &sequence[i]);
    }

    Stack stack;
    initStack(&stack, n);

    int current = 1;
    int sequenceIndex = 0;
    int possible = 1;

    while (sequenceIndex < n) {
        if (stack.top >= 0 && stack.elements[stack.top] == sequence[sequenceIndex]) {
            pop(&stack);
            printf("POP %d\n", sequence[sequenceIndex]);
            sequenceIndex++;
        } else if (current <= n) {
            push(&stack, current);
            printf("PUSH %d\n", current);
            current++;
        } else {
            possible = 0;
            break;
        }
    }

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

    free(sequence);
    free(stack.elements);

    return 0;
}

代码中，我们使用Stack结构体表示栈，其中elements是一个动态数组，用于保存栈中的元素，top表示栈顶的索引。

initStack函数用于初始化栈，分配内存并将栈顶初始化为-1。

push函数用于将元素压入栈中，栈顶指针加1，并将元素存入栈顶位置。

pop函数用于弹出栈顶的元素，返回栈顶元素的值，并将栈顶指针减1。

在main函数中，我们首先读入输入序列，并初始化一个大小为n的栈。

然后，我们使用current变量表示下一个要进栈的元素，使用sequenceIndex变量表示输入序列的当前位置，使用possible变量表示输入序列是否可由栈操作得到。

我们使用循环对输入序列进行处理，判断栈顶元素和当前输入序列位置的元素是否相等，如果相等，则执行弹栈操作，并将sequenceIndex加1；如果不相等，则执行压栈操作，并将current加1。

如果栈操作结束后，输入序列已全部处理完毕（sequenceIndex等于n），则说明输入序列可以由栈操作得到，将possible设为1；否则，将possible设为0。

最后，根据possible的值输出结果。如果输入序列可由栈操作得到，则输出栈的操作过程，否则输出"NO"。

第4题：双端队列

定义一个双端队列，进队操作与普通队列一样，从队尾进入。出队操作既可以从队头，也可以从队尾。编程实现这个数据结构。
时间限制：1000
内存限制：65535
输入
第一行输入一个整数t，代表测试数据的组数。 每组数据的第一行输入一个整数n，表示操作的次数。 接着输入n行，每行对应一个操作，首先输入一个整数type。 当type=1，进队操作，接着输入一个整数x，表示进入队列的元素。 当type=2，出队操作，接着输入一个整数c，c=0代表从队头出队，c=1代表从队尾出队。 n <= 1000
输出
对于每组测试数据，输出执行完所有的操作后队列中剩余的元素,元素之间用空格隔开，按队头到队尾的顺序输出，占一行。如果队列中已经没有任何的元素，输出NULL。
样例输入
2
5
1 2
1 3
1 4
2 0
2 1
6
1 1
1 2
1 3
2 0
2 1
2 0
样例输出
3
NULL

下面是一个使用C语言编写的双端队列的实现，满足题目的要求：

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

#define MAX_SIZE 1000

typedef struct {
    int data[MAX_SIZE];
    int front; // 队头指针
    int rear;  // 队尾指针
} Deque;

void initDeque(Deque* deque) {
    deque->front = -1; // 初始化队头指针为-1
    deque->rear = -1;  // 初始化队尾指针为-1
}

int isDequeEmpty(Deque* deque) {
    return deque->front == -1; // 如果队头指针为-1，表示队列为空
}

int isDequeFull(Deque* deque) {
    return (deque->front == 0 && deque->rear == MAX_SIZE - 1) || (deque->front == deque->rear + 1);
    // 如果队头指针在队尾指针之前一个位置，或者队头指针在队尾指针之后一个位置，表示队列已满
}

void enqueueFront(Deque* deque, int x) {
    if (isDequeFull(deque)) {
        printf("Deque is full. Cannot enqueue.\n");
        return;
    }

    if (deque->front == -1) {
        deque->front = 0;
        deque->rear = 0;
    } else if (deque->front == 0) {
        deque->front = MAX_SIZE - 1;
    } else {
        deque->front--;
    }

    deque->data[deque->front] = x; // 将元素放入队头位置
}

void enqueueRear(Deque* deque, int x) {
    if (isDequeFull(deque)) {
        printf("Deque is full. Cannot enqueue.\n");
        return;
    }

    if (deque->front == -1) {
        deque->front = 0;
        deque->rear = 0;
    } else if (deque->rear == MAX_SIZE - 1) {
        deque->rear = 0;
    } else {
        deque->rear++;
    }

    deque->data[deque->rear] = x; // 将元素放入队尾位置
}

int dequeueFront(Deque* deque) {
    if (isDequeEmpty(deque)) {
        printf("Deque is empty. Cannot dequeue.\n");
        return -1;
    }

    int x = deque->data[deque->front]; // 获取队头元素的值

    if (deque->front == deque->rear) {
        deque->front = -1; // 如果队列中只有一个元素，出队后将队头指针重置为-1
        deque->rear = -1;  // 如果队列中只有一个元素，出队后将队尾指针重置为-1
    } else if (deque->front == MAX_SIZE - 1) {
        deque->front = 0; // 如果队头指针在队尾指针之前一个位置，出队后将队头指针移到队头位置
    } else {
        deque->front++; // 队头指针向后移动一位
    }

    return x; // 返回出队的元素值
}

int dequeueRear(Deque* deque) {
    if (isDequeEmpty(deque)) {
        printf("Deque is empty. Cannot dequeue.\n");
        return -1;
    }

    int x = deque->data[deque->rear]; // 获取队尾元素的值

    if (deque->front == deque->rear) {
        deque->front = -1; // 如果队列中只有一个元素，出队后将队头指针重置为-1
        deque->rear = -1;  // 如果队列中只有一个元素，出队后将队尾指针重置为-1
    } else if (deque->rear == 0) {
        deque->rear = MAX_SIZE - 1; // 如果队尾指针在队头指针之后一个位置，出队后将队尾指针移到队尾位置
    } else {
        deque->rear--; // 队尾指针向前移动一位
    }

    return x; // 返回出队的元素值
}

void printDeque(Deque* deque) {
    if (isDequeEmpty(deque)) {
        printf("NULL\n");
        return;
    }

    int i;

    if (deque->front <= deque->rear) {
        for (i = deque->front; i <= deque->rear; i++) {
            printf("%d ", deque->data[i]);
        }
    } else {
        for (i = deque->front; i < MAX_SIZE; i++) {
            printf("%d ", deque->data[i]);
        }
        for (i = 0; i <= deque->rear; i++) {
            printf("%d ", deque->data[i]);
        }
    }

    printf("\n");
}

int main() {
    int t, n, i, type, x, c;

    scanf("%d", &t);

    while (t--) {
        Deque deque;
        initDeque(&deque);

        scanf("%d", &n);

        for (i = 0; i < n; i++) {
            scanf("%d", &type);

            if (type == 1) {
                scanf("%d", &x);
                enqueueRear(&deque, x);
            } else if (type == 2) {
                scanf("%d", &c);

                if (c == 0) {
                    dequeueFront(&deque);
                } else if (c == 1) {
                    dequeueRear(&deque);
                }
            }
        }

        printDeque(&deque);
    }

    return 0;
}

这个程序定义了一个双端队列的数据结构，并实现了进队和出队的操作。在主函数中，首先读取测试数据的组数t，然后对于每组数据，读取操作的次数n。接下来，根据操作类型进行进队或出队操作，最后打印队列中剩余的元素。

请注意，这个程序假设输入的数据是有效的，即不会出现在空队列中进行出队操作的情况。在实际应用中，可能需要添加更多的错误处理逻辑来确保程序的稳定性。另外，由于题目要求输出的格式是以空格分隔的元素列表，所以在输出时需要注意最后一个元素后面不要输出多余的空格。

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

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

相关文章

百万级并发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通信协议解决了通过串行线路在电子设备之间发送信息的问题。该协议在遵循该协议的体系结构中实现主…
阅读更多...
网络分层的真实含义

网络分层的真实含义

复杂的程序都要分层&#xff0c;这是程序设计的要求。比如&#xff0c;复杂的电商还会分数据库层、缓存层、Compose 层、Controller 层和接入层&#xff0c;每一层专注做本层的事情。 当一个网络包从一个网口经过的时候&#xff0c;你看到了&#xff0c;首先先看看要不要请进来…
阅读更多...
如何进行微服务测试？一文4个知识点带入门微服务测试！

如何进行微服务测试？一文4个知识点带入门微服务测试！

关注留言点赞&#xff0c;带你了解最流行的软件开发知识与最新科技行业趋势。 本文将讨论微服务测试的重要性、挑战和最佳实践。 微服务架构是一种越来越流行的构建复杂分布式系统的方法。在此体系结构中&#xff0c;大型应用程序被分成较小的、独立的服务&#xff0c;这些服务…
阅读更多...
uniapp 实现滑动元素删除效果

uniapp 实现滑动元素删除效果

官网地址&#xff1a;uni-app官网 (dcloud.net.cn) 最终效果如下图&#xff1a; 滑动删除需要用到 uni-ui 的 uni-swipe-action 组件和 uni-swipe-action-item 属性名类型可选值默认值是否必填说明left-optionsArray/Object--否左侧选项内容及样式right-optionsArray/Object--…
阅读更多...
算法通关村第10关【黄金】| 归并排序

算法通关村第10关【黄金】| 归并排序

归并排序&#xff08;Merge Sort&#xff09;是一种常见的基于比较的排序算法&#xff0c;它的主要思想是分而治之&#xff08;Divide and Conquer&#xff09;。它的核心思想是将一个大的问题分解为小的子问题&#xff0c;解决子问题&#xff0c;然后将它们合并&#xff08;me…
阅读更多...
【论文阅读】Pay Attention to MLPs

【论文阅读】Pay Attention to MLPs

作者&#xff1a;Google Research, Brain Team 泛读&#xff1a;只关注其中cv的论述 提出了一个简单的网络架构&#xff0c;gMLP&#xff0c;基于门控的MLPs&#xff0c;并表明它可以像Transformers一样在关键语言和视觉应用中发挥作用 提出了一个基于MLP的没有self-attentio…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023