[已解决]求大佬教教我第五题怎么做

啊啊啊空空

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

最佳答案

月排行榜 / 总排行榜

人造人

2022-11-1 19:15:21

像这样，写一个容器来存储这些表达式

1. sh-5.1$ ls
   
2. list.c        list.h        main.c
   
3. sh-5.1$ cat main.c
   
4. #include "list.h"
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <time.h>
   
8. 
   
9. typedef struct {
   
10.     int a, b;
    
11.     char op;
    
12.     int result;
    
13. } exp_t;
    
14. 
    
15. int calc(int a, char op, int b) {
    
16.     switch(op) {
    
17.         case '+': return a + b;
    
18.         case '-': return a - b;
    
19.         case '*': return a * b;
    
20.         case '/': return a / b;
    
21.     }
    
22.     return 0;
    
23. }
    
24. 
    
25. void output(const list_t *list, size_t index) {
    
26.     if(index >= list_size(list)) return;
    
27.     output(list, index + 1);
    
28.     exp_t e; list_get(list, index, &e, sizeof(e));
    
29.     printf("%d %c %d = %d\n", e.a, e.op, e.b, e.result);
    
30. }
    
31. 
    
32. int main(void) {
    
33.     srand(time(NULL));
    
34.     list_t *list = list_init();
    
35.     for(size_t i = 0; i < 10; ++i) {
    
36.         exp_t e;
    
37.         e.a = rand() % 100;
    
38.         e.b = rand() % 100;
    
39.         e.a = rand() % 2 ? e.a : -e.a;
    
40.         e.b = rand() % 2 ? e.b : -e.b;
    
41.         char op[] = {'+', '-', '*', '/'};
    
42.         e.op = op[rand() % 4];
    
43.         e.op = e.op == '/' && e.b == 0 ? op[0] : e.op;
    
44.         e.result = calc(e.a, e.op, e.b);
    
45.         list_append(list, &e, sizeof(e));
    
46.     }
    
47.     output(list, 0);
    
48.     list_deinit(list);
    
49.     return 0;
    
50. }
    
51. sh-5.1$ cat list.h
    
52. #ifndef _LIST_H_
    
53. #define _LIST_H_
    
54. 
    
55. #include <stddef.h>
    
56. #include <stdbool.h>
    
57. 
    
58. struct list_node_tag {
    
59.     void *data; size_t size;
    
60.     struct list_node_tag *next;
    
61. };
    
62. 
    
63. typedef struct {
    
64.     struct list_node_tag *head;
    
65.     size_t size;
    
66. } list_t;
    
67. 
    
68. list_t *list_init(void);
    
69. void list_deinit(list_t *list);
    
70. bool list_clean(list_t *list);
    
71. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
72. bool list_delete(list_t *list, size_t index);
    
73. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
74. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
75. bool list_append(list_t *list, const void *data, size_t size);
    
76. size_t list_size(const list_t *list);
    
77. bool list_empty(const list_t *list);
    
78. 
    
79. #endif
    
80. sh-5.1$ cat list.c
    
81. #include "list.h"
    
82. #include <stdlib.h>
    
83. #include <memory.h>
    
84. 
    
85. list_t *list_init(void) {
    
86.     list_t *list = malloc(sizeof(*list));
    
87.     if(!list) return NULL;
    
88.     list->head = NULL;
    
89.     list->size = 0;
    
90.     return list;
    
91. }
    
92. 
    
93. void list_deinit(list_t *list) {
    
94.     if(!list) return;
    
95.     list_clean(list);
    
96.     free(list);
    
97. }
    
98. 
    
99. bool list_clean(list_t *list) {
    
100.     if(!list) return false;
     
101.     while(!list_empty(list)) list_delete(list, 0);
     
102.     return true;
     
103. }
     
104. 
     
105. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
     
106.     if(!list) return false;
     
107.     if(list_size(list) < index) return false;
     
108.     if(!data) return false;
     
109.     struct list_node_tag **current = &list->head;
     
110.     while(index--) current = &(*current)->next;
     
111.     struct list_node_tag *node = malloc(sizeof(*node));
     
112.     if(!node) return false;
     
113.     node->data = malloc(size);
     
114.     if(!node->data) {free(node); return false;}
     
115.     memcpy(node->data, data, size);
     
116.     node->size = size;
     
117.     node->next = *current;
     
118.     *current = node;
     
119.     ++list->size;
     
120.     return true;
     
121. }
     
122. 
     
123. bool list_delete(list_t *list, size_t index) {
     
124.     if(!list) return false;
     
125.     if(list_size(list) <= index) return false;
     
126.     struct list_node_tag **current = &list->head;
     
127.     while(index--) current = &(*current)->next;
     
128.     struct list_node_tag *temp = *current;
     
129.     *current = temp->next;
     
130.     free(temp->data); free(temp);
     
131.     --list->size;
     
132.     return true;
     
133. }
     
134. 
     
135. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
136.     if(!list) return false;
     
137.     if(list_size(list) <= index) return false;
     
138.     if(!data) return false;
     
139.     struct list_node_tag *const *current = &list->head;
     
140.     while(index--) current = &(*current)->next;
     
141.     struct list_node_tag *temp = *current;
     
142.     if(temp->size > size) return false;
     
143.     memcpy(data, temp->data, temp->size);
     
144.     return true;
     
145. }
     
146. 
     
147. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
148.     bool res = list_delete(list, index);
     
149.     return res ? list_insert(list, index, data, size) : res;
     
150. }
     
151. 
     
152. bool list_append(list_t *list, const void *data, size_t size) {
     
153.     if(!list) return false;
     
154.     return list_insert(list, list_size(list), data, size);
     
155. }
     
156. 
     
157. size_t list_size(const list_t *list) {
     
158.     if(!list) return 0;
     
159.     return list->size;
     
160. }
     
161. 
     
162. bool list_empty(const list_t *list) {
     
163.     if(!list) return true;
     
164.     return list_size(list) == 0;
     
165. }
     
166. sh-5.1$ gcc -g -Wall -o main main.c list.c
     
167. sh-5.1$ ls
     
168. list.c        list.h        main  main.c
     
169. sh-5.1$ ./main
     
170. 23 - -77 = 100
     
171. 37 * -58 = -2146
     
172. 94 * 19 = 1786
     
173. 7 - -24 = 31
     
174. 51 * 99 = 5049
     
175. 68 + -48 = 20
     
176. -95 * -80 = 7600
     
177. -5 + -33 = -38
     
178. 15 * 18 = 270
     
179. -93 - 95 = -188
     
180. sh-5.1$
     

复制代码

跳转到最佳答案楼层

人造人

就是按照题目要求做么
先做一个菜单，菜单会做不？先把菜单做出来

啊啊啊空空

啊这，我说第五题那个，不是前面的

tommyyu

啊啊啊空空 发表于 2022-11-1 07:51
啊这，我说第五题那个，不是前面的

可以通过一个队列储存
队列的使用：
https://www.cnblogs.com/xzxl/p/7266370.html
https://blog.csdn.net/zichen_ziqi/article/details/80819939

啊啊啊空空

要去是用c语言来做

人造人

啊啊啊空空 发表于 2022-11-1 09:20
要去是用c语言来做

那就自己写一个容器，其实链表就可以，队列也行

人造人

像这样，写一个容器来存储这些表达式

1. sh-5.1$ ls
   
2. list.c        list.h        main.c
   
3. sh-5.1$ cat main.c
   
4. #include "list.h"
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <time.h>
   
8. 
   
9. typedef struct {
   
10.     int a, b;
    
11.     char op;
    
12.     int result;
    
13. } exp_t;
    
14. 
    
15. int calc(int a, char op, int b) {
    
16.     switch(op) {
    
17.         case '+': return a + b;
    
18.         case '-': return a - b;
    
19.         case '*': return a * b;
    
20.         case '/': return a / b;
    
21.     }
    
22.     return 0;
    
23. }
    
24. 
    
25. void output(const list_t *list, size_t index) {
    
26.     if(index >= list_size(list)) return;
    
27.     output(list, index + 1);
    
28.     exp_t e; list_get(list, index, &e, sizeof(e));
    
29.     printf("%d %c %d = %d\n", e.a, e.op, e.b, e.result);
    
30. }
    
31. 
    
32. int main(void) {
    
33.     srand(time(NULL));
    
34.     list_t *list = list_init();
    
35.     for(size_t i = 0; i < 10; ++i) {
    
36.         exp_t e;
    
37.         e.a = rand() % 100;
    
38.         e.b = rand() % 100;
    
39.         e.a = rand() % 2 ? e.a : -e.a;
    
40.         e.b = rand() % 2 ? e.b : -e.b;
    
41.         char op[] = {'+', '-', '*', '/'};
    
42.         e.op = op[rand() % 4];
    
43.         e.op = e.op == '/' && e.b == 0 ? op[0] : e.op;
    
44.         e.result = calc(e.a, e.op, e.b);
    
45.         list_append(list, &e, sizeof(e));
    
46.     }
    
47.     output(list, 0);
    
48.     list_deinit(list);
    
49.     return 0;
    
50. }
    
51. sh-5.1$ cat list.h
    
52. #ifndef _LIST_H_
    
53. #define _LIST_H_
    
54. 
    
55. #include <stddef.h>
    
56. #include <stdbool.h>
    
57. 
    
58. struct list_node_tag {
    
59.     void *data; size_t size;
    
60.     struct list_node_tag *next;
    
61. };
    
62. 
    
63. typedef struct {
    
64.     struct list_node_tag *head;
    
65.     size_t size;
    
66. } list_t;
    
67. 
    
68. list_t *list_init(void);
    
69. void list_deinit(list_t *list);
    
70. bool list_clean(list_t *list);
    
71. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
72. bool list_delete(list_t *list, size_t index);
    
73. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
74. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
75. bool list_append(list_t *list, const void *data, size_t size);
    
76. size_t list_size(const list_t *list);
    
77. bool list_empty(const list_t *list);
    
78. 
    
79. #endif
    
80. sh-5.1$ cat list.c
    
81. #include "list.h"
    
82. #include <stdlib.h>
    
83. #include <memory.h>
    
84. 
    
85. list_t *list_init(void) {
    
86.     list_t *list = malloc(sizeof(*list));
    
87.     if(!list) return NULL;
    
88.     list->head = NULL;
    
89.     list->size = 0;
    
90.     return list;
    
91. }
    
92. 
    
93. void list_deinit(list_t *list) {
    
94.     if(!list) return;
    
95.     list_clean(list);
    
96.     free(list);
    
97. }
    
98. 
    
99. bool list_clean(list_t *list) {
    
100.     if(!list) return false;
     
101.     while(!list_empty(list)) list_delete(list, 0);
     
102.     return true;
     
103. }
     
104. 
     
105. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
     
106.     if(!list) return false;
     
107.     if(list_size(list) < index) return false;
     
108.     if(!data) return false;
     
109.     struct list_node_tag **current = &list->head;
     
110.     while(index--) current = &(*current)->next;
     
111.     struct list_node_tag *node = malloc(sizeof(*node));
     
112.     if(!node) return false;
     
113.     node->data = malloc(size);
     
114.     if(!node->data) {free(node); return false;}
     
115.     memcpy(node->data, data, size);
     
116.     node->size = size;
     
117.     node->next = *current;
     
118.     *current = node;
     
119.     ++list->size;
     
120.     return true;
     
121. }
     
122. 
     
123. bool list_delete(list_t *list, size_t index) {
     
124.     if(!list) return false;
     
125.     if(list_size(list) <= index) return false;
     
126.     struct list_node_tag **current = &list->head;
     
127.     while(index--) current = &(*current)->next;
     
128.     struct list_node_tag *temp = *current;
     
129.     *current = temp->next;
     
130.     free(temp->data); free(temp);
     
131.     --list->size;
     
132.     return true;
     
133. }
     
134. 
     
135. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
136.     if(!list) return false;
     
137.     if(list_size(list) <= index) return false;
     
138.     if(!data) return false;
     
139.     struct list_node_tag *const *current = &list->head;
     
140.     while(index--) current = &(*current)->next;
     
141.     struct list_node_tag *temp = *current;
     
142.     if(temp->size > size) return false;
     
143.     memcpy(data, temp->data, temp->size);
     
144.     return true;
     
145. }
     
146. 
     
147. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
148.     bool res = list_delete(list, index);
     
149.     return res ? list_insert(list, index, data, size) : res;
     
150. }
     
151. 
     
152. bool list_append(list_t *list, const void *data, size_t size) {
     
153.     if(!list) return false;
     
154.     return list_insert(list, list_size(list), data, size);
     
155. }
     
156. 
     
157. size_t list_size(const list_t *list) {
     
158.     if(!list) return 0;
     
159.     return list->size;
     
160. }
     
161. 
     
162. bool list_empty(const list_t *list) {
     
163.     if(!list) return true;
     
164.     return list_size(list) == 0;
     
165. }
     
166. sh-5.1$ gcc -g -Wall -o main main.c list.c
     
167. sh-5.1$ ls
     
168. list.c        list.h        main  main.c
     
169. sh-5.1$ ./main
     
170. 23 - -77 = 100
     
171. 37 * -58 = -2146
     
172. 94 * 19 = 1786
     
173. 7 - -24 = 31
     
174. 51 * 99 = 5049
     
175. 68 + -48 = 20
     
176. -95 * -80 = 7600
     
177. -5 + -33 = -38
     
178. 15 * 18 = 270
     
179. -93 - 95 = -188
     
180. sh-5.1$
     

复制代码

啊啊啊空空

可是要用到数组来解决唉，求大佬教教我

啊啊啊空空

能不能写一个简化一点的，用C语言的数组完成，求大佬写一下，感谢