鱼C论坛

 找回密码
 立即注册
查看: 1608|回复: 4

[已解决]帮忙看一道题目

[复制链接]
发表于 2021-4-4 14:43:38 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能^_^

您需要 登录 才可以下载或查看,没有账号?立即注册

x
问题描述
  输入任意10个浮点数,根据它们的聚集程度划分为3组,输出每一组的平均值。
  提供老师上课讲的一种思路:将10个数字进行在数轴上排序,然后计算每两个点间的距离,在所有的距离中选取两个最大距离处断开,这样就把10个数字分为了3组。
  本题难度较大,如果深入讨论会比较复杂,大家可以只考虑如下面样例所示的分组情况非常简单的情况,只要简单情况能够成功计算,本题就能得分。
  十个待输入的浮点数,使用空格隔开
输出格式
  三组数的平均数,每输出一个需要换行
样例输入
一个满足题目要求的输入范例。
例1:
50.4 51.3 52.3 9.5 10.4 11.6 19.1 20.8 21.9 49.6

例2:
8.6 7.4 3.5 17.9 19.1 18.5 37.6 40.4 38.5 40.0
样例输出
与上面的样例输入对应的输出。
例1:
10.5
20.6
50.9

例2:
6.5
18.5
39.125
数据规模和约定
  仅考虑如样例一样简单情况、分组明显的输入
最佳答案
2021-4-7 15:15:47
一共3个版本

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>

  5. struct data_d_t {
  6.     double *v;
  7.     size_t s;
  8. };

  9. struct data_vd_t {
  10.     struct data_d_t *v;
  11.     size_t s;
  12. };

  13. struct data_ds_t {
  14.     double d;
  15.     size_t s;
  16. };

  17. struct data_pds_t {
  18.     struct data_ds_t *v;
  19.     size_t s;
  20. };

  21. int compar_d(const void *a, const void *b) {
  22.     return *(const double *)a > *(const double *)b;
  23. }

  24. int compar_pds(const void *a, const void *b) {
  25.     return ((const struct data_ds_t *)a)->s > ((const struct data_ds_t *)b)->s;
  26. }

  27. void free_d(struct data_d_t d) {
  28.     free(d.v);
  29. }

  30. void free_vd(struct data_vd_t d) {
  31.     for(size_t i = 0; i < d.s; ++i) {
  32.         free_d(d.v[i]);
  33.     }
  34.     free(d.v);
  35. }

  36. void free_pds(struct data_pds_t d) {
  37.     free(d.v);
  38. }

  39. void data_pds_insert(size_t i, struct data_pds_t *d, struct data_ds_t v) {
  40.     memmove(&d->v[i + 1], &d->v[i], (d->s - i) * sizeof(v));
  41.     d->v[i] = v;
  42.     ++d->s;
  43. }

  44. void data_pds_append(struct data_pds_t *d, struct data_ds_t v) {
  45.     d->v[d->s++] = v;
  46. }

  47. struct data_d_t create_data_d(const double *a, const double *b) {
  48.     struct data_d_t result;
  49.     result.v = malloc(sizeof(*result.v) * 100);
  50.     result.s = 0;
  51.     for(size_t i = 0; &a[i] != b; ++i) {
  52.         result.v[i] = a[i];
  53.         ++result.s;
  54.     }
  55.     return result;
  56. }

  57. struct data_d_t get_input(FILE *f, size_t s) {
  58.     struct data_d_t d;
  59.     d.s = 0;
  60.     d.v = malloc(sizeof(*d.v) * 100);
  61.     for(size_t i = 0; i < s; ++i) {
  62.         double tmp;
  63.         fscanf(f, "%lf", &tmp);
  64.         d.v[i] = tmp;
  65.         ++d.s;
  66.     }
  67.     return d;
  68. }

  69. struct data_pds_t get_max_distance(struct data_d_t d, size_t s) {
  70.     struct data_pds_t result;
  71.     result.v = malloc(sizeof(*result.v) * 100);
  72.     result.s = 0;
  73.     struct data_d_t distance;
  74.     distance.s = d.s - 1;
  75.     distance.v = malloc(sizeof(*distance.v) * distance.s);
  76.     for(size_t i = 0; i < distance.s; ++i) {
  77.         distance.v[i] = fabs(d.v[i] - d.v[i + 1]);
  78.     }
  79.     for(size_t i = 0; i < s; ++i) {
  80.         struct data_ds_t tmp;
  81.         tmp.d = distance.v[0];
  82.         tmp.s = 0;
  83.         result.v[i] = tmp;
  84.         ++result.s;
  85.         distance.v[0] = 0;
  86.         for(size_t j = 1; j < distance.s; ++j) {
  87.             struct data_ds_t *p = &result.v[i];
  88.             if(distance.v[j] > p->d) {
  89.                 distance.v[p->s] = p->d;
  90.                 p->d = distance.v[j];
  91.                 p->s = j;
  92.                 distance.v[j] = j;
  93.             }
  94.         }
  95.     }
  96.     free_d(distance);
  97.     return result;
  98. }

  99. struct data_vd_t get_groups(struct data_d_t d, size_t s) {
  100.     struct data_vd_t result;
  101.     result.v = malloc(sizeof(*result.v) * 100);
  102.     result.s = 0;
  103.     struct data_pds_t distance = get_max_distance(d, s - 1);
  104.     qsort(distance.v, distance.s, sizeof(*distance.v), compar_pds);
  105.     struct data_ds_t tmp;
  106.     tmp.d = 0;
  107.     tmp.s = -1;
  108.     data_pds_insert(0, &distance, tmp);
  109.     tmp.d = 0;
  110.     tmp.s = d.s - 1;
  111.     data_pds_append(&distance, tmp);
  112.     for(size_t i = 0; i < distance.s - 1; ++i) {
  113.         result.v[i] = create_data_d(&d.v[distance.v[i].s + 1], &d.v[distance.v[i + 1].s + 1]);
  114.         ++result.s;
  115.     }
  116.     free_pds(distance);
  117.     return result;
  118. }

  119. struct data_d_t get_average(struct data_vd_t d) {
  120.     struct data_d_t result;
  121.     result.v = malloc(sizeof(*result.v) * 100);
  122.     result.s = 0;
  123.     for(size_t i = 0; i < d.s; ++i) {
  124.         double sum = 0;
  125.         for(size_t j = 0; j < d.v[i].s; ++j) {
  126.             sum += d.v[i].v[j];
  127.         }
  128.         result.v[i] = sum / d.v[i].s;
  129.         ++result.s;
  130.     }
  131.     return result;
  132. }

  133. void print(struct data_d_t d) {
  134.     for(size_t i = 0; i < d.s; ++i) {
  135.         printf("%f ", d.v[i]);
  136.     }
  137.     printf("\n");
  138. }

  139. int main(void) {
  140.     struct data_d_t raw_data = get_input(stdin, 10);
  141.     qsort(raw_data.v, raw_data.s, sizeof(*raw_data.v), compar_d);
  142.     struct data_vd_t group_data = get_groups(raw_data, 3);
  143.     struct data_d_t average = get_average(group_data);
  144.     print(average);
  145.     free_d(average);
  146.     free_vd(group_data);
  147.     free_d(raw_data);
  148.     return 0;
  149. }
复制代码


  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>

  4. int compar_d(const void *a, const void *b) {
  5.     return *(const double *)a > *(const double *)b;
  6. }

  7. void print(double data[], size_t size) {
  8.     for(size_t i = 0; i < size; ++i) {
  9.         printf("%f ", data[i]);
  10.     }
  11.     printf("\n");
  12. }

  13. int main(void) {
  14.     double raw_buff[10];
  15.     for(size_t i = 0; i < 10; ++i) {
  16.         scanf("%lf", &raw_buff[i]);
  17.     }
  18.     qsort(raw_buff, 10, sizeof(*raw_buff), compar_d);
  19.     size_t group_buff[2];
  20.     //size_t group_size = get_groups(group_buff, raw_buff, 10);
  21.     {
  22.         double distance_buff[9];
  23.         for(size_t i = 0; i < 9; ++i) {
  24.             distance_buff[i] = fabs(raw_buff[i] - raw_buff[i + 1]);
  25.         }
  26.         for(size_t i = 0; i < 2; ++i) {
  27.             size_t max_index = 0;
  28.             for(size_t j = 1; j < 9; ++j) {
  29.                 if(distance_buff[max_index] < distance_buff[j]) {
  30.                     max_index = j;
  31.                 }
  32.             }
  33.             distance_buff[max_index] = 0;
  34.             group_buff[i] = max_index;
  35.         }
  36.         if(group_buff[0] > group_buff[1]) {
  37.             size_t tmp = group_buff[0];
  38.             group_buff[0] = group_buff[1];
  39.             group_buff[1] = tmp;
  40.         }
  41.     }
  42.     double average_buff[3];
  43.     //size_t average_size = get_average(average_buff, raw_buff, group_buff, group_size);
  44.     {
  45.         {
  46.             double sum = 0;
  47.             for(size_t i = 0; i <= group_buff[0]; ++i) {
  48.                 sum += raw_buff[i];
  49.             }
  50.             average_buff[0] = sum / (group_buff[0] + 1);
  51.         }
  52.         {
  53.             double sum = 0;
  54.             for(size_t i = group_buff[0] + 1; i <= group_buff[1]; ++i) {
  55.                 sum += raw_buff[i];
  56.             }
  57.             average_buff[1] = sum / (group_buff[1] - group_buff[0]);
  58.         }
  59.         {
  60.             double sum = 0;
  61.             for(size_t i = group_buff[1] + 1; i <= 9; ++i) {
  62.                 sum += raw_buff[i];
  63.             }
  64.             average_buff[2] = sum / (9 - group_buff[1]);
  65.         }
  66.     }
  67.     print(average_buff, 3);
  68.     return 0;
  69. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

发表于 2021-4-4 20:38:17 | 显示全部楼层
本帖最后由 人造人 于 2021-4-4 20:48 编辑

1. 没说用什么语言写,那就用C++写了
2. 完全按照你们老师的思路写的
3. 没有注释,^_^

  1. #include <iostream>
  2. #include <vector>
  3. #include <algorithm>
  4. #include <cmath>

  5. const std::vector<double> get_input(std::istream &is, size_t size) {
  6.     std::vector<double> v;
  7.     for(size_t i = 0; i < size; ++i) {
  8.         double tmp; is >> tmp;
  9.         v.push_back(tmp);
  10.     }
  11.     return v;
  12. }

  13. const std::vector<std::pair<double, size_t>> get_max_distance(const std::vector<double> &lhs, size_t size) {
  14.     std::vector<std::pair<double, size_t>> result;
  15.     std::vector<double> distance(lhs.size() - 1);
  16.     for(size_t i = 0; i < distance.size(); ++i) {
  17.         distance[i] = std::fabs(lhs[i] - lhs[i + 1]);
  18.     }
  19.     for(size_t i = 0; i < size; ++i) {
  20.         result.push_back(std::pair<double, size_t>(distance[0], 0));
  21.         distance[0] = 0;
  22.         for(size_t j = 1; j < distance.size(); ++j) {
  23.             auto p = result.end() - 1;
  24.             if(distance[j] > p->first) {
  25.                 distance[p->second] = p->first;
  26.                 p->first = distance[j];
  27.                 p->second = j;
  28.                 distance[j] = 0;
  29.             }
  30.         }
  31.     }
  32.     return result;
  33. }

  34. const std::vector<std::vector<double>> get_groups(const std::vector<double> &v, size_t size) {
  35.     std::vector<std::vector<double>> result;
  36.     std::vector<std::pair<double, size_t>> distance = get_max_distance(v, size - 1);
  37.     std::sort(distance.begin(), distance.end(), [](const std::pair<double, size_t> &a, \
  38.                 const std::pair<double, size_t> &b) -> bool {return a.second < b.second;});
  39.     distance.insert(distance.begin(), std::pair<double, size_t>(0, -1));
  40.     distance.push_back(std::pair<double, size_t>(0, v.size() - 1));
  41.     for(size_t i = 0; i < distance.size() - 1; ++i) {
  42.         result.push_back(std::vector<double>(v.begin() + distance[i].second + 1, v.begin() + distance[i + 1].second + 1));
  43.     }
  44.     return result;
  45. }

  46. std::vector<double> get_average(const std::vector<std::vector<double>> &data) {
  47.     std::vector<double> v;
  48.     for(auto iter = data.begin(); iter != data.end(); ++iter) {
  49.         double sum = 0;
  50.         for(const auto &j: *iter) sum += j;
  51.         v.push_back(sum / iter->size());
  52.     }
  53.     return v;
  54. }

  55. std::ostream &operator<<(std::ostream &os, const std::vector<double> &rhs) {
  56.     for(const auto &i: rhs) os << i << " ";
  57.     return os;
  58. }

  59. int main() {
  60.     std::vector<double> raw_data = get_input(std::cin, 10);
  61.     std::sort(raw_data.begin(), raw_data.end());
  62.     std::vector<std::vector<double>> group_data = get_groups(raw_data, 3);
  63.     std::cout << get_average(group_data) << std::endl;
  64.     return 0;
  65. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2021-4-7 08:06:30 From FishC Mobile | 显示全部楼层
人造人 发表于 2021-4-4 20:38
1. 没说用什么语言写,那就用C++写了
2. 完全按照你们老师的思路写的
3. 没有注释,^_^

可以换成c吗,这看不懂
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2021-4-7 15:15:47 | 显示全部楼层    本楼为最佳答案   
一共3个版本

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>

  5. struct data_d_t {
  6.     double *v;
  7.     size_t s;
  8. };

  9. struct data_vd_t {
  10.     struct data_d_t *v;
  11.     size_t s;
  12. };

  13. struct data_ds_t {
  14.     double d;
  15.     size_t s;
  16. };

  17. struct data_pds_t {
  18.     struct data_ds_t *v;
  19.     size_t s;
  20. };

  21. int compar_d(const void *a, const void *b) {
  22.     return *(const double *)a > *(const double *)b;
  23. }

  24. int compar_pds(const void *a, const void *b) {
  25.     return ((const struct data_ds_t *)a)->s > ((const struct data_ds_t *)b)->s;
  26. }

  27. void free_d(struct data_d_t d) {
  28.     free(d.v);
  29. }

  30. void free_vd(struct data_vd_t d) {
  31.     for(size_t i = 0; i < d.s; ++i) {
  32.         free_d(d.v[i]);
  33.     }
  34.     free(d.v);
  35. }

  36. void free_pds(struct data_pds_t d) {
  37.     free(d.v);
  38. }

  39. void data_pds_insert(size_t i, struct data_pds_t *d, struct data_ds_t v) {
  40.     memmove(&d->v[i + 1], &d->v[i], (d->s - i) * sizeof(v));
  41.     d->v[i] = v;
  42.     ++d->s;
  43. }

  44. void data_pds_append(struct data_pds_t *d, struct data_ds_t v) {
  45.     d->v[d->s++] = v;
  46. }

  47. struct data_d_t create_data_d(const double *a, const double *b) {
  48.     struct data_d_t result;
  49.     result.v = malloc(sizeof(*result.v) * 100);
  50.     result.s = 0;
  51.     for(size_t i = 0; &a[i] != b; ++i) {
  52.         result.v[i] = a[i];
  53.         ++result.s;
  54.     }
  55.     return result;
  56. }

  57. struct data_d_t get_input(FILE *f, size_t s) {
  58.     struct data_d_t d;
  59.     d.s = 0;
  60.     d.v = malloc(sizeof(*d.v) * 100);
  61.     for(size_t i = 0; i < s; ++i) {
  62.         double tmp;
  63.         fscanf(f, "%lf", &tmp);
  64.         d.v[i] = tmp;
  65.         ++d.s;
  66.     }
  67.     return d;
  68. }

  69. struct data_pds_t get_max_distance(struct data_d_t d, size_t s) {
  70.     struct data_pds_t result;
  71.     result.v = malloc(sizeof(*result.v) * 100);
  72.     result.s = 0;
  73.     struct data_d_t distance;
  74.     distance.s = d.s - 1;
  75.     distance.v = malloc(sizeof(*distance.v) * distance.s);
  76.     for(size_t i = 0; i < distance.s; ++i) {
  77.         distance.v[i] = fabs(d.v[i] - d.v[i + 1]);
  78.     }
  79.     for(size_t i = 0; i < s; ++i) {
  80.         struct data_ds_t tmp;
  81.         tmp.d = distance.v[0];
  82.         tmp.s = 0;
  83.         result.v[i] = tmp;
  84.         ++result.s;
  85.         distance.v[0] = 0;
  86.         for(size_t j = 1; j < distance.s; ++j) {
  87.             struct data_ds_t *p = &result.v[i];
  88.             if(distance.v[j] > p->d) {
  89.                 distance.v[p->s] = p->d;
  90.                 p->d = distance.v[j];
  91.                 p->s = j;
  92.                 distance.v[j] = j;
  93.             }
  94.         }
  95.     }
  96.     free_d(distance);
  97.     return result;
  98. }

  99. struct data_vd_t get_groups(struct data_d_t d, size_t s) {
  100.     struct data_vd_t result;
  101.     result.v = malloc(sizeof(*result.v) * 100);
  102.     result.s = 0;
  103.     struct data_pds_t distance = get_max_distance(d, s - 1);
  104.     qsort(distance.v, distance.s, sizeof(*distance.v), compar_pds);
  105.     struct data_ds_t tmp;
  106.     tmp.d = 0;
  107.     tmp.s = -1;
  108.     data_pds_insert(0, &distance, tmp);
  109.     tmp.d = 0;
  110.     tmp.s = d.s - 1;
  111.     data_pds_append(&distance, tmp);
  112.     for(size_t i = 0; i < distance.s - 1; ++i) {
  113.         result.v[i] = create_data_d(&d.v[distance.v[i].s + 1], &d.v[distance.v[i + 1].s + 1]);
  114.         ++result.s;
  115.     }
  116.     free_pds(distance);
  117.     return result;
  118. }

  119. struct data_d_t get_average(struct data_vd_t d) {
  120.     struct data_d_t result;
  121.     result.v = malloc(sizeof(*result.v) * 100);
  122.     result.s = 0;
  123.     for(size_t i = 0; i < d.s; ++i) {
  124.         double sum = 0;
  125.         for(size_t j = 0; j < d.v[i].s; ++j) {
  126.             sum += d.v[i].v[j];
  127.         }
  128.         result.v[i] = sum / d.v[i].s;
  129.         ++result.s;
  130.     }
  131.     return result;
  132. }

  133. void print(struct data_d_t d) {
  134.     for(size_t i = 0; i < d.s; ++i) {
  135.         printf("%f ", d.v[i]);
  136.     }
  137.     printf("\n");
  138. }

  139. int main(void) {
  140.     struct data_d_t raw_data = get_input(stdin, 10);
  141.     qsort(raw_data.v, raw_data.s, sizeof(*raw_data.v), compar_d);
  142.     struct data_vd_t group_data = get_groups(raw_data, 3);
  143.     struct data_d_t average = get_average(group_data);
  144.     print(average);
  145.     free_d(average);
  146.     free_vd(group_data);
  147.     free_d(raw_data);
  148.     return 0;
  149. }
复制代码


  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>

  4. int compar_d(const void *a, const void *b) {
  5.     return *(const double *)a > *(const double *)b;
  6. }

  7. void print(double data[], size_t size) {
  8.     for(size_t i = 0; i < size; ++i) {
  9.         printf("%f ", data[i]);
  10.     }
  11.     printf("\n");
  12. }

  13. int main(void) {
  14.     double raw_buff[10];
  15.     for(size_t i = 0; i < 10; ++i) {
  16.         scanf("%lf", &raw_buff[i]);
  17.     }
  18.     qsort(raw_buff, 10, sizeof(*raw_buff), compar_d);
  19.     size_t group_buff[2];
  20.     //size_t group_size = get_groups(group_buff, raw_buff, 10);
  21.     {
  22.         double distance_buff[9];
  23.         for(size_t i = 0; i < 9; ++i) {
  24.             distance_buff[i] = fabs(raw_buff[i] - raw_buff[i + 1]);
  25.         }
  26.         for(size_t i = 0; i < 2; ++i) {
  27.             size_t max_index = 0;
  28.             for(size_t j = 1; j < 9; ++j) {
  29.                 if(distance_buff[max_index] < distance_buff[j]) {
  30.                     max_index = j;
  31.                 }
  32.             }
  33.             distance_buff[max_index] = 0;
  34.             group_buff[i] = max_index;
  35.         }
  36.         if(group_buff[0] > group_buff[1]) {
  37.             size_t tmp = group_buff[0];
  38.             group_buff[0] = group_buff[1];
  39.             group_buff[1] = tmp;
  40.         }
  41.     }
  42.     double average_buff[3];
  43.     //size_t average_size = get_average(average_buff, raw_buff, group_buff, group_size);
  44.     {
  45.         {
  46.             double sum = 0;
  47.             for(size_t i = 0; i <= group_buff[0]; ++i) {
  48.                 sum += raw_buff[i];
  49.             }
  50.             average_buff[0] = sum / (group_buff[0] + 1);
  51.         }
  52.         {
  53.             double sum = 0;
  54.             for(size_t i = group_buff[0] + 1; i <= group_buff[1]; ++i) {
  55.                 sum += raw_buff[i];
  56.             }
  57.             average_buff[1] = sum / (group_buff[1] - group_buff[0]);
  58.         }
  59.         {
  60.             double sum = 0;
  61.             for(size_t i = group_buff[1] + 1; i <= 9; ++i) {
  62.                 sum += raw_buff[i];
  63.             }
  64.             average_buff[2] = sum / (9 - group_buff[1]);
  65.         }
  66.     }
  67.     print(average_buff, 3);
  68.     return 0;
  69. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2021-4-7 20:27:34 | 显示全部楼层

谢谢
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-7-13 18:44

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表