函数练习

16. 函数练习题

1. 计算两个数的最大值

题目描述： 编写一个 C 程序，定义一个函数max，接受两个整数参数，返回其中较大的一个数。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为max的函数，该函数接受两个整数参数，通过条件判断返回较大的数。在main函数中，提示用户输入两个整数，调用max函数并打印返回值。

详细代码：

#include <stdio.h>

// 定义函数max，返回两个整数中的较大者
int max(int a, int b) {
    if(a > b)
        return a;
    else
        return b;
}

int main() {
    int num1, num2, maximum;

    // 提示用户输入两个整数
    printf("请输入两个整数:\n");
    printf("第一个整数: ");
    scanf("%d", &num1);
    printf("第二个整数: ");
    scanf("%d", &num2);

    // 调用max函数并获取较大值
    maximum = max(num1, num2);

    // 输出结果
    printf("较大的数是 %d。\n", maximum);

    return 0;
}

代码注释：

• int max(int a, int b)：定义一个名为max的函数，接受两个整数参数a和b。

• if(a > b)：比较a和b，如果a大于b，则返回a。

• else：否则，返回b。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的两个整数。
  • 调用max(num1, num2)函数，获取较大值并存储在maximum变量中。
  • 使用printf输出结果。

2. 计算阶乘

题目描述： 编写一个 C 程序，定义一个递归函数factorial，接受一个非负整数参数，返回其阶乘。在main函数中调用该函数并输出结果。

解题思路： 创建一个递归函数factorial，其基本情况为n = 0或n = 1时返回 1。对于n > 1，返回n * factorial(n-1)。在main函数中，提示用户输入一个非负整数，调用factorial函数并打印结果。

详细代码：

#include <stdio.h>

// 定义递归函数factorial，返回n的阶乘
unsigned long long factorial(int n) {
    if(n == 0 || n == 1)
        return 1;
    else
        return n * factorial(n - 1);
}

int main() {
    int number;
    unsigned long long fact;

    // 提示用户输入一个非负整数
    printf("请输入一个非负整数: ");
    scanf("%d", &number);

    // 检查输入是否为非负整数
    if(number < 0) {
        printf("错误: 阶乘不存在于负数。\n");
        return 1; // 非正常退出
    }

    // 调用factorial函数计算阶乘
    fact = factorial(number);

    // 输出结果
    printf("%d 的阶乘是 %llu。\n", number, fact);

    return 0;
}

代码注释：

• unsigned long long factorial(int n)：定义一个递归函数factorial，返回n的阶乘。

• if(n == 0 || n == 1)：基例，当n为 0 或 1 时，阶乘为 1。

• else：对于n > 1，返回n * factorial(n - 1)，实现递归计算。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的非负整数。
  • 检查输入是否为负数，若是，则输出错误信息并退出程序。
  • 调用factorial(number)函数，获取阶乘值并存储在fact变量中。
  • 使用printf输出结果。

3. 判断素数

题目描述： 编写一个 C 程序，定义一个函数isPrime，接受一个整数参数，返回 1 如果该数是素数，返回 0 否则。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为isPrime的函数，通过遍历从 2 到sqrt(n)的数，检查是否有任何数能整除n。如果找到一个因数，则不是素数。否则，是素数。在main函数中，提示用户输入一个整数，调用isPrime函数并根据返回值输出结果。

详细代码：

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

// 定义函数isPrime，判断一个数是否为素数
int isPrime(int n) {
    if(n <= 1)
        return 0; // 0和1不是素数
    if(n == 2)
        return 1; // 2是素数
    if(n % 2 == 0)
        return 0; // 偶数不是素数

    // 检查从3到sqrt(n)的奇数是否能整除n
    for(int i = 3; i <= sqrt(n); i += 2) {
        if(n % i == 0)
            return 0; // 找到因数，不是素数
    }
    return 1; // 没有因数，是素数
}

int main() {
    int number;

    // 提示用户输入一个整数
    printf("请输入一个整数: ");
    scanf("%d", &number);

    // 调用isPrime函数并输出结果
    if(isPrime(number))
        printf("%d 是素数。\n", number);
    else
        printf("%d 不是素数。\n", number);

    return 0;
}

代码注释：

• int isPrime(int n)：定义一个函数isPrime，接受一个整数n作为参数。

• if(n <= 1)：如果n小于或等于 1，则不是素数。

• if(n == 2)：2 是素数，直接返回 1。

• if(n % 2 == 0)：除 2 之外的偶数不是素数。

• for(int i = 3; i <= sqrt(n); i += 2)：遍历从 3 到sqrt(n)的奇数，检查是否能整除n。

• if(n % i == 0)：如果n能被i整除，则不是素数，返回 0。

• return 1：如果没有找到因数，则n是素数。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的整数。
  • 调用isPrime(number)函数，判断是否为素数。
  • 根据返回值使用printf输出相应的信息。

4. 计算斐波那契数列

题目描述： 编写一个 C 程序，定义一个函数fibonacci，接受一个整数参数n，返回斐波那契数列的第n项。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为fibonacci的函数，通过递归或迭代的方式计算斐波那契数列的第n项。为了提高效率，采用迭代方法。在main函数中，提示用户输入一个整数n，调用fibonacci函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数fibonacci，返回斐波那契数列的第n项
long long fibonacci(int n) {
    if(n == 0)
        return 0;
    if(n == 1)
        return 1;

    long long a = 0, b = 1, fib = 0;
    for(int i = 2; i <= n; i++) {
        fib = a + b;
        a = b;
        b = fib;
    }
    return fib;
}

int main() {
    int term;
    long long result;

    // 提示用户输入要计算的斐波那契数列项数
    printf("请输入斐波那契数列的项数 (n): ");
    scanf("%d", &term);

    // 检查输入是否为非负整数
    if(term < 0) {
        printf("错误: 斐波那契数列的项数必须为非负整数。\n");
        return 1; // 非正常退出
    }

    // 调用fibonacci函数计算第n项
    result = fibonacci(term);

    // 输出结果
    printf("斐波那契数列的第 %d 项是 %lld。\n", term, result);

    return 0;
}

代码注释：

• long long fibonacci(int n)：定义一个函数fibonacci，返回斐波那契数列的第n项。

• if(n == 0)和if(n == 1)：处理斐波那契数列的前两项，分别为 0 和 1。

• for(int i = 2; i <= n; i++)
  

  ：使用迭代方法计算斐波那契数列的第

  n
  

  项。

  • fib = a + b;：当前项等于前两项之和。
  • a = b; b = fib;：更新前两项。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的项数n。
  • 检查输入是否为非负整数，若不是，则输出错误信息并退出程序。
  • 调用fibonacci(term)函数，获取斐波那契数列的第n项。
  • 使用printf输出结果。

5. 字符串长度函数

题目描述： 编写一个 C 程序，定义一个函数stringLength，接受一个字符串参数，返回该字符串的长度。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为stringLength的函数，通过遍历字符串，直到遇到\0，计数字符的数量并返回。在main函数中，提示用户输入一个字符串，调用stringLength函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数stringLength，返回字符串的长度
int stringLength(char str[]) {
    int length = 0;
    while(str[length] != '\0') {
        length++;
    }
    return length;
}

int main() {
    char input[100];
    int len;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(input, sizeof(input), stdin);

    // 去除fgets读取的换行符
    int i;
    for(i = 0; input[i] != '\0'; i++) {
        if(input[i] == '\n') {
            input[i] = '\0';
            break;
        }
    }

    // 调用stringLength函数计算长度
    len = stringLength(input);

    // 输出结果
    printf("字符串的长度是 %d。\n", len);

    return 0;
}

代码注释：

• int stringLength(char str[])：定义一个函数stringLength，接受一个字符数组作为参数。

• while(str[length] != '\0')：遍历字符串，直到遇到字符串结束符\0。

• length++：计数字符的数量。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的字符串，包括空格。
  • 遍历字符串，遇到换行符\n则替换为\0，避免影响长度计算。
  • 调用stringLength(input)函数，获取字符串长度并存储在len变量中。
  • 使用printf输出字符串的长度。

6. 判断字符串是否相等

题目描述： 编写一个 C 程序，定义一个函数areEqual，接受两个字符串参数，返回 1 如果两个字符串相等，返回 0 否则。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为areEqual的函数，通过逐字符比较两个字符串，直到遇到不同的字符或字符串结束符。如果所有对应字符都相同，则返回 1；否则，返回 0。在main函数中，提示用户输入两个字符串，调用areEqual函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数areEqual，比较两个字符串是否相等
int areEqual(char str1[], char str2[]) {
    int i = 0;
    // 比较每个字符
    while(str1[i] != '\0' && str2[i] != '\0') {
        if(str1[i] != str2[i])
            return 0; // 不相等
        i++;
    }
    // 如果两个字符串都结束，说明相等
    if(str1[i] == '\0' && str2[i] == '\0')
        return 1;
    else
        return 0;
}

int main() {
    char string1[100], string2[100];
    int result;

    // 提示用户输入第一个字符串
    printf("请输入第一个字符串: ");
    fgets(string1, sizeof(string1), stdin);

    // 去除第一个字符串中的换行符
    int i;
    for(i = 0; string1[i] != '\0'; i++) {
        if(string1[i] == '\n') {
            string1[i] = '\0';
            break;
        }
    }

    // 提示用户输入第二个字符串
    printf("请输入第二个字符串: ");
    fgets(string2, sizeof(string2), stdin);

    // 去除第二个字符串中的换行符
    for(i = 0; string2[i] != '\0'; i++) {
        if(string2[i] == '\n') {
            string2[i] = '\0';
            break;
        }
    }

    // 调用areEqual函数比较两个字符串
    result = areEqual(string1, string2);

    // 输出结果
    if(result)
        printf("两个字符串相等。\n");
    else
        printf("两个字符串不相等。\n");

    return 0;
}

代码注释：

• int areEqual(char str1[], char str2[])：定义一个函数areEqual，比较两个字符串是否相等。

• while(str1[i] != '\0' && str2[i] != '\0')：逐字符比较，直到任一字符串结束。

• if(str1[i] != str2[i])：如果发现不同字符，返回 0，表示不相等。

• if(str1[i] == '\0' && str2[i] == '\0')：如果两个字符串同时结束，返回 1，表示相等。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的两个字符串，包括空格。
  • 遍历字符串，遇到换行符\n则替换为\0。
  • 调用areEqual(string1, string2)函数，获取比较结果。
  • 使用printf输出结果。

7. 计算数组中元素的平均值

题目描述： 编写一个 C 程序，定义一个函数average，接受一个整数数组和其大小作为参数，返回数组元素的平均值。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为average的函数，通过遍历数组，累加所有元素的值，然后除以数组的大小，返回平均值。在main函数中，提示用户输入数组的大小和元素，调用average函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数average，计算数组元素的平均值
double average(int arr[], int size) {
    if(size == 0)
        return 0.0; // 避免除以零
    int sum = 0;
    for(int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return (double)sum / size;
}

int main() {
    int n;
    double avg;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 调用average函数计算平均值
    avg = average(arr, n);

    // 输出结果
    printf("数组元素的平均值是 %.2lf。\n", avg);

    return 0;
}

代码注释：

• double average(int arr[], int size)：定义一个函数average，接受一个整数数组和其大小作为参数，返回平均值。

• if(size == 0)：检查数组大小是否为零，避免除以零错误。

• for(int i = 0; i < size; i++)：遍历数组，累加所有元素的值。

• return (double)sum / size;：计算并返回平均值。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 使用for循环读取数组元素。
  • 调用average(arr, n)函数，获取平均值并存储在avg变量中。
  • 使用printf输出结果。

8. 交换两个数的值

题目描述： 编写一个 C 程序，定义一个函数swap，接受两个整数指针作为参数，交换这两个整数的值。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为swap的函数，接受两个整数指针，通过临时变量交换它们指向的值。在main函数中，提示用户输入两个整数，调用swap函数并打印交换后的值。

详细代码：

#include <stdio.h>

// 定义函数swap，交换两个整数的值
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int num1, num2;

    // 提示用户输入两个整数
    printf("请输入两个整数:\n");
    printf("第一个整数: ");
    scanf("%d", &num1);
    printf("第二个整数: ");
    scanf("%d", &num2);

    printf("交换前: num1 = %d, num2 = %d\n", num1, num2);

    // 调用swap函数交换num1和num2的值
    swap(&num1, &num2);

    printf("交换后: num1 = %d, num2 = %d\n", num1, num2);

    return 0;
}

代码注释：

• void swap(int *a, int *b)：定义一个函数swap，接受两个整数指针作为参数。

• int temp = *a;：使用临时变量temp存储指针a指向的值。

• *a = *b;：将指针b指向的值赋给指针a指向的变量。

• *b = temp;：将临时变量temp的值赋给指针b指向的变量，实现交换。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的两个整数。
  • 打印交换前的值。
  • 调用swap(&num1, &num2)函数，传递两个整数的地址，实现交换。
  • 打印交换后的值。

9. 计算数组元素的最大差值

题目描述： 编写一个 C 程序，定义一个函数maxDifference，接受一个整数数组和其大小作为参数，返回数组中元素的最大差值（最大值减去最小值）。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为maxDifference的函数，通过遍历数组找到最大值和最小值，计算它们的差值并返回。在main函数中，提示用户输入数组的大小和元素，调用maxDifference函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数maxDifference，返回数组中元素的最大差值
int maxDifference(int arr[], int size) {
    if(size == 0)
        return 0; // 如果数组为空，返回0

    int max = arr[0];
    int min = arr[0];

    // 遍历数组，找出最大值和最小值
    for(int i = 1; i < size; i++) {
        if(arr[i] > max)
            max = arr[i];
        if(arr[i] < min)
            min = arr[i];
    }

    return max - min;
}

int main() {
    int n, diff;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 调用maxDifference函数计算最大差值
    diff = maxDifference(arr, n);

    // 输出结果
    printf("数组中元素的最大差值是 %d。\n", diff);

    return 0;
}

代码注释：

• int maxDifference(int arr[], int size)：定义一个函数maxDifference，接受一个整数数组和其大小作为参数，返回最大差值。

• if(size == 0)：检查数组是否为空，若是，则返回 0。

• int max = arr[0]; int min = arr[0];：初始化最大值和最小值为数组的第一个元素。

• for(int i = 1; i < size; i++)：遍历数组，更新最大值和最小值。

• return max - min;：返回最大差值。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 使用for循环读取数组元素。
  • 调用maxDifference(arr, n)函数，获取最大差值并存储在diff变量中。
  • 使用printf输出结果。

10. 计算数组中偶数的个数

题目描述： 编写一个 C 程序，定义一个函数countEven，接受一个整数数组和其大小作为参数，返回数组中偶数的个数。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为countEven的函数，通过遍历数组，检查每个元素是否为偶数，若是，则增加计数器。最后返回计数器的值。在main函数中，提示用户输入数组的大小和元素，调用countEven函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数countEven，返回数组中偶数的个数
int countEven(int arr[], int size) {
    int count = 0;
    for(int i = 0; i < size; i++) {
        if(arr[i] % 2 == 0)
            count++;
    }
    return count;
}

int main() {
    int n, evenCount;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 调用countEven函数计算偶数的个数
    evenCount = countEven(arr, n);

    // 输出结果
    printf("数组中偶数的个数是 %d。\n", evenCount);

    return 0;
}

代码注释：

• int countEven(int arr[], int size)：定义一个函数countEven，接受一个整数数组和其大小作为参数，返回偶数的个数。

• int count = 0;：初始化计数器为 0。

• for(int i = 0; i < size; i++)：遍历数组。

• if(arr[i] % 2 == 0)：检查当前元素是否为偶数，若是，则增加计数器。

• return count;：返回偶数的总数。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 使用for循环读取数组元素。
  • 调用countEven(arr, n)函数，获取偶数的个数并存储在evenCount变量中。
  • 使用printf输出结果。

11. 计算字符串中元音字母的个数

题目描述： 编写一个 C 程序，定义一个函数countVowels，接受一个字符串参数，返回字符串中元音字母（a, e, i, o, u）的个数。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为countVowels的函数，通过遍历字符串，检查每个字符是否为元音字母（不区分大小写），若是，则增加计数器。最后返回计数器的值。在main函数中，提示用户输入一个字符串，调用countVowels函数并打印结果。

详细代码：

#include <stdio.h>
#include <ctype.h> // 用于tolower函数

// 定义函数countVowels，返回字符串中元音字母的个数
int countVowels(char str[]) {
    int count = 0;
    for(int i = 0; str[i] != '\0'; i++) {
        char ch = tolower(str[i]); // 将字符转换为小写
        if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
            count++;
    }
    return count;
}

int main() {
    char input[100];
    int vowelCount;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(input, sizeof(input), stdin);

    // 去除fgets读取的换行符
    int i;
    for(i = 0; input[i] != '\0'; i++) {
        if(input[i] == '\n') {
            input[i] = '\0';
            break;
        }
    }

    // 调用countVowels函数计算元音字母的个数
    vowelCount = countVowels(input);

    // 输出结果
    printf("字符串中元音字母的个数是 %d。\n", vowelCount);

    return 0;
}

代码注释：

• int countVowels(char str[])：定义一个函数countVowels，接受一个字符串参数，返回元音字母的个数。

• char ch = tolower(str[i]);：将当前字符转换为小写，便于比较。

• if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')：检查当前字符是否为元音字母，若是，则增加计数器。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的字符串，包括空格。
  • 遍历字符串，遇到换行符\n则替换为\0。
  • 调用countVowels(input)函数，获取元音字母的个数并存储在vowelCount变量中。
  • 使用printf输出结果。

12. 计算数组元素的平均数和标准差

题目描述： 编写一个 C 程序，定义两个函数：calculateAverage，计算数组元素的平均值；calculateStdDev，计算数组元素的标准差。在main函数中调用这两个函数并输出结果。

解题思路： 创建两个函数：

1. calculateAverage：遍历数组，累加所有元素的值，计算平均值。
2. calculateStdDev：先调用calculateAverage获取平均值，然后遍历数组，计算每个元素与平均值的差的平方，求和后取平均，再开平方得到标准差。 在main函数中，提示用户输入数组的大小和元素，调用这两个函数并打印结果。

详细代码：

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

// 定义函数calculateAverage，返回数组元素的平均值
double calculateAverage(int arr[], int size) {
    if(size == 0)
        return 0.0;
    int sum = 0;
    for(int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return (double)sum / size;
}

// 定义函数calculateStdDev，返回数组元素的标准差
double calculateStdDev(int arr[], int size, double average) {
    if(size == 0)
        return 0.0;
    double sumSquares = 0.0;
    for(int i = 0; i < size; i++) {
        double diff = arr[i] - average;
        sumSquares += diff * diff;
    }
    return sqrt(sumSquares / size);
}

int main() {
    int n;
    double avg, stddev;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 调用calculateAverage函数计算平均值
    avg = calculateAverage(arr, n);

    // 调用calculateStdDev函数计算标准差
    stddev = calculateStdDev(arr, n, avg);

    // 输出结果
    printf("数组元素的平均值是 %.2lf。\n", avg);
    printf("数组元素的标准差是 %.2lf。\n", stddev);

    return 0;
}

代码注释：

• double calculateAverage(int arr[], int size)：定义一个函数calculateAverage，计算数组元素的平均值。

• double calculateStdDev(int arr[], int size, double average)：定义一个函数calculateStdDev，计算数组元素的标准差。

• sum += arr[i];：累加数组元素的值。

• double diff = arr[i] - average; sumSquares += diff * diff;：计算每个元素与平均值的差的平方，并累加。

• return sqrt(sumSquares / size);：计算并返回标准差。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 使用for循环读取数组元素。
  • 调用calculateAverage(arr, n)函数，获取平均值。
  • 调用calculateStdDev(arr, n, avg)函数，获取标准差。
  • 使用printf输出结果。

13. 判断字符串是否为数字

题目描述： 编写一个 C 程序，定义一个函数isNumeric，接受一个字符串参数，返回 1 如果字符串只包含数字字符，返回 0 否则。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为isNumeric的函数，通过遍历字符串，检查每个字符是否为数字字符（'0'到'9'）。如果遇到非数字字符，则返回 0；否则，返回 1。在main函数中，提示用户输入一个字符串，调用isNumeric函数并打印结果。

详细代码：

#include <stdio.h>
#include <ctype.h> // 用于isdigit函数

// 定义函数isNumeric，判断字符串是否只包含数字字符
int isNumeric(char str[]) {
    int i = 0;
    // 空字符串不算数字
    if(str[0] == '\0')
        return 0;
    while(str[i] != '\0') {
        if(!isdigit(str[i]))
            return 0; // 发现非数字字符
        i++;
    }
    return 1; // 全部字符都是数字
}

int main() {
    char input[100];
    int result;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(input, sizeof(input), stdin);

    // 去除fgets读取的换行符
    int i;
    for(i = 0; input[i] != '\0'; i++) {
        if(input[i] == '\n') {
            input[i] = '\0';
            break;
        }
    }

    // 调用isNumeric函数判断
    result = isNumeric(input);

    // 输出结果
    if(result)
        printf("字符串 \"%s\" 只包含数字字符。\n", input);
    else
        printf("字符串 \"%s\" 包含非数字字符。\n", input);

    return 0;
}

代码注释：

• int isNumeric(char str[])：定义一个函数isNumeric，接受一个字符串参数，判断是否只包含数字字符。

• if(str[0] == '\0')：如果字符串为空，返回 0。

• if(!isdigit(str[i]))：使用isdigit函数检查当前字符是否为数字，若不是，则返回 0。

• return 1：如果所有字符都是数字，返回 1。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的字符串，包括空格。
  • 遍历字符串，遇到换行符\n则替换为\0。
  • 调用isNumeric(input)函数，获取判断结果并存储在result变量中。
  • 使用printf输出结果。

14. 递归函数求数组元素的和

题目描述： 编写一个 C 程序，定义一个递归函数recursiveSum，接受一个整数数组、数组大小和当前索引作为参数，返回数组中所有元素的总和。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为recursiveSum的递归函数。函数基例为当前索引等于数组大小时，返回 0。递归步骤为返回当前元素加上数组剩余部分的和。在main函数中，提示用户输入数组的大小和元素，调用recursiveSum函数并打印结果。

详细代码：

#include <stdio.h>

// 定义递归函数recursiveSum，返回数组元素的总和
int recursiveSum(int arr[], int size, int index) {
    if(index == size)
        return 0; // 基例：所有元素已累加
    return arr[index] + recursiveSum(arr, size, index + 1);
}

int main() {
    int n;
    int sum;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 调用recursiveSum函数计算总和
    sum = recursiveSum(arr, n, 0);

    // 输出结果
    printf("数组元素的总和是 %d。\n", sum);

    return 0;
}

代码注释：

• int recursiveSum(int arr[], int size, int index)：定义一个递归函数recursiveSum，接受数组、数组大小和当前索引作为参数，返回数组元素的总和。

• if(index == size)：基例，当索引等于数组大小时，返回 0，表示所有元素已被累加。

• return arr[index] + recursiveSum(arr, size, index + 1);：递归步骤，返回当前元素加上剩余元素的和。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 使用for循环读取数组元素。
  • 调用recursiveSum(arr, n, 0)函数，获取总和并存储在sum变量中。
  • 使用printf输出结果。

15. 使用可变参数函数计算总和

题目描述： 编写一个 C 程序，定义一个可变参数函数sum，接受一个整数参数count表示接下来有多少个整数需要相加，返回这些整数的总和。在main函数中调用该函数并输出结果。

解题思路： 使用 C 语言的标准库stdarg.h，定义一个可变参数函数sum，通过va_list来访问传递的参数。函数先初始化va_list，然后遍历参数，累加总和，最后返回总和。在main函数中，提示用户输入要相加的整数个数和这些整数，调用sum函数并打印结果。

详细代码：

#include <stdio.h>
#include <stdarg.h>

// 定义可变参数函数sum，返回所有参数的总和
int sum(int count, ...) {
    va_list args;
    va_start(args, count);
    int total = 0;

    for(int i = 0; i < count; i++) {
        int num = va_arg(args, int); // 获取下一个参数
        total += num;
    }

    va_end(args);
    return total;
}

int main() {
    int count, result;

    // 提示用户输入要相加的整数个数
    printf("请输入要相加的整数个数: ");
    scanf("%d", &count);

    // 检查是否有要相加的整数
    if(count <= 0) {
        printf("整数个数必须为正整数。\n");
        return 1; // 非正常退出
    }

    int numbers[count];

    // 提示用户输入要相加的整数
    printf("请输入 %d 个整数:\n", count);
    for(int i = 0; i < count; i++) {
        scanf("%d", &numbers[i]);
    }

    // 调用sum函数计算总和
    // 注意：由于C语言中无法直接传递数组作为可变参数，需要逐个传递
    // 这里使用一个辅助函数或手动调用sum函数
    // 为简单起见，手动传递参数
    // 如果count较大，不推荐这种方法
    // 以下示例假设count不超过10
    switch(count) {
        case 1:
            result = sum(1, numbers[0]);
            break;
        case 2:
            result = sum(2, numbers[0], numbers[1]);
            break;
        case 3:
            result = sum(3, numbers[0], numbers[1], numbers[2]);
            break;
        case 4:
            result = sum(4, numbers[0], numbers[1], numbers[2], numbers[3]);
            break;
        case 5:
            result = sum(5, numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
            break;
        // 可以继续添加更多情况
        default:
            printf("当前实现仅支持最多5个整数的相加。\n");
            return 1;
    }

    // 输出结果
    printf("总和是 %d。\n", result);

    return 0;
}

代码注释：

• #include <stdarg.h>：包含处理可变参数的标准库。

• int sum(int count, ...)：定义一个可变参数函数sum，接受一个整数count和count个整数参数。

• va_list args; va_start(args, count);：初始化va_list以访问可变参数。

• int num = va_arg(args, int);：获取下一个参数，类型为int。

• va_end(args);：清理va_list。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的要相加的整数个数和这些整数。
  • 由于 C 语言中无法直接传递数组作为可变参数，使用switch语句手动传递参数。
  • 注意：这种方法仅适用于较少数量的参数，实际应用中可以采用其他方法，如使用函数指针或重载（在 C++中）。

16. 查找数组中的元素

题目描述： 编写一个 C 程序，定义一个函数findElement，接受一个整数数组、数组大小和目标值作为参数，返回目标值在数组中的索引。如果目标值不存在，返回-1。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为findElement的函数，通过遍历数组，比较每个元素与目标值。如果找到匹配的元素，则返回其索引。如果遍历完数组后未找到，则返回-1。在main函数中，提示用户输入数组的大小、元素和目标值，调用findElement函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数findElement，返回目标值在数组中的索引
int findElement(int arr[], int size, int target) {
    for(int i = 0; i < size; i++) {
        if(arr[i] == target)
            return i; // 返回找到的索引
    }
    return -1; // 未找到
}

int main() {
    int n, target, index;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 提示用户输入目标值
    printf("请输入要查找的目标值: ");
    scanf("%d", &target);

    // 调用findElement函数查找目标值
    index = findElement(arr, n, target);

    // 输出结果
    if(index != -1)
        printf("目标值 %d 在数组中的索引是 %d。\n", target, index);
    else
        printf("目标值 %d 不存在于数组中。\n", target);

    return 0;
}

代码注释：

• int findElement(int arr[], int size, int target)：定义一个函数findElement，接受数组、数组大小和目标值作为参数，返回目标值的索引或-1。

• for(int i = 0; i < size; i++)：遍历数组。

• if(arr[i] == target)：如果找到目标值，返回当前索引。

• return -1：如果未找到目标值，返回-1。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小、元素和目标值。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 调用findElement(arr, n, target)函数，获取目标值的索引并存储在index变量中。
  • 使用printf输出结果。

17. 计算字符串的字符频率

题目描述： 编写一个 C 程序，定义一个函数charFrequency，接受一个字符串和一个字符作为参数，返回该字符在字符串中出现的次数。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为charFrequency的函数，通过遍历字符串，比较每个字符是否与目标字符相同，若是，则增加计数器。最后返回计数器的值。在main函数中，提示用户输入一个字符串和一个字符，调用charFrequency函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数charFrequency，返回字符在字符串中出现的次数
int charFrequency(char str[], char target) {
    int count = 0;
    for(int i = 0; str[i] != '\0'; i++) {
        if(str[i] == target)
            count++;
    }
    return count;
}

int main() {
    char input[100];
    char targetChar;
    int freq;

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(input, sizeof(input), stdin);

    // 去除fgets读取的换行符
    int i;
    for(i = 0; input[i] != '\0'; i++) {
        if(input[i] == '\n') {
            input[i] = '\0';
            break;
        }
    }

    // 提示用户输入一个字符
    printf("请输入一个字符: ");
    scanf(" %c", &targetChar); // 注意前面的空格用于跳过任何残留的换行符

    // 调用charFrequency函数计算频率
    freq = charFrequency(input, targetChar);

    // 输出结果
    printf("字符 '%c' 在字符串中出现了 %d 次。\n", targetChar, freq);

    return 0;
}

代码注释：

• int charFrequency(char str[], char target)：定义一个函数charFrequency，接受一个字符串和一个字符，返回字符出现的次数。

• for(int i = 0; str[i] != '\0'; i++)：遍历字符串。

• if(str[i] == target)：如果当前字符等于目标字符，增加计数器。

• return count;：返回字符出现的次数。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的字符串，包括空格。
  • 遍历字符串，遇到换行符\n则替换为\0。
  • 使用scanf(" %c", &targetChar);读取用户输入的字符，前面的空格用于跳过任何残留的换行符。
  • 调用charFrequency(input, targetChar)函数，获取字符的频率并存储在freq变量中。
  • 使用printf输出结果。

18. 计算数组中元素的乘积

题目描述： 编写一个 C 程序，定义一个函数product，接受一个整数数组和其大小作为参数，返回数组中所有元素的乘积。在main函数中调用该函数并输出结果。

解题思路： 创建一个名为product的函数，通过遍历数组，累乘所有元素的值。初始化乘积为 1，逐一乘以每个元素。在main函数中，提示用户输入数组的大小和元素，调用product函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数product，返回数组中元素的乘积
long long product(int arr[], int size) {
    if(size == 0)
        return 0; // 如果数组为空，返回0
    long long prod = 1;
    for(int i = 0; i < size; i++) {
        prod *= arr[i];
    }
    return prod;
}

int main() {
    int n;
    long long prod;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 检查数组大小是否为正
    if(n <= 0) {
        printf("数组大小必须为正整数。\n");
        return 1; // 非正常退出
    }

    int arr[n];

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 调用product函数计算乘积
    prod = product(arr, n);

    // 输出结果
    printf("数组中元素的乘积是 %lld。\n", prod);

    return 0;
}

代码注释：

• long long product(int arr[], int size)：定义一个函数product，接受一个整数数组和其大小作为参数，返回乘积。

• if(size == 0)：检查数组是否为空，若是，则返回 0。

• long long prod = 1;：初始化乘积变量为 1。

• for(int i = 0; i < size; i++)：遍历数组，累乘所有元素的值。

• return prod;：返回乘积。

• 在

  main
  

  函数中：

  • 使用printf和scanf获取用户输入的数组大小。
  • 检查数组大小是否为正，若不是，则输出错误信息并退出程序。
  • 使用for循环读取数组元素。
  • 调用product(arr, n)函数，获取乘积并存储在prod变量中。
  • 使用printf输出结果。

19. 计算两个数的最大公约数（GCD）

题目描述： 编写一个 C 程序，定义一个函数gcd，接受两个整数参数，返回它们的最大公约数（GCD）。在main函数中调用该函数并输出结果。

解题思路： 使用欧几里得算法计算最大公约数。创建一个名为gcd的函数，接受两个整数，重复将较大数替换为两数的差，直到两数相等，此时即为最大公约数。在main函数中，提示用户输入两个整数，调用gcd函数并打印结果。

详细代码：

#include <stdio.h>

// 定义函数gcd，返回两个数的最大公约数
int gcd(int a, int b) {
    if(a == 0)
        return b;
    if(b == 0)
        return a;

    // 欧几里得算法
    while(b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int main() {
    int num1, num2, result;

    // 提示用户输入两个整数
    printf("请输入两个整数:\n");
    printf("第一个整数: ");
    scanf("%d", &num1);
    printf("第二个整数: ");
    scanf("%d", &num2);

    // 调用gcd函数计算最大公约数
    result = gcd(num1, num2);

    // 输出结果
    printf("最大公约数是 %d。\n", result);

    return 0;
}

代码注释：

• int gcd(int a, int b)：定义一个函数gcd，接受两个整数参数，返回它们的最大公约数。

• if(a == 0)和if(b == 0)：处理当其中一个数为 0 的情况，GCD 为另一个数。

• while(b != 0)：使用欧几里得算法，通过取模操作不断更新a和b，直到b为 0。

• return a;：返回最大公约数。

• 在main函数中：

  • 使用printf和scanf获取用户输入的两个整数。
  • 调用gcd(num1, num2)函数，获取最大公约数并存储在result变量中。
  • 使用printf输出结果。