谭浩强c程序设计例题+习题 第七章 用函数实现模块化程序设计习题

第七章习题

1.求两个整数的最大公约数与最大公倍数

主函数调用两个函数来输出结果

#include <stdio.h>

// 计算最大公约数
int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// 计算最大公倍数
int lcm(int a, int b) {
    return (a * b) / gcd(a, b);
}

int main() {
    int num1, num2;
    printf("请输入两个整数：");
    scanf("%d %d", &num1, &num2);

    printf("最大公约数: %d\n", gcd(num1, num2));
    printf("最大公倍数: %d\n", lcm(num1, num2));

    return 0;
}

2.求方程ax²+bx+c=0的根

用三个函数分别求当△>0、=0、<0的根并输出结果

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

// 当△ > 0时求根
void roots_positive(double a, double b, double c) {
    double delta = b * b - 4 * a * c;
    double x1 = (-b + sqrt(delta)) / (2 * a);
    double x2 = (-b - sqrt(delta)) / (2 * a);
    printf("方程有两个不同的实根: x1 = %.2lf, x2 = %.2lf\n", x1, x2);
}

// 当△ = 0时求根
void roots_zero(double a, double b) {
    double x = -b / (2 * a);
    printf("方程有两个相等的实根: x = %.2lf\n", x);
}

// 当△ < 0时求根
void roots_negative(double a, double b, double c) {
    double delta = b * b - 4 * a * c;
    double realPart = -b / (2 * a);
    double imaginaryPart = sqrt(-delta) / (2 * a);
    printf("方程有两个虚根: x1 = %.2lf + %.2lfi, x2 = %.2lf - %.2lfi\n",
           realPart, imaginaryPart, realPart, imaginaryPart);
}

int main() {
    double a, b, c, delta;
    printf("请输入方程的系数a, b, c：");
    scanf("%lf %lf %lf", &a, &b, &c);

    delta = b * b - 4 * a * c;

    if (delta > 0) {
        roots_positive(a, b, c);
    } else if (delta == 0) {
        roots_zero(a, b);
    } else {
        roots_negative(a, b, c);
    }

    return 0;
}

3.判断是否为素数

主函数输入一个整数，调用函数判断，输出是否为素数

#include <stdio.h>
#include <stdbool.h>

// 判断是否为素数
bool is_prime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i <= n / 2; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

int main() {
    int num;
    printf("请输入一个整数：");
    scanf("%d", &num);

    if (is_prime(num)) {
        printf("%d 是素数。\n", num);
    } else {
        printf("%d 不是素数。\n", num);
    }

    return 0;
}

4.写一个函数，把3*3矩阵行列互换

#include <stdio.h>

// 矩阵转置
void transpose(int matrix[3][3], int transposed[3][3]) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            transposed[i][j] = matrix[j][i];
        }
    }
}

int main() {
    int matrix[3][3], transposed[3][3];

    printf("请输入3x3矩阵的元素：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    transpose(matrix, transposed);

    printf("转置后的矩阵为：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", transposed[i][j]);
        }
        printf("\n");
    }

    return 0;
}

5.写一个函数，使输入的一个字符串按反序存放，在主函数中输入输出字符串

#include <stdio.h>
#include <string.h>

// 反转字符串函数
void reverse_string(char str[]) {
    int length = strlen(str);
    for (int i = 0; i < length / 2; i++) {
        char temp = str[i];
        str[i] = str[length - i - 1];
        str[length - i - 1] = temp;
    }
}

int main() {
    char str[100];

    printf("请输入一个字符串：");
    scanf("%s", str);

    reverse_string(str);

    printf("反序后的字符串为：%s\n", str);

    return 0;
}

6.写一个函数将两字符连接

#include <stdio.h>
#include <string.h>

// 字符串连接函数
void concatenate(char str1[], char str2[], char result[]) {
    strcpy(result, str1);
    strcat(result, str2);
}

int main() {
    char str1[100], str2[100], result[200];

    printf("请输入第一个字符串：");
    scanf("%s", str1);
    printf("请输入第二个字符串：");
    scanf("%s", str2);

    concatenate(str1, str2, result);

    printf("连接后的字符串为：%s\n", result);

    return 0;
}

7.写一个函数，将一个字符串中的元音字母复制到另一字符串中，然后输出

#include <stdio.h>
#include <string.h>

// 判断字符是否为元音
int is_vowel(char ch) {
    return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
           ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U';
}

// 将元音字母复制到新字符串中
void copy_vowels(char str[], char vowels[]) {
    int j = 0;
    for (int i = 0; i < strlen(str); i++) {
        if (is_vowel(str[i])) {
            vowels[j++] = str[i];
        }
    }
    vowels[j] = '\0';  // 添加字符串结束符
}

int main() {
    char str[100], vowels[100];

    printf("请输入一个字符串：");
    scanf("%s", str);

    copy_vowels(str, vowels);

    printf("字符串中的元音字母为：%s\n", vowels);

    return 0;
}

8.写一个函数，输入一个四位数字，要求输出这四个字符，但是每两个数字间要空一格空格

例如：输入1990 应输出"1 9 9 0"

#include <stdio.h>

// 输出四位数字，数字之间添加空格
void format_output(int num) {
    printf("%d %d %d %d\n", num / 1000, (num / 100) % 10, (num / 10) % 10, num % 10);
}

int main() {
    int num;

    printf("请输入一个四位数字：");
    scanf("%d", &num);

    format_output(num);

    return 0;
}

9.编写一个函数，由实参传来一个字符串，统计此字符串中字母、数字、空格以及其他字符个数，并在主函数中输入字符串和输出结果

#include <stdio.h>
#include <ctype.h>

// 统计字符类型
void count_characters(char str[], int *letters, int *digits, int *spaces, int *others) {
    *letters = *digits = *spaces = *others = 0;

    for (int i = 0; str[i] != '\0'; i++) {
        if (isalpha(str[i])) {
            (*letters)++;
        } else if (isdigit(str[i])) {
            (*digits)++;
        } else if (isspace(str[i])) {
            (*spaces)++;
        } else {
            (*others)++;
        }
    }
}

int main() {
    char str[100];
    int letters, digits, spaces, others;

    printf("请输入一个字符串：");
    fgets(str, 100, stdin);

    count_characters(str, &letters, &digits, &spaces, &others);

    printf("字母个数: %d\n", letters);
    printf("数字个数: %d\n", digits);
    printf("空格个数: %d\n", spaces);
    printf("其他字符个数: %d\n", others);

    return 0;
}

10.写一个函数，输入一行字符，将此字符串中最长的单词输出

#include <stdio.h>
#include <string.h>

// 找出最长的单词
void find_longest_word(char str[], char longest[]) {
    int maxLength = 0;
    int length = 0;
    int start = 0;
    int i = 0;

    while (str[i] != '\0') {
        if (str[i] != ' ' && str[i] != '\n') {
            length++;
        } else {
            if (length > maxLength) {
                maxLength = length;
                strncpy(longest, str + start, length);
                longest[length] = '\0';
            }
            length = 0;
            start = i + 1;
        }
        i++;
    }
    if (length > maxLength) {
        strncpy(longest, str + start, length);
        longest[length] = '\0';
    }
}

int main() {
    char str[100];
    char longest[100];

    printf("请输入一行字符：");
    fgets(str, 100, stdin);

    find_longest_word(str, longest);

    printf("最长的单词是：%s\n", longest);

    return 0;
}

11.写一个函数，用起泡法对输入的10个字符由小到大排序

#include <stdio.h>

// 起泡排序
void bubble_sort(char arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                char temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    char arr[10];

    printf("请输入10个字符：\n");
    for (int i = 0; i < 10; i++) {
        scanf(" %c", &arr[i]);
    }

    bubble_sort(arr, 10);

    printf("排序后的字符：\n");
    for (int i = 0; i < 10; i++) {
        printf("%c ", arr[i]);
    }
    printf("\n");

    return 0;
}

12.用牛顿迭代法求根。方程为a³+b²+cx+d=0，系数abcd的值依次为1、2、3、4，由主函数输入。求x在1附近的一个实根，求出根后主函数输出。

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

// 计算函数值
double f(double x, double a, double b, double c, double d) {
    return a * x * x * x + b * x * x + c * x + d;
}

// 计算函数的导数
double f_prime(double x, double a, double b, double c) {
    return 3 * a * x * x + 2 * b * x + c;
}

// 牛顿迭代法求解
double newton_method(double x0, double a, double b, double c, double d) {
    double x1;
    do {
        x1 = x0 - f(x0, a, b, c, d) / f_prime(x0, a, b, c);
        if (fabs(x1 - x0) < 1e-7)  // 判断是否收敛
            break;
        x0 = x1;
    } while (1);
    return x1;
}

int main() {
    double a = 1, b = 2, c = 3, d = 4;
    double x0 = 1.0;  // 初始猜测值

    double root = newton_method(x0, a, b, c, d);

    printf("方程的一个实根为：%.7lf\n", root);

    return 0;
}

13.用递归法求n阶勒让德多项式的值，递归公式为

#include <stdio.h>

// 勒让德多项式递归公式
double legendre(int n, double x) {
    if (n == 0) {
        return 1.0;
    } else if (n == 1) {
        return x;
    } else {
        return ((2 * n - 1) * x * legendre(n - 1, x) - (n - 1) * legendre(n - 2, x)) / n;
    }
}

int main() {
    int n;
    double x;

    printf("请输入n的值：");
    scanf("%d", &n);
    printf("请输入x的值：");
    scanf("%lf", &x);

    printf("勒让德多项式P_%d(%.2lf) = %.6lf\n", n, x, legendre(n, x));

    return 0;
}

14.输入10个同学5门课的成绩，分别用函数实现下列功能

1.计算每个学生平均分

2.计算每门课平均分

3.找出所有50个分数中最高分数所对应的学生和课程

4.计算平均分方差

其中xi为某一学生的平均分。

#include <stdio.h>

#define STUDENTS 10
#define COURSES 5

// 计算每个学生的平均分
void student_average(double scores[STUDENTS][COURSES], double averages[STUDENTS]) {
    for (int i = 0; i < STUDENTS; i++) {
        double sum = 0;
        for (int j = 0; j < COURSES; j++) {
            sum += scores[i][j];
        }
        averages[i] = sum / COURSES;
    }
}

// 计算每门课的平均分
void course_average(double scores[STUDENTS][COURSES], double averages[COURSES]) {
    for (int j = 0; j < COURSES; j++) {
        double sum = 0;
        for (int i = 0; i < STUDENTS; i++) {
            sum += scores[i][j];
        }
        averages[j] = sum / STUDENTS;
    }
}

// 找出最高分及其对应的学生和课程
void find_highest_score(double scores[STUDENTS][COURSES], int *student, int *course) {
    double max_score = scores[0][0];
    *student = 0;
    *course = 0;

    for (int i = 1; i < STUDENTS; i++) {
        for (int j = 0; j < COURSES; j++) {
            if (scores[i][j] > max_score) {
                max_score = scores[i][j];
                *student = i;
                *course = j;
            }
        }
    }
}

// 计算平均分的方差
double variance(double averages[STUDENTS]) {
    double mean = 0, var = 0;
    for (int i = 0; i < STUDENTS; i++) {
        mean += averages[i];
    }
    mean /= STUDENTS;
    for (int i = 0; i < STUDENTS; i++) {
        var += (averages[i] - mean) * (averages[i] - mean);
    }
    return var / STUDENTS;
}

int main() {
    double scores[STUDENTS][COURSES];
    double studentAverages[STUDENTS];
    double courseAverages[COURSES];
    int highestStudent, highestCourse;

    // 输入成绩
    printf("请输入10个学生的5门课成绩：\n");
    for (int i = 0; i < STUDENTS; i++) {
        for (int j = 0; j < COURSES; j++) {
            scanf("%lf", &scores[i][j]);
        }
    }

    // 计算学生平均分
    student_average(scores, studentAverages);
    printf("\n每个学生的平均分：\n");
    for (int i = 0; i < STUDENTS; i++) {
        printf("学生 %d: %.2lf\n", i + 1, studentAverages[i]);
    }

    // 计算课程平均分
    course_average(scores, courseAverages);
    printf("\n每门课的平均分：\n");
    for (int j = 0; j < COURSES; j++) {
        printf("课程 %d: %.2lf\n", j + 1, courseAverages[j]);
    }

    // 找出最高分及对应的学生和课程
    find_highest_score(scores, &highestStudent, &highestCourse);
    printf("\n最高分数为学生 %d 在课程 %d 中的分数：%.2lf\n",
           highestStudent + 1, highestCourse + 1, scores[highestStudent][highestCourse]);

    // 计算方差
    double var = variance(studentAverages);
    printf("\n平均分方差：%.6lf\n", var);

    return 0;
}

15.写几个函数

1.输入10个职工的姓名和职工号

2.按照职工号从小到大顺序排序，姓名顺序也随之调整

3.要求输入一个职工号，用折半查找法找出该职工的姓名，从主函数输入要查找的职工号，输出该职工姓名

#include <stdio.h>
#include <string.h>

#define EMPLOYEES 10

typedef struct {
    char name[50];
    int id;
} Employee;

// 冒泡排序按职工号排序
void sort_employees(Employee employees[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (employees[j].id > employees[j + 1].id) {
                Employee temp = employees[j];
                employees[j] = employees[j + 1];
                employees[j + 1] = temp;
            }
        }
    }
}

// 折半查找职工号
int binary_search(Employee employees[], int n, int id) {
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (employees[mid].id == id) {
            return mid;
        } else if (employees[mid].id < id) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1;  // 没有找到
}

int main() {
    Employee employees[EMPLOYEES];
    int searchId, index;

    // 输入职工信息
    printf("请输入10个职工的姓名和职工号：\n");
    for (int i = 0; i < EMPLOYEES; i++) {
        printf("职工 %d 姓名：", i + 1);
        scanf("%s", employees[i].name);
        printf("职工 %d 号：", i + 1);
        scanf("%d", &employees[i].id);
    }

    // 排序
    sort_employees(employees, EMPLOYEES);

    // 输出排序后的结果
    printf("\n按职工号排序后的信息：\n");
    for (int i = 0; i < EMPLOYEES; i++) {
        printf("职工号: %d, 姓名: %s\n", employees[i].id, employees[i].name);
    }

    // 输入要查找的职工号
    printf("\n请输入要查找的职工号：");
    scanf("%d", &searchId);

    // 折半查找
    index = binary_search(employees, EMPLOYEES, searchId);
    if (index != -1) {
        printf("职工号 %d 的职工姓名为 %s\n", searchId, employees[index].name);
    } else {
        printf("未找到职工号 %d\n", searchId);
    }

    return 0;
}

16.写一个函数，输入一个16进制数，输出对应的十进制数

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

// 将16进制数转换为10进制数
int hex_to_decimal(char hex[]) {
    int len = strlen(hex);
    int base = 1;
    int dec_val = 0;

    for (int i = len - 1; i >= 0; i--) {
        if (hex[i] >= '0' && hex[i] <= '9') {
            dec_val += (hex[i] - '0') * base;
            base = base * 16;
        } else if (hex[i] >= 'A' && hex[i] <= 'F') {
            dec_val += (hex[i] - 'A' + 10) * base;
            base = base * 16;
        } else if (hex[i] >= 'a' && hex[i] <= 'f') {
            dec_val += (hex[i] - 'a' + 10) * base;
            base = base * 16;
        }
    }
    return dec_val;
}

int main() {
    char hex[20];

    printf("请输入一个16进制数：");
    scanf("%s", hex);

    printf("对应的10进制数为：%d\n", hex_to_decimal(hex));

    return 0;
}

17.用递归法将一个整数n转换成字符串。

例如输入483应输出字符串"483"。n的位数不确定，可以是任意位数的正数

#include <stdio.h>

// 递归将整数转换为字符串
void int_to_string(int n, char str[], int *index) {
    if (n == 0) {
        if (*index == 0) {  // 如果n为0，需要处理边界情况
            str[(*index)++] = '0';
        }
        str[*index] = '\0';
        return;
    }

    int digit = n % 10;  // 取得最后一位数字
    int_to_string(n / 10, str, index);  // 递归调用处理剩余部分
    str[(*index)++] = digit + '0';  // 将数字转换为字符并存入字符串
}

int main() {
    int n;
    char str[20];  // 假设整数不会超过20位
    int index = 0;

    printf("请输入一个正整数：");
    scanf("%d", &n);

    int_to_string(n, str, &index);

    printf("转换后的字符串为：%s\n", str);

    return 0;
}

18.给出年月日，计算该日是第几天，自定义函数

#include <stdio.h>

// 判断是否为闰年
int is_leap_year(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// 计算该日是第几天
int day_of_year(int year, int month, int day) {
    int days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    if (is_leap_year(year)) {
        days_in_month[1] = 29;  // 闰年2月有29天
    }

    int day_of_year = 0;
    for (int i = 0; i < month - 1; i++) {
        day_of_year += days_in_month[i];
    }
    day_of_year += day;

    return day_of_year;
}

int main() {
    int year, month, day;

    printf("请输入年月日（格式：YYYY MM DD）：");
    scanf("%d %d %d", &year, &month, &day);

    int result = day_of_year(year, month, day);

    printf("%d年%d月%d日是该年的第%d天\n", year, month, day, result);

    return 0;
}