C&C++数组实训(国防科大)

第1关：销售波动统计

100

• 任务要求
• 参考答案
• 评论472

• 任务描述
• 相关知识
  • 一维数组
  • 数组元素的访问
  • 数组的初始化
  • 数组的遍历
• 编程要求
• 测试说明

---

任务描述

本关任务：假定有一组数据记录着卖场每天（不超过30天）的销售额（假设都是整数），要求你统计并输出销售的波动情况，即计算每天相对于前一天的销售额的增减情况（即后项减前项的差值）。

例如连续5天的销售额分别是：23 56 12 76 43，则销售波动情况的输出为：33 -44 64 -33。

其中：33 = 56 - 23，-44 = 12 - 56，以此类推。

相关知识

一段时间内每天销售额的记录需要由一组数据来完成，其中，数据的个数可能为0到30中的任何一个数，尽管我们可以用30个变量来存储它们，但这显然很不方便。

使用数组则不仅简单直观，而且逻辑清晰。本关我们就一起来学习数组的运用。

一维数组

声明一维数组的一般形式为：

1. <元素类型> <数组名>[<元素个数>];

• <元素类型>指明了数组元素的类型，可以是整型、实型、布尔型和字符型等简单数据类型，也可以是用户定义的复合数据类型，包括数组类型；

• <数组名>由标识符充当，是整个数组的名字；<数组名>后面的方括号是必须的，C 和 C++ 把[]作为运算符处理，其优先级与括号相同，左结合；

• 方括号中的<元素个数>是整常量表达式，可以省略，表示数组元素的个数，注意数组元素的下标是从零开始计数的。

例如：

1. int a[10];

上述声明了一个数组名为 a 的整型数组，它有10个整型元素，下标的变化范围是0~9。

数组元素的访问

给定一个数组，我们可以采用以下形式访问数组里的元素：

1. <数组名>[<下标表达式>]

• <下标表达式>是值为整型的表达式，它指明了拟访问的数组元素的下标。

例如，数组 a 的10个元素可以依次表示为：a[0] ，a[1] ，a[2] ，…… ，a[9]。

注意：如果访问数组元素时使用的下标超出了元素的数目，会导致访问越界错误。C 和 C++ 不检查访问越界，如果发生了访问越界，有可能导致程序在运行时发生错误。

数组的各元素按顺序存储在一片连续的内存单元中。数组int a[10]的内存分配见下图所示：

 

数组的初始化

数组初始化的方法是把初始值按顺序放在花括号中，数值之间用逗号分开。

例如：

1. int a[10]={4};
2. float r[20]={0.1, 5.1};
3. double d[3]={10.0,5.0,1.0};

需要注意以下两点：

1. 如果初始值的数目小于数组元素的数目，数组剩余的元素被自动初始化为 0。

例如：

1. int n[5]={0}; //将数组 n 的所有数组元素都初始化为 0

注意：初始值的数目不能超过数组中元素的数目。

1. 声明数组时可以省略数组元素的数目，这时系统会根据初始值的数目来确定数组元素的数目。

例如：

1. int x[]={ 1, 2, 3, 4, 5 };

实际上声明了一个包含了5个整型元素的数组 x ：x[0] …… x[4] ，其值分别被初始化为 1 ，…… ，5。

这里再强调一下：我们不能直接操作某个数组，只能对数组中的某一个元素进行操作。也就是说，数组需要“拆开来用”，每次只能操作一个数组元素，操作数组元素的方法和操作普通变量的方法相同，“拆开数组”的方法就是数组名加下标访问数组元素的方式。

例如：

1. a[7]= 4; // 给数组元素 a[7] 赋值
2. x = 2 * a[i+2]; // 数组元素作表达式的运算量

数组的遍历

对于数组而言，最常见的用法是使用循环语句来操作数组，对数组元素进行遍历和处理。

例如下面的程序对数组 n 中的元素求和：

1. int n[10] = {12,34,55,71,1,65,423,19,540,10}; // 声明数组n并初始化
2. int i, sum = 0; // 定义循环变量和累加和变量
4. // 循环遍历数组并求和
5. for (i = 0; i <= 10-1; i++)
6. {
7. sum += n[i];
8. }
10. cout << "The summary is: " << sum << endl; // 输出求和结果

编程要求

在右侧编辑器中的Begin-End之间补充代码，程序给出计算几天的销售额分并给出这些天的额分（数据由平台提供，已获取，直接使用即可），统计并输出销售的波动情况，即计算每天相对于前一天的销售额的增减情况（即后项减前项的差值）。

温馨提示：这里要求输出的每个数字之间用一个空格隔开，最后一个数字后面没有空格。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：8 34 56 234 87 43 98 109 234（第一个数据表示有 8 天的销售额分，剩下的数据为具体额分） 预期输出：22 178 -147 -44 55 11 125

测试输入：4 0 89 190 289 预期输出：89 101 99

---

开始你的任务吧，祝你成功！

#include 
#include 
using namespace std;

int main()
{
    int n, a[30], i;     // 定义变量及数组，n-销售额个数，a-销售额
    cin >> n;     // 输入销售额数量，n <= 30
    // 输入n个销售额，分别存入a[0]到a[n-1]
    for(i = 0; i < n; i++)
        cin >> a[i];
    // 请在此添加代码，计算并输出销售额的波动情况
    /********** Begin *********/
	for(i=0;i

第2关：最大销售增幅

200

• 任务要求
• 参考答案
• 评论472

• 任务描述
• 相关知识
  • 数组作为函数的参数
• 编程要求
• 测试说明

---

任务描述

本关任务：编写函数 maxIncrease，用于计算一个销售额序列中的最大销售增幅并返回。这里的销售额都是非负整数。

对于给定的销售额序列 A，假设序列 A 的长度为 n（ n >= 2 ），最大销售额增幅是指满足0 <= x <= y < n的A[y] - A[x]的最大值。

例如，销售额序列11,3,5,7,9,2,4,6,8,10的最大增幅为8（在 x=5 ， y=9 时）。

相关知识

数组作为函数的参数

由于数组的存储是内存中一块连续的单元，数组元素的个数也是不确定的（不同的数组可能包含不同个数的数组元素），因此函数传递数组需要传递两个信息，一个是数组的地址（数组名就是数组地址），告诉被调用函数该数组存放在内存什么地方，另一个是数组元素个数，告诉被调用函数访问该数组时允许的下标范围（防止访问越界）。

参数传入一个整型数组的函数的函数原型如下：

1. void convertScores(int a[], int len);

• 第一个参数 a 是一个数组类型的形式参数。该参数 a 接收传入数组的数组名，也就是数组的首地址，其后的方括号中的数组长度不需要，即使有，编译器也会将其忽略；

• 第二个参数 len 是整型参数。该参数 len 传入数组 a 的长度，即 a 有 len 个数组元素，访问 a 的元素的下标范围就是 0 到 len-1。

例如：下面的程序将一个整型数组中存放的10名同学的百分制成绩转换为5分制，并输出。

1. #include
2. using namespace std;
4. // 分数转换函数的函数原型，其中：s-学生成绩数组名，len-学生成绩个数
5. void convertScores(int s[], int len);
7. int main()
8. {
9. // 定义学生成绩数组并初始化
10. int scores[10] = {85, 63, 72, 52, 95, 82, 77, 69, 88, 73};
11. convertScores(scores, 10); // 调用分数转换函数convertScores
12. // 转换完成后输出分数数组中的分数
13. for(int i = 0; i < 10; i++)
14. cout << "scores["<
15. return 0;
16. }
18. // 函数convertScores
19. void convertScores(int s[], int len)
20. {
21. // 逐个访问数组中的每个元素，并做转换
22. for (int i = 0; i < len; i++)
23. s[i] = s[i]/20; // 修改 s[i] 实际上就是修改 main 函数中的 scores[i]，因为 s 和 scores 拥有相同的地址值
24. }

程序的输出为：

1. scores[0] = 4
2. scores[1] = 3
3. scores[2] = 3
4. scores[3] = 2
5. scores[4] = 4
6. scores[5] = 4
7. scores[6] = 3
8. scores[7] = 3
9. scores[8] = 4
10. scores[9] = 3

上述示例中函数调用convertScores(scores, 10);导致数组 scores 中的每个元素都被转换了。也就是说，在被调用函数体内对数组 s（形式参数）的元素进行的修改操作实际上作用在了数组 scores（实在参数）的元素上，这是否就是传引用呢？

实际上，C 和 C++ 在处理数组参数时是严格地采取了传值方式。

参数传递数组的方式有比较特殊的地方，要理解传递数组的机制，首先要明确下面两点：

1. 和一般变量一样，数组名也是有值的，数组名的值就是数组的第一个元素的地址（首地址）；

2. 和一般变量一样，数组作为函数参数进行传递时，传递的也是数组变量的值，即数组第一个元素的地址。

由于数组名的值就是数组的第一个元素的地址，而访问数组元素的方式是数组名加下标（也就是首地址加下标），才使得尽管采取的是传值方式，但在被调用函数 convertScores 中，通过 s 加下标的方式访问数组元素，实际上访问的就是 main 函数中定义的数组 scores 的数组元素，因为 s 和 scores 代表了同样的地址位置。

编程要求

在右侧编辑器中的Begin-End之间补充代码，计算一个销售额序列中的最大销售增幅并返回。具体要求如下：

1. 如对于销售额序列 A ，假设序列 A 的长度为 n（ n >= 2 ） ，最大销售额增幅是指满足 0<=x<=yA[y] - A[x]的最大值；

2. 函数 maxIncrease 需要将数组作为参数传入，在该数组中计算最大销售额增幅并返回。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：6 12 34 78 45 10 23（第一个数据表示有6天的销售额分，剩下的数据为具体额分） 预期输出：最大销售增幅为：66

测试输入：9 90 2 80 3 70 6 50 7 40 预期输出：最大销售增幅为：78

---

开始你的任务吧，祝你成功！

#include 
using namespace std;

// 函数maxIncrease：计算销售额增幅
// 参数：s-销售额数组，n-销售额数组长度，n>1
// 返回值：销售额最大增幅
int maxIncrease(int s[], int n);

int main()
{
    int n, a[30], i;     // 定义变量及数组，n-销售额个数，a-销售额数组
    cin >> n;      // 输入销售额数量，n>1
    // 输入n个销售额，分别存入a[0]到a[n-1]
    for(i = 0; i < n; i++)
        cin >> a[i];
    i = maxIncrease(a,n);
    cout << "最大销售增幅为：" << i << endl;
    return 0;
}

int maxIncrease(int s[], int n)
{
    //请在此添加代码，实现函数maxIncrease
    /********** Begin *********/
    int i,j,max=0;
    for(i=0;imax){
                max=s[j]-s[i];
            }
        }
    }
    return max; 
    /********** End **********/
}

第3关：猴子选大王

300

• 任务要求
• 参考答案
• 评论472

• 任务描述
• 相关知识
• 编程要求
• 测试说明

---

任务描述

本关任务：编写一个函数 king，实现猴子选大王的功能。

新猴王的选择方法是：让 N 只候选猴子围成一圈（最多100只猴子），从某位置起顺序编号为 1 ~ N 号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。

相关知识

针对上述任务的描述，我们假设 N 只猴子分别占据数组 a 的下标从 1 ~ N 的位置（0号位置空着），从序号为1的猴子开始报数。返回值为猴王的序号。

本关可以把数组当作循环表来看，即第 N 个猴子的下一个猴子是第1个猴子。每次选出一个猴子，则对该位置进行标注，下次报数的时候跳过这些标注的位置即可。

在这里，我们假设 k 是当前报数猴子的序号，则下一个报数猴子的序号可以用如下程序求得：

1. k++;
2. if(k == N + 1)
3. k = 1;

当有些猴子出局后，报数时就需要跳过空位。所以可以对每个位置进行标注，以区分有没有猴子。

例如为0时表示没有猴子，否则就是有。当有很多空位时，可以使用如下程序获得下一个猴子的位置：

1. // nx 是当前报数的序号，如果为 0 则找后面不为 0 的，否则就是它了
2. while(a[nx]==0)
3. { // 为0时
4. nx++; // 看下一个位置的猴子
5. if(nx == N + 1) // 到尾部了，再回到头部
6. nx = 1;
7. }

编程要求

在右侧编辑器中的Begin-End之间补充代码，输出 N（数据由平台提供，已获取，直接使用即可） 只猴子中谁是猴子大王的。具体要求如下：

1. 让 N 只候选猴子围成一圈（最多100只猴子），从某位置起顺序编号为 1 ~ N 号；

2. 从第 1 号开始报数，每轮从 1 报到 3 ，凡报到 3 的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数；

3. 如此不断循环，最后剩下的一只猴子就选为猴王。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：5 预期输出：4号猴子是大王。

测试输入：18 预期输出：14号猴子是大王。

---

开始你的任务吧，祝你成功！

#include 
using namespace std;

// 函数king：猴子选大王
// 参数：a-猴子数组n-1个猴子分别占据下标为~n-1的位置，n-数组长度
// 返回值：新猴王的下标序号
int king(int a[], int n);

int main()
{
    int n, a[1000], i;     // 定义变量及数组，n-猴子数量，a-猴子数组
    cin >> n;     // 输入猴子数量，n>0

    // 初始化猴子数组,n 个猴子分别占据 n 个位置
    a[0] = 0; // 0号位置没有猴子
    for(i = 1;i <= n; i++)
        a[i] = i;

    // 选大王啦
    i = king(a, n );
    cout << i << "号猴子是大王。" << endl;
    return 0;
}

int king(int a[], int n)
{
    // 请在此添加代码，实现函数king
    /********** Begin *********/
    int i,j,t=0;
    for(i=0;i

第4关：犯二的程度

200

• 任务要求
• 参考答案
• 评论472

• 任务描述
• 相关知识
  • 字符串数组
  • 获取字符对应的整数
• 编程要求
• 测试说明

---

任务描述

本关任务：编写函数 silly，计算整数（不多于100位）犯二的程度并返回。

数字也可以“犯二”，一个整数“犯二的程度”定义为：该数字中包含2的个数与其位数的比值，如果这个整数是负数，则程度增加0.5倍，如果还是个偶数，则再增加1倍。

例如，数字−56782223456是个11位数，其中有3个2，是负数，也是偶数，则它的犯二程度为：3/11×1.5×2，约为0.818182。

相关知识

由于 C 和 C++ 中 int 类型的表示范围有限，为−2147483648~2147483647，所以超过10位的整数就会溢出。

例如下面的程序：

1. int a;
2. cin >> a;
3. cout << a << endl;

测试输入：77777777777

输出结果：-858993460

很显然整型变量 a 无法表示超出范围的数。

字符串数组

在 C 和 C++ 中，一个字符串就是用一对双引号括起来的一串字符。字符串的存储是利用一维字符数组来实现的，该字符数组的长度为待存字符串的长度加1。即如果一个字符串的长度为 n ，则用于存储该字符串的数组的长度应为 n+1。

当字符串存入数组时，是把每个字符依次存入到数组的对应元素中，即把第一个字符存入到下标为0的元素中，第二个字符存入到下标为1的元素中，依次类推，最后会把一个空字符 ′\0′ 存入到下标为 n 的元素中（这里假定字符串的长度为 n）。字符存储的是它的 ASCII 码或区位码。

例如用一维字符数组 a[12] 来存储字符串 ″Strings.\n″ 时，数组 a 中的内容参见下图：

 

接下来，我们可以利用字符串来初始化字符数组，如：

1. char a[10] = ″array″;
2. char b[20] = ″This is a pen. ″;
3. char c[8] = ″″;

• 第一条语句定义了字符数组 a[10] 并被初始化为“array”，其中 a[0] ~ a[5] 元素的值依次为字符‘a’, ‘r’,‘r’,‘a’,‘y’和‘\0’；

• 第二条语句定义了字符数组 b[20] ，其中 b[i] 元素（ 0 ≤ i ≤ 13 ）被初始化为所给字符串中的第 i+1 个字符，b[14] 被初始化为字符串结束标志符‘\0’；

• 第三条语句定义了一个字符数组 c[8] 并初始化为一个空串，此时它的每个元素的值均为‘\0’。

我们可以看到对于字符串而言，它的存储总是以 '\0' 结尾。

例如下面的程序可以计算并输出字符串的长度：

1. char s[1000]; // 定义一维字符数组
2. cin >> s; // 输入一个字符串存入字符数组s中
3. int i = 0;
5. // 逐个判断字符数组的某一位是否是'\0'，该字符意味着字符串的结束
6. while(s[i] != '\0')
7. i++;
9. cout << i << endl; // 输出字符串的长度

获取字符对应的整数

由于使用字符形式存储数字时，存储的是数字对应的 ASCII 码，由于在 ASCII 码表中字符‘0’到字符‘9’是连续存放的，所以下面的程序可以获得字符对应的数字：

1. char c = '2'; // c 中存储的是字符 '2' 的ASCII码
2. int k = c - '0'; // k 即为字符 '2' 对应的整数 2

编程要求

在右侧编辑器中的Begin-End之间补充代码，计算整数（不多于100位，数据由平台提供）犯二的程度并返回。具体“犯二的程度”定义如下：

1. 该数字中包含 2 的个数与其位数的比值；

2. 如果整数是负数，则程度增加 0.5 倍；

3. 如果整数是偶数，则再增加 1 倍。

提示：对于本关要求计算不超过100位的整数，很显然不能使用 int 类型，但可以把输入的一串数字当做字符串处理，使用字符数组来接收输入的整数。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：-13142223336 预期输出：0.818182

测试输入：122335468912334612 预期输出：0.444444

---

开始你的任务吧，祝你成功！

#include 
using namespace std;

// 函数silly：计算数值有多二
// 参数：a-存储数值的字符数组，以'\0'结束，所以不需要另一个参数告诉函数数组有多长
// 返回值：数值犯二的程度
double silly(char a[]);

int main()
{
    char s[102];     // 定义存储数值的数组
    cin >> s;     // 输入不超过位的整数
    double sy = silly(s);     // 计算犯二的程度
    cout << sy << endl;     // 输出犯二的程度
    return 0;
}

double silly(char a[])
{
    // 请在此添加代码，实现函数silly
    /********** Begin *********/
    double k=1,sum;
    int i=0,j=0,zs=0;
    // 先判断是否为负数
    if(a[0]=='-'){
        k*=1.5;
        i++;
    }
    while(a[i]!='\0'){
        zs++;
        if(a[i]=='2')
            j++;
        i++;
    }
    // 判断是否为偶数
    if((a[zs]-'0')%2==0)
        k*=2;
    sum=(double)j/zs*k;
    return sum;
    /********** End **********/
}

第5关：队列变换

500

• 任务要求
• 参考答案
• 评论472

• 任务描述
• 相关知识
  • 多维数组 / 二维数组
  • 二维数组的初始化
  • 二维数组的操作
• 编程要求
• 测试说明

---

任务描述

本关任务：编写函数 rotateLeft，该函数实现对一个n×n方阵中的每个元素循环向左移m个位置（0

相关知识

多维数组 / 二维数组

C 和 C++ 中有多个下标的数组称为多维数组。具有两个下标表示的数组称为二维数组。

例如：

1. int a[3][4];
2. char c[4][3][5];

其中 a 是一个整型二维数组，c 是一个字符型三维数组。

数学上的二维矩阵可以看成其元素是向量的向量，也可以看成元素是一维数组的一维数组，所以二维矩阵可以用二维数组表示出来。

上述示例中的二维数组 a 有 2 个下标：

• 第1个下标可以称为行，变化范围是0~2；

• 第2个下标可以称为列，变化范围是0~3。

因此，a 共有3行4列，12个元素。每个数组元素用数组名和两个下标表示。

例如：a[1][2]和a[2][1]分别表示第1行第2列的元素和第2行第1列的元素（从第0行0列开始）。

二维数组 a 的逻辑结构如下图所示：

 

多维数组在内存中“按行”存放，越靠后的下标先变化，越靠前面的下标后变化。二维数组 a 在内存中的物理存储形式如下图所示：

 

二维数组的初始化

二维数组可以在声明时初始化。

例如，下面是对2∗2的二维数组 matrix 的初始化：

1. int matrix[2][2]＝{ {1, 2}, {3, 4} };

数组元素的值用花括号按行分组，上述示例中将整常数1和2赋给了matrix[0][0]和matrix[0][1]，将整常数3和4赋给了matrix[1][0]和matrix[1][1]。

特别注意以下两点：

1. 如果指定行没有足够的初始值，与一维数组类似，则该行的剩余元素初始化为0，如果初始值只给出了部分行，则剩余的行中的所有元素都被初始化为0；

2. 如果初始值之间没有用花括号按行分组，那么编译器会自动用初始值顺序初始化第0行的元素、第1行的元素、…… 。如果初始值的数目少于数组元素的数目，剩余的元素自动初始化为0。

例如：

1. int matrix[3][4]={ 1, 2, 3, 4, 5, 6 };

初始化完成后，数组 a 的各元素的值为：

1. matrix[0][0] = 1 ，
2. matrix[0][1] = 2 ，
3. matrix[0][2] = 3，
4. matrix[0][3] = 4 ，
5. matrix[1][0] = 5 ，
6. matrix[1][1] = 6 ，
7. 其余元素均为 0 。

二维数组的操作

二维数组的典型操作方法：使用两重循环对数组进行遍历，并逐个元素进行操作。两重循环分别遍历两个下标的范围。

例如：下面的程序可以遍历二维数组并输出每一个元素的值。

1. // 定义并初始化二维数组m
2. int m[4][4] = { {1, 1, 1, 1},
3. {2, 2, 2, 2},
4. {3, 3, 3, 3},
5. {4, 4, 4, 4}};
7. // line遍历第一维
8. for (int line = 0; line < 4; line++)
9. {
10. // col遍历第二维，输出某一行
11. for (int col = 0; col < 4; col++)
12. cout << "\t" << a[line][col];
14. // 输出完一行后换行
15. cout << endl;
16. }

温馨提示：如果循环左移多个位置不好处理，可以用循环，每次循环左移一个位置。

编程要求

在右侧编辑器中的Begin-End之间补充代码，实现队列变换的功能。具体要求如下：

1. 队列为 n×n；

2. 每个元素循环向左移m个位置（0

提示：存储n×n的方阵需要使用二维数组。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：

1. 3 1
2. 1 2 3
3. 4 5 6
4. 7 8 9

预期输出：

1. 2 3 1
2. 5 6 4
3. 8 9 7

测试输入：

1. 4 2
2. 1 2 3 4
3. 2 3 4 5
4. 3 4 5 6
5. 4 5 6 7

预期输出：

1. 3 4 1 2
2. 4 5 2 3
3. 5 6 3 4
4. 6 7 4 5

---

开始你的任务吧，祝你成功！

#include 
using namespace std;

// 函数rotateLeft：矩阵循环左移
// 参数：a-100*100的二维数组，用来存储n行n列的数组（n<100)，存储在其~n-1行和~n-1列，
// m-循环左移的位数(0> n >> m;     // 输入n和m

    // 输入n*n的矩阵，存储在数组a的~n-1行和~n-1列
    int i, j;
    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            cin >> a[i][j];

    // 循环左移
    // 说明：传递多维数组时，实在参数只需要给出数组名就可以了
    rotateLeft(a,n,m);

    // 输出循环右移的结果
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            cout << " " << a[i][j];
        cout << endl;
    }
    return 0;
}

void rotateLeft(int a[][100],int n,int m)
{
    // 请在此添加代码，实现函数rotateLeft
    /********** Begin *********/
    int b[100],i,j,p; 
    for(i=0;i

第6关：朋友圈点赞

600

• 任务要求
• 参考答案
• 评论472

• 任务描述
• 相关知识
• 编程要求
• 测试说明

---

任务描述

朋友圈有一个点赞功能，你可以为你喜欢的文章点赞表示支持。每篇文章都可以根据其内容给出一些标签，这些标签用数字表示（如：1 代表心灵鸡汤、2 代表政治、3 代表经济、...），你点赞的文章的类型，也间接反应了你的喜好。

本关任务：编写一个完整的程序，通过统计一个人点赞的纪录，分析这个人的喜好。

相关知识

本关的程序实现可以边输入，边统计每个标签出现的次数，标签最多可能会有1000个，用数组很合适。统计完之后，再查找其中出现次数最多的最大标签即可。

编程要求

本关的编程任务是完成文件 step6/upvote.cpp 的编写，以实现朋友圈点赞的功能。 upvote.cpp 文件为空，需要你从头开始编写。具体要求如下：

• 程序的输入格式为：

第一行输入一个正整数 N （ N < 1000 ），是该用户点赞的文章数量。

随后的 N 行，每行给出一篇被其点赞的文章的标签描述，格式为“k S1​ S2​ ......Sk​”。

k表示该文章的标签数，1≤k≤10，即每篇文章最多10个标签； Sk​是标签，是1到1000之间的整数，即总共有不超过1000种标签。

所有数值之间以空格分隔。

• 程序的输出格式为：

统计所有被点赞的文章中最常出现的那个标签，在一行中输出它的标签编号和出现次数，数字间隔1个空格。如果有并列，则输出编号最大的那个。

例如：

1. 4
2. 3 889 233 2
3. 5 100 3 233 2 73
4. 4 3 73 889 2
5. 2 233 123

输出结果为：233 3

上述示例中出现最多次（3次）的标签有233和2，存在并列时，输出最大的那个标签233，然后输出其出现的次数3。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：

1. 4
2. 3 889 233 2
3. 5 100 3 233 2 73
4. 4 3 73 889 2
5. 2 233 123

预期输出：233 3

测试输入：

1. 8
2. 3 12 45 2
3. 4 1 334 45 7
4. 3 7 12 8
5. 2 2 12
6. 5 45 67 2 3 1
7. 3 23 12 6
8. 2 12 2
9. 4 45 12 7 8

预期输出：12 6

---

开始你的任务吧，祝你成功！

// 请在此添加代码，通过统计朋友圈点赞，统计个人爱好功能
/********** Begin *********/
#include
using namespace std;
int main(){
    int n,x,i,lab,t,a[1000]={0},max=0;
    cin>>n;
    while(n--){
        cin>>x;
        for(i=0;i>t;
            a[t]++;
        }
    }
    for(i=0;i<1000;i++){
        if(a[i]>=max){
            lab=i;
            max = a[i];
        }
    }
    cout<