乙级的题目训练主要用来熟悉编程语言的语法和形成良好的编码习惯和编码规范。从小白开始逐步掌握用编程解决问题。

PAT乙级BasicLevelPractice 1012

问题分析

题目给出了明确的处理内容:

1. 对一些系列正数进行分类
2. 按照要求计算出5个数
3. 输出5个数字

而根据所要求的5个数的定义, 每个数都是从除以5之后得到的余数相同的数中进行计算.
所以分类时, 需要按照除以5之后所得余数来分.
【这里有个坑，A1的要求里，不是除以5之后余0就可以归到A1组，而是余0且是偶数才可以归到A1组】

分析计算要求

• A1: 求组别中所有偶数的和 - 要求十分明确, 没有需要额外厘清的概念
• A2: 题设直接出给了表达式, 按照表达式计算即可
• A3: 求个数
• A4: 平均数
• A5: 最大值

要求都十分明确, 重点在于如何对数分类(包括分类之类各组数的存储)

完整地描述步骤

1. 读入正数个数以及各个正数
2. 遍历各个正数, 进行求余操作, 按照余数的值分类
3. 遍历各组分类后的数, 按照要求计算所求数值

伪代码描述

1. 读入数据

2. 建立5个空间用于存放5组分类后的数

3. for (number in input_numbers):
   if number % 5 == 0: 放入分组1
   if number % 5 == 1: 放入分组2
   if number % 5 == 2: 放入分组3
   if number % 5 == 3: 放入分组4
   if number % 5 == 4: 放入分组5

4. 建立五个空间, 用于存放之后计算得到的5个数值(可以设置初始值为0)

5. for(number in 分组1):
   如果number是偶数, 累加

6. for(number in 分组2):
   如果number的次序是奇数, 加上这个数
   如果number的次序是偶数, 减去这个数

7. for(number in 分组3):
   计数器+1

8. for(number in 分组4):
   累加
   计数器+1
   循环结束后, 和 / 计数器的值

9. for(number in 分组5):
   如果比当前的最大值大, 更新最大值

【实现上需要补充的细节】

1. C语言中, 如何精确到小数点后1位? 如何输出小数?

   • float a = 3.456; //保留到小数点后两位
   • float b =(int)((a * 100) + 0.5) / 100.0;

2. 函数如何传入/返回数组(甚至是二维数组)?

完整提交代码

/*
问题分析:
题目给出了明确的处理内容:
1. 对一些系列正数进行分类
2. 按照要求计算出5个数
3. 输出5个数字

而根据所要求的5个数的定义, 每个数都是从除以5之后得到的余数相同的书中进行计算.
所以分类时, 需要按照除以5之后所得余数来分.

## 分析计算要求
- A1: 求组别中所有偶数的和 - 要求十分明确, 没有需要额外厘清的概念
- A2: 题设直接出给了表达式, 按照表达式计算即可
- A3: 求个数
- A4: 平均数
- A5: 最大值

要求都十分明确, 重点在于如何对数分类(包括分类之类各组数的存储)

# 完整地描述步骤
1. 读入正数个数以及各个正数
2. 遍历各个正数, 进行求余操作, 按照余数的值分类
3. 遍历各组分类后的数, 按照要求计算所求数值


# 伪代码描述
1. 读入数据
2. 建立5个空间用于存放5组分类后的数
3. for (number in input_numbers):
    if number % 5 == 0: 放入分组1
    if number % 5 == 1: 放入分组2
    if number % 5 == 2: 放入分组3
    if number % 5 == 3: 放入分组4
    if number % 5 == 4: 放入分组5

4. 建立五个空间, 用于存放之后计算得到的5个数值(可以设置初始值为0)
5. for(number in 分组1):
    如果number是偶数, 累加
6. for(number in 分组2):
    如果number的次序是奇数, 加上这个数
    如果number的次序是偶数, 减去这个数
7. for(number in 分组3):
    计数器+1
8. for(number in 分组4):
    累加
    计数器+1
   循环结束后, 和 / 计数器的值
9. for(number in 分组5):
    如果比当前的最大值大, 更新最大值

【实现上需要补充的细节】
1. C语言中, 如何精确到小数点后1位? 如何输出小数?
    - float a = 3.456; //保留到小数点后两位
    - float b =(int)((a * 100) + 0.5) / 100.0;

2. 函数如何传入/返回数组(甚至是二维数组)?

*/

#include 

void group_numbers(int number_amount, int *numbers, int grouped_results[5][1000], int *counter_of_group_number)
{
    for (int i = 0; i < number_amount; i++)
    {
        int current_number = numbers[i];
        int remainder = current_number % 5;
        grouped_results[remainder][counter_of_group_number[remainder]] = current_number;
        counter_of_group_number[remainder]++;
    }
}

int calculate_required_number_1(int group_size, int *number_group)
{
    int sum_of_odd_number = 0;
    for (int i = 0; i < group_size; i++)
    {
        if (number_group[i] % 2 == 0)
        {
            sum_of_odd_number += number_group[i];
        }
    }

    return sum_of_odd_number;
}

int calculate_required_number_2(int group_size, int *number_group)
{
    int required_sum = 0;
    for (int i = 0; i < group_size; i++)
    {
        if (i % 2 == 0)
        {
            required_sum += number_group[i];
        }
        else
        {
            required_sum -= number_group[i];
        }
    }

    return required_sum;
}

int calculate_required_number_3(int group_size, int *number_group)
{
    return group_size;
}

double calculate_required_number_4(int group_size, int *number_group)
{
    double result = 0.0;
    if (group_size == 0)
    {
        return result;
    }

    int sum_of_all_numbers = 0;
    for (int i = 0; i < group_size; i++)
    {
        sum_of_all_numbers += number_group[i];
    }
    result = (double)sum_of_all_numbers / group_size;
    result = (int)(result * 10 + 0.5) / 10.0;

    return result;
}

int calculate_required_number_5(int group_size, int *number_group)
{
    int max_number = 0;
    for (int i = 0; i < group_size; i++)
    {
        if (number_group[i] > max_number)
        {
            max_number = number_group[i];
        }
    }
    return max_number;
}

int main()
{
    int number_amount;
    scanf("%d", &number_amount);

    int numbers[number_amount];
    for (int i = 0; i < number_amount; i++)
    {
        scanf("%d", &numbers[i]);
    }

    int number_groups[5][1000];
    int counter_of_group_number[5] = {0, 0, 0, 0, 0};

    group_numbers(number_amount, numbers, number_groups, counter_of_group_number);
    double results[5];

    results[0] = calculate_required_number_1(counter_of_group_number[0], number_groups[0]);
    results[1] = calculate_required_number_2(counter_of_group_number[1], number_groups[1]);
    results[2] = calculate_required_number_3(counter_of_group_number[2], number_groups[2]);
    results[3] = calculate_required_number_4(counter_of_group_number[3], number_groups[3]);
    results[4] = calculate_required_number_5(counter_of_group_number[4], number_groups[4]);

    for (int i = 0; i < 5; i++)
    {
        if (counter_of_group_number[i] == 0 || (i == 0  && results[i] == 0))
        {
            printf("N");
        }
        else if (i == 3)
        {
            printf("%.1f", results[i]);
        }
        else
        {
            printf("%d", (int)results[i]);
        }
        if (i != 4)
        {
            printf(" ");
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185