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;
}