C++之while循环性质

第1关：求1到n间所有整数的和

本关必读

作为计算机编程语言的循环语句实例，求累加和几乎遍及所有的主流编程语言，理解累加和的求解过程对于掌握循环语句的精髓具有重要的作用。其中最常见的求累加和实例是求1到100的和。

本关要求用while循环语句来求1到n间所有整数的和。

本关任务

本关的编程任务是实现step1/SumOfWhile.cpp文件中的Sum函数，代码如下：

1. // 使用while循环求1到n间所有整数的和
2. int Sum(int n)
3. {
4. // 请在此添加实现代码
5. }

测试说明

本关的测试文件是step1/SumOfWhileTest.cpp，负责对你写的实现代码进行测试。具体说明如下：

1. #include <iostream>
2. #include "SumOfWhile.h"
3. using namespace std;
5. int main()
6. {
7. int n;
9. // 从命令行读入一个int型数值
10. // 这个数取自测试集的输入
11. cin >> n;
13. cout << Sum(n) << endl;
14. }

上述main函数从命令行读入，并将处理后的结果通过命令行输出。注意，step1/SumOfWhileTest.cpp的代码不能被修改。

其中：SumOfWhile.h文件代码如下：

1. #ifndef _ISLEAPYEAR_H_
2. #define _ISLEAPYEAR_H_
4. int Sum(int );
6. #endif

以下是平台对step1.SumOfWhileTest的测试样例： 测试输入：10 预期输出：55

测试输入：20 预期输出：210

测试输入：50 预期输出：1275

int Sum(int n)
{
	int i=1,sum=0;
 	while(i<=n)
 	{
  		sum=sum+i;
  		i++;
 	}
 	return sum;
}

第2关：计算x的n次方

本关必读

幂指乘方运算的结果。a^n指将a自乘n次，a称为幂的底数，n称为幂的指数，乘方的结果叫做a的n次幂。

本关要求用while循环语句来求x的n次方（幂）。

本关任务

本关的编程任务是实现step2/PowerCalculate.cpp文件中的Power函数，代码如下：

1. // 计算x的n次方
2. long Power(int x,int n)
3. {
4. // 请在此填入实现代码
5. }

测试说明

本关的测试文件是step2/PowerCalculateTest.cpp，负责对你写的实现代码进行测试。具体说明如下：

1. #include <iostream>
2. #include "PowerCalculate.h"
3. using namespace std;
5. int main()
6. {
7. int x, n;
9. // 从命令行读入两个int型数值
10. // 这两个数取自测试集的输入
11. cin >> x >> n;
13. cout << Power(x,n) << endl;
14. }

上述main函数从命令行读入，并将处理后的结果通过命令行输出。注意，step2/PowerCalculateTest.cpp的代码不能被修改。

其中：PowerCalculate.h文件代码如下：

1. #ifndef _ISLEAPYEAR_H_
2. #define _ISLEAPYEAR_H_
4. long Power(int ,int );
6. #endif

以下是平台对step2.PowerCalculateTest的测试样例： 测试输入：12 2 预期输出：144

测试输入：2 10 预期输出：1024

测试输入：4 7 预期输出：16384

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

// 计算x的n次方
long Power(int x,int n)
{
int x1 = 1;
while(n > 0)
{
x1 = x1 * x;
n--;
}
return x1;
}

第3关：求给定正整数的“亲密对数”

本关必读

亲密对数就是指两个整数，除了整数本身外的其所有因子之和等于另一个整数，则这两个数为亲密对数。如220和284。220的因子是1、2、4、5、10、11、20、22、44、55、110，它们之和为284，而284的因子是1、2、4、71、142，它们之和为220，所以220与284为一对亲密对数。

本关要求用while循环语句来求给定正整数的亲密对数。若给定正整数存在亲密对数则返回该值，否则返回No。

本关任务

本关的编程任务是实现step3/InLogarithmCal.cpp文件中的Fun函数，代码如下：

1. // 求给定正整数的“亲密对数”
2. int Fun(int x)
3. {
4. // 请在此提供实现代码
5. }

测试说明

本关的测试文件是step3/InLogarithmCalTest.cpp，负责对你写的实现代码进行测试。具体说明如下：

1. #include <iostream>
2. #include "InLogarithmCal.h"
3. using namespace std;
5. int main()
6. {
7. int a, m, n;
9. // 从命令行读入一个int型数值
10. // 这个数取自测试集的输入
11. cin >> a;
13. m = Fun(a);
14. n = Fun(m);
16. if(n == a)
17. {
18. cout << m << endl;
19. }
20. else
21. {
22. cout << "NO" << endl;
23. }
24. }

上述main函数从命令行读入，并将处理后的结果通过命令行输出。注意，step3/InLogarithmCalTest.cpp的代码不能被修改。

其中：InLogarithmCal.h文件代码如下：

1. #ifndef _ISLEAPYEAR_H_
2. #define _ISLEAPYEAR_H_
4. int Fun(int );
6. #endif

以下是平台对step3.InLogarithmCalTest的测试样例： 测试输入：220 预期输出：284

测试输入：100 预期输出：NO

测试输入：1210 预期输出：1184

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

// 求给定正整数的“亲密对数”
int Fun(int x)
{
 int b=0;
    for(int i=1;i<x;i++)
 {
  if(x%i==0)
  {
   b=b+i;
  }
 }
 int c;
 for(int m=1;m<b;m++)
 {
  if(b%m==0)
  {
   c=c+m;
  }
 }
 if(b==c)
 {
  return b;
 }
}

第4关：判断正整数n的各位数字中是否包含数字3或4c

本关必读

本关要求用while循环语句来断正整数n的各位数字中是否包含数字3或4，是则返回TRUE，否则返回FALSE。

本关任务

本关的编程任务是实现step4/IfContainNum.cpp文件中的Valid`函数，代码如下：

1. // 判断整数n的各位数字中是否包含数字3或4
2. bool Valid(int n)
3. {
4. // 请在此提供实现代码
5. }

测试说明

本关的测试文件是step4/IfContainNumTest.cpp，负责对你写的实现代码进行测试。具体说明如下：

1. #include <iostream>
2. #include "IfContainNum.h"
3. using namespace std;
5. int main()
6. {
7. int n;
9. // 从命令行读入一个int型数值
10. // 这个数取自测试集的输入
11. cin >> n;
13. if (Valid(n))
14. cout << "TRUE" << endl;
15. else
16. cout << "FALSE" << endl;
17. }

上述main函数从命令行读入，并将处理后的结果通过命令行输出。注意，step4/IfContainNumTest.cpp的代码不能被修改。

其中：IfContainNum.h文件代码如下：

1. #ifndef _ISLEAPYEAR_H_
2. #define _ISLEAPYEAR_H_
4. bool Valid(int );
6. #endif

以下是平台对step4.IfContainNumTest的测试样例： 测试输入：132 预期输出：TRUE

测试输入：100 预期输出：FALSE

测试输入：15030 预期输出：TRUE

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

// 判断整数n的各位数字中是否包含数字3或4
bool Valid(int n)
{
    if(1<=n&&n<=9)
 {
  if(n==3||n==4)
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 else if(10<=n&&n<=99)
 {
  int a,b=0;
  a=n/10;
  b=n%10;
  if((a==3)||(b==4)||(a==4)||(b==3))
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 else if(100<=n&&n<=999)
 {
  int a,b,c=0;
  a=n/100;
  b=n/10%10;
  c=n%10%10;
  if((a==3)||(b==3)||(c==3)||(a==4)||(b==4)||(c==4))
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 else if(1000<=n&&n<=9999)
 {
  int a,b,c,d=0;
  a=n/1000;
  b=n/100%10;
  c=n%10%100;
  d=n%10%10%10;
  if((a==3)||(b==3)||(c==3)||(d==3)||(a==4)||(b==4)||(c==4)||(d==4))
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 else if(10000<=n&&n<=99999)
 {
  int a,b,c,d,e=0;
  a=n/10000;
  b=n/1000%10;
  c=n/100%100%10;
  d=n/10%100%10;
  e=n%10%10%10%10;
  if((a==3)||(b==3)||(c==3)||(d==3)||(e==3)||(a==4)||(b==4)||(c==4)||(d==4)||(e==4))
  {
   return true;
  }
  else
  {
   return false;
  }
 }
}