1. int func(int now, int type)
2. {
3.  
4. //存款利息的计算。有1000元，想存5年，可按以下5种办法存：
5. float res = now, r;
6. if (type == 1) {
7. // （1）一次存5年期
8. // 5年期定期存款利息为3%;
9. r = 0.03;
10. res *= (5 * r + 1);
11. }
12. if (type == 2) {
13. // （2）先存2年期，到期后将本息再存3年期
14. // 2年期定期存款利息为2.1%; 3年期定期存款利息为2.75%;
15. r = 0.021;
16. res *= (2 * r + 1);
17. r = 0.0275;
18. res *= (3 * r + 1);
19. }
20. if (type == 3) {
21. // （3）先存3年期，到期后将本息再存2年期
22. // 2年期定期存款利息为2.1%; 3年期定期存款利息为2.75%;
23. r = 0.0275;
24. res *= (3 * r + 1);
25. r = 0.021;
26. res *= (2 * r + 1);
27. }
28. if (type == 4) {
29. // （4）存1年期，到期后将本息再存1年期，连续存5次
30. // 1年期定期存款利息为1.5%;
31. r = 0.015;
32. for (int i = 0; i < 5; i++)
33. {
34. res *= (r + 1);
35. }
36.  
37. }
38. if (type == 5)
39. {
40. //（5）存活期存款，活期利息每一季度结算一次
41. //活期存款利息为0.35%(活期存款每一-季度结算一次利息)
42. r = 0.0035;
43. for (int i = 0; i < 5 * 4; i++)
44. {
45. res *= (r + 1);
46. }
47. }
48.  
49. return res;
50. }

1. int main()
2. {
3. float r5, r3, r2, r1, r0, p, p1, p2, p3, p4, p5;
4. p = 1000;
5. r5 = 0.0585;
6. r3 = 0.054;
7. r2 = 0.0468;
8. r1 = 0.0414;
9. r0 = 0.0072;
10.  
11. p1 = p*((1 + r5) * 5); // 一次存5年期
12. p2 = p*(1 + 2 * r2)*(1 + 3 * r3); // 先存2年期，到期后将本息再存3年期
13. p3 = p*(1 + 3 * r3)*(1 + 2 * r2); // 先存3年期，到期后将本息再存2年期
14. p4 = p*pow(1 + r1, 5); // 存1年期，到期后将本息存再存1年期，连续存5次
15. p5 = p*pow(1 + r0 / 4, 4 * 5); // 存活期存款。活期利息每一季度结算一次
16. printf("p1=%f\n", p1); // 输出按第1方案得到的本息和
17. printf("p2=%f\n", p2); // 输出按第2方案得到的本息和
18. printf("p3=%f\n", p3); // 输出按第3方案得到的本息和
19. printf("p4=%f\n", p4); // 输出按第4方案得到的本息和
20. printf("p5=%f\n", p5); // 输出按第5方案得到的本息和
21. return 0;
22. }

1. int func(int now, int type)
2. {
3.  
4. //存款利息的计算。有1000元，想存5年，可按以下5种办法存：
5. float res = now, r;
6. if (type == 1) {
7. // （1）一次存5年期
8. // 5年期定期存款利息为3%;
9. r = 0.03;
10. res *= (5 * r + 1);
11. }
12. if (type == 2) {
13. // （2）先存2年期，到期后将本息再存3年期
14. // 2年期定期存款利息为2.1%; 3年期定期存款利息为2.75%;
15. r = 0.021;
16. res *= (2 * r + 1);
17. r = 0.0275;
18. res *= (3 * r + 1);
19. }
20. if (type == 3) {
21. // （3）先存3年期，到期后将本息再存2年期
22. // 2年期定期存款利息为2.1%; 3年期定期存款利息为2.75%;
23. r = 0.0275;
24. res *= (3 * r + 1);
25. r = 0.021;
26. res *= (2 * r + 1);
27. }
28. if (type == 4) {
29. // （4）存1年期，到期后将本息再存1年期，连续存5次
30. // 1年期定期存款利息为1.5%;
31. r = 0.015;
32. for (int i = 0; i < 5; i++)
33. {
34. res *= (r + 1);
35. }
36.  
37. }
38. if (type == 5)
39. {
40. //（5）存活期存款，活期利息每一季度结算一次
41. //活期存款利息为0.35%(活期存款每一-季度结算一次利息)
42. r = 0.0035;
43. for (int i = 0; i < 5 * 4; i++)
44. {
45. res *= (r + 1);
46. }
47. }
48.  
49. return res;
50. }

1

int func(int now, int type) 
{

	//存款利息的计算。有1000元，想存5年，可按以下5种办法存：
	float res = now, r;
	if (type == 1) {
		// （1）一次存5年期 
		// 5年期定期存款利息为3%;
		r = 0.03;
		res *= (5 * r + 1);
	}
	if (type == 2) {
		// （2）先存2年期，到期后将本息再存3年期 
		// 2年期定期存款利息为2.1%; 3年期定期存款利息为2.75%;
		r = 0.021;
		res *=  (2 * r + 1);
		r = 0.0275;
		res *= (3 * r + 1);
	}
	if (type == 3) {
		// （3）先存3年期，到期后将本息再存2年期 
		// 2年期定期存款利息为2.1%; 3年期定期存款利息为2.75%;
		r = 0.0275;
		res *= (3 * r + 1);
		r = 0.021;
		res *= (2 * r + 1);
	}
	if (type == 4) {
		// （4）存1年期，到期后将本息再存1年期，连续存5次
		// 1年期定期存款利息为1.5%;
		r = 0.015;
		for (int i = 0; i < 5; i++) 
		{
			res *= (r + 1);
		}
		
	}
	if (type == 5) 
	{
		//（5）存活期存款，活期利息每一季度结算一次
		//活期存款利息为0.35%(活期存款每一-季度结算一次利息)
		r = 0.0035;
		for (int i = 0; i < 5 * 4; i++) 
		{
			res *= (r + 1);
		}
	}
	
	return res;
}

#include #include #include #include int main(void) { int type; double money = 1000.0, profit, origin = money;//origin 本金 puts("请选择存钱方式：\n1.一次存5年期\n2.先存2年期，到期后将本息再存3年期\n3.先存3年期，到期后将本息再存2年期\n4.存1年期，到期后将本息再存1年期，连续存5次\n5.存活期存款，活期利息每一季度结算一次"); scanf("%d", &type); switch (type) { case 1:profit = money * (1 + 5 * 0.03) - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break; case 2:money *= (1 + 2 * 0.021); profit = money * (1 + 0.0275 * 3) - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break; case 3:money *= (1 + 3 * 0.0275); profit = money * (1 + 0.021 * 3) - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break; case 4:money = 1000 * pow((1 + 0.015), 5); profit = money - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break; case 5:money = 1000 * pow((1 + 0.015 / 4), 4 * 5); profit = money - origin; ; printf("方式%d存钱利润为：%lf\n", type, profit); break; } return 0; }

#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
int main(void)
{
    int type;
    double money = 1000.0, profit, origin = money;//origin 本金

    puts("请选择存钱方式：\n1.一次存5年期\n2.先存2年期，到期后将本息再存3年期\n3.先存3年期，到期后将本息再存2年期\n4.存1年期，到期后将本息再存1年期，连续存5次\n5.存活期存款，活期利息每一季度结算一次");
    scanf("%d", &type);
    switch (type) {
    case 1:profit = money * (1 + 5 * 0.03) - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break;
    case 2:money *= (1 + 2 * 0.021); profit = money * (1 + 0.0275 * 3) - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break;
    case 3:money *= (1 + 3 * 0.0275); profit = money * (1 + 0.021 * 3) - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break;
    case 4:money = 1000 * pow((1 + 0.015), 5); profit = money - origin; printf("方式%d存钱利润为：%lf\n", type, profit); break;
    case 5:money = 1000 * pow((1 + 0.015 / 4), 4 * 5); profit = money - origin; ; printf("方式%d存钱利润为：%lf\n", type, profit); break;
    }
    return 0;
}

1. #include <stdio.h>
2. #include "math.h"
3.  
4. // 各种存款方式的利率
5. double interest[5] = {0.0035, 0.015, 0.021, 0.0275, 0.03};
6.  
7.  
8. double get_deposit_interest_by_year(double money, int year) {
9. int index = year < 5 ? year : year - 1;
10. return money * (1 + year * interest[index]);
11. }
12.  
13. double get_deposit_interest_5year(double money, int option) {
14. double p = 0;
15. switch (option) {
16. case 1: {
17. // 一次存5年
18. p = get_deposit_interest_by_year(money, 5);
19. break;
20. }
21. case 2: {
22. // 先存2年期，到期后将本息再存3年期
23. double tmp_money = get_deposit_interest_by_year(money, 2);
24. p = get_deposit_interest_by_year(tmp_money, 3);
25. break;
26. }
27. case 3: {
28. // 先存3年期，到期后将本息再存2年期
29. double tmp_money = get_deposit_interest_by_year(money, 3);
30. p = get_deposit_interest_by_year(tmp_money, 2);
31. break;
32. }
33. case 4: {
34. // 存1年期，到期后将本息再存1年期，连续存5次
35. double tmp_money = money;
36. for (int i = 0; i < 5; ++i) {
37. tmp_money = get_deposit_interest_by_year(tmp_money, 1);
38. }
39. p = tmp_money;
40. break;
41. }
42. case 5: {
43. // 存活期存款，活期利息每一季度结算一次
44. p = money * pow((1 + interest[0] / 4), 4 * 5);
45. break;
46. }
47. default: {
48. printf("操作不存在");
49. }
50. }
51. return p;
52. }
53.  
54.  
55. int main() {
56. printf("一次存5年: %lf\n", get_deposit_interest_5year(1000, 1));
57. printf("先存2年期，到期后将本息再存3年期: %lf\n", get_deposit_interest_5year(1000, 2));
58. printf("先存3年期，到期后将本息再存2年期: %lf\n", get_deposit_interest_5year(1000, 3));
59. printf("存1年期，到期后将本息再存1年期，连续存5次: %lf\n", get_deposit_interest_5year(1000, 4));
60. printf("存活期存款，活期利息每一季度结算一次: %lf\n", get_deposit_interest_5year(1000, 5));
61.  
62. return 0;
63. }

#include <stdio.h>
#include "math.h"

// 各种存款方式的利率
double interest[5] = {0.0035, 0.015, 0.021, 0.0275, 0.03};


double get_deposit_interest_by_year(double money, int year) {
    int index = year < 5 ? year : year - 1;
    return money * (1 + year * interest[index]);
}

double get_deposit_interest_5year(double money, int option) {
    double p = 0;
    switch (option) {
        case 1: {
            // 一次存5年
            p = get_deposit_interest_by_year(money, 5);
            break;
        }
        case 2: {
            // 先存2年期，到期后将本息再存3年期
            double tmp_money = get_deposit_interest_by_year(money, 2);
            p = get_deposit_interest_by_year(tmp_money, 3);
            break;
        }
        case 3: {
            // 先存3年期，到期后将本息再存2年期
            double tmp_money = get_deposit_interest_by_year(money, 3);
            p = get_deposit_interest_by_year(tmp_money, 2);
            break;
        }
        case 4: {
            // 存1年期，到期后将本息再存1年期，连续存5次
            double tmp_money = money;
            for (int i = 0; i < 5; ++i) {
                tmp_money = get_deposit_interest_by_year(tmp_money, 1);
            }
            p = tmp_money;
            break;
        }
        case 5: {
            // 存活期存款，活期利息每一季度结算一次
            p = money * pow((1 + interest[0] / 4), 4 * 5);
            break;
        }
        default: {
            printf("操作不存在");
        }
    }
    return p;
}


int main() {
    printf("一次存5年: %lf\n", get_deposit_interest_5year(1000, 1));
    printf("先存2年期，到期后将本息再存3年期: %lf\n", get_deposit_interest_5year(1000, 2));
    printf("先存3年期，到期后将本息再存2年期: %lf\n", get_deposit_interest_5year(1000, 3));
    printf("存1年期，到期后将本息再存1年期，连续存5次: %lf\n", get_deposit_interest_5year(1000, 4));
    printf("存活期存款，活期利息每一季度结算一次: %lf\n", get_deposit_interest_5year(1000, 5));

    return 0;
}