Table des matières
1. Exigences expérimentales
Au cours du processus d'enseignement, l'enseignant testera souvent l'apprentissage des élèves sous la forme d'épreuves. C'est maintenant à vous d'aider l'enseignant à concevoir un système de génération automatique de feuilles de test pour compléter l'extraction aléatoire du livre de sujets spécifié à partir de la banque de questions existante (la banque de questions contient 2 fichiers, 1 est un fichier de banque de questions à choix multiples et 1 est un fichier de banque de questions à remplir) Un nouveau test papier. Il n'y a que 2 types de questions dans le papier de test généré par le système : les questions à choix multiples et les questions à remplir (un seul blanc). Parmi elles,
les questions à choix unique incluent le numéro de la question, la question, l'option A, l'option B, l'option C, l'option D et la réponse Les questions à remplir
incluent le numéro de la question, la question et la réponse
Fonctions :
(1) Question de test ajout : ajoutez une nouvelle question à la banque de questions du test, le numéro de la question doit être généré automatiquement et non dupliqué avec le numéro de la question existante ; tout le contenu ne peut pas être vide. C'est-à-dire pour enrichir en permanence la banque de questions ;
(2) Suppression des questions du test : supprimez les questions via le numéro de la question. Si la suppression est réussie, il indiquera que la suppression a réussi, sinon il indiquera que la suppression a échoué ; ( 3) Sauvegarder
toutes les questions ;
(4) Supprimer toutes les questions ;
(5) Tester les questions Modifier : recherchez le sujet correspondant grâce au numéro de sujet et modifiez le contenu du sujet spécifié. Notez qu'il ne s'agit pas de modifier l'ensemble contenu du sujet, mais pour modifier une partie du contenu de manière ciblée ; (6) Requête de question : interrogez tout le contenu du sujet spécifié via le numéro de sujet Contenu ; (7) Comptez le nombre de questions qu'il y a ;
(
8
) Interroger toutes les questions qui contiennent un contenu spécifique (saisi par l'utilisateur) dans le titre
; Il existe 2 fichiers de réponses standard (exam.txt et answer.txt), et le nombre de questions pour chaque type de question est saisi par l'utilisateur. Notez que le nombre de questions pour les questions à choix multiples et les questions à remplir peut être différent ; il est nécessaire que les questions et l'ordre des épreuves générées à chaque fois ne puissent pas être exactement les mêmes. C'est-à-dire qu'une véritable extraction aléatoire des questions est nécessaire.
(10) Les fonctions ci-dessus doivent être utilisées via le menu ; les contrôles de légalité nécessaires sont requis pour le contenu correspondant. Cette question doit être implémentée avec une liste chaînée. Nécessite une bonne interface d'interaction homme-machine. Pour chaque type de question, au moins 10 questions doivent être saisies au préalable.
2. Affichage des menus
3. Code complet
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 选择题结构体
typedef struct ChoiceQuestion {
int id; // 题目编号
char question[1000]; // 题目
char optionA[200]; // 选项A
char optionB[200]; // 选项B
char optionC[200]; // 选项C
char optionD[200]; // 选项D
char answer; // 答案
} ChoiceQuestion;
// 填空题结构体
typedef struct FillQuestion {
int id; // 题目编号
char question[1000]; // 题目
char answer[50]; // 答案
} FillQuestion;
// 选择题链表结点
typedef struct ChoiceNode {
ChoiceQuestion data; // 选择题数据
struct ChoiceNode *next; // 下一个选择题结点
} ChoiceNode;
// 填空题链表结点
typedef struct FillNode {
FillQuestion data; // 填空题数据
struct FillNode *next; // 下一个填空题结点
} FillNode;
// 选择题链表
typedef struct ChoiceList {
ChoiceNode *head; // 选择题链表头结点
ChoiceNode *tail; // 选择题链表尾结点
int size; // 选择题链表中的结点数
} ChoiceList;
// 填空题链表
typedef struct FillList {
FillNode *head; // 填空题链表头结点
FillNode *tail; // 填空题链表尾结点
int size; // 填空题链表中的结点数
} FillList;
// 创建选择题链表
ChoiceList *createChoiceList() {
ChoiceList *list = malloc(sizeof(ChoiceList));
list->head = list->tail = NULL;
list->size = 0;
return list;
}
// 创建填空题链表
FillList *createFillList() {
FillList *list = malloc(sizeof(FillList));
list->head = list->tail = NULL;
list->size = 0;
return list;
}
ChoiceList *readChoiceQuestionFile(const char *fileName, ChoiceList *list) {
FILE *fp = fopen(fileName, "r");
if (fp == NULL) {
printf("文件打开失败\n");
return list;
}
while (!feof(fp)) {
ChoiceQuestion question;
int readNum = fscanf(fp, "%d %s %s %s %s %s %s", &question.id, question.question, question.optionA, question.optionB,
question.optionC, question.optionD, &question.answer);
if (readNum != 7) {
break;
}
ChoiceNode *node = malloc(sizeof(ChoiceNode));
node->data = question;
node->next = NULL;
if (list->tail == NULL) {
list->head = list->tail = node;
} else {
list->tail->next = node;
list->tail = node;
}
list->size++;
}
fclose(fp);
return list;
}
FillList *readFillQuestionFile(const char *fileName, FillList *list) {
FILE *fp = fopen(fileName, "r");
if (fp == NULL) {
printf("文件打开失败\n");
return list;
}
while (!feof(fp)) {
FillQuestion question;
int readNum = fscanf(fp, "%d %s %s", &question.id, question.question, question.answer);
if (readNum != 3) {
break;
}
FillNode *node = malloc(sizeof(FillNode));
node->data = question;
node->next = NULL;
if (list->tail == NULL) {
list->head = list->tail = node;
} else {
list->tail->next = node;
list->tail = node;
}
list->size++;
}
fclose(fp);
return list;
}
ChoiceNode *findChoiceNode(ChoiceList *list, int index) {
if (index < 0 || index >= list->size) {
return NULL;
}
ChoiceNode *node = list->head;
int i;
for (i = 0; i < index; i++) {
node = node->next;
}
return node;
}
void swapChoiceNodes(ChoiceList *list, int i, int j) {
if (i < 0 || i >= list->size || j < 0 || j >= list->size) {
return;
}
// 如果i和j相等，则不用交换
if (i == j) {
return;
}
// 查找结点i和结点j
ChoiceNode *nodeI = findChoiceNode(list, i);
ChoiceNode *nodeJ = findChoiceNode(list, j);
// 交换结点i和结点j的数据
ChoiceQuestion temp = nodeI->data;
nodeI->data = nodeJ->data;
nodeJ->data = temp;
}
FillNode *findFillNode(FillList *list, int index) {
if (index < 0 || index >= list->size) {
return NULL;
}
FillNode *node = list->head;
int i;
for (i = 0; i < index; i++) {
node = node->next;
}
return node;
}
void swapFillNodes(FillList *list, int i, int j) {
if (i < 0 || i >= list->size || j < 0 || j >= list->size) {
return;
}
// 如果i和j相等，则不用交换
if (i == j) {
return;
}
// 查找结点i和结点j
FillNode *nodeI = findFillNode(list, i);
FillNode *nodeJ = findFillNode(list, j);
// 交换结点i和结点j的数据
FillQuestion temp = nodeI->data;
nodeI->data = nodeJ->data;
nodeJ->data = temp;
}
void shuffleChoiceQuestions(ChoiceList *list) {
int i;
for (i = 0; i < list->size; i++) {
int j = rand() % list->size;
// 交换结点i和结点j的位置
swapChoiceNodes(list, i, j);
}
}
void shuffleFillQuestions(FillList *list) {
int i;
for (i = 0; i < list->size; i++) {
int j = rand() % list->size;
// 交换结点i和结点j的位置
swapFillNodes(list, i, j);
}
}
void generateExam(ChoiceList *choiceList, FillList *fillList, int choiceNum, int fillNum) {
// 随机打乱选择题和填空题的顺序
shuffleChoiceQuestions(choiceList);
shuffleFillQuestions(fillList);
// 将选择题和填空题写入试卷
FILE *examFile = fopen("exam.txt", "w");
if (examFile == NULL) {
printf("试卷文件打开失败\n");
return;
}
int i;
int number = 1;
// 将选择题和填空题写入试卷
ChoiceNode *choiceNode = choiceList->head;
for (i = 0; i < choiceNum; i++) {
fprintf(examFile, "%d. %s ", number++, choiceNode->data.question);
fprintf(examFile, "A. %s ", choiceNode->data.optionA);
fprintf(examFile, "B. %s ", choiceNode->data.optionB);
fprintf(examFile, "C. %s ", choiceNode->data.optionC);
fprintf(examFile, "D. %s\n", choiceNode->data.optionD);
choiceNode = choiceNode->next;
}
FillNode *fillNode = fillList->head;
for (i = 0; i < fillNum; i++) {
fprintf(examFile, "%d. %s\n", number++, fillNode->data.question);
fillNode = fillNode->next;
}
fclose(examFile);
// 将标准答案写入标准答案文件
FILE *answerFile = fopen("answer.txt", "w");
if (answerFile == NULL) {
printf("标准答案文件打开失败\n");
return;
}
choiceNode = choiceList->head;
for (i = 0; i < choiceNum; i++) {
fprintf(answerFile, "%c\n", choiceNode->data.answer);
choiceNode = choiceNode->next;
}
fillNode = fillList->head;
for (i = 0; i < fillNum; i++) {
fprintf(answerFile, "%s\n", fillNode->data.answer);
fillNode = fillNode->next;
}
fclose(answerFile);
}
void addChoiceQuestion(ChoiceList *list, ChoiceQuestion question) {
// 寻找下一个可用的序号
int currentIndex = 1; // 声明并初始化当前序号
while (findChoiceNode(list, currentIndex) != NULL) {
currentIndex++;
}
currentIndex++;
question.id = currentIndex; // 将当前序号赋值给题目的序号
// 打开choice_questions.txt文件
FILE *choiceFile = fopen("choice_questions.txt", "a");
if (choiceFile == NULL) {
printf("打开choice_questions.txt文件失败\n");
return;
}
// 将新的题目写入choice_questions.txt文件
fprintf(choiceFile, "\n%d %s", question.id, question.question);
fprintf(choiceFile, " %s", question.optionA);
fprintf(choiceFile, " %s", question.optionB);
fprintf(choiceFile, " %s", question.optionC);
fprintf(choiceFile, " %s", question.optionD);
fprintf(choiceFile, " %c", question.answer);
// 关闭choice_questions.txt文件
fclose(choiceFile);
// 创建新的选择题结点
ChoiceNode *newNode = malloc(sizeof(ChoiceNode));
newNode->data = question;
newNode->next = NULL;
// 将新结点插入链表末尾
if (list->tail == NULL) {
list->head = list->tail = newNode;
} else {
list->tail->next = newNode;
list->tail = newNode;
}
// 更新链表大小
list->size++;
}
void addFillQuestion(FillList *list, FillQuestion question) {
// 声明并初始化当前序号
int currentIndex = 1;
// 寻找下一个可用的序号
while (findFillNode(list, currentIndex) != NULL) {
currentIndex++;
}
question.id = currentIndex; // 将当前序号赋值给题目的序号
// 打开fill_questions.txt文件
FILE *file = fopen("fill_questions.txt", "a");
if (file == NULL) {
printf("文件打开失败\n");
return;
}
// 将新题目写入文件
fprintf(file, "%d %s %s\n", question.id, question.question, question.answer);
// 关闭文件
fclose(file);
// 创建新的填空题结点
FillNode *newNode = malloc(sizeof(FillNode));
newNode->data = question;
newNode->next = NULL;
// 将新结点插入链表末尾
if (list->tail == NULL) {
list->head = list->tail = newNode;
} else {
list->tail->next = newNode;
list->tail = newNode;
}
// 更新链表大小
list->size++;
}
void deleteChoiceQuestion(ChoiceList *list, int id) {
ChoiceNode *prev = NULL;
ChoiceNode *curr = list->head;
// 遍历链表，找到要删除的选择题结点
while (curr != NULL && curr->data.id != id) {
prev = curr;
curr = curr->next;
}
// 如果找到了要删除的结点
if (curr != NULL) {
// 如果要删除的结点是第一个结点
if (prev == NULL) {
list->head = curr->next;
} else {
prev->next = curr->next;
}
// 如果要删除的结点是最后一个结点
if (curr->next == NULL) {
list->tail = prev;
}
free(curr);
list->size--;
printf("删除成功\n");
} else {
printf("删除失败，没有找到题目编号为 %d 的选择题\n", id);
}
}
void deleteFillQuestion(FillList *list, int id) {
FillNode *prev = NULL;
FillNode *curr = list->head;
// 遍历链表，找到要删除的填空题结点
while (curr != NULL && curr->data.id != id) {
prev = curr;
curr = curr->next;
}
// 如果找到了要删除的填空题结点
if (curr != NULL) {
// 如果要删除的是链表的第一个结点
if (prev == NULL) {
list->head = curr->next;
} else {
prev->next = curr->next;
}
// 如果要删除的是链表的最后一个结点
if (curr == list->tail) {
list->tail = prev;
}
list->size--;
free(curr);
printf("填空题删除成功\n");
} else {
printf("填空题删除失败\n");
}
}
void backupQuestions(ChoiceList *choiceList, FillList *fillList) {
// 备份选择题
FILE *choiceFp = fopen("choice_questions_backup.txt", "w");
if (choiceFp == NULL) {
printf("打开选择题备份文件失败\n");
return;
}
ChoiceNode *curr = choiceList->head;
while (curr != NULL) {
fprintf(choiceFp, "%d %s %s %s %s %s %c\n",
curr->data.id, curr->data.question, curr->data.optionA, curr->data.optionB,
curr->data.optionC, curr->data.optionD, curr->data.answer);
curr = curr->next;
}
fclose(choiceFp);
// 备份填空题
FILE *fillFp = fopen("fill_questions_backup.txt", "w");
if (fillFp == NULL) {
printf("打开填空题备份文件失败\n");
return;
}
FillNode *curr2 = fillList->head;
while (curr2 != NULL) {
fprintf(fillFp, "%d %s %s\n", curr2->data.id, curr2->data.question, curr2->data.answer);
curr2 = curr2->next;
}
fclose(fillFp);
}
void deleteAllQuestions(ChoiceList *choiceList, FillList *fillList) {
// 删除选择题链表中的所有结点
ChoiceNode *curr = choiceList->head;
while (curr != NULL) {
ChoiceNode *temp = curr;
curr = curr->next;
free(temp);
}
choiceList->head = choiceList->tail = NULL;
choiceList->size = 0;
// 删除填空题链表中的所有结点
FillNode *curr2 = fillList->head;
while (curr2 != NULL) {
FillNode *temp = curr2;
curr2 = curr2->next;
free(temp);
}
fillList->head = fillList->tail = NULL;
fillList->size = 0;
}
void updateChoiceQuestion(ChoiceList *list, int id, char *question, char *optionA, char *optionB, char *optionC, char *optionD, char answer) {
// 找到要修改的选择题结点
ChoiceNode *node = findChoiceNode(list, id);
if (node == NULL) {
printf("未找到要修改的选择题\n");
return;
}
// 修改题目信息
if (strcmp(question, "-") != 0) {
strcpy(node->data.question, question);
}
if (strcmp(optionA, "-") != 0) {
strcpy(node->data.optionA, optionA);
}
if (strcmp(optionB, "-") != 0) {
strcpy(node->data.optionB, optionB);
}
if (strcmp(optionC, "-") != 0) {
strcpy(node->data.optionC, optionC);
}
if (strcmp(optionD, "-") != 0) {
strcpy(node->data.optionD, optionD);
}
if (answer != '-') {
node->data.answer = answer;
}
// 打开choice_questions.txt文件
FILE *file = fopen("choice_questions.txt", "w");
if (file == NULL) {
printf("文件打开失败\n");
return;
}
// 将所有选择题写入文件
ChoiceNode *curr = list->head;
while (curr != NULL) {
fprintf(file, "%d %s %s %s %s %s %c\n", curr->data.id, curr->data.question, curr->data.optionA,
curr->data.optionB, curr->data.optionC, curr->data.optionD, curr->data.answer);
curr = curr->next;
}
// 关闭文件
fclose(file);
}
void updateFillQuestion(FillList *list, int id, char *question, char *answer) {
FillNode *curr = list->head;
// 遍历链表，找到要修改的填空题结点
while (curr != NULL && curr->data.id != id) {
curr = curr->next;
}
// 如果没有找到，提示错误
if (curr == NULL) {
printf("没有找到编号为%d的填空题\n", id);
return;
}
// 更新题目
if (question != NULL) {
strcpy(curr->data.question, question);
}
// 更新答案
if (answer != NULL) {
strcpy(curr->data.answer, answer);
}
// 打开choice_questions.txt文件
FILE *file = fopen("choice_questions.txt", "w");
if (file == NULL) {
printf("文件打开失败\n");
return;
}
// 将所有填空题写入文件
while (curr != NULL) {
fprintf(file, "%d %s %s\n", curr->data.id, curr->data.question, curr->data.answer);
curr = curr->next;
}
// 关闭文件
fclose(file);
}
void queryChoiceQuestion(ChoiceList *list, int id) {
ChoiceNode *curr = list->head;
// 遍历链表，找到要查询的选择题结点
while (curr != NULL && curr->data.id != id) {
curr = curr->next;
}
// 如果没有找到，提示错误
if (curr == NULL) {
printf("没有找到编号为%d的选择题\n", id);
return;
}
// 打印题目内容
printf("编号: %d\n", curr->data.id);
printf("题目: %s\n", curr->data.question);
printf("选项A: %s\n", curr->data.optionA);
printf("选项B: %s\n", curr->data.optionB);
printf("选项C: %s\n", curr->data.optionC);
printf("选项D: %s\n", curr->data.optionD);
printf("正确答案: %c\n", curr->data.answer);
}
void queryFillQuestion(FillList *list, int id) {
FillNode *curr = list->head;
// 遍历链表，找到要查询的填空题结点
while (curr != NULL && curr->data.id != id) {
curr = curr->next;
}
// 如果没有找到，提示错误
if (curr == NULL) {
printf("没有找到编号为%d的填空题\n", id);
return;
}
// 打印题目内容
printf("编号: %d\n", curr->data.id);
printf("题目: %s\n", curr->data.question);
printf("答案: %s\n", curr->data.answer);
}
int countChoiceQuestions(ChoiceList *list) {
int count = 0;
ChoiceNode *curr = list->head;
while (curr != NULL) {
count++;
curr = curr->next;
}
return count;
}
int countFillQuestions(FillList *list) {
int count = 0;
FillNode *curr = list->head;
while (curr != NULL) {
count++;
curr = curr->next;
}
return count;
}
void printChoiceQuestion(const ChoiceQuestion *question) {
// 打印题目
printf("%d. %s\n", question->id, question->question);
// 打印选项
printf("A. %s\n", question->optionA);
printf("B. %s\n", question->optionB);
printf("C. %s\n", question->optionC);
printf("D. %s\n", question->optionD);
// 打印答案
printf("Answer: %c\n", question->answer);
}
void printFillQuestion(const FillQuestion *question) {
// 打印题目
printf("%d. %s\n", question->id, question->question);
// 打印答案
printf("Answer: %s\n", question->answer);
}
void queryQuestionsByContent(const ChoiceList *choiceList, const FillList *fillList, const char *content) {
// 遍历选择题链表，查找含有content的选择题
ChoiceNode *currChoice = choiceList->head;
while (currChoice != NULL) {
if (strstr(currChoice->data.question, content) != NULL ||
strstr(currChoice->data.optionA, content) != NULL ||
strstr(currChoice->data.optionB, content) != NULL ||
strstr(currChoice->data.optionC, content) != NULL ||
strstr(currChoice->data.optionD, content) != NULL) {
// 如果找到了，就打印这道题
printChoiceQuestion(&currChoice->data);
}
currChoice = currChoice->next;
}
// 遍历填空题链表，查找含有content的填空题
FillNode *currFill = fillList->head;
while (currFill != NULL) {
if (strstr(currFill->data.question, content) != NULL ||
strstr(currFill->data.answer, content) != NULL) {
// 如果找到了，就打印这道题
printFillQuestion(&currFill->data);
}
currFill = currFill->next;
}
}
void printMenu(){
printf("\n\n\n");
printf("\t\t\t====================================\n");
printf("\t\t\t| |\n");
printf("\t\t\t| 试 卷 系 统 |\n");
printf("\t\t\t| |\n");
printf("\t\t\t===================================\n");
printf("\t\t\t| |\n");
printf("\t\t\t| 1. 添加选择题 |\n");
printf("\t\t\t| 2. 删除选择题 |\n");
printf("\t\t\t| 3. 添加填空题 |\n");
printf("\t\t\t| 4. 删除填空题 |\n");
printf("\t\t\t| 5. 备份全部题目 |\n");
printf("\t\t\t| 6. 删除全部题目 |\n");
printf("\t\t\t| 7. 修改选择题 |\n");
printf("\t\t\t| 8. 修改填空题 |\n");
printf("\t\t\t| 9. 查询选择题 |\n");
printf("\t\t\t|10. 查询填空题 |\n");
printf("\t\t\t|11. 统计共有多少道题目 |\n");
printf("\t\t\t|12. 查询题目中含有特定内容的所有题目内容 |\n");
printf("\t\t\t|13.生成试卷 |\n");
printf("\t\t\t| 0.退出系统 |\n");
printf("\t\t\t====================================\n");
printf("\t\t\t请选择操作(输入0~13):");
}
int main() {
ChoiceList *choiceList = createChoiceList();
FillList *fillList = createFillList();
// 从文件中读取选择题和填空题
choiceList = readChoiceQuestionFile("choice_questions.txt", choiceList);
fillList = readFillQuestionFile("fill_questions.txt", fillList);
int choice;
int id;
int type;
int choiceNum;
int fillNum;
char content[100];
ChoiceQuestion choiceQuestion;
FillQuestion fillQuestion;
while (1) {
char question[100];
char optionA[100];
char optionB[100];
char optionC[100];
char optionD[100];
char answer[100];
char answerChoice;
// 打印菜单
printMenu();
printf("请输入您要进行的操作:");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("请输入要添加的选择题的题目内容:");
scanf("%s", choiceQuestion.question);
printf("请输入要添加的选择题的选项A:");
scanf("%s", choiceQuestion.optionA);
printf("请输入要添加的选择题的选项B:");
scanf("%s", choiceQuestion.optionB);
printf("请输入要添加的选择题的选项C:");
scanf("%s", choiceQuestion.optionC);
printf("请输入要添加的选择题的选项D:");
scanf("%s", choiceQuestion.optionD);
printf("请输入要添加的选择题的答案:");
scanf(" %c", &choiceQuestion.answer);
addChoiceQuestion(choiceList, choiceQuestion);
break;
case 2:
printf("请输入要删除的选择题的题目编号:");
scanf("%d", &id);
deleteChoiceQuestion(choiceList, id);
break;
case 3:
printf("请输入要添加的填空题的题目内容:");
scanf("%s", fillQuestion.question);
printf("请输入要添加的填空题的答案:");
scanf("%s", fillQuestion.answer);
addFillQuestion(fillList, fillQuestion);
break;
case 4:
printf("请输入要删除的填空题的题目编号:");
scanf("%d", &id);
deleteFillQuestion(fillList, id);
break;
case 5:
backupQuestions(choiceList, fillList);
break;
case 6:
deleteAllQuestions(choiceList, fillList);
break;
case 7:
printf("请输入要修改的选择题的题目编号:");
scanf("%d", &id);
printf("请输入要修改的选择题的题目内容(输入'-'表示不修改):");
scanf("%s", question);
printf("请输入要修改的选择题的选项A(输入'-'表示不修改):");
scanf("%s", optionA);
printf("请输入要修改的选择题的选项B(输入'-'表示不修改):");
scanf("%s", optionB);
printf("请输入要修改的选择题的选项C(输入'-'表示不修改):");
scanf("%s", optionC);
printf("请输入要修改的选择题的选项D(输入'-'表示不修改):");
scanf("%s", optionD);
printf("请输入要修改的选择题的正确答案(输入'-'表示不修改):");
scanf(" %c", &answerChoice);
updateChoiceQuestion(choiceList, id, question, optionA, optionB, optionC, optionD, answerChoice);
break;
case 8:
printf("请输入要修改的填空题的题目编号:");
scanf("%d", &id);
printf("请输入要修改的填空题的题目内容(输入'-'表示不修改):");
scanf("%s", question);
printf("请输入要修改的填空题的答案(输入'-'表示不修改):");
scanf("%s", answer);
updateFillQuestion(fillList, id, question, answer);
break;
case 9:
printf("请输入要查询的选择题的题目编号:");
scanf("%d", &id);
queryChoiceQuestion(choiceList, id);
break;
case 10:
printf("请输入要查询的填空题的题目编号:");
scanf("%d", &id);
queryFillQuestion(fillList, id);
break;
case 11:
printf("请输入要统计的题目的类型(0表示选择题，1表示填空题):");
scanf("%d", &type);
if (type == 0) {
printf("共有%d道选择题\n", countChoiceQuestions(choiceList));
} else if (type == 1) {
printf("共有%d道填空题\n", countFillQuestions(fillList));
} else {
printf("输入的类型错误\n");
}
break;
case 12:
printf("请输入要查询的题目中含有的特定内容:");
scanf("%s", content);
queryQuestionsByContent(choiceList, fillList, content);
break;
case 13:
printf("请输入选择题的数量:\n");
scanf("%d", &choiceNum);
printf("请输入填空题的数量:\n");
scanf("%d", &fillNum);
generateExam(choiceList, fillList, choiceNum, fillNum);
break;
case 0:
printf("退出系统\n");
exit(0);
break;
default:
printf("输入的操作编号有误\n");
break;
}
}
}
Résumer
Pour des explications détaillées des fonctions et des idées générales, veuillez consulter mon autre article :
[Expérience de programmation en langage C] Système de gestion des épreuves d'examen (code complet + fonctions détaillées)
Ce qui précède est le contenu de cette expérience. Un système simple de papier test a été mis en place, qui contient une série de fonctions pour gérer et générer des papiers test. Si vous l'aimez, n'oubliez pas d'aimer, de suivre et de mettre en signet. Merci pour la navigation.
Collection de fichiers d'expérience
Cliquez ici pour obtenir directement le fichier d'expérience . Si c'est utile, vous pouvez aimer, collecter et suivre, merci.