首页 > 代码库 > 六道题 ： 1.设计一个函数，用来计算b的n次方 2.（n! = 1*2*3*4*...n） 3.（1! + 2! + 3! + 4! + ... + n!） 4.成绩 5. 数组中的元素逆序存放 6.九九乘法口诀

六道题 ： 1.设计一个函数，用来计算b的n次方 2.（n! = 1*2*3*4*...n） 3.（1! + 2! + 3! + 4! + ... + n!） 4.成绩 5. 数组中的元素逆序存放 6.九九乘法口诀

2024-07-06 05:17:40   224人阅读

/*

设计一个函数，用来计算b的n次方

 

 递归的2个条件：

 1.函数自己调用自己

 2.必须有个明确的返回值

*/

#include <stdio.h>

int pow2(int b, int n);

 

int main()

{

    int c = pow2(3, 2);

    

    printf("%d\n", c);

    return 0;

}

 

/*

 pow2(b, 0) == 1

 pow2(b, 1) == b == pow2(b, 0) * b

 pow2(b, 2) == b*b == pow2(b, 1) * b

 pow2(b, 3) == b*b*b == pow2(b, 2) * b

 

 1> n为0，结果肯定是1

 2> n>0，pow2(b, n) == pow2(b, n-1) * b

 */

 

int pow2(int b, int n)

{

    if (n <= 0) return 1;

    return pow2(b, n-1) * b;

}

 

/*

int pow2(int b, int n)

{

    // 用来保存计算结果

    int result = 1;

    

    

    //result *= b;

    //result *= b;

    //result *= b;

    //result *= b;

    //....

    

    //n次

 

    

    for (int i = 0; i<n; i++)

    {

        result *= b;

    }

    

    return result;

}*/

?
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
/*第一题：
 提示用户输入一个正整数n，求出并输出其阶乘值n! = 1*2*3*4*...n
 要求：用递归的方式编写一个函数实现n的阶乘
*/
 
#include <stdio.h>
 
int jieCheng(int n);
 
int main()
{
    // 1.定义变量存储用户输入的整数
    int n = 0;
     
    // 2.判断n是否为正整数
    while (n <= 0)
    {
        // 2.1 提示输入
        printf("输入一个正整数：\n");
         
        // 2.2 让用户输入
        scanf("%d", &n);
    }
     
    // 3.计算阶乘
    int result = jieCheng(n);
     
    printf("%d! = %d\n", n, result);
    return 0;
}
 
int jieCheng(int n)
{
    // 如果n为1，那么阶乘值就是1
    if (n == 1) return 1;
     
    // jieCheng(n) = n! = 1*2*3*...*(n-1)*n
    // jieCheng(n-1) = (n-1)! = 1*2*3*...*(n-1)
    // jieCheng(n) = jieCheng(n-1) * n
    return jieCheng(n-1) * 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
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/*第二题
 提示用户输入一个正整数n，求出并输出下列结果：1! + 2! + 3! + 4! + ... + n!
 要求：用至少两种方式实现(函数名自拟，函数个数不限)
 1> 非递归
 2> 递归
*/
#include <stdio.h>
int pieAdd(int n);
 
int main()
{
    // 1.定义变量存储用户输入的整数
    int n = 0;
     
    // 2.判断n是否为正整数
    while (n <= 0)
    {
        // 2.1 提示输入
        printf("输入一个正整数：\n");
         
        // 2.2 让用户输入
        scanf("%d", &n);
    }
     
    // 3.计算结果
    int result = pieAdd(n);
     
    printf("结果是%d\n", result);
     
    return 0;
}
 
// ------------------非递归的方式----------------
int pieAdd(int n)
{
    // 1.定义变量保存总和
    int sum = 0;
     
    // 2.需要累加n次，每次累加的都是一个阶乘值
    for (int i = 1; i<=n; i++)
    {
        // 3.计算阶乘i!
        // 3.1 定义变量保存阶乘的结果
        int multi = 1;
        for (int j = 1; j<=i; j++)
        {
            multi *= j;
        }
         
        // 4.累加每次的阶乘结果
        sum += multi;
    }
     
    // 5.返回和
    return sum;
}
 
/*
// ------------------递归的方式----------------
// 为了代码方便和性能，额外定义一个函数求阶乘
int jieCheng(int n)
{
    // 如果n为1，那么阶乘值就是1
    if (n == 1) return 1;
     
    // jieCheng(n) = n! = 1*2*3*...*(n-1)*n
    // jieCheng(n-1) = (n-1)! = 1*2*3*...*(n-1)
    // jieCheng(n) = jieCheng(n-1) * n
    return jieCheng(n-1) * n;
}
 
int pieAdd(int n)
{
    // 1.如果n是1，计算结果就是1
    if (n == 1) return 1;
     
    // pieAdd(n) = 1! + 2! + ... + (n-1)!+ n!
    // pieAdd(n-1) = 1! + 2! + ... + (n-1)!
    // pidAdd(n) = pieAdd(n-1) + n!
    return pieAdd(n - 1) + jieCheng(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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/* 第三题：
提示输入5个学生的成绩(保证分数在0~100之间)，算出平均分、最高分、最低分，然后输出
*/
#include <stdio.h>
// 学生的个数
#define kCount 5
 
int main()
{
    // 1.定义一个数组保存5个学生的分数
    // 初始化一下，默认都是-1分，只要默认值不是0~100都行
    int scores[kCount] = {-1, -1, -1, -1, -1};
     
    // 2.定义变量保存总分、最高分（默认是0分）、最低分（默认是100分）
    int sum = 0, max = 0, min = 100;
     
    // 3.提示输入
    for (int i = 0; i<kCount; i++)
    {
        // 3.1 如果学生的成绩不在0~100内，就重新提示输入
        while (scores[i]<0 || scores[i]>100)
        {
            // 3.1.1 提示输入
            printf("请输入第%d个学生的成绩（0~100）：\n", i + 1);
             
            // 3.1.2 接收输入
            scanf("%d", &scores[i]);
        }
         
        // 3.2 累加成绩
        sum += scores[i];
         
        // 3.3 判断最高分
        if (scores[i] > max)
        {
            max = scores[i];
        }
         
        // 3.4 判断最低分
        if (scores[i] < min)
        {
            min = scores[i];
        }
    }
     
    // 4.输出结果
    printf("平均分是%d，最高分是%d，最低分是%d\n", sum/kCount, max, min);
}

　　

?
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
/*第四题
设计一个函数：将一维整型数组中的元素逆序存放。比如本来是1,3,4,2，逆序存放就变成了：2，4，3，1
*/
#include <stdio.h>
void reverse(int array[], int len);
 
int main()
{
    int ages[4] = {1, 3, 4, 2};
     
    reverse(ages, 4);
     
    for (int i = 0; i<4; i++)
    {
        printf("%d\n", ages[i]);
    }
     
    return 0;
}
 
// 第一个参数是数组，第二个参数是数组长度
// 不需要返回值
// 因为改变了形参数组就相当于修改了外面的实参数组
void reverse(int array[], int len)
{
    // 思路：以数组中间为轴，交换左右对称元素的值
    // 比如array[0] array[1] array[2] array[3] array[4] array[5]
    // 交换array[0]和array[5]的值
    // 交换array[1]和array[4]的值
    // 交换array[2]和array[3]的值
     
    // 左边元素的下标(默认是最左边)
    int left = 0;
    // 右边元素的下标(默认是最右边)
    int right = len - 1;
     
    // 如果左边元素的下标 < 右边元素的下标
    while (left < right)
    {
        // 利用中间变量交换两个元素的值
        int temp = array[left];
        array[left] = array[right];
        array[right] = temp;
         
        // 交换一次后，左边元素下标增加，右边元素下标减小
         
        left++;
        right--;
    }
}

　　

?
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
/*第五题：
输出99乘法表
 1x1=1
 2x1=2  2x2=4
 3x1=3  3x2=6   3x3=9
 4x1=4  4x2=8   4x3=12  4x4=16
 5x1=5  5x2=10  5x3=15  5x4=20  5x5=25
 6x1=6  6x2=12  6x3=18  6x4=24  6x5=30  6x6=36
 7x1=7  7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49
 8x1=8  8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64
 9x1=9  9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81
*/
#include <stdio.h>
int main()
{
    // 一共有多少行
    for (int row = 1; row<=9; row++)
    {
        // 一共有多少列（其实列数==行数）
        for(int column = 1; column<=row; column++)
        {
            // \t是tab键，目的是保持每列之间有相同的距离
            printf("%dx%d=%d\t", row, column, row * column);
        }
         
        // 换行
        printf("\n");
    }
}

　　


联系
我们