求大佬写一下第七题，谢谢

啊啊啊空空

题目二：先做一菜单，菜单格式如下：
*********
请选择运算符：
加法运算，请按1；
减法运算，请按2；
乘法运算，请按3；
除法运算，请按4；
*****
程序要求：先显示菜单，客户选择1-4中任意一个数字，就做相应的计算。然后要求客户输入两个数，运算出结果。比如客户选择了...
在题目二的基础上进行改进。程序要求：先显示菜单，客户选择了数字，就做相应的计算。然后系统随机产生两个整数，列出式子，要求客户写出答案，最后系统判断客户答题是否正确，正确显示“你很棒，加油！”，错误显示“很遗憾！”。比如客户选择了2，系统就随机产生一个式子（例23-12＝），然后要求客户做减法。                                                    在题目三的基础上进行改进。客户做完一题后，询问客户是否继续答题（继续请输入Y，退出请输入N）。如客户选择继续答题，就重复显题目四，否则退出。
即用户可以循环做答，直到其输入N.
在题目四的基础上进行改进。客户做完多道题目后，可以查询最近十道题的答题情况（如没有做到十道题，就显示全部的题目）。查询显示结果的格式如下：
2＊3＝6正确
2＊4＝7错误
提示：要用到数组
6、在题目五的基础上进行改进。 客户做完多道题目后(题目的数量是不确定的，不能使用数组)，可以查询所有的答题情况。
提示：要用到链表
7、在题目六的基础上进行改进。 客户可以任何时候都可以查询所有的答题情况(包括重启电脑后)。

啊啊啊空空

大佬，尽量简化一下，谢谢了，用c语言做，真的太感谢了，求大佬解答

人造人

1. sh-5.1$ cat main.c
   
2. #include "list.h"
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <time.h>
   
6. 
   
7. typedef struct {
   
8.     char ch;
   
9.     int (*func)(int a, int b);
   
10.     size_t index;
    
11. } op_t;
    
12. 
    
13. typedef struct {
    
14.     int a, b, c;
    
15.     op_t op;
    
16. } exp_t;
    
17. 
    
18. int add(int a, int b) {return a + b;}
    
19. int sub(int a, int b) {return a - b;}
    
20. int mul(int a, int b) {return a * b;}
    
21. int div_(int a, int b) {return a / b;}
    
22. 
    
23. op_t op_table[] = {{'+', add, 0}, {'-', sub, 1}, {'*', mul, 2}, {'/', div_, 3}};
    
24. 
    
25. void menu(void) {
    
26.     puts("*********");
    
27.     puts("请选择运算符：");
    
28.     puts("加法运算，请按1；");
    
29.     puts("减法运算，请按2；");
    
30.     puts("乘法运算，请按3；");
    
31.     puts("除法运算，请按4；");
    
32.     puts("历史记录，请按5；");
    
33.     puts("退出程序，请按0；");
    
34.     puts("*********");
    
35. }
    
36. 
    
37. void history(const list_t *list) {
    
38.     for(size_t i = 0; i < list_size(list); ++i) {
    
39.         exp_t e; list_get(list, i, &e, sizeof(e));
    
40.         printf("%d%c%d=%d", e.a, e.op.ch, e.b, e.c);
    
41.         if(e.c == e.op.func(e.a, e.b)) puts("正确");
    
42.         else puts("错误");
    
43.     }
    
44. }
    
45. 
    
46. list_t *read_history(const char *filename) {
    
47.     list_t *list = list_init();
    
48.     FILE *fp = fopen(filename, "rb");
    
49.     if(!fp) return list;
    
50.     size_t size; fread(&size, 1, sizeof(size), fp);
    
51.     for(size_t i = 0; i < size; ++i) {
    
52.         exp_t e; fread(&e, 1, sizeof(e), fp);
    
53.         e.op = op_table[e.op.index];
    
54.         list_append(list, &e, sizeof(e));
    
55.     }
    
56.     fclose(fp);
    
57.     return list;
    
58. }
    
59. 
    
60. void save_history(const list_t *list, const char *filename) {
    
61.     FILE *fp = fopen(filename, "wb");
    
62.     if(!fp) return;
    
63.     size_t size = list_size(list);
    
64.     fwrite(&size, 1, sizeof(size), fp);
    
65.     for(size_t i = 0; i < size; ++i) {
    
66.         exp_t e; list_get(list, i, &e, sizeof(e));
    
67.         fwrite(&e, 1, sizeof(e), fp);
    
68.     }
    
69.     fclose(fp);
    
70. }
    
71. 
    
72. int main(void) {
    
73.     srand(time(NULL));
    
74.     //list_t *list = list_init();
    
75.     list_t *list = read_history("history.dat");
    
76.     while(1) {
    
77.         menu();
    
78.         int command; scanf("%d", &command);
    
79.         if(command == 0) break;
    
80.         if(command == 5) {history(list); continue;}
    
81.         if(!(command >= 1 && command <= 4)) {puts("输入错误，请重新输入"); continue;}
    
82.         exp_t e = {.a = rand() % 99 + 1, .b = rand() % 99 + 1, .op = op_table[command - 1]};
    
83.         printf("%d%c%d=", e.a, e.op.ch, e.b);
    
84.         scanf("%d", &e.c);
    
85.         if(e.c == e.op.func(e.a, e.b)) puts("你很棒，加油！");
    
86.         else puts("很遗憾！");
    
87.         list_append(list, &e, sizeof(e));
    
88.         //if(list_size(list) > 10) list_delete(list, 0);
    
89. repeat: printf("是否继续答题？(Y/n) ");
    
90.         char q; getchar(); scanf("%c", &q);
    
91.         if(q == 'n' || q == 'N') break;
    
92.         if(!(q == 'y' || q == 'Y')) {puts("输入错误，请重新输入"); goto repeat;}
    
93.     }
    
94.     save_history(list, "history.dat");
    
95.     list_deinit(list);
    
96.     return 0;
    
97. }
    
98. sh-5.1$ cat list.h
    
99. #ifndef _LIST_H_
    
100. #define _LIST_H_
     
101. 
     
102. #include <stddef.h>
     
103. #include <stdbool.h>
     
104. 
     
105. struct list_node_tag {
     
106.     void *data; size_t size;
     
107.     struct list_node_tag *next;
     
108. };
     
109. 
     
110. typedef struct {
     
111.     struct list_node_tag *head;
     
112.     size_t size;
     
113. } list_t;
     
114. 
     
115. list_t *list_init(void);
     
116. void list_deinit(list_t *list);
     
117. bool list_clean(list_t *list);
     
118. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
     
119. bool list_delete(list_t *list, size_t index);
     
120. bool list_get(const list_t *list, size_t index, void *data, size_t size);
     
121. bool list_set(list_t *list, size_t index, const void *data, size_t size);
     
122. bool list_append(list_t *list, const void *data, size_t size);
     
123. size_t list_size(const list_t *list);
     
124. bool list_empty(const list_t *list);
     
125. 
     
126. #endif
     
127. sh-5.1$ cat list.c
     
128. #include "list.h"
     
129. #include <stdlib.h>
     
130. #include <memory.h>
     
131. 
     
132. list_t *list_init(void) {
     
133.     list_t *list = malloc(sizeof(*list));
     
134.     if(!list) return NULL;
     
135.     list->head = NULL;
     
136.     list->size = 0;
     
137.     return list;
     
138. }
     
139. 
     
140. void list_deinit(list_t *list) {
     
141.     if(!list) return;
     
142.     list_clean(list);
     
143.     free(list);
     
144. }
     
145. 
     
146. bool list_clean(list_t *list) {
     
147.     if(!list) return false;
     
148.     while(!list_empty(list)) if(!list_delete(list, 0)) return false;
     
149.     return true;
     
150. }
     
151. 
     
152. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
     
153.     if(!list) return false;
     
154.     if(list_size(list) < index) return false;
     
155.     if(!data) return false;
     
156.     struct list_node_tag **current = &list->head;
     
157.     while(index--) current = &(*current)->next;
     
158.     struct list_node_tag *node = malloc(sizeof(*node));
     
159.     if(!node) return false;
     
160.     node->data = malloc(size);
     
161.     if(!node->data) {free(node); return false;}
     
162.     memcpy(node->data, data, size);
     
163.     node->size = size;
     
164.     node->next = *current;
     
165.     *current = node;
     
166.     ++list->size;
     
167.     return true;
     
168. }
     
169. 
     
170. bool list_delete(list_t *list, size_t index) {
     
171.     if(!list) return false;
     
172.     if(list_size(list) <= index) return false;
     
173.     struct list_node_tag **current = &list->head;
     
174.     while(index--) current = &(*current)->next;
     
175.     struct list_node_tag *temp = *current;
     
176.     *current = temp->next;
     
177.     free(temp->data); free(temp);
     
178.     --list->size;
     
179.     return true;
     
180. }
     
181. 
     
182. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
183.     if(!list) return false;
     
184.     if(list_size(list) <= index) return false;
     
185.     if(!data) return false;
     
186.     struct list_node_tag *const *current = &list->head;
     
187.     while(index--) current = &(*current)->next;
     
188.     struct list_node_tag *temp = *current;
     
189.     if(temp->size > size) return false;
     
190.     memcpy(data, temp->data, temp->size);
     
191.     return true;
     
192. }
     
193. 
     
194. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
195.     bool res = list_delete(list, index);
     
196.     return res ? list_insert(list, index, data, size) : res;
     
197. }
     
198. 
     
199. bool list_append(list_t *list, const void *data, size_t size) {
     
200.     if(!list) return false;
     
201.     return list_insert(list, list_size(list), data, size);
     
202. }
     
203. 
     
204. size_t list_size(const list_t *list) {
     
205.     if(!list) return 0;
     
206.     return list->size;
     
207. }
     
208. 
     
209. bool list_empty(const list_t *list) {
     
210.     if(!list) return true;
     
211.     return list_size(list) == 0;
     
212. }
     
213. sh-5.1$
     

复制代码

啊啊啊空空

大佬能不能写得再简单些啊

啊啊啊空空

谢谢

人造人

啊啊啊空空 发表于 2022-11-22 17:03
大佬能不能写得再简单些啊

这代码哪里复杂了，你哪里看不懂？