C++第二次上机作业

Maths

      1.输入一个两整数，要求将该数逆序输出。例如，输入68，输出86。

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
#include<iostream>
using namespace std;
/*
1.输入一个两位整数，要求将该数逆序输出。
*/
int main() {
	int input;	//	定义要输入的整数
	int digit, unit;	//	定义十位数和个位数
	//	为了让程序可以重复输入输出，使用循环
	while (1) {
		cout << "请输入一个两位整数(10-99):";
		cin >> input;
		//	绝对值超过100的数字不符合题目要求
		if (input >= 100 || input <= -100) {
			cout << "你输入的数字不是两位整数，请重新输入" << endl;
			//	清除cin流的缓存，方便下次输入不会有问题。
			cin.clear();
			cin.sync();
			continue;
		}
		else {
			//	input整除10就能取出十位数
			digit = input / 10;
			//	input减去十位数乘以10就是个位数
			unit = input - digit * 10;
			//	重新组合输出数字
			cout << unit * 10 + digit << endl;
		}
	}
	return 0;
}
/*
输出测试：
-568	"你输入的数字不是两位整数，请重新输入"
-89		-98
89		98
7		70
-6		-60
589		"你输入的数字不是两位整数，请重新输入"
可以循环输入，每次都会有提示："请输入一个两位整数(10-99):"
*/

      2.求PI，求PI的公式如下：
$$ \frac{π}{4}≈1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+……=\sum_{n=1}^∞(-1)^{n-1}\frac{1}{2n-1} $$

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
#include<iostream>
#include<ctime>		//	引入clock_t类
#include<iomanip>	//	显示小数点的位数用的头文件
using namespace std;
double const EPS = 1e-9;
int main() {
	clock_t start, finish;	//	引入记录程序运行时间的对象
	start = clock();	// start对象执行clock()方法，开始计时
	double sum = 0;
	double k = 1;
	int i = 1;
	int flag = 0;
	while (k / i >= EPS) {
		if (i % 4 == 1) {
			sum = sum + k / i;
		}
		else {
			sum = sum - k / i;
		}
		i = i + 2;
		flag++;
	}
	double Sum = 4 * sum;
	cout << "π的值是：" << setprecision(10)<< Sum << endl;
	cout << EPS << "精度下共执行了" << flag << "次循环" << endl;
	finish = clock();	//	finish对象执行clock()方法，结束计时。
	cout << "花费的时间是："<< finish - start << "/" << CLOCKS_PER_SEC << "(s)" << endl;
	system("pause");
	return 0;
}
/*
	实现的代码不难写，但是为了效率的问题，对EPS测试了几个常数，并记录了实验结果。
	π的值是：3.141572654
	1e-05精度下共执行了50000次循环
	花费的时间是：2/1000(s)
	π的值是：3.141590654
	1e-06精度下共执行了500000次循环
	花费的时间是：9/1000(s)
	π的值是：3.141592454
	1e-07精度下共执行了5000000次循环
	花费的时间是：76/1000(s)
	π的值是：3.141592634
	1e-08精度下共执行了50000000次循环
	花费的时间是：742/1000(s)
	π的值是：3.141592652
	1e-09精度下共执行了500000000次循环
	花费的时间是：7392/1000(s)
	到了1e-10时，循环数又翻10倍，花费的时间也会是10倍，70s的等待已经是到了不能忍受的范围。
	因此纵观以上取得精度以及准确性，可以取1e-08或者1e-09作为近似值。
*/

      3.编写一个判断素数的函数，在主函数中输入一个整数n,调用判素数的函数，在主函数中输出判断结果。

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
#include<iostream>
using namespace std;
//	函数的声明
bool isprime(int prime);
int main() {
	int test;
	cout << "请输入一个整数:";
	cin >> test;
	if (isprime(test)) {
		cout << test << "是质数" << endl;
	}
	else {
		cout << test << "不是质数" << endl;
	}
	system("pause");
	return 0;
}
bool isprime(int prime) {
	if (prime == 2) {
		return true;
	}
	if (prime % 2 == 0) {
		return false;
	}
	else {
		for (int temp = 3; temp <= prime / 2; temp = temp + 2) {
			if (prime%temp == 0) {
				cout << prime << "=" << temp << "*" << prime / temp << endl;
				return false;
			}
		}
	}
	return true;
}

      4.编写一个判润年的函数，在主函数中输入一个年份year,调用判润年的函数，在主函数中输出判断结果。

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
#include<iostream>
using namespace std;
bool isleapyear(int year) {
	if (year % 4 != 0) {
		return false;
	}
	else if (year % 100 == 0) {
		if (year % 400 == 0) {
			return true;
		}
		else {
			return false;
		}
	}
	else {
		return true;
	}
}
int main() {
	int year;
	while (!cin.fail()) {
		cin.clear();
		cin.sync();
		cout << "请输入一个年份：";
		cin >> year;
		if (isleapyear(year)) {
			cout << year << "年是闰年！可以找铎神领取红包！" << endl;
		}
		else {
			cout << year << "年不是闰年，但是也可以找铎神领取红包！" << endl;
		}
	}
	cout << "你输入的不是年份，请重新运行程序！" << endl;
	system("pause");
	return 0;
}

      5.通过键盘输入一个实数，要求按四舍五入的规则保留两位小数并输出。

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
#include<iostream>
#include<cmath>
using namespace std;
/*
	不论输入的是多少位小数，我们需要的是保留两位小数，所以需要接触到的关键点是小数点后第三位。
	四舍五入版
*/
double rounding(double number) {
	int integer = static_cast<int>(number);	//	取输入实数的整数部分
	double knumber = number * 100;	//将需要判断第三位小数点移动到第一位。
	int kinteger = static_cast<int>(knumber);	//	取得增大100倍以后的整数，到时是输出的主体
	double dnumber = knumber-kinteger;	//	取剩余的小数部分
	if (abs(dnumber) < 0.5) {
		return	kinteger / 100.0;
	}
	else {
		if (dnumber > 0) {
			return kinteger / 100.0 + 0.01;
		}
		else {
			return kinteger / 100.0 - 0.01;
		}
	}
}
int main() {
	double number;
	double result;
	while (!cin.fail()) {
		cin.clear();
		cin.sync();
		cout << "请输入一个实数：";
		cin >> number;
		result = rounding(number);
		cout << number << "经过四舍五入以后的结果是" << result << endl;
	}
	system("pause");
	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
#include<iostream>
#include<cmath>
using namespace std;
/*
	不论输入的是多少位小数，我们需要的是保留两位小数，所以需要接触到的关键点是小数点后第三位。
	四舍六入五成双版(常见于分析化学有效位数取舍)。
	规则：
	对于位数很多的近似数，当有效位数确定后，其后面多余的数字应该舍去，只保留有效数字最末一位，这种修约（舍入）规则是“四舍六入五成双”，
	也即“4舍6入5凑偶”这里“四”是指≤4 时舍去，"六"是指≥6时进上，
	"五"指的是根据5后面的数字来定，当5后有数时，舍5入1；
	当5后无有效数字时，
	需要分两种情况来讲：①5前为奇数，舍5入1；②5前为偶数，舍5不进。（0是偶数）
	由于计算机中大量的浮点数都是带有很多位的，为了体现四舍六入五成双的算法。
	根据题目需要的2位小数，我统一截取4位小数开始计算。
	这样子会有一个bug,比如9.82501,因为截取了4位小数，所以修正出来是9.82,正确答案是9.83。
	但是只是为了演示，实际上必须是取定位数来统一输入，再用这个算法。
	可以再优化为要求输入小数的位数或判断输入数据的位数，但是这需要到数组和字符串的知识。
*/
double intercept(double number) {
	int integer = static_cast<int>(number);	//	取输入实数的整数部分
	double knumber = number * 10000;	//	将所需要的部分全部化为一个整数
	int kinteger = static_cast<int>(knumber);	//	截取整数部分
	double dnumber = kinteger / 10000.0;	//	取得所需要的数。
	return dnumber;
}
double rounding(double number) {
	double temp = intercept(number);	//	截取所需要判断的数字，应该已经告知此时的数字有4位。
	int ktemp = static_cast<int>(temp * 10000);
	int integer_result = static_cast<int>(temp);	//	输出结果的整数部分
	double	digital_result = temp - integer_result;	//	剩余的小数部分
	int judge_number = (((ktemp % 100000) % 10000) % 1000) % 100;	//	为了能取到最后低的两位数。
	if (judge_number != 50) {
		if (judge_number <= 49) {
			return integer_result + (static_cast<int>(digital_result * 100)) / 100.0;
		}
		else {
			return integer_result + (static_cast<int>(digital_result * 100)) / 100.0 + 0.01;
		}
	}
	else {
		if ((ktemp / 100) % 2 == 0) {	//	倒数第3位是偶数的时候，此时应该不进位
			return integer_result + (static_cast<int>(digital_result * 100)) / 100.0;
		}
		else {
			return integer_result + (static_cast<int>(digital_result * 100)) / 100.0 + 0.01;
		}
	}
}
int main() {
	double number;
	double result;
	while (!cin.fail()) {
		cin.clear();
		cin.sync();
		cout << "请输入一个实数：";
		cin >> number;
		result = rounding(number);
		cout << number << "经过四舍六入五成双以后的结果是" << result << endl;
	}
	system("pause");
	return 0;
}
文章目录
|