[已解决]一个题目请大佬过目

2084153280

输入一批整数，输入数字0则结束，不再接收。将整数保存并正、逆序打印输出。

例如：输入 35    25   15  5   0  输出则为：5  15  25  35     正序为：35 25 15 5

最佳答案

月排行榜 / 总排行榜

傻眼貓咪

2021-12-2 22:31:20

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int increasing(const void * elem1, const void * elem2) // 定义函数：用于升序排序
   
5. {
   
6.     int f = *((int*)elem1);
   
7.     int s = *((int*)elem2);
   
8.     if (f > s) return  1;
   
9.     if (f < s) return -1;
   
10.     return 0;
    
11. }
    
12. 
    
13. int decreasing(const void * elem1, const void * elem2) // 定义函数：用于降序排序
    
14. {
    
15.     int f = *((int*)elem1);
    
16.     int s = *((int*)elem2);
    
17.     if (f < s) return  1;
    
18.     if (f > s) return -1;
    
19.     return 0;
    
20. }
    
21. 
    
22. int main()
    
23. {
    
24.     int n = 0, arr[256], x = 1;
    
25.     while(x){
    
26.         scanf("%d", &x);
    
27.         if(x) arr[n++] = x;
    
28.     }
    
29.     printf("升序排序：");
    
30.     qsort(arr, n, sizeof(*arr), increasing); // 升序排序
    
31.     for(size_t i = 0; arr[i]; i++) printf("%d ", arr[i]);
    
32.    
    
33.     printf("\n降序排序：");
    
34.     qsort(arr, n, sizeof(*arr), decreasing); // 降序排序
    
35.     for(size_t i = 0; arr[i]; i++) printf("%d ", arr[i]);
    
36.     return 0;
    
37. }

复制代码

跳转到最佳答案楼层

2084153280

输入一批整数，输入数字0则结束，不再接收。将整数保存并正、逆序打印输出。

例如：输入 35    25   15  5   0  输出则为：5  15  25  35     正序为：35 25 15 5

2084153280

2084153280 发表于 2021-12-2 22:14
输入一批整数，输入数字0则结束，不再接收。将整数保存并正、逆序打印输出。

例如：输入 35    25   15  ...

这个题目

傻眼貓咪

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int increasing(const void * elem1, const void * elem2) // 定义函数：用于升序排序
   
5. {
   
6.     int f = *((int*)elem1);
   
7.     int s = *((int*)elem2);
   
8.     if (f > s) return  1;
   
9.     if (f < s) return -1;
   
10.     return 0;
    
11. }
    
12. 
    
13. int decreasing(const void * elem1, const void * elem2) // 定义函数：用于降序排序
    
14. {
    
15.     int f = *((int*)elem1);
    
16.     int s = *((int*)elem2);
    
17.     if (f < s) return  1;
    
18.     if (f > s) return -1;
    
19.     return 0;
    
20. }
    
21. 
    
22. int main()
    
23. {
    
24.     int n = 0, arr[256], x = 1;
    
25.     while(x){
    
26.         scanf("%d", &x);
    
27.         if(x) arr[n++] = x;
    
28.     }
    
29.     printf("升序排序：");
    
30.     qsort(arr, n, sizeof(*arr), increasing); // 升序排序
    
31.     for(size_t i = 0; arr[i]; i++) printf("%d ", arr[i]);
    
32.    
    
33.     printf("\n降序排序：");
    
34.     qsort(arr, n, sizeof(*arr), decreasing); // 降序排序
    
35.     for(size_t i = 0; arr[i]; i++) printf("%d ", arr[i]);
    
36.     return 0;
    
37. }

复制代码

人造人

1. #include "list.h"
   
2. #include <stdio.h>
   
3. 
   
4. void positive_sequence(const list_t *list, size_t index) {
   
5.     if(index >= list_size(list)) return;
   
6.     int temp; list_get(list, index, &temp, sizeof(temp));
   
7.     printf("%d ", temp);
   
8.     positive_sequence(list, index + 1);
   
9. }
   
10. 
    
11. void inverted_sequence(const list_t *list, size_t index) {
    
12.     if(index >= list_size(list)) return;
    
13.     inverted_sequence(list, index + 1);
    
14.     int temp; list_get(list, index, &temp, sizeof(temp));
    
15.     printf("%d ", temp);
    
16. }
    
17. 
    
18. int main(void) {
    
19.     list_t *list = list_init();
    
20.     while(1) {
    
21.         int temp; scanf("%d", &temp);
    
22.         if(!temp) break;
    
23.         list_append(list, &temp, sizeof(temp));
    
24.     }
    
25.     positive_sequence(list, 0); puts("");
    
26.     inverted_sequence(list, 0); puts("");
    
27.     list_deinit(list);
    
28.     return 0;
    
29. }
    

复制代码

list.h

1. #ifndef _LIST_H_
   
2. #define _LIST_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. struct list_node_tag {
   
8.     void *data; size_t size;
   
9.     struct list_node_tag *next;
   
10. };
    
11. 
    
12. typedef struct {
    
13.     struct list_node_tag *head;
    
14.     size_t size;
    
15. } list_t;
    
16. 
    
17. list_t *list_init(void);
    
18. void list_deinit(list_t *list);
    
19. bool list_clean(list_t *list);
    
20. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
21. bool list_delete(list_t *list, size_t index);
    
22. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
23. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
24. bool list_append(list_t *list, const void *data, size_t size);
    
25. size_t list_size(const list_t *list);
    
26. bool list_empty(const list_t *list);
    
27. 
    
28. #endif
    

复制代码

list.c

1. #include "list.h"
   
2. #include <stdlib.h>
   
3. #include <memory.h>
   
4. 
   
5. list_t *list_init(void) {
   
6.     list_t *list = malloc(sizeof(*list));
   
7.     if(!list) return NULL;
   
8.     list->head = NULL;
   
9.     list->size = 0;
   
10.     return list;
    
11. }
    
12. 
    
13. void list_deinit(list_t *list) {
    
14.     if(!list) return;
    
15.     list_clean(list);
    
16.     free(list);
    
17. }
    
18. 
    
19. bool list_clean(list_t *list) {
    
20.     if(!list) return false;
    
21.     while(!list_empty(list)) list_delete(list, 0);
    
22.     return true;
    
23. }
    
24. 
    
25. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
26.     if(!list) return false;
    
27.     if(list_size(list) < index) return false;
    
28.     if(!data) return false;
    
29.     struct list_node_tag **current = &list->head;
    
30.     while(index--) current = &(*current)->next;
    
31.     struct list_node_tag *node = malloc(sizeof(*node));
    
32.     if(!node) return false;
    
33.     node->data = malloc(size);
    
34.     if(!node->data) {free(node); return false;}
    
35.     memcpy(node->data, data, size);
    
36.     node->size = size;
    
37.     node->next = *current;
    
38.     *current = node;
    
39.     ++list->size;
    
40.     return true;
    
41. }
    
42. 
    
43. bool list_delete(list_t *list, size_t index) {
    
44.     if(!list) return false;
    
45.     if(list_size(list) <= index) return false;
    
46.     struct list_node_tag **current = &list->head;
    
47.     while(index--) current = &(*current)->next;
    
48.     struct list_node_tag *temp = *current;
    
49.     *current = temp->next;
    
50.     free(temp->data); free(temp);
    
51.     --list->size;
    
52.     return true;
    
53. }
    
54. 
    
55. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    
56.     if(!list) return false;
    
57.     if(list_size(list) <= index) return false;
    
58.     if(!data) return false;
    
59.     struct list_node_tag *const *current = &list->head;
    
60.     while(index--) current = &(*current)->next;
    
61.     struct list_node_tag *temp = *current;
    
62.     if(temp->size > size) return false;
    
63.     memcpy(data, temp->data, temp->size);
    
64.     return true;
    
65. }
    
66. 
    
67. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
    
68.     bool res = list_delete(list, index);
    
69.     return res ? list_insert(list, index, data, size) : res;
    
70. }
    
71. 
    
72. bool list_append(list_t *list, const void *data, size_t size) {
    
73.     if(!list) return false;
    
74.     return list_insert(list, list_size(list), data, size);
    
75. }
    
76. 
    
77. size_t list_size(const list_t *list) {
    
78.     if(!list) return 0;
    
79.     return list->size;
    
80. }
    
81. 
    
82. bool list_empty(const list_t *list) {
    
83.     if(!list) return true;
    
84.     return list_size(list) == 0;
    
85. }
    

复制代码

jackz007

1. #include <stdio.h>
   
2. 
   
3. int main(void)
   
4. {
   
5.         int d[2000] , i , j , n , t                            ;
   
6.         for(n = 0 ; ; n ++) {
   
7.                 scanf("%d" , & d[n])                           ;
   
8.                 if(! d[n]) break                               ;
   
9.         }
   
10.         for(i = 0 ; i < n - 1 ; i ++) {
    
11.                 for(j = i + 1 ; j && d[j] < d[j - 1] ; j --) {
    
12.                         t = d[j - 1]                           ;
    
13.                         d[j - 1] = d[j]                        ;
    
14.                         d[j] = t                               ;
    
15.                 }
    
16.         }
    
17.         printf("%d" , d[0])                                    ;
    
18.         for(i = 1 ; i < n ; i ++) printf(" %d" , d[i])         ;
    
19.         printf("\n")                                           ;
    
20.         printf("%d" , d[n - 1])                                ;
    
21.         for(i = 1 ; i < n ; i ++) printf(" %d" , d[n - i - 1]) ;
    
22.         printf("\n")                                           ;
    
23. }

复制代码

        编译、运行实况：

1. D:\00.Excise\C>g++ -o x x.c
   
2. 
   
3. D:\00.Excise\C>x
   
4. 12 3 9 8 1 2 5 13 4 6 7 0
   
5. 1 2 3 4 5 6 7 8 9 12 13
   
6. 13 12 9 8 7 6 5 4 3 2 1
   
7. 
   
8. D:\00.Excise\C>

复制代码

2084153280

jackz007 发表于 2021-12-2 22:51
编译、运行实况：

这么多

jackz007

2084153280 发表于 2021-12-2 22:58
这么多

        你指什么？

2084153280

jackz007 发表于 2021-12-2 23:00
你指什么？

大佬这个是有很多种方法吗

1514155012

我只有思路，代码没写（不一定会写）。
先赋值你要输入的整数列表
循环输入到0也就是False就不循环了
然后分别打印分别从[0:X(这个可以不写)：1（步长是1）]
[0:x(同上)：-1（倒数着打印）]
你可以尝试一下，等下我也尝试一下

2084153280

1514155012 发表于 2021-12-2 23:04
我只有思路，代码没写（不一定会写）。
先赋值你要输入的整数列表
循环输入到0也就是False就不循环了

大佬非常抱歉我忘记说明是python语言了

2084153280

大佬们非常非常抱歉

1514155012

2084153280 发表于 2021-12-2 23:08
大佬非常抱歉我忘记说明是python语言了

我说的就是python啊

2084153280

1514155012 发表于 2021-12-2 23:09
我说的就是python啊

上面那个代码呢，我有点糊涂

2084153280

1514155012 发表于 2021-12-2 23:04
我只有思路，代码没写（不一定会写）。
先赋值你要输入的整数列表
循环输入到0也就是False就不循环了

然后分别打印分别从[0:X(这个可以不写)：1（步长是1）]
[0:x(同上)：-1（倒数着打印）]
大佬这个类型是整形不能用
用字符串可以用，然后我就不知道怎么搞0的问题

1514155012

2084153280 发表于 2021-12-2 23:14
然后分别打印分别从[0:X(这个可以不写)：1（步长是1）]
[0:x(同上)：-1（倒数着打印）]
大佬这个类型是 ...

那个啥 我俩不是一个人 上面代码相当于一个程序似的 不知道有多少数就能打印出来。（个人猜测，我也刚学 ）
我的意思是你知道这个数 然后赋值这写 我也知道整形不能用，所以只是个思路，0=False就是假可以利用这个来循环打印。
可以先试一下你上面32 25 15 0如果做出了还请分享一下代码

2084153280

1514155012 发表于 2021-12-2 23:22
那个啥 我俩不是一个人 上面代码相当于一个程序似的 不知道有多少数就能打印出来。（个人猜测，我也刚学  ...

我试试我也没学多久

2084153280

1514155012 发表于 2021-12-2 23:22
那个啥 我俩不是一个人 上面代码相当于一个程序似的 不知道有多少数就能打印出来。（个人猜测，我也刚学  ...

我想问一下大佬怎么保存输入的数据

1514155012

2084153280 发表于 2021-12-2 23:29
我想问一下大佬怎么保存输入的数据

代码出来了 不过是列表的形式不知道是不是你想要的
这个只是列表分片 原来的数据还在
a = [45,55,66,77,0]
print(a[:len(a)-1])
print(a[-2::-1])
print(a)
上面a里面的列表可以是任何数 我就会那么多 哈哈哈哈我也是刚学。如果能帮到你我很高兴，如果不能请不要生气。

人造人

jackz007 发表于 2021-12-2 23:00
你指什么？

我估计他指的是我的代码，他回复错人了