31个C语言实战经典例子，期末考试/考研必背

已于 2023-09-13 22:46:01 修改
阅读量871 收藏 24
点赞数 5
文章标签： c语言 c++ 开源 开发语言
于 2023-07-14 17:27:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69235635/article/details/131727802
版权
  1. 判断一个年份是否为闰年： 
    #include<stdio.h>

int isLeapYear(int year) {
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {  // 判断是否能被4整除但不能被100整除，或者能被400整除
        return 1;  // 是闰年
    }
    
    return 0;  // 不是闰年
}

int main() {
    int year = 2020;

    if (isLeapYear(year)) {
        printf("%d is a leap year\n", year);
    } else {
        printf("%d is not a leap year\n", year);
    }

    return 0;
}

    #手动输入年份


#include<stdio.h>

int isLeapYear(int year) {
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {  // 判断是否能被4整除但不能被100整除，或者能被400整除
        return 1;  // 是闰年
    }

    return 0;  // 不是闰年
}

int main() {
    int year;

    printf("请输入一个年份：");
    scanf("%d", &year);

    if (isLeapYear(year)) {
        printf("%d 是闰年\n", year);
    } else {
        printf("%d 不是闰年\n", year);
    }

    return 0;
}

  2. 计算两个数的最大公约数（欧几里得算法）： 
    #include<stdio.h>

int gcd(int a, int b) {
    if (b == 0) {  // 如果第二个数为0，返回第一个数作为最大公约数
        return a;
    }
    
    return gcd(b, a % b);  // 递归计算最大公约数
}

int main() {
    int num1 = 48, num2 = 36;

    int result = gcd(num1, num2);

    printf("GCD of %d and %d is %d\n", num1, num2, result);

    return 0;
}

    例子：计算48和36的最大公约数。首先，将会调用gcd(48, 36)函数。

    在gcd函数内部，首先判断b是否为0，如果是0，则返回a作为最大公约数。在此例中，b不等于0，因此继续执行递归调用gcd(36, 48 % 36)。

    再次进入gcd函数，判断b是否为0。由于48 % 36的结果为12，所以b不等于0，继续执行递归调用gcd(12, 36 % 12)。

    继续进入gcd函数，判断b是否为0。由于36 % 12的结果为0，所以b等于0，返回a的值12作为最大公约数。

    回到main函数，将得到的最大公约数12赋值给变量result，然后使用printf函数输出结果："GCD of 48 and 36 is 12"。

    因此，输出的结果是"GCD of 48 and 36 is 12"。

  3. 将一个二进制数转换为十进制数： 
    #include<stdio.h>

int binaryToDecimal(int binary) {
    int decimal = 0, base = 1;

    while (binary > 0) {
        int reminder = binary % 10;  // 获取最后一位数字
        decimal += reminder * base;  // 将最后一位数字乘以对应的权重加到结果中
        binary /= 10;  // 去掉最后一位数字
        base *= 2;  // 权重每次乘以2
    }

    return decimal;  // 返回对应的十进制数
}

int main() {
    int binary = 101010;
    
    int decimal = binaryToDecimal(binary);

    printf("Binary number %d in decimal is %d\n", binary, decimal);

    return 0;
}

    计算二进制数101010转换为十进制数的过程如下：

初始值：binary = 101010, decimal = 0, base = 1

第一次循环：

reminder = binary % 10 = 0 （获取最后一位数字）
decimal += reminder * base = 0 * 1 = 0 （将最后一位数字乘以权重加到结果中）
binary /= 10 = 10101 （去掉最后一位数字）
base *= 2 = 1 * 2 = 2 （权重每次乘以2）
第二次循环：

reminder = binary % 10 = 1
decimal += reminder * base = 1 * 2 = 2
binary /= 10 = 1010
base *= 2 = 2 * 2 = 4
第三次循环：

reminder = binary % 10 = 0
decimal += reminder * base = 0 * 4 = 0
binary /= 10 = 101
base *= 2 = 4 * 2 = 8
第四次循环：

reminder = binary % 10 = 1
decimal += reminder * base = 1 * 8 = 8
binary /= 10 = 10
base *= 2 = 8 * 2 = 16
第五次循环：

reminder = binary % 10 = 0
decimal += reminder * base = 0 * 16 = 0
binary /= 10 = 1
base *= 2 = 16 * 2 = 32
第六次循环：

reminder = binary % 10 = 1
decimal += reminder * base = 1 * 32 = 32
binary /= 10 = 0
base *= 2 = 32 * 2 = 64
循环结束，此时binary = 0，跳出while循环。

最终结果：decimal = 32

因此，二进制数101010转换为的十进制数为32。

  4. 实现斐波那契数列（递归版本）： 
    #斐波那契数列是一个数列，其中每个数字都是前两个数字之和。

#include<stdio.h>

int fibonacci(int n) {
    if (n <= 1) {  // 斐波那契数列的前两个数字是1
        return n;
    }

    return fibonacci(n - 1) + fibonacci(n - 2);  // 递归调用计算下一个数字
}

int main() {
    int n = 7;

    printf("Fibonacci series up to index %d: ", n);
    for (int i = 0; i <= n; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");

    return 0;
}


    在这个例子中，我们希望计算斐波那契数列的前n个数字。

首先，在 main 函数中定义了一个变量 n 并赋值为 7。

然后，调用 printf 函数输出提示信息：
"Fibonacci series up to index 7: "。

接着，使用 for 循环从0到n遍历，变量 i 表示当前的索引位置。
在循环内部，调用 fibonacci 函数，并传入 i 作为参数。
fibonacci 函数根据传入的索引位置计算对应的斐波那契数，并返回结果。
使用 printf 函数将计算得到的数值输出。

循环执行完毕后，调用 printf 函数输出换行符"\n"。

最后，返回0表示程序正常结束。

运行以上代码，输出结果为：
Fibonacci series up to index 7: 0 1 1 2 3 5 8 13

因此，输出的结果是斐波那契数列的前7个数字：
"0 1 1 2 3 5 8 13"。

  5. 将一个十进制数转换为二进制数： 
    #include<stdio.h>

void decimalToBinary(int decimal) {
    int binary[32], index = 0;

    while (decimal > 0) {
        binary[index++] = decimal % 2;  // 获取余数作为二进制位
        decimal /= 2;  // 计算商继续转换
    }

    printf("Binary representation: ");
    for (int i = index - 1; i >= 0; i--) {
        printf("%d", binary[i]);  // 倒序输出二进制位
    }
    printf("\n");
}

int main() {
    int decimal = 42;

    decimalToBinary(decimal);

    return 0;
}


    以上是一个将十进制数转换为二进制数的示例代码。

在此示例中，我们定义了一个名为 `decimalToBinary` 的函数，
该函数接受一个十进制数作为参数，并将其转换为二进制数。

在 `decimalToBinary` 函数内部，我们首先定义了一个大小为32的整数数组 `binary` 
和一个变量 `index`，用于保存二进制数的每一位和当前位置。

然后，我们使用一个 `while` 循环来进行转换。循环条件是十进制数大于0。
在每次循环迭代中，我们通过对2取余数的方式获取当前位的二进制值，并将其存储在 `binary` 数组中。然后，我们将十进制数除以2（即向右移位），以计算下一位的值。同时，`index` 变量自增，表示当前位置已经用于存储了一个二进制位。

循环结束后，我们使用 `printf` 函数输出提示信息："Binary representation: "。

接下来，我们使用一个 `for` 循环从最高位开始，倒序输出 `binary` 数组中的二进制位。循环条件是 `i` 大于等于0，每次迭代时，`i` 自减。

最后，我们使用 `printf` 函数输出换行符 "\n"。

在 `main` 函数中，我们定义了一个变量 `decimal` 并赋值为42。

然后，调用 `decimalToBinary` 函数并传入 `decimal` 作为参数进行转换。

最后，返回0表示程序正常结束。

运行以上代码，输出结果为：Binary representation: 101010

因此，42的二进制表示为101010。

  6. 求一个数组中的最大值和最小值： 
    #include<stdio.h>

// 函数：查找数组中的最小值和最大值
void findMinMax(int arr[], int size) {
    int min = arr[0], max = arr[0];

    // 遍历数组，更新最大值和最小值
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {  // 如果当前元素小于最小值，则更新最小值
            min = arr[i];
        }
        if (arr[i] > max) {  // 如果当前元素大于最大值，则更新最大值
            max = arr[i];
        }
    }

    // 输出最小值和最大值
    printf("Minimum value: %d\n", min);
    printf("Maximum value: %d\n", max);
}

// 主函数
int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  // 数组
    int size = sizeof(arr) / sizeof(arr[0]);  // 数组大小

    // 调用函数查找最小值和最大值
    findMinMax(arr, size);

    return 0;
}

  7. 实现简单的计算器（加法、减法、乘法、除法）： 
    #include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

float divide(int a, int b) {
    if (b != 0) {  // 避免除数为0
        return (float)a / b;
    }
    return -1;  // 返回-1表示非法操作
}

int main() {
    char expr[100];  // 定义字符数组存储用户输入的表达式
    int num1, num2;
    char op;

    printf("请输入表达式：");
    scanf("%s", expr);  // 读取用户输入的表达式

    // 从表达式中提取数字和运算符号
    sscanf(expr, "%d %c %d", &num1, &op, &num2);

    // 根据运算符号进行相应的运算
    switch (op) {
        case '+':
            printf("%d + %d = %d\n", num1, num2, add(num1, num2));
            break;
        case '-':
            printf("%d - %d = %d\n", num1, num2, subtract(num1, num2));
            break;
        case '*':
            printf("%d * %d = %d\n", num1, num2, multiply(num1, num2));
            break;
        case '/':
            printf("%d / %d = %.2f\n", num1, num2, divide(num1, num2));
            break;
        default:
            printf("非法运算符号\n");
            break;
    }

    return 0;
}

  8. 判断一个字符串是否为回文字符串： 
    #include<stdio.h>
#include<string.h>

int isPalindrome(char str[]) {
    int len = strlen(str);
    
    for (int i = 0, j = len - 1; i < j; i++, j--) {
        if (str[i] != str[j]) {  // 检查对应位置的字符是否相等
            return 0;  // 不是回文字符串
        }
    }
    
    return 1;  // 是回文字符串
}

int main() {
    char str[] = "level";
    
    if (isPalindrome(str)) {
        printf("%s is a palindrome\n", str);
    } else {
        printf("%s is not a palindrome\n", str);
    }
    
    return 0;
}

  9. 实现简单的线性查找算法在数组中查找指定元素： 
    #include<stdio.h>

int linearSearch(int arr[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {  // 如果找到目标元素，返回索引
            return i;
        }
    }
    
    return -1;  // 如果未找到目标元素，返回-1
}

int main() {
    int arr[] = {5, 3, 9, 7, 2};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 7;

    int index = linearSearch(arr, size, target);

    if (index != -1) {
        printf("Target element %d found at index %d\n", target, index);
    } else {
        printf("Target element %d not found\n", target);
    }

    return 0;
}

  10. 实现选择排序算法对数组进行排序： 
    #include<stdio.h>

void selectionSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        int minIndex = i;  // 假设当前位置为最小值的索引
        
        for (int j = i + 1; j < size; j++) {
            if (arr[j] < arr[minIndex]) {  // 更新最小值的索引
                minIndex = j;
            }
        }
        
        // 将最小值与当前位置交换
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, size);

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

    return 0;
}

  11. 将一个十进制数转换为十六进制数： 
    #include<stdio.h>

void decimalToHexadecimal(int decimal) {
    char hexadecimal[100];
    int index = 0;
    
    while (decimal > 0) {
        int reminder = decimal % 16;  // 获取余数作为十六进制位
        
        if (reminder < 10) {
            hexadecimal[index++] = reminder + '0';  // 将数字直接转换为字符
        } else {
            hexadecimal[index++] = reminder - 10 + 'A';  // 将大于9的数字转换为对应的字母字符
        }
        
        decimal /= 16;  // 计算商继续转换
    }
    
    printf("Hexadecimal representation: ");
    for (int i = index - 1; i >= 0; i--) {
        printf("%c", hexadecimal[i]);
    }
    printf("\n");
}

int main() {
    int decimal = 305;
    
    decimalToHexadecimal(decimal);

    return 0;
}

  12. 实现求和函数（递归版本）： 
    #include<stdio.h>

int sum(int n) {
    if (n == 0) {  // 终止条件，当n等于0时，返回0
        return 0;
    }

    return n + sum(n - 1);  // 递归调用计算1到n的和
}

int main() {
    int n = 5;

    int result = sum(n);

    printf("Sum of first %d numbers is %d\n", n, result);

    return 0;
}

  13. 判断一个数是否为素数： 
    #include<stdio.h>

int isPrime(int num) {
    if (num <= 1) {  // 小于等于1的数不是素数
        return 0;
    }
    
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) {  // 如果能整除，则不是素数
            return 0;
        }
    }
    
    return 1;  // 是素数
}

int main() {
    int num = 17;

    if (isPrime(num)) {
        printf("%d is a prime number\n", num);
    } else {
        printf("%d is not a prime number\n", num);
    }

    return 0;
}

  14. 实现插入排序算法对数组进行排序： 
    #include<stdio.h>

void insertionSort(int arr[], int size) {
    for (int i = 1; i < size; i++) {
        int key = arr[i];  // 当前待排序的元素
        int j = i - 1;
        
        while (j >= 0 && arr[j] > key) {  // 将大于当前元素的元素向后移动
            arr[j + 1] = arr[j];
            j--;
        }
        
        arr[j + 1] = key;  // 插入当前元素到正确位置
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, size);

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

    return 0;
}

  15. 计算两个数的幂： 
    #include<stdio.h>

double power(double base, int exponent) {
    double result = 1.0;
    
    if (exponent > 0) {
        for (int i = 0; i < exponent; i++) {
            result *= base;  // 计算正指数的幂
        }
    } else if (exponent < 0) {
        for (int i = 0; i > exponent; i--) {
            result /= base;  // 计算负指数的幂
        }
    }
    
    return result;
}

int main() {
    double base = 2.5;
    int exponent = -3;

    double result = power(base, exponent);

    printf("%.2lf raised to the power of %d is %.2lf\n", base, exponent, result);

    return 0;
}

  16. 实现冒泡排序算法对数组进行排序： 
    #include<stdio.h>

void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {  // 比较相邻元素并交换位置
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    bubbleSort(arr, size);

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

    return 0;
}

  17. 在数组中查找指定元素的索引： 
    #include<stdio.h>

int findIndex(int arr[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {  // 如果找到目标元素，返回索引
            return i;
        }
    }
    
    return -1;  // 如果未找到目标元素，返回-1
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 3;

    int index = findIndex(arr, size, target);

    if (index != -1) {
        printf("Target element %d found at index %d\n", target, index);
    } else {
        printf("Target element %d not found\n", target);
    }

    return 0;
}

  18. 判断一个字符串是否为回文排列（忽略空格和标点符号）： 
    #include<stdio.h>
#include<string.h>
#include<ctype.h>

int isPalindromePermutation(char str[]) {
    int count[26] = {0};

    for (int i = 0; i < strlen(str); i++) {
        if (isalpha(str[i])) {  // 统计字符出现的次数
            count[tolower(str[i]) - 'a']++;
        }
    }

    int oddCount = 0;
    for (int i = 0; i < 26; i++) {
        if (count[i] % 2 != 0) {  // 统计字符出现奇数次的个数
            oddCount++;
        }
    }

    if (oddCount <= 1) {  // 如果奇数字符的个数小于等于1，则是回文排列
        return 1;
    }
    
    return 0;
}

int main() {
    char str[] = "Tact Coa";

    if (isPalindromePermutation(str)) {
        printf("%s is a palindrome permutation\n", str);
    } else {
        printf("%s is not a palindrome permutation\n", str);
    }
    
    return 0;
}

  19. 统计一个字符串中的字符、单词和行数： 
    #include<stdio.h>
#include<string.h>

void countCharactersWordsLines(char str[]) {
    int characters = 0, words = 0, lines = 1;
    
    for (int i = 0; i < strlen(str); i++) {
        if (str[i] != '\n' && str[i] != ' ') {  // 统计字符数
            characters++;
        }
        if (str[i] == ' ' || str[i] == '\n') {  // 统计单词数
            words++;
        }
        if (str[i] == '\n') {  // 统计行数
            lines++;
        }
    }

    printf("Character count: %d\n", characters);
    printf("Word count: %d\n", words);
    printf("Line count: %d\n", lines);
}

int main() {
    char str[] = "Hello World!\nThe quick brown fox jumps over the lazy dog.";

    countCharactersWordsLines(str);

    return 0;
}

  20. 计算一个数的平方根（使用牛顿迭代法）： 
    #include<stdio.h>

float sqrtUsingNewton(float num) {
    float x = num;
    float y = 1;
    float epsilon = 0.00001;

    while (x - y > epsilon) {
        x = (x + y) / 2;  // 使用牛顿迭代法更新x和y
        y = num / x;
    }

    return x;  // 返回x作为平方根近似值
}

int main() {
    float number = 16;

    printf("Square root of %.2f: %.4f\n", number, sqrtUsingNewton(number));

    return 0;
}

  21. 实现选择排序算法对数组进行排序： 
    #include<stdio.h>

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {  // 寻找最小值的索引
                minIndex = j;
            }
        }
        int temp = arr[i];  // 将最小值与当前位置交换
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, n);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

  22. 判断一个字符串是否为回文句子（忽略空格和标点符号）： 
    #include<stdio.h>
#include<string.h>
#include<ctype.h>

int isPalindromeSentence(char str[]) {
    int left = 0, right = strlen(str) - 1;

    while (left < right) {
        if (!isalpha(str[left])) {  // 跳过非字母字符
            left++;
        } else if (!isalpha(str[right])) {
            right--;
        } else {
            if (tolower(str[left]) != tolower(str[right])) {  // 忽略大小写比较字符
                return 0;  // 不是回文句子
            }
            left++;
            right--;
        }
    }
    
    return 1;  // 是回文句子
}

int main() {
    char str[] = "A man, a plan, a canal, Panama!";

    if (isPalindromeSentence(str)) {
        printf("%s is a palindrome sentence\n", str);
    } else {
        printf("%s is not a palindrome sentence\n", str);
    }

    return 0;
}

  23. 将一个整数数组倒置： 
    #include<stdio.h>

void reverseArray(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];  // 交换数组两端的元素
        arr[i] = arr[size - i - 1];
        arr[size - i - 1] = temp;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);

    reverseArray(arr, size);

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

    return 0;
}

  24. 判断一个数是否为完全平方数： 
    #include<stdio.h>
#include<math.h>

int isPerfectSquare(int num) {
    int squareRoot = sqrt(num);
    if (squareRoot * squareRoot == num) {  // 判断平方根的平方是否等于原数
        return 1;  // 是完全平方数
    }
    return 0;  // 不是完全平方数
}

int main() {
    int number = 16;

    if (isPerfectSquare(number)) {
        printf("%d is a perfect square\n", number);
    } else {
        printf("%d is not a perfect square\n", number);
    }

    return 0;
}

  25. 将一个字符串转换为整数： 
    #include<stdio.h>
#include<stdlib.h>

int main() {
    char numStr[] = "12345";
    int num = atoi(numStr); // 使用atoi函数将字符串转换为整数

    printf("Number: %d\n", num);

    return 0;
}

  26. 反转一个字符串： 
    #include<stdio.h>
#include<string.h>

int main() {
    char str[] = "Hello World";
    int length = strlen(str);

    for (int i = length - 1; i >= 0; i--) {
        printf("%c", str[i]);
    }
    printf("\n");

    return 0;
}

  27. 计算一个数的阶乘： 
    #include<stdio.h>

int main() {
    int num = 5;
    int factorial = 1;

    for (int i = 1; i <= num; i++) {
        factorial *= i;
    }

    printf("Factorial of %d: %d\n", num, factorial);

    return 0;
}

  28. 输出乘法表： 
    #include<stdio.h>

int main() {
    int i, j;

    for (i = 1; i <= 10; i++) {
        for (j = 1; j <= 10; j++) {
            printf("%d * %d = %d\n", i, j, i*j);
        }
        printf("\n");
    }

    return 0;
}

  29. 将一个字符串中的所有小写字母转换为大写： 
    #include<stdio.h>
#include<string.h>

void toUpperCase(char str[]) {
    int len = strlen(str);
    
    for (int i = 0; i < len; i++) {
        if (islower(str[i])) {
            str[i] = toupper(str[i]);  // 转换为大写字母
        }
    }
}

int main() {
    char str[] = "Hello, World!";

    toUpperCase(str);

    printf("After conversion: %s\n", str);

    return 0;
}

  30. 判断一个数是否为完全数： 
    #include<stdio.h>

int isPerfectNumber(int num) {
    int sum = 0;

    for (int i = 1; i < num; i++) {
        if (num % i == 0) {
            sum += i;
        }
    }

    return sum == num;
}

int main() {
    int num = 6;

    if (isPerfectNumber(num)) {
        printf("%d is a perfect number\n", num);
    } else {
        printf("%d is not a perfect number\n", num);
    }

    return 0;
}

  31. 计算斐波那契数列的第n项： 
    #include<stdio.h>

int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }

    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int n = 10;

    int result = fibonacci(n);

    printf("The %dth term of Fibonacci sequence is %d\n", n, result);

    return 0;
}

苏苏不是叔
关注
c语言项目开发实例
11-01
十个c语言案例 （1）贪吃蛇 （2）五子棋游戏 （3）电话薄管理系统 （4）计算器 （5）万年历 （6）电子表 （7）客户端和服务器通信 （8）潜艇大战游戏 （9）鼠标器程序 （10）手机通讯录系统
C语言项目实战
05-29
本实例包含常见小游戏和日常使用工具，有：贪吃蛇，小熊时钟，学生信息管理系统，学生个人消费管理系统，火车订票系统，通讯录管理系统，企业员工管理系统，网络通讯管理系统，图书管理系统，10窗体版图书管理系统。还有一些其他视频教学，有需要的可以联系我，内容太大上传不上去。
100个经典C程序：21-33
最新发布
zhaohongjian000的专栏
06-26 342
题目：学习使用auto定义变量的用法程序分析：现代C编译器通常忽略auto关键字，也就是说在C语言中，auto已经没有实际作用了。所以这个例子随便看看就好。num=2;for (i=0;i
2024年最新C语言入门实战系列教程-嵌入式必备-IT营大地老师
yuanlaile的博客
01-03 514
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，C语言是一个功能简化的版本，它使C语言能够在内存有限的大量硬件设备中运行，像。05 C语言运算符 关系运算符 逻辑运算符 条件运算符 类型转换运算符 求字节数运算符(41分35秒)13 C语言中的数组详解 交换位置 选择排序 冒泡排序(2)(38分24秒)15 C语言指针 指针变量、取地址、取值(34分58秒)
C语言实战105例（附源码）
12-09
C语言实战105例 附源代码
12个C语言必背实例
m0_64460287的博客
10-28 2万+
原因如下：如果数组s中含有10个元素，那么它的长度为10，而s的数组下标从0开始那么下标的最大值为9，j这里是代表数组下标，所以开始时的最大值应是。处理每行第一个数和对角线上的数都是1意外，其它的数就是前一行相邻的两数之和。对存入数组中的元素进行判断，统计出各个候选人的票数和无效的票数。首先找到数组中的最大值和最小值，记录它们的位置，然后交换位置，最后将交换后的数组输出。第一个for循环控制整个图形的行数，本实例中的图形共5行，所以i的范围为0～4。,如果不是，就判断是不是空格，是空格的话，单词数加1.
C语言小例子【基础】
海到无边天作岸 山登绝顶我为峰
10-19 7299
1.Hello World 代码 #include <stdio.h> /* 包含标准输入输出头文件 */ void main() /* 主函数 */ { printf("Hello World!\n"); /* 打印输出信息 */ } 运行结果 2.两数之积 代码 #include <stdio.h> void main() { int x,y,m; /* 定义整型变量x，y，m */ printf("Please input x and y\
C语言学习—实战篇—经典100例（1-5）
kangkang_yue的博客
05-18 2018
c语言经典100例
C语言——经典实例
weixin_46646164的博客
12-14 2054
例题1：输出九九乘法口诀表 #include <stdio.h> int main() { int i,j; for (i = 1; i <= 9; i++) {//使用两次循环 for (j = 1; j <= i; j++) { printf("%d*%d=%d ", j, i, i * j); } printf("\n"); } return 0; } 测试结果： 1*1= 1 1*2= 2 2*2= 4 1*3= 3 2*3= 6 ...
期中期末考试/考研 C语言练习题
12-01
本资源包含日常考试/考研C语言常出题目，可以用作日常考试/考研 C语言的练习。熟悉C语言的运行流程，熟悉C语言的算法书写规范。预祝您考研成功。
0 C语言必背18个经典程序_C语言必背18个经典程序_
09-29
"0 C语言必背18个经典程序"这个压缩包文件，旨在提供一系列C语言的经典示例程序，帮助学习者巩固和加深对C语言的理解。下面我们将详细探讨这18个经典程序可能涵盖的知识点，并扩展相关的C语言知识。 1. **输入输出...
重庆科技学院C语言期末考试答案以及历年试题
11-28
本资料包包含的是重庆科技学院C语言课程的期末考试答案及历年试题，旨在帮助学生备考，加深对C语言的理解。 在学习C语言时，以下几个核心知识点至关重要： 1. **基本语法**：包括变量定义、数据类型（如int、char...
C语言期末考试试题及详细答案
11-25
C语言期末考试试题及详细答案
C语言程序设计期末考试试题(含答案)
11-06
C语言程序设计期末考试试题(含答案)， C语言程序设计期末考试试题(含答案)
c语言基础程序——100实例
热门推荐
xujx1997的博客
04-06 5万+
/根据公示Π/4=1-1/3+1/5-1/7+1/9-1/11+......,计算Π的近似值，当最后一项的绝对值小于0.000001为止。int f=1;//变号用//i是分母，sum是Π/4的值while (fabs(1.0/i)>=1e-6)//当绝对值小于10的-5次方认为为0//累加每项的值f*=-1;//变号i+=2;//分母+2变化printf("Π的近似值为%.5lf",sum*4);
C语言经典算法100道实战题
C/C++编程指南
07-12 2万+
C语言经典算法100道实战题
26个C语言小实例
shlr_的博客
04-11 4742
：C语言 fun5()/*求两个整数之和*/ fun6()/*求两个整数相减的结果*/ fun7()/*求整数和小数相加的结果，结果强制转换成整数并打印到屏幕*/ fun8()/*求整数和小数相乘的结果，结果强制转换成整数并打印到屏幕*/ fun9()/*求两个整数之和并按照16进制形式打印到屏幕*/ fun10()/*求两个小数之和，保留两位小数输出*/ fun11()/*两个整数乘积*/ fun12()/*两个整数取余数*/ fun13()/*求两个字符相加的结果,以无符号整型显示在.
十个C语言项目，从小白到月入10K
学益得的博客
04-27 2万+
C/C++项目实战，从小白到精通，累计代码量3万行。
【C语言实战项目】扫雷游戏
C/C++领域,数据结构,linux,MySQl学习者
02-27 1262
C语言实现扫雷游戏详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值