第三讲循环结构

最新推荐文章于 2023-01-18 16:53:31 发布

董洞洞同学

最新推荐文章于 2023-01-18 16:53:31 发布

阅读量586

点赞数

分类专栏： C++语法基础练习题文章标签： c++

本文链接：https://blog.csdn.net/weixin_44356316/article/details/118185132

版权

C++语法基础练习题专栏收录该内容

7 篇文章 5 订阅

订阅专栏

1.经典题型

1.1 斐波那契数列

【分析】
在这里插入图片描述

通过上面分析， $f (n)$ 需要循环 $n - 1$ 次

"""while版本"""
#include <iostream>
using namespace std;

int main()
{
	int a, b, c, n;
	a = 1;
	b = 1;
	int i = 0;
	cin >> n;
	while(i < n - 1)
	{
		c = a + b;
		a = b;
		b = c;
		i ++;
	}
	cout << a << endl;
	return 0;
}

"""for版本"""
#include <iostream>
using namespace std;
int main()
{
	int a, b, c, i, n;
	a = 1;
	b = 1;
	cin >> n;
	for(i = 0; i < n - 1; i ++)
	{
		c = a + b;
		a = b;
		b = c;
	}
	cout << a << endl;
	return 0;
}

递归的效率不如循环快

1.2 质数

'''我觉得写的规范'''
'''优点1：独立设置了一个符号变量，循环中仅仅处理符号变量'''
'''优点2：循环和最后输出结果分离'''
#include <iostream>
using namespace std;

int main()
{

	int n;
	cin >> n;
	
	bool is_prime = true;

	for(int i = 2; i <= n - 1; i ++)
	{
		if(n % i == 0) 
		{
			is_prime = false;
			break;
		}
	}
	
	if(is_prime) cout << "YES!" << endl;
	else cout << "NO!" << endl;
	return 0;
}

1.3 打印n阶菱形

传统的做法使用两重循环，本文使用一种巧妙的方法，曼哈顿距离的方式。

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	int n;
	cin >> n;
	
	int cx = n / 2, cy = n / 2;
	for(int i = 0; i < n; i ++)
	{
		for(int j = 0; j < n; j ++)
		{
			if(abs(cx - i) + abs(cy - j) <= n / 2) cout << '*';
			else cout << ' ';
		}
		cout << endl;
	}
	return 0;
}

2.练习题

2.1偶数

编写一个程序，输出 1 到 100 之间（包括 1 和 100）的全部偶数。

输入格式
无输入。

输出格式
输出全部偶数，每个偶数占一行。

输入样例
No input
输出样例
2
4
6
…
100

'''方法一，从1枚举到n，留下偶数'''
#include <iostream>
using namespace std;

int main()
{
    
    for(int i = 1; i <= 100; i ++)
    {
        if(i % 2 == 0) cout << i << endl;
    }
    return 0;
}

方法二，从2开始枚举，每次枚举的单位进2

2.2 奇数

输入一个整数 X，输出 1 到 X 之间（包括 1 和 X）的全部奇数。

输入格式
一个整数 X。

输出格式
输出所有满足条件的奇数，每个数占一行。

数据范围
1≤X≤1000
输入样例：
8
输出样例：
1
3
5
7

#include <iostream>
using namespace std;

int main()
{
    int X;
    cin >> X;
    for(int i = 1; i <= X; i ++)
    {
        if(i % 2) cout << i << endl;
    }
    return 0;
}

2.3 正数

输入 6 个数字，它们要么是正数，要么是负数。

请你统计并输出正数的个数。

输入格式
六个数字，每个占一行。

输出格式
输出格式为 x positive numbers，其中 x 为正数的个数。

数据范围
输入数字的绝对值不超过 100。

输入样例：
7
-5
6
-3.4
4.6
12
输出样例：
4 positive numbers

#include <iostream>
using namespace std;

int main()
{
    float n;
    int i = 0;
    while(cin >> n)
    {
        if(n > 0) i ++;
    }
    cout << i << " positive numbers";
    return 0;
}

2.4 连续奇数的和 1

给定两个整数 X 和 Y，输出在他们之间（不包括 X 和 Y）的所有奇数的和。

输入格式
第一行输入 X，第二行输入 Y。

输出格式
输出一个整数，表示所有满足条件的奇数的和。

数据范围
−100≤X,Y≤100
输入样例1：
6
-5
输出样例1：
5
输入样例2：
15
12
输出样例2：
13
输入样例3：
12
12
输出样例3：
0

'''复杂版本'''
#include <iostream>
using namespace std;

int main()
{
    int x, y, tmp, sum;
    sum = 0;
    cin >> x >> y;
    
    if(y < x)
    {
        tmp = x;
        x = y;
        y = tmp;
    }
    
    
    if(x % 2 == 0)
    {
        x ++;
        for(; x < y;)
        {
            sum += x;
            x += 2;
        }
    }
    else 
    {
        x += 2;
        for(; x < y;)
        {
            sum += x;
            x += 2;
        }
    }
    
    cout << sum << endl;
    return 0;
}

'''改良版'''
#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int x, y, tmp, sum;
    sum = 0;
    cin >> x >> y;
    
    if(y < x) swap(x, y);
    
    tmp = x;
    tmp ++;
    for(; tmp < y;)
    {
        if(tmp % 2) sum += tmp;
        tmp ++;
    }
    
    cout << sum << endl;
    return 0;
}

2.5 最大数和它的位置

给定 100 个整数，请你找出其中最大的数字，以及它的输入位置（位置从 1 开始）。

输入格式
共 100 行，每行包含一个整数。

输出格式
第一行输出最大的数字。

第二行输出该数字的输入位置。

数据范围
1≤输入数字≤50000,
保证输入数字互不相同。

输入样例：
22229
48558
24992
4755
11923
…
20213
输出样例：
48558
2

#include <iostream>
using namespace std;

int main()
{
    int max, flag, n;
    max = 1;
    for(int i = 1; i <= 100; i ++)
    {
        cin >> n;
        if(n >= max)
        {
            max = n;
            flag = i;
        }
    }
    
    cout << max << endl;
    cout << flag << endl;
    return 0;
}

2.6 递增序列

读取一系列的整数 X，对于每个 X，输出一个 1,2,…,X 的序列。

输入格式
输入文件中包含若干个整数，其中最后一个为 0，其他的均为正整数。

每个整数占一行。

对于输入的正整数，按题目要求作输出处理。

对于最后一行的整数 0，不作任何处理。

输出格式
对于每个输入的正整数 X，输出一个从 1 到 X 的递增序列，每个序列占一行。

数据范围
1≤X≤100
输入样例：
5
10
3
0
输出样例：
1 2 3 4 5
1 2 3 4 5 6 7 8 9 10
1 2 3

#include <iostream>
using namespace std;

int main()
{
    int n;
    while(cin >> n)
    {
        if(!n) break;
        
        for(int i = 1; i <= n; i ++)
        {
            cout << i << " ";
        }   
        cout << endl;
        
    }
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int n;
    '''这种写法更简单'''
    while(cin >> n && n)
    { 
        for(int i = 1; i <= n; i ++)
        {
            cout << i << " ";
        }   
        cout << endl;
        
    }
    return 0;
}

'''第三种书写方式逗号'''
'''逗号在逻辑表达式输出的结果是最后一个式子的答案'''
#include <iostream>
using namespace std;

int main()
{
    int n;

    while(cin >> n, n)
    { 
        for(int i = 1; i <= n; i ++)
        {
            cout << i << " ";
        }   
        cout << endl;
        
    }
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int n;
	'''scanf如果成功输入，返回的是-1'''
    while(scanf("%d", &n) != -1)
    { 
        for(int i = 1; i <= n; i ++)
        {
            cout << i << " ";
        }   
        cout << endl;
        
    }
    return 0;
}

2.7 连续整数相加

读入两个整数值 A 和 N，计算从 A 开始的 N 个连续整数的和。

注意，如果读入的 N 为 0 或负数，则继续读取数字直至读入 N 值为正整数为止。

输入格式
共一行，包含整数 A 和若干个整数 N。

输出格式
一个整数，表示从 A 开始的 N 个连续整数的和。

数据范围
1≤A≤100,
−100≤N≤100
输入样例1：
3 2
输出样例1：
7
输入样例2：
3 -1 0 -2 2
输出样例2：
7

'''
版本一
'''
#include <iostream>
using namespace std;

int main()
{
    int a, t;
    cin >> a;
    //while()里面多个表达式，有效的是最后一个表达式
    //逗号表达式的值为系列中最后一个表达式的值
    while(cin >> t, t <= 0);
    
    int sum = 0;
    for(int i = 0; i < t; i ++)
    {
        sum += a + i;
    }
    cout << sum << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int n1, n2;
    cin >> n1;
    while(cin >> n2)
    {
    '''本来求和想遍历'''
        if(n2 > 0) cout << (n1 + n1 + n2 - 1) * n2 / 2 << endl;
        
    }
    return 0;
}

2.8 约数

输入一个整数 N，按照从小到大的顺序输出它的全部约数。

输入格式
一个整数 N。

输出格式
输出全部约数，每个约数占一行。

数据范围
1≤N≤1000
输入样例：
6
输出样例：
1
2
3
6

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    float tmp;
    for(float i = 1.0; i <= n; i ++)
    {
        tmp = n / i;
        if(tmp - int(tmp) == 0) cout << i << endl;
        else continue;
    }
    return 0;
}

2.9 PUM

输入两个整数 N 和 M，构造一个 N 行 M 列的数字矩阵，矩阵中的数字从第一行到最后一行，按从左到右的顺序依次为 1,2,3,…,N×M。

矩阵构造完成后，将每行的最后一个数字变为 PUM。

输出最终矩阵。

输入格式
共一行，包含两个整数 N 和 M。

输出格式
输出最终矩阵，具体形式参照输出样例。

数据范围
1≤N,M≤20
输入样例：
7 4
输出样例：
1 2 3 PUM
5 6 7 PUM
9 10 11 PUM
13 14 15 PUM
17 18 19 PUM
21 22 23 PUM
25 26 27 PUM

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
    int N, M;
    cin >> N >> M;
    int S = N * M;
    int k = 1;
    for(int i = 1; i <= N; i ++)
    {
        for(int j = 1; j <= M; j ++)
        {
            if(k % M == 0)
            {
                cout << "PUM" << endl;
                break;
            }
            else cout << k << " ";
            k ++;
        }
        k ++;
        if(k == S) break;
    }
    return 0;
}

2.10 余数

输入一个整数 N，请按顺序输出 1 到 10000 之间（不包括 1 和 10000）的所有除以 N 余 2 的数字。

输入格式
一个整数 N。

输出格式
输出所有满足条件的数字，从小到大每行输出一个。

数据范围
2<N<10000
输入样例：
13
输出样例：
2
15
28
41
…

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int i = 1;
    while(i < 10000)
    {
        if(i % n == 2) cout << i << endl;
        i ++;
    }
    return 0;
}

2.11 六个奇数

读取一个整数 X，输出 X 之后的 6 个奇数，如果 X 也是奇数，那么它也算作 6 个奇数之一。

输入格式
一个整数 X。

输出格式
所有满足条件的奇数，每个占一行。

数据范围
1≤X≤100
输入样例：
9
输出样例：
9
11
13
15
17
19

'''
方法一
'''
#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    if(n % 2 == 1)
    {   
        for(int i = 0; i < 6; i ++, n = n + 2) cout << n << endl;
    }
    else
    {
        n ++;
        for(int i = 0; i < 6;i ++, n = n + 2) cout << n << endl;
    }
    return 0;
}

'''
方法二：化简版
'''
#include <iostream>
using namespace std;

int main()
{
	int n;
	cin >> n;
	if(n % 2 == 0) n ++;
	for(int i = 0; i < 6; i += 2) cout << n << endl;
	return 0;
}

2.12 乘法表

输入一个整数 N，输出 N 的乘法表，如下：

1 x N = N
2 x N = 2N
…
10 x N = 10N
输入格式
一个整数 N。

输出格式
输出 N 的乘法表，具体形式参照输出样例。

数据范围
1<N<1000
输入样例：
140
输出样例：
1 x 140 = 140
2 x 140 = 280
3 x 140 = 420
4 x 140 = 560
5 x 140 = 700
6 x 140 = 840
7 x 140 = 980
8 x 140 = 1120
9 x 140 = 1260
10 x 140 = 1400

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= 10; i ++)
    {
        cout << i << " x " << n << " = " << i * n << endl;
        
    }
    return 0;
}

2.13 实验

医学部一共进行了 N 场动物实验。

共有三种小动物可用来实验，分别是青蛙、老鼠和兔子。

每次实验都会选取其中一种动物来参与实验，选取数量若干。

现在请你统计一下医学部一共用了多少小动物，每种分别用了多少，每种动物使用数量占总量的百分比分别是多少。

输入格式
第一行包含整数 N，表示实验次数。

接下来 N 行，每行包含一个整数 A（表示一次实验使用的小动物的数量）和一个字符 T（表示一次实验使用的小动物的类型，C 表示兔子(coney)，R 表示老鼠(rat)，F 表示青蛙(frog)）。

输出格式
请你参照输出样例，输出所用动物总数，每种动物的数量，以及每种动物所占百分比。

注意输出百分比时，保留两位小数。

数据范围
1≤N≤100,
1≤A≤15
输入样例：
10
10 C
6 R
15 F
5 C
14 R
9 C
6 R
8 F
5 C
14 R
输出样例：
Total: 92 animals
Total coneys: 29
Total rats: 40
Total frogs: 23
Percentage of coneys: 31.52 %
Percentage of rats: 43.48 %
Percentage of frogs: 25.00 %

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
    int n;
    cin >> n;
    float total = 0;
    float total_coneys = 0, total_rats = 0, total_frogs = 0;
    char ani;
    int tmp;
    int i = 0;
    for(int i = 0; i < n; i ++)
    {
        cin >> tmp >> ani;
        if(ani == 'C') total_coneys += tmp;
        if(ani == 'R') total_rats += tmp;
        if(ani == 'F') total_frogs += tmp;
    }
    
    total = total_coneys + total_rats + total_frogs;
    cout << "Total: " << total << " animals" << endl;
    cout << "Total coneys: " << total_coneys << endl;
    cout << "Total rats: " << total_rats << endl;
    cout << "Total frogs: " << total_frogs << endl;
    //如果变量是整型，（double）total_coneys 或者 1.0 * total_coneys
    printf("Percentage of coneys: %.2f %% \n", total_coneys / total * 100);
    printf("Percentage of rats: %.2f %% \n", total_rats / total * 100);
    printf("Percentage of frogs: %.2f %% \n", total_frogs / total * 100);
    
    return 0;
}

#注意：
1.此题不能用scanf("%d%c",&a1,&a2).因为scanf在读入字符时，不会自动过滤空格、回车、制表符；
2.如果需要用scanf("%d %c", &a1, &a2)手动添加空格。
3.比如输入"A = 2, B = 3".代码"scanf(“A = %d, B = %d”, &a, &b)"

2.14 区间 2

读取 N 个整数 X1,X2,…,XN，判断这 N 个整数中有多少个在 [10,20] 的范围内，有多少个在范围外。

输入格式
第一行包含整数 N，表示共有 N 个整数需要进行判断。
接下来 N 行，每行包含一个整数 Xi。

输出格式
第一行输出 x in，其中 x 为在范围内的整数的数量。

第二行输出 y out，其中 y 为在范围外的整数的数量。

数据范围
1≤N≤10000,
−107<Xi<107
输入样例：
4
14
123
10
-25
输出样例：
2 in
2 out

#include <iostream>
using namespace std;

int main()
{
    
    int n1, n2;
    int sum_in = 0, sum_out = 0;
    cin >> n1;
    while(cin >> n2)
    {
        if(n2 >= 10 && n2 <= 20) sum_in ++;
        else sum_out ++;
    }
    
    cout << sum_in << " in" << endl;
    cout << sum_out << " out" << endl;
    return 0;
}

2.15 连续奇数的和 2

输入 N 对整数对 X,Y，对于每对 X,Y，请你求出它们之间（不包括 X 和 Y）的所有奇数的和。

输入格式
第一行输入整数 N，表示共有 N 对测试数据。

接下来 N 行，每行输入一组整数 X 和 Y。

输出格式
每对 X,Y 输出一个占一行的奇数和。

数据范围
1≤N≤100,
−1000≤X,Y≤1000
输入样例：
7
4 5
13 10
6 4
3 3
3 5
3 4
3 8
输出样例：
0
11
5
0
0
0
12

#include <iostream>
using namespace std;

void swap(int &x, int &y)
{
    if(x > y)
    {
        int tmp;
        tmp = x;
        x = y;
        y = tmp;
    }
}

int main()
{
    int n;
    cin >> n;
    
    int x, y;
    while(cin >> x >> y)
    {
        swap(x, y);
        int sum = 0;
        if(x % 2 == 0)
        {
            for(int tmp = x + 1; tmp < y; tmp = tmp + 2)
            {
                sum += tmp;
            }
            cout << sum << endl;
        }
        else
        {
            for(int tmp = x + 2; tmp < y; tmp = tmp + 2)
            {
                sum += tmp;
            }
            cout << sum << endl;
        }
    }
    return 0;
}

//注意:输入n个数字也可以这样写
int n;
cin >> n;
while(n --)
{}

#include <algorithm>
swap()

2.16 简单斐波那契

以下数列 0 1 1 2 3 5 8 13 21 … 被称为斐波纳契数列。

这个数列从第 3 项开始，每一项都等于前两项之和。

输入一个整数 N，请你输出这个序列的前 N 项。

输入格式
一个整数 N。

输出格式
在一行中输出斐波那契数列的前 N 项，数字之间用空格隔开。

数据范围
0<N<46
输入样例：
5
输出样例：
0 1 1 2 3

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int a = 0, b = 1;
    
    for(int i = 1; i <= n; i ++)
    {
        if(i % 2 != 0) 
        {
            cout << a << " ";
            a = a + b;
        }
        if(i % 2 == 0)
        {
            cout << b << " ";
            b = a + b;
        }
    }
    return 0;
}

2.17 数字序列和它的和

输入若干个整数对 M,N，对于每个数对，输出以这两个数为最大值和最小值的公差为 1 的等差数列。

注意，当输入整数对中，任意一个数为 0 或负整数时，立即停止输入，且该组数对无需作任何处理。

输入格式
输入共若干行，每行包含两个整数。

最后一行的两个整数中，至少有一个是非正整数。

输出格式
对于每组需作处理的数对，输出一个结果，每个结果占一行。

结果包含从最小值到最大值的数字序列以及数字序列各数字之和。

具体格式请参照输出样例。

数据范围
M,N≤100
输入样例：
2 5
6 3
5 0
输出样例：
2 3 4 5 Sum=14
3 4 5 6 Sum=18

#include <iostream>
using namespace std;

int main()
{
    int a, b;
    while(cin >> a >> b)
    {
        if(a <= 0 || b <= 0) break;
        if(a > b) swap(a , b);
        
        
        for(int i = a; i <= b; i ++)
        {
            cout << i << " ";
        }
        cout << "Sum=" << (a + b) * (b - a + 1) / 2 << endl;
        
    }
    return 0;
}

2.18 完全数

一个整数，除了本身以外的其他所有约数的和如果等于该数，那么我们就称这个整数为完全数。

例如，6 就是一个完全数，因为它的除了本身以外的其他约数的和为 1+2+3=6。

现在，给定你 N 个整数，请你依次判断这些数是否是完全数。

输入格式
第一行包含整数 N，表示共有 N 个测试用例。

接下来 N 行，每行包含一个需要你进行判断的整数 X。

输出格式
每个测试用例输出一个结果，每个结果占一行。

如果测试数据是完全数，则输出 X is perfect，其中 X 是测试数据。

如果测试数据不是完全数，则输出 X is not perfect，其中 X 是测试数据。

数据范围
1≤N≤100,
1≤X≤108
输入样例：
3
6
5
28
输出样例：
6 is perfect
5 is not perfect
28 is perfect

//答案是正确地，但是运行时间超时
//c++每秒运行1亿次
//如果测试数据100个，每次循环最大数1千万（题给的），总时间为10亿
//测评系统限制1s的话，完不成，所以要优化
#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int x, sum;
    while(n --)
    {
        cin >> x;
        sum = 0;
        if(x == 1) cout << x << " is not perfect" << endl;
        else
        {
            for(int i = 2; i < x; i ++)
            {
                if(x % i == 0) sum += i;
            }
       
            if(sum + 1 == x) cout << x << " is perfect" << endl;
            else cout << x << " is not perfect" << endl;    
        }
        
    }
    return 0;
}

2.18.1 补充知识

设某个数为 $d$ ，如果 $x$ 是 $d$ 的约数，那么 $d / x$ 也一定是 $d$ 的约数。由 $\leq \frac{d}{x}$ （我们先列举小的数字，然后再列举大的数字）得到 $\leq \sqrt{d}$ ，也就是我们只要列举到 $\sqrt{d}$ 就型。

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int x, sum;
    while(n --)
    {
        cin >> x;
        sum = 0;
        if(x == 1) cout << x << " is not perfect" << endl;
        else
        {
            for(int i = 2; i < sqrt(x); i ++)
            {
                if(x % i == 0) sum += (i + x / i);
            }
       
            if(sum + 1 == x) cout << x << " is perfect" << endl;
            else cout << x << " is not perfect" << endl;    
        }
        
    }
    return 0;
}

2.19 质数

一个大于 1 的自然数，如果除了 1 和它自身外，不能被其他自然数整除则称该数为质数。

例如 7 就是一个质数，因为它只能被 1 和 7 整除。

现在，给定你 N 个大于 1 的自然数，请你依次判断这些数是否是质数。

输入格式
第一行包含整数 N，表示共有 N 个测试数据。

接下来 N 行，每行包含一个自然数 X。

输出格式
每个测试用例输出一个结果，每个结果占一行。

如果测试数据是质数，则输出 X is prime，其中 X 是测试数据。

如果测试数据不是质数，则输出 X is not prime，其中 X 是测试数据。

数据范围
1≤N≤100,
1<X≤107
输入样例：
3
8
51
7
输出样例：
8 is not prime
51 is not prime
7 is prime

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int x;
    while(cin >> x)
    {
        int tmp = 1;
        for(int i = 2; i <= x; i ++)
        {
            if(x % i == 0) break;
            tmp ++;
        }
        if(tmp == x - 1) cout << x << " is prime" << endl;
        else cout << x << " is not prime" << endl;
    }
    return 0;
}

2.20 菱形

输入一个奇数 n，输出一个由 * 构成的 n 阶实心菱形。

输入格式
一个奇数 n。

输出格式
输出一个由 * 构成的 n 阶实心菱形。

具体格式参照输出样例。

数据范围
1≤n≤99
输入样例：
5
输出样例：

  *  
 *** 
*****
 *** 
  *

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            if(abs(i - (n / 2 + 1)) + abs(j - (n / 2 + 1)) <= n / 2) cout << "*";
            else cout << " ";
        }
        cout << endl;
    }
    return 0;
}

2.20.1 拓展

若要输出这样的图形该怎么改动代码？

  *  
 * * 
*   *
 * * 
  *

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            if(abs(i - (n / 2 + 1)) + abs(j - (n / 2 + 1)) == n / 2) cout << "*";
            else cout << " ";
        }
        cout << endl;
    }
    return 0;
}