[已解决]输入不得重复

Eat.随

想要编写一个C语言程序，并实现以下功能
1.用户持续输入数字
2.当用户输入的数字与之前输入每一个的数字重复时，停止。

最佳答案

月排行榜 / 总排行榜

人造人

2023-11-7 20:33:34

1. sh-5.2$ cat main.c
   
2. #include "list.h"
   
3. #include <stdio.h>
   
4. 
   
5. size_t find(const list_t *list, int n) {
   
6.     for(size_t i = 0; i < list_size(list); ++i) {
   
7.         int x; list_get(list, i, &x, sizeof(x));
   
8.         if(x == n) return i;
   
9.     }
   
10.     return -1;
    
11. }
    
12. 
    
13. int main(void) {
    
14.     list_t *list = list_init();
    
15.     while(1) {
    
16.         int n; scanf("%d", &n);
    
17.         if(find(list, n) != -1) break;
    
18.         list_append(list, &n, sizeof(n));
    
19.     }
    
20.     list_deinit(list);
    
21.     return 0;
    
22. }
    
23. sh-5.2$ cat list.h
    
24. #ifndef _LIST_H_
    
25. #define _LIST_H_
    
26. 
    
27. #include <stddef.h>
    
28. #include <stdbool.h>
    
29. 
    
30. struct list_node_tag {
    
31.     void *data; size_t size;
    
32.     struct list_node_tag *next;
    
33. };
    
34. 
    
35. typedef struct {
    
36.     struct list_node_tag *head;
    
37.     size_t size;
    
38. } list_t;
    
39. 
    
40. list_t *list_init(void);
    
41. void list_deinit(list_t *list);
    
42. bool list_clean(list_t *list);
    
43. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
44. bool list_delete(list_t *list, size_t index);
    
45. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
46. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
47. bool list_append(list_t *list, const void *data, size_t size);
    
48. size_t list_size(const list_t *list);
    
49. bool list_empty(const list_t *list);
    
50. 
    
51. #endif
    
52. sh-5.2$ cat list.c
    
53. #include "list.h"
    
54. #include <stdlib.h>
    
55. #include <string.h>
    
56. 
    
57. static struct list_node_tag *new_node(const void *data, size_t size) {
    
58.     struct list_node_tag *result = malloc(sizeof(*result));
    
59.     if(!result) return NULL;
    
60.     result->data = malloc(size);
    
61.     if(!result->data) {free(result); return NULL;}
    
62.     memcpy(result->data, data, size);
    
63.     result->size = size;
    
64.     result->next = NULL;
    
65.     return result;
    
66. }
    
67. 
    
68. static void free_node(struct list_node_tag *n) {
    
69.     free(n->data);
    
70.     free(n);
    
71. }
    
72. 
    
73. static struct list_node_tag *const *locate_node_const(const list_t *list, size_t index) {
    
74.     struct list_node_tag *const *result = &list->head;
    
75.     while(index--) result = &(*result)->next;
    
76.     return result;
    
77. }
    
78. 
    
79. static struct list_node_tag **locate_node(list_t *list, size_t index) {
    
80.     return (struct list_node_tag **)locate_node_const(list, index);
    
81. }
    
82. 
    
83. list_t *list_init(void) {
    
84.     list_t *list = malloc(sizeof(*list));
    
85.     if(!list) return NULL;
    
86.     list->head = NULL;
    
87.     list->size = 0;
    
88.     return list;
    
89. }
    
90. 
    
91. void list_deinit(list_t *list) {
    
92.     if(!list) return;
    
93.     list_clean(list);
    
94.     free(list);
    
95. }
    
96. 
    
97. bool list_clean(list_t *list) {
    
98.     if(!list) return false;
    
99.     while(!list_empty(list)) if(!list_delete(list, 0)) return false;
    
100.     return true;
     
101. }
     
102. 
     
103. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
     
104.     if(!list) return false;
     
105.     if(list_size(list) < index) return false;
     
106.     if(!data) return false;
     
107.     struct list_node_tag **current = locate_node(list, index);
     
108.     struct list_node_tag *node = new_node(data, size);
     
109.     if(!node) return false;
     
110.     node->next = *current;
     
111.     *current = node;
     
112.     ++list->size;
     
113.     return true;
     
114. }
     
115. 
     
116. bool list_delete(list_t *list, size_t index) {
     
117.     if(!list) return false;
     
118.     if(list_size(list) <= index) return false;
     
119.     struct list_node_tag **current = locate_node(list, index);
     
120.     struct list_node_tag *temp = *current;
     
121.     *current = temp->next;
     
122.     free_node(temp);
     
123.     --list->size;
     
124.     return true;
     
125. }
     
126. 
     
127. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
128.     if(!list) return false;
     
129.     if(list_size(list) <= index) return false;
     
130.     if(!data) return false;
     
131.     struct list_node_tag *current = *locate_node_const(list, index);
     
132.     if(current->size > size) return false;
     
133.     memcpy(data, current->data, current->size);
     
134.     return true;
     
135. }
     
136. 
     
137. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
138.     bool res = list_delete(list, index);
     
139.     return res ? list_insert(list, index, data, size) : res;
     
140. }
     
141. 
     
142. bool list_append(list_t *list, const void *data, size_t size) {
     
143.     if(!list) return false;
     
144.     return list_insert(list, list_size(list), data, size);
     
145. }
     
146. 
     
147. size_t list_size(const list_t *list) {
     
148.     if(!list) return 0;
     
149.     return list->size;
     
150. }
     
151. 
     
152. bool list_empty(const list_t *list) {
     
153.     if(!list) return true;
     
154.     return list_size(list) == 0;
     
155. }
     
156. sh-5.2$ ./main
     
157. 1 2 3
     
158. 1
     
159. sh-5.2$
     

复制代码

跳转到最佳答案楼层

isdkz

你可以使用Python来实现这个功能。你可以使用一个集合（set）来存储用户输入的数字，并在每次输入后检查是否重复。下面是一个示例代码：

1. numbers = set()
   
2. while True:
   
3.     num = input("请输入一个数字：")
   
4.     if num in numbers:
   
5.         print("输入重复，程序停止。")
   
6.         break
   
7.     numbers.add(num)
   

复制代码

在这个示例中，我们使用了一个集合（set）来存储用户输入的数字。每次用户输入一个数字后，我们都会检查这个数字是否已经在集合中出现过，如果是的话就停止程序。

Mike_python小

2. #include <stdio.h>
4. int main() {
5.     int prev_num = -1;  // 用于存储上一个输入的数字，初始值设为-1表示第一个输入不可能重复
6.     int current_num;
8.     printf("请输入数字：");
9.     scanf("%d", &current_num);
11.     while (current_num != prev_num) {
12.         prev_num = current_num;  // 更新上一个输入的数字为当前输入的数字
14.         printf("请输入数字：");
15.         scanf("%d", &current_num);
16.     }
18.     printf("输入重复，程序终止。\n");
20.     return 0;
21. }

复制代码

以上是一个简单的C语言程序，实现了用户持续输入数字，当用户输入的数字与之前输入的数字重复时，程序停止。希望能帮到你。

球一个最佳答案谢谢啦！这对我非常重要！

Eat.随

Mike_python小 发表于 2023-11-7 19:22
以上是一个简单的C语言程序，实现了用户持续输入数字，当用户输入的数字与之前输入的数字重复时，程序停 ...

但是当我输入1，2，3，再次输入1，此时程序不会停止

人造人

1. sh-5.2$ cat main.cpp
   
2. #include <iostream>
   
3. #include <vector>
   
4. #include <algorithm>
   
5. 
   
6. using std::cin;
   
7. using std::vector;
   
8. using std::find;
   
9. 
   
10. int main() {
    
11.     vector<int> v;
    
12.     while(true) {
    
13.         int n; cin >> n;
    
14.         if(find(v.begin(), v.end(), n) != v.end()) break;
    
15.         v.push_back(n);
    
16.     }
    
17.     return 0;
    
18. }
    
19. sh-5.2$ ./main
    
20. 1 2 3
    
21. 1
    
22. sh-5.2$
    

复制代码

人造人

1. sh-5.2$ cat main.c
   
2. #include "list.h"
   
3. #include <stdio.h>
   
4. 
   
5. size_t find(const list_t *list, int n) {
   
6.     for(size_t i = 0; i < list_size(list); ++i) {
   
7.         int x; list_get(list, i, &x, sizeof(x));
   
8.         if(x == n) return i;
   
9.     }
   
10.     return -1;
    
11. }
    
12. 
    
13. int main(void) {
    
14.     list_t *list = list_init();
    
15.     while(1) {
    
16.         int n; scanf("%d", &n);
    
17.         if(find(list, n) != -1) break;
    
18.         list_append(list, &n, sizeof(n));
    
19.     }
    
20.     list_deinit(list);
    
21.     return 0;
    
22. }
    
23. sh-5.2$ cat list.h
    
24. #ifndef _LIST_H_
    
25. #define _LIST_H_
    
26. 
    
27. #include <stddef.h>
    
28. #include <stdbool.h>
    
29. 
    
30. struct list_node_tag {
    
31.     void *data; size_t size;
    
32.     struct list_node_tag *next;
    
33. };
    
34. 
    
35. typedef struct {
    
36.     struct list_node_tag *head;
    
37.     size_t size;
    
38. } list_t;
    
39. 
    
40. list_t *list_init(void);
    
41. void list_deinit(list_t *list);
    
42. bool list_clean(list_t *list);
    
43. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
44. bool list_delete(list_t *list, size_t index);
    
45. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
46. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
47. bool list_append(list_t *list, const void *data, size_t size);
    
48. size_t list_size(const list_t *list);
    
49. bool list_empty(const list_t *list);
    
50. 
    
51. #endif
    
52. sh-5.2$ cat list.c
    
53. #include "list.h"
    
54. #include <stdlib.h>
    
55. #include <string.h>
    
56. 
    
57. static struct list_node_tag *new_node(const void *data, size_t size) {
    
58.     struct list_node_tag *result = malloc(sizeof(*result));
    
59.     if(!result) return NULL;
    
60.     result->data = malloc(size);
    
61.     if(!result->data) {free(result); return NULL;}
    
62.     memcpy(result->data, data, size);
    
63.     result->size = size;
    
64.     result->next = NULL;
    
65.     return result;
    
66. }
    
67. 
    
68. static void free_node(struct list_node_tag *n) {
    
69.     free(n->data);
    
70.     free(n);
    
71. }
    
72. 
    
73. static struct list_node_tag *const *locate_node_const(const list_t *list, size_t index) {
    
74.     struct list_node_tag *const *result = &list->head;
    
75.     while(index--) result = &(*result)->next;
    
76.     return result;
    
77. }
    
78. 
    
79. static struct list_node_tag **locate_node(list_t *list, size_t index) {
    
80.     return (struct list_node_tag **)locate_node_const(list, index);
    
81. }
    
82. 
    
83. list_t *list_init(void) {
    
84.     list_t *list = malloc(sizeof(*list));
    
85.     if(!list) return NULL;
    
86.     list->head = NULL;
    
87.     list->size = 0;
    
88.     return list;
    
89. }
    
90. 
    
91. void list_deinit(list_t *list) {
    
92.     if(!list) return;
    
93.     list_clean(list);
    
94.     free(list);
    
95. }
    
96. 
    
97. bool list_clean(list_t *list) {
    
98.     if(!list) return false;
    
99.     while(!list_empty(list)) if(!list_delete(list, 0)) return false;
    
100.     return true;
     
101. }
     
102. 
     
103. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
     
104.     if(!list) return false;
     
105.     if(list_size(list) < index) return false;
     
106.     if(!data) return false;
     
107.     struct list_node_tag **current = locate_node(list, index);
     
108.     struct list_node_tag *node = new_node(data, size);
     
109.     if(!node) return false;
     
110.     node->next = *current;
     
111.     *current = node;
     
112.     ++list->size;
     
113.     return true;
     
114. }
     
115. 
     
116. bool list_delete(list_t *list, size_t index) {
     
117.     if(!list) return false;
     
118.     if(list_size(list) <= index) return false;
     
119.     struct list_node_tag **current = locate_node(list, index);
     
120.     struct list_node_tag *temp = *current;
     
121.     *current = temp->next;
     
122.     free_node(temp);
     
123.     --list->size;
     
124.     return true;
     
125. }
     
126. 
     
127. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
128.     if(!list) return false;
     
129.     if(list_size(list) <= index) return false;
     
130.     if(!data) return false;
     
131.     struct list_node_tag *current = *locate_node_const(list, index);
     
132.     if(current->size > size) return false;
     
133.     memcpy(data, current->data, current->size);
     
134.     return true;
     
135. }
     
136. 
     
137. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
138.     bool res = list_delete(list, index);
     
139.     return res ? list_insert(list, index, data, size) : res;
     
140. }
     
141. 
     
142. bool list_append(list_t *list, const void *data, size_t size) {
     
143.     if(!list) return false;
     
144.     return list_insert(list, list_size(list), data, size);
     
145. }
     
146. 
     
147. size_t list_size(const list_t *list) {
     
148.     if(!list) return 0;
     
149.     return list->size;
     
150. }
     
151. 
     
152. bool list_empty(const list_t *list) {
     
153.     if(!list) return true;
     
154.     return list_size(list) == 0;
     
155. }
     
156. sh-5.2$ ./main
     
157. 1 2 3
     
158. 1
     
159. sh-5.2$
     

复制代码

jackz007

1. #include <stdio.h>
   
2. #include <conio.h>
   
3. 
   
4. int main(void)
   
5. {
   
6.         char c , s[2048]                    ;
   
7.         int  k , n , m                      ;
   
8.         for(k = m = 0 ; k < 2048 ;) {
   
9.                 c = getch()                 ;
   
10.                 n = 0                       ;
    
11.                 while(n < m) {
    
12.                         if(s[n] == c) break ;
    
13.                         n ++                ;
    
14.                 }
    
15.                 if(n == m) {
    
16.                         s[m ++] = c         ;
    
17.                         putch(c)            ;
    
18.                 } else {
    
19.                         break               ;
    
20.                 }
    
21.         }
    
22.         putch('\r')                         ;
    
23. }

复制代码