用C语言写出如下条件程序

ctyaa

xxm8023

yuxijian2020

工具人报到
太晚了，就弄了第一个

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. 
   
5. //从 pos 开始往左 找到第一个 0值 在数组中的位置距离当前位置的距离
   
6. int LeftFindZero(int* box, int num, int pos)
   
7. {
   
8.         int cur = (pos - 1) < 0 ? num - 1 : pos - 1;
   
9.         int distance = 1;
   
10. 
    
11.         while (box[cur] != 0)
    
12.         {
    
13.                 distance++;
    
14.                 cur = (cur - 1) < 0 ? num - 1 : cur - 1;
    
15.         }
    
16. 
    
17.         return distance;
    
18. }
    
19. //从 pos 开始往右 找到第一个 0值 在数组中的位置距离当前位置的距离
    
20. int RightFindZero(int* box, int num, int pos)
    
21. {
    
22.         int cur = (pos + 1) < num ? pos + 1 : 0;
    
23.         int distance = 1;
    
24. 
    
25.         while (box[cur] != 0)
    
26.         {
    
27.                 distance++;
    
28.                 cur = (cur + 1) < num ? cur + 1 : 0;
    
29.         }
    
30. 
    
31.         return distance;
    
32. }
    
33. //优先向左边填充
    
34. int LeftFindNearestZeroAndSwap(int* box, int num, int pos)
    
35. {
    
36.         int leftZero = LeftFindZero(box, num, pos);
    
37.         int rightZero = RightFindZero(box, num, pos);
    
38.         int cur = 0;
    
39. 
    
40.         if (leftZero > rightZero)
    
41.         {
    
42.                 cur = rightZero + pos >= num ? (rightZero + pos - num) : rightZero + pos;
    
43.                 box[cur]++;
    
44.                 box[pos]--;
    
45.                 return rightZero;
    
46.         }
    
47.         else
    
48.         {
    
49.                 cur = pos - leftZero < 0 ? (pos + num - leftZero) : pos - leftZero;
    
50.                 box[cur]++;
    
51.                 box[pos]--;
    
52.                 return leftZero;
    
53.         }
    
54. }
    
55. //优先向右边填充
    
56. int RightFindNearestZeroAndSwap(int* box, int num, int pos)
    
57. {
    
58.         int leftZero = LeftFindZero(box, num, pos);
    
59.         int rightZero = RightFindZero(box, num, pos);
    
60.         int cur = 0;
    
61. 
    
62.         if (rightZero > leftZero)
    
63.         {
    
64.                 cur = pos - leftZero < 0 ? (pos + num - leftZero) : pos - leftZero;
    
65.                 box[cur]++;
    
66.                 box[pos]--;
    
67.                 return leftZero;
    
68.         }
    
69.         else
    
70.         {
    
71.                 cur = rightZero + pos >= num ? (rightZero + pos - num) : rightZero + pos;
    
72.                 box[cur]++;
    
73.                 box[pos]--;
    
74.                 return rightZero;
    
75.         }
    
76. }
    
77. //分发
    
78. int HandOut(int* box, int num)
    
79. {
    
80.         if (num <= 0) return 0;
    
81. 
    
82.         int left                = 0;                //左边
    
83.         int right                = 0;                //右边
    
84.         int leftCount        = 0;                //优先往左移动
    
85.         int rightCount        = 0;                //优先往右移动
    
86.         int count                = 0;                //返回值
    
87.         int* leftBox        = (int*)malloc(sizeof(int) * num);        //临时数组
    
88.         int* rightBox        = (int*)malloc(sizeof(int) * num);        //临时数组
    
89.         if (leftBox == NULL || rightBox == NULL) return 0;
    
90. 
    
91.         memset(leftBox, 0, sizeof(int) * num);
    
92.         memset(rightBox, 0, sizeof(int) * num);
    
93. 
    
94.         for (int i = 0; i < num; i++)
    
95.         {
    
96.                 leftBox[i]        = box[i];
    
97.                 rightBox[i] = box[i];
    
98.         }
    
99. 
    
100.         for (int i = 0; i < num; i++)
     
101.         {
     
102.                 while (leftBox[i] > 1)
     
103.                         leftCount += LeftFindNearestZeroAndSwap(leftBox, num, i);
     
104.         }
     
105. 
     
106.         for (int j = num - 1; j >= 0; j--)
     
107.         {
     
108.                 while (rightBox[j] > 1)
     
109.                         rightCount += RightFindNearestZeroAndSwap(rightBox, num, j);
     
110.         }
     
111. 
     
112.         free(leftBox);
     
113.         free(rightBox);
     
114. 
     
115.         count = leftCount > rightCount ? rightCount : leftCount;
     
116.         return count;
     
117. }
     
118. 
     
119. void OperatorCount()
     
120. {
     
121.         int t = 51;                //数据组数
     
122.         int N = 501;        //盒子数量 和 糖果的最大数量
     
123.         int** boxs;                //盒子
     
124.         int* result;        //结果
     
125.         //获取用户输入
     
126.         while (t < 0 || t > 50)
     
127.         {
     
128.                 printf_s("本次输入几组数据？(0 <= t <= 50)\n");
     
129.                 scanf_s("%d%*c", &t);
     
130.                 if (t < 0 || t > 50)
     
131.                         printf_s("输入错误，请重新输入 t\n");
     
132.         }
     
133. 
     
134.         while (N < 1 || N > 500)
     
135.         {
     
136.                 printf_s("共有几个盒子？(1 <= N <= 500)\n");
     
137.                 scanf_s("%d%*c", &N);
     
138.                 if (N < 1 || N > 500)
     
139.                         printf_s("盒子数量错误！请重新输入！\n");
     
140.         }
     
141.         //申请空间
     
142.         boxs = (int**)malloc(sizeof(int*) * t);
     
143.         if (boxs == NULL) return;                                        //判断是否申请成功
     
144.         for (int i = 0; i < t; i++)
     
145.         {
     
146.                 boxs[i] = (int*)malloc(sizeof(int) * N);
     
147.                 if (boxs[i] == NULL) return;
     
148.                 memset(boxs[i], 0, sizeof(int) * N);
     
149.         }
     
150. 
     
151.         result = (int*)malloc(sizeof(int) * t);
     
152.         if (result == NULL) return;
     
153.         memset(result, 0, sizeof(int) * t);
     
154. 
     
155.         for (int i = 0; i < t; i++)
     
156.         {
     
157.                 for (int j = 0; j < N; j++)
     
158.                 {
     
159.                         printf_s("请输入第 %d 组 第 %d 个盒子中的糖果数量:", i, j);
     
160.                         scanf_s("%d", &boxs[i][j]);
     
161.                 }
     
162.                 result[i] = HandOut(boxs[i], N);
     
163.         }
     
164. 
     
165.         for (int i = 0; i < t; i++)
     
166.                 printf_s("第 %d 组数据需要至少操作 %d 次\n", i, result[i]);
     
167. 
     
168.         free(result);
     
169.         for (int i = 0; i < t; i++)
     
170.                 free(boxs[i]);
     
171.         free(boxs);
     
172. }
     
173. 
     
174. int main()
     
175. {
     
176.         OperatorCount();
     
177. 
     
178.         system("pause");
     
179.         return 0;
     
180. }

复制代码

最强废铁h

新鱼油不会

王之叹息

等我操作

江河之缘

jia1230

狱鬼·泪魂

小徐是我呀

我哇

万千只cnm

hoh478

怀瑾啊怀瑾

好多作业

小灰灰呀

不会

a2316565897