C语言程序设计

1. 从键盘输入一个整数，判断该数是否为素数

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

int isPrime(int number){
    if(number == 1){
        return 0;
    }
    int m = sqrt(number);
    for(int i = 2; i <= m; i++){
        if(number % i == 0){
            return 0;
        }
    }
    return 1;
}

int main(){
    int number = 0;
    scanf("%d",&number);
    while(number >= 0){
        int res = isPrime(number);
        if(res == 1){
            printf("Is Prime\n");
        } else{
            printf("Not Is Prime\n");
        }
        scanf("%d",&number);
    }
    return 0;
}

2. 求解从1到20000内的所有水仙花数。水仙花数是每位数字的n次方之和等于本身，n是这个数的位数

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

int isNarcissistic(int num) {
    int originalNum, remainder, n = 0, result = 0;
    originalNum = num;

    // 获取数字的位数
    while (originalNum != 0) {
        originalNum /= 10;
        ++n;
    }

    originalNum = num;

    // 计算每个位上的数字的n次幂之和
    while (originalNum != 0) {
        remainder = originalNum % 10;
        result += pow(remainder, n);
        originalNum /= 10;
    }

    // 判断是否等于原数
    return (result == num);
}

int main() {
    printf("1到20000内的所有水仙花数为：\n");

    for (int num = 1; num <= 20000; num++) {
        if (isNarcissistic(num)) {
            printf("%d\n", num);
        }
    }

    return 0;
}

3. 求解从2到20000的所有完数。所有真因数（一个数的所有因数，不包括本身）的和等于本身的数字称为完数

#include <stdio.h>

// 判断一个数是否为完数
int isPerfectNumber(int num) {
    int sum = 0;

    // 计算所有真因数的和
    for (int i = 1; i <= num / 2; i++) {
        if (num % i == 0) {
            sum += i;
        }
    }

    // 判断真因数之和是否等于原数
    return (sum == num);
}

int main() {
    printf("2到20000内的所有完数为：\n");

    for (int num = 2; num <= 20000; num++) {
        if (isPerfectNumber(num)) {
            printf("%d\n", num);
        }
    }

    return 0;
}

4. 从键盘输入两个数字n,m,求解m和n的最小公倍数

#include <stdio.h>

// 计算最小公倍数的函数
int calculateLCM(int a, int b) {
    int max = (a > b) ? a : b;
    int lcm = max;

    // 循环找到最小公倍数
    while (1) {
        if (lcm % a == 0 && lcm % b == 0) {
            break;
        }
        lcm++;
    }

    return lcm;
}

int main() {
    int n, m;

    // 从键盘输入两个数字
    printf("请输入两个数字 n 和 m：\n");
    scanf("%d %d", &n, &m);

    // 计算最小公倍数
    int result = calculateLCM(n, m);

    // 输出结果
    printf("%d 和 %d 的最小公倍数是 %d\n", n, m, result);

    return 0;
}

5. 一个小球从10m处落下，每次的弹回之前高度的一半，请问小球在静止之前一共走过了多少距离？

#include <stdio.h>

int main() {
    // 初始化变量
    double height = 10.0; // 初始高度
    double total_distance = 0.0; // 总距离

    // 计算总距离
    while (height > 0) {
        total_distance += height; // 下落的距离
        height /= 2; // 反弹的高度
        total_distance += height; // 反弹的距离
    }

    // 打印总距离
    printf("小球在静止之前一共走过的距离是: %.2f 米\n", total_distance);

    return 0;
}

6. 斐波拉契数列。输入数列项数n=9，输出数列：1 1 2 3 5 8 13 21 34

#include <stdio.h>

// 动态规划计算斐波那契数列
int fibonacciSequence(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }

    int fib[n + 1];
    fib[1] = 1;
    fib[2] = 1;

    for (int i = 3; i <= n; i++) {
        fib[i] = fib[i - 1] + fib[i - 2];
    }

    return fib[n];
}

int main() {
    int n;

    // 提示用户输入n的值
    printf("请输入一个正整数n：");
    scanf("%d", &n);

    // 打印前n个斐波那契数
    for (int i = 1; i <= n; i++) {
        printf("%d ", fibonacciSequence(i));
    }
    printf("\n");

    return 0;
}

7. 输入一行英文，判断其一共有多少单词，不能包括冠词a。例如：A pen drop from tree.一共有4个单词

#include <stdio.h>

#define MAX_LENGTH 1000

// 函数声明
int isAlpha(char c);
char toLowerCase(char c);
int countWordsExcludingA(char *sentence);

int main() {
    char sentence[MAX_LENGTH];

    // 提示用户输入一句英文
    printf("请输入一句英文：");

    // 读取用户输入的一行文本
    fgets(sentence, MAX_LENGTH, stdin);

    // 统计单词数量（不包括冠词a）
    int wordCount = countWordsExcludingA(sentence);

    // 输出结果
    printf("单词总数（不包括冠词a）：%d\n", wordCount);

    return 0;
}

// 检查字符是否为字母
int isAlpha(char c) {
    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}

// 将大写字符转换为小写字符
char toLowerCase(char c) {
    if (c >= 'A' && c <= 'Z') {
        return c + ('a' - 'A');
    }
    return c;
}

// 统计单词数量（不包括冠词a）
int countWordsExcludingA(char *sentence) {
    int wordCount = 0; // 初始化单词计数
    int inWord = 0;    // 标记当前是否在一个单词中

    // 遍历输入的每个字符
    for (int i = 0; sentence[i] != '\0'; i++) {
        // 如果当前字符是字母
        if (isAlpha(sentence[i])) {
            // 如果之前不在一个单词中，表示找到一个新单词的开始
            if (!inWord) {
                inWord = 1; // 设置为在单词中
                // 检查当前单词是否为冠词"a"
                // toLowerCase转换为小写，避免大小写问题
                // 确保下一个字符不是字母，以判断单词是否结束
                if (!(toLowerCase(sentence[i]) == 'a' && !isAlpha(sentence[i+1]))) {
                    wordCount++; // 如果不是冠词"a"，则计数增加
                }
            }
        } else {
            // 如果当前字符不是字母，则标记不在单词中
            inWord = 0;
        }
    }

    return wordCount; // 返回单词总数
}

8. 将3个字符串的由小到大排序

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

void swapStrings(char **str1, char**str2){
    char *temp = *str1;
    *str1 = *str2;
    *str2 = temp;
}

void sortStrings(char *str1, char *str2, char *str3) {
    if (strcmp(str1, str2) > 0) {
        swapStrings(&str1, &str2);
    }
    if (strcmp(str1, str3) > 0) {
        swapStrings(&str1, &str3);
    }
    if (strcmp(str2, str3) > 0) {
        swapStrings(&str2, &str3);
    }

    printf("Sorted strings: %s, %s, %s\n", str1, str2, str3);
}

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

    printf("Enter first string: ");
    scanf("%s", str1);
    printf("Enter second string: ");
    scanf("%s", str2);
    printf("Enter third string: ");
    scanf("%s", str3);

    sortStrings(str1, str2, str3);

    return 0;
}

9. 一篇文本中共有3行文字，每行不多余5个字符，要求分别统计出每行中的大写字母，小写字母，数字，空格，以及其他字符的个数

#include <stdio.h>

#define MAX_LINES 3
#define MAX_CHARS 5

void CountCharacters(char *lines[MAX_LINES]) {
    for (int i = 0; i < MAX_LINES; i++) {
        int uppercase = 0, lowercase = 0, digits = 0, spaces = 0, others = 0;
        char *p = lines[i];

        while (*p != '\0') {
            if (*p >= 'A' && *p <= 'Z') {
                uppercase++;
            } else if (*p >= 'a' && *p <= 'z') {
                lowercase++;
            } else if (*p >= '0' && *p <= '9') {
                digits++;
            } else if (*p == ' ') {
                spaces++;
            } else {
                others++;
            }
            p++;
        }

        printf("第 %d 行:\n", i + 1);
        printf("大写字母: %d\n", uppercase);
        printf("小写字母: %d\n", lowercase);
        printf("数字: %d\n", digits);
        printf("空格: %d\n", spaces);
        printf("其他字符: %d\n", others);
        printf("\n");
    }
}

int main() {
    char line1[MAX_CHARS + 1] = "Abc1 ";
    char line2[MAX_CHARS + 1] = "D3eF!";
    char line3[MAX_CHARS + 1] = "Ghi2@";

    char *lines[MAX_LINES] = {line1, line2, line3};

    CountCharacters(lines);

    return 0;
}

10. 求出一个二维数组的鞍点。鞍点就是在行上最大，列上最小，一个二维数组可能有鞍点也可能没有鞍点

#include <stdio.h>

#define ROWS 3
#define COLS 3

void findSaddlePoints(int arr[ROWS][COLS]) {
    int i, j, k;
    int maxVal, isSaddlePoint;
    int found = 0;  // 标记是否找到鞍点

    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            // 假设 arr[i][j] 是鞍点
            maxVal = arr[i][j];
            isSaddlePoint = 1;

            // 检查是否为所在行的最大值
            for (k = 0; k < COLS; k++) {
                if (arr[i][k] > maxVal) {
                    isSaddlePoint = 0;
                    break;
                }
            }

            // 检查是否为所在列的最小值
            if (isSaddlePoint) {
                for (k = 0; k < ROWS; k++) {
                    if (arr[k][j] < maxVal) {
                        isSaddlePoint = 0;
                        break;
                    }
                }
            }

            // 如果满足条件，则为鞍点
            if (isSaddlePoint) {
                printf("鞍点位于(%d, %d)，值为 %d\n", i, j, maxVal);
                found = 1;  // 标记找到鞍点
            }
        }
    }

    if (!found) {
        printf("没有找到鞍点\n");
    }
}

int main() {
    int arr[ROWS][COLS] = {
        {10, 9, 8},
        {3, 3, 0},
        {11, 12, 13}
    };

    findSaddlePoints(arr);

    return 0;
}

11. 将两个字符串s1、s2进行比较，如果s1>s2，则输出一个正数。如果s1=s2，输出零。如果s1<s2，输出一个负数。不用strcmp函数，输出的正数或者负数的绝对值应该是比较两字符串相应字符的ASCII码的差值

#include <stdio.h>

int compareStrings(const char *s1, const char *s2) {
    // 逐个字符进行比较
    while (*s1 != '\0' && *s2 != '\0') {
        // 如果发现不同字符，返回它们的ASCII码差值
        if (*s1 != *s2) {
            return *s1 - *s2;
        }
        s1++;
        s2++;
    }

    // 如果一个字符串先结束，返回它们最后一个字符的ASCII码差值
    return *s1 - *s2;
}

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

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

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

    int result = compareStrings(str1, str2);

    if (result > 0) {
        printf("第一个字符串大于第二个字符串，差值为: %d\n", result);
    } else if (result < 0) {
        printf("第一个字符串小于第二个字符串，差值为: %d\n", result);
    } else {
        printf("两个字符串相等，差值为: %d\n", result);
    }

    return 0;
}

12. 将字符串数组s2中全部字符复制到字符数组s1中，不用strcpy函数

#include<stdio.h>

void copyString(char *s1, char *s2){
    while(*s2 != '\0'){
        *s1 = *s2;
        s1++;
        s2++;
    }

    // 添加字符串结束符
    *s1 = '\0';
}

int main(){
    char s1[100];
    char s2[100];

    scanf("%s,%s",s1,s2);
    copyString(s1, s2);

    return 0;
}

13. 用时间最短的方法将负数全部排在正数的前面

#include <stdio.h>

void rearrange(int *arr, int length) {
    int low = 0;
    int high = length - 1;

    while (low < high) {
        while (low < high && arr[low] < 0) {
            low++;
        }
        while (low < high && arr[high] >= 0) {
            high--;
        }
        // 直接交换
        if (low < high) { // 这个条件在这里已经保证不会越界，可以不加
            int temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
            low++;
            high--;
        }
    }
}

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {12, 11, -13, -5, 6, -7, 5, -3, 11};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("原始数组: \n");
    printArray(arr, size);

    rearrange(arr, size);

    printf("交换后数组: \n");
    printArray(arr, size);

    return 0;
}

14. 数组a和b各有10个元素。将他们对应地逐个比较，如果a中元素大于b中相应的元素次数多于b数组中元素大于a中元素次数，则a大于b，并统计大于等于小于的次数

#include <stdio.h>

void CompareArrays(int a[], int b[], int size, int *greaterCount, int *lessCount, int *equalCount) {
    *greaterCount = 0;
    *lessCount = 0;
    *equalCount = 0;

    for(int i = 0; i < size; i++) {
        if(a[i] > b[i]) {
            (*greaterCount)++;
        } else if(a[i] < b[i]) {
            (*lessCount)++;
        } else {
            (*equalCount)++;
        }
    }
}

int main() {
    int a[10] = {1, 5, 3, 7, 9, 2, 6, 8, 4, 10};
    int b[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    int greaterCount, lessCount, equalCount;

    CompareArrays(a, b, 10, &greaterCount, &lessCount, &equalCount);

    printf("a > b 的次数: %d\n", greaterCount);
    printf("a < b 的次数: %d\n", lessCount);
    printf("a = b 的次数: %d\n", equalCount);

    if(greaterCount > lessCount) {
        printf("数组 a 大于 数组 b\n");
    } else if(lessCount > greaterCount) {
        printf("数组 a 小于 数组 b\n");
    } else {
        printf("数组 a 等于 数组 b\n");
    }

    return 0;
}

15. 编写函数，使输入一个字符串按反序存放

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

// 定义函数，采用大驼峰命名法
void ReverseString(char *inputString) {
    int length = strlen(inputString);

    for (int i = 0; i < length / 2; ++i) {
        char temp = inputString[i];
        inputString[i] = inputString[length - 1 - i];
        inputString[length - 1 - i] = temp;
    }
}

int main() {
    char testString[] = "Hello, World!";
    printf("原字符串: %s\n", testString);

    ReverseString(testString);
    printf("反转后的字符串: %s\n", testString);

    return 0;
}

16. 求Sn=a+aa+aaa+...+aa..a，其中a为一个数字，一共有n项。a和n由用户的键盘输入

#include <stdio.h>

// 函数定义：计算数列和
int CalculateSum(int a, int n) {
    int currentTerm = a;
    int sum = 0;
    int i;

    // 计算数列的和
    for (i = 0; i < n; ++i) {
        sum += currentTerm;
        currentTerm = currentTerm * 10 + a; // 更新下一项
    }

    return sum;
}

int main() {
    int a, n;

    // 从用户输入获取a和n的值
    printf("请输入数字a和项数n：");
    scanf("%d %d", &a, &n);

    // 调用函数计算和并输出结果
    int sum = CalculateSum(a, n);
    printf("数列的和为：%d\n", sum);

    return 0;
}

17. 设计一个函数process，在你调用该函数的时候，每次实现不同的功能。输入a,b两个数，第一次调用时找出a,b中的最大者，第二次找出最小者，第三次求两个数的和

#include <stdio.h>

int Process(int a, int b) {
    static int callCount = 0; // 静态变量用于记录函数调用次数
    callCount++;

    switch (callCount % 3) {
        case 1:
            return (a > b) ? a : b; // 第一次调用：返回最大值
        case 2:
            return (a < b) ? a : b; // 第二次调用：返回最小值
        case 0:
            return a + b;           // 第三次调用：返回两个数的和
    }
    return 0; // 默认返回值，实际不会到达这里
}

int main() {
    int a = 5, b = 3;

    printf("第一次调用: %d\n", Process(a, b)); // 输出最大值
    printf("第二次调用: %d\n", Process(a, b)); // 输出最小值
    printf("第三次调用: %d\n", Process(a, b)); // 输出和
    printf("第四次调用: %d\n", Process(a, b)); // 输出最大值
    printf("第五次调用: %d\n", Process(a, b)); // 输出最小值
    printf("第六次调用: %d\n", Process(a, b)); // 输出和

    return 0;
}

18. 输入某年某月某日，判断这一天是该年的第几天

#include <stdio.h>

// 定义日期结构体
typedef struct {
    int year;
    int month;
    int day;
} Date;

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

// 计算该日期是这一年的第几天
int DayOfYear(Date date) {
    // 各月的天数（不考虑闰年）
    int daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    // 如果是闰年，调整2月的天数
    if (IsLeapYear(date.year)) {
        daysInMonth[1] = 29;
    }

    int dayOfYear = 0;
    // 累加前几个月的天数
    for (int i = 0; i < date.month - 1; i++) {
        dayOfYear += daysInMonth[i];
    }

    // 加上当前月的天数
    dayOfYear += date.day;

    return dayOfYear;
}

int main() {
    Date date;

    // 输入年、月、日
    printf("请输入年：");
    scanf("%d", &date.year);
    printf("请输入月：");
    scanf("%d", &date.month);
    printf("请输入日：");
    scanf("%d", &date.day);

    // 计算并输出结果
    int result = DayOfYear(date);
    printf("%d年%d月%d日是该年的第%d天\n", date.year, date.month, date.day, result);

    return 0;
}

19. 有n个正数，使得前面每个数依次向后移动m个位置，最后m个数变成最前面m个数

#include <stdio.h>

// 反转数组的一部分
void Reverse(int *array, int start, int end) {
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

// 旋转数组
void RotateArray(int *array, int size, int m) {
    if (m > size) {
        m = m % size; // 如果m大于数组长度，取模
    }

    // 第一次反转：反转前size-m个元素
    Reverse(array, 0, size - m - 1);

    // 第二次反转：反转后m个元素
    Reverse(array, size - m, size - 1);

    // 第三次反转：反转整个数组
    Reverse(array, 0, size - 1);
}

// 测试函数
int main() {
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int size = sizeof(array) / sizeof(array[0]);
    int m = 3;

    RotateArray(array, size, m);

    // 打印结果
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    return 0;
}

20. 有一个字符串，包含n个字符，编写一函数，将此字符串中从第m个字符开始的全部字符串复制成另一个字符串

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

// 函数定义
void CopySubstringFromIndex(const char *sourceString, char *destinationString, int startIndex) {
    // 检查起始索引是否在有效范围内
    if (startIndex < 0 || startIndex >= strlen(sourceString)) {
        printf("起始索引无效\n");
        destinationString[0] = '\0'; // 设置目标字符串为空字符串
        return;
    }

    // 复制从指定索引开始的子串
    int j = 0;
    for (int i = startIndex; i < strlen(sourceString); i++) {
        destinationString[j] = sourceString[i];
        j++;
    }
    destinationString[j] = '\0'; // 添加字符串结束符
}

int main() {
    // 示例输入
    const char *sourceString = "HelloWorld";
    int startIndex = 5;
    char destinationString[100]; // 假设目标字符串足够大以容纳子串

    // 调用函数复制子串
    CopySubstringFromIndex(sourceString, destinationString, startIndex);

    // 输出结果
    printf("原始字符串: %s\n", sourceString);
    printf("复制后的字符串: %s\n", destinationString);

    return 0;
}

21. 编写一个函数void replace(char str1, char str2, int i, int j)，将字符串中str1中的第i个字符开始到第j个字符结束的位置替换成str2

#include <stdio.h>

void replace(char *str1, char *str2, int i, int j){
    char temp[100]; // 临时数组，用来存储替换后的字符串
    char *p1 = str1;
    char *p2 = str1 + j + 1; // 从 j 位置后面一个字符开始
    char *t = temp; // 临时数组指针

    // 将前面的部分复制到临时数组
    while (p1 < str1 + i) {
        *t++ = *p1++;
    }

    // 将 str2 的内容复制到临时数组
    while (*str2 != '\0') {
        *t++ = *str2++;
    }

    // 将后面的部分复制到临时数组
    while (*p2 != '\0') {
        *t++ = *p2++;
    }

    *t = '\0'; // 添加字符串结束符

    // 将临时数组的内容复制回 str1
    t = temp;
    p1 = str1;
    while (*t != '\0') {
        *p1++ = *t++;
    }
    *p1 = '\0'; // 确保 str1 以 \0 结尾
}

int main(){
    char str1[100] = "Hello, World!";
    char str2[] = "Beautiful";
    int i = 7;
    int j = 11;

    printf("原始字符串1: %s\n", str1);
    replace(str1, str2, i, j);
    printf("替换后字符串1: %s\n", str1);

    return 0;
}

22. 有一分数序列：2/1，3/2，5/3，8/5，13/8，...求前20项之和

#include <stdio.h>

double CalculateSum(int n) {
    double sum = 0.0;
    int numerator = 2, denominator = 1;
    int temp = 0;

    for (int i = 0; i < n; i++) {
        sum += (double) numerator / denominator;
        temp = numerator + denominator;
        denominator = numerator;
        numerator = temp;
    }

    return sum;
}

int main() {
    int n = 20;
    double sum = CalculateSum(n);
    printf("前 %d 项的和是: %lf\n", n, sum);
    return 0;
}