一 输入一个整数，计算这个整数有几位

#include "stdio.h"
/**
 * 输入一个正整数，判断它是几位
 * @return
 */
int main()
{
    int number;
    int count=0;
    scanf("%d",&number);
    while (number!=0){
        number=number/10;
        count++;

    }
    printf("这个数是：%d 位数",count);
}

二 编写程序计算一个分布函数

运行示例：

输入x=4, y=5，输出41.0

输入x=3, y=-2，输出5.0

输入x=-3, y=4，输出1.0

输入x=-1，y=-2，输出1.0

#include "stdio.h"
/**
 * 输入一个正整数，判断它是几位
 * 该程序中count为计数器，记录输入数字的位数
 * @return
 */
int main()
{
    float x=0;
    float y=0;
    float sum;

    scanf("%f",&x);

    scanf("%f",&y);
    if(x>0&&y>0){
        sum=x*x+y*y;
    }else if(x>0&&y<=0){
        sum=x*x-y*y;
    } else if(x<=0&&y>0){
        sum=x+y;
    }else{
        sum=x-y;
    }
    printf("求得的函数值f(x)是: %f",sum);
    return 0;

}

三 输入一个字符串，再随便输入一个字母，判断这个字母出现几次

运行示例：

输入一个字符串：ahenejhehke

输入一个字符：h

字符在字符串中出现的次数是：3

#include "stdio.h"
/**
 * 输入一个字符串，再输入一个字符，判断这个字符在字符串中出现了几次，C语言
 * 该程序中count为计数器，记录输入数字的位数
 * @return
 */
int main() {
    char str[100]="qwertyuioqrrut";
    char ch='r';
    int count=0;
    int i=0;
    while(str[i]!='\0'){
        if(str[i]==ch){
            count++;
        }
        i++;
    }
    printf("%d",count);

    return 0;
}

四 求 1到10的阶乘之和

#include "stdio.h"
/**
 * 求1到10的阶乘之和
 * @return
 */
int main() {
    int i=1;
    int j=1;
    int n=10;
    int sum=0;
    for (i = 1; i <=n ; i++) {
        j=i*j;
        sum=sum+j;
    }
    printf("%d",sum);
    return 0;
}

五 求一个球体体积

#include "stdio.h"
/**
 *
 * @return
 */
#define PI 3.1415926
int main() {
    double r;
    double V;
    scanf("%lf",&r);
    V=4.0/3.0*PI*r*r*r;

    printf("%lf \n",V);
    return 0;
}

六 写一个链表，存1，2，3

#include "stdio.h"
/**
 * @return
 */
//结构体
struct Test
{
    int data;
    struct Test *next;//链表有一个指向自己的指针
};

int main()
{
    int i;
    int arry[] = {1,2,3};
    for(i=0;i<sizeof(arry)/sizeof(arry[0]);i++)
    {
        printf("%d ",arry[i]);
    }
    putchar('\n');
    //定义结构体变量
    struct Test t1 = {1,NULL};
    struct Test t2 = {2,NULL};
    struct Test t3 = {3,NULL};
    //指向对应节点地址形成链表
    t1.next = &t2;
    t2.next = &t3;
    //输出
    printf("%d %d %d\n",t1.data, t1.next->data, t1.next->next->data);
    return 0;
}

简化

#include "stdio.h"
/**
 * @return
 */
//结构体
struct Test
{
    int data;
    struct Test *next;//链表有一个指向自己的指针
};

int main()
{
    int i;
    int arr[3]={1,2,3};
    for (int j = 0; j < 3; j++) {
        printf("%d ",arr[j]);
    }
    printf("\n");
    struct Test t1={1,NULL};
    struct Test t2={2,NULL};
    struct Test t3={3,NULL};
    t1.next=&t2;
    t2.next=&t3;
    printf("%d %d %d ",t1.data,t1.next->data,t1.next->next->data);
    return 0;
}

七 链表插入操作

#include "stdio.h"
/**
 * @return
 */
//结构体
struct Test
{
    int data;
    struct Test *next;//链表有一个指向自己的指针
};
// 输出链表数据
void printLink(struct Test *head){
    struct  Test *point=head;
    while (point!=NULL){
        printf("%d ",point->data);
        point=point->next;
    }
    putchar('\n');
}

int main()
{
    struct Test t1={1,NULL};
    struct Test t2={2,NULL};
    struct Test t3={3,NULL};
    struct Test t4={4,NULL};
    struct Test t5={5,NULL};
    t1.next=&t2;
    t2.next=&t3;
    t3.next=&t4;
    t4.next=&t5;
    printLink(&t1);
    putchar('\n');
    return 0;
}

八 链表节点删除

#include "stdio.h"
/**

● @return  
*/
//结构体
struct Test
{
int data;
struct Test *next;//链表有一个指向自己的指针
};
// 输出链表数据
void printLink(struct Test *head){
struct  Test *point=head;
while (point!=NULL){
printf("%d ",point->data);
point=point->next;
}
putchar('\n');
}

void deleteNode(struct Test* node) {
struct Test *p;
p = node->next;
node->data = p->data;
node->next = p->next;

}

int main()
{
struct Test t1={1,NULL};
struct Test t2={2,NULL};
struct Test t3={3,NULL};
struct Test t4={4,NULL};
struct Test t5={5,NULL};
t1.next=&t2;
t2.next=&t3;
t3.next=&t4;
t4.next=&t5;
printLink(&t1);
putchar('\n');
deleteNode(&t1);
printLink(&t3);
putchar('\n');
return 0;
}

九 鸡兔同笼

一个笼子里面关了鸡和兔子（鸡有 2 只脚，兔子有 4 只脚，没有例外）。已经知
道了笼子里面脚的总数 a，问笼子里面至少有多少只动物，至多有多少只动物？

输入： 
第 1 行是测试数据的组数 n，后面跟着 n 行输入。每组测试数据占 1 行，每行一个正整数 a。 
输出： 
输出包含 n 行，每行对应一个输入,包含两个正整数，第一个是最少的动物数，第二个是最 
多的动物数，两个正整数用一个空格分开。 
如果没有满足要求的答案，则输出两个 0。 
输入样例： 
2 
3 
20 
输出样例： 
0 0 
5 10

#include "stdio.h"
int main(){
    int num=1;
    int a[100000]={0};
    /**
     * 输入num行脚的数据
     */
    scanf("%d",&num);
    for (int i = 0; i < num; ++i) {
        scanf("%d",&a[i]);
    }
    /**
     * 输出包括两个。最少动物个数，最多动物数
     */
    for (int j = 0; j <num ;j++)
    {

        if(a[j]%2==1){
            printf("0 0\n");
        }
        else if(a[j]%4==0)
        {
            printf("%d %d\n",a[j]%4,a[j%2]);
        }else if(a[j]%4!=0)
        {
            printf("%d %d\n",a[j]%4+1,a[j]/2);
        }
    }
    return 0;



}

十 求一组数据最大值

输入一组整数，输出最大值

输入：
第 1 行是测试数据的组数 n，后面跟着 n 行输入。每组测试数据占 1 行，每行一个正整数。
输出：
输出包含 1 行，为该组数最大值。
输入样例：
3
546
343
237
输出样例：
546

#include "stdio.h"
int main(){
    int num=1;
    int a[100000]={0};
    int max=a[0];
    /**
     * 输入num组的数据
     */
    scanf("%d",&num);
    /**
     * 输入每组的数据
     */

    for (int i = 0; i < num; ++i) {
        scanf("%d",&a[i]);
    }
    /**
     * 出力包括两个。最少动物个数，最多动物数
     */

    for (int j = 0; j <num ;j++)
    {
        if(a[j]>max){
            max=a[j];
        }
    }
    printf("最大值是： %d",max);
    return 0;
    
}

十一 数位拆分

本题要求编写程序，对输入的一个整数，从高位开始逐位分割并输出它的各位数
字。输入在一行中给出一个长整型范围内的非负整数。从高位开始逐位输出该整数的各位数
字，每个数字后面有一个空格。

输入样例:
123456
输出样例:
1 2 3 4 5 6

#include "stdio.h"
int main(){
    int num=1;
    int a[100000]={0};
    int max=a[0];
    /**
     * 输入num组的数据
     */
    scanf("%d",&num);
    /**
     * 输入这个数
     */
    int t=1;
    int i=0;
    while(num!=0){
        t=num%10;
        num=num/10;
        a[i]=t;
        i=i+1;
    }
    for (int k = i-1; k >= 0; k=k-1) {
        printf(" %d ",a[k]);
    }

    return 0;
    
}

十二 计算累加和

描述：给定整数 a 和正整数 n，考虑以下序列：a + aa + aaa + ⋯

• a…aa（共 n 项）。 其中，每一项均由连续的 a 组成，重复次数逐项递增。编写一个 C 语言程序，计算并输出 上述序列的总和。

输入： 
整数 a（
-9 ≤ a ≤ 9）：表示序列中连续的数字。 
正整数 n（
1 ≤ n ≤ 10）：表示序列的项数。 
输出： 
一个整数，表示给定序列的总和。 
输入样例： 
a = 2, n = 3 
输出样例： 
246

#include "stdio.h"
int main(){
    int a;
    int n;
    int v[12]={0};
    int t=1;
    int i=0;
    int j=0;
    int sum=0;
    scanf("%d",&a);
    scanf("%d",&n);
    for (i = 0; i < n; i++)
    {

         v[i]=a*t;
         t=t*10+1;
    }
    for (j = 0; j <n ; j++) {
        printf("%d ",v[j]);
        sum=sum+v[j];
    }
    printf("\n");
    printf("%d",sum);
    return 0;
    
}

十三 字典序最大的字母

给定一个仅包含小写字母的字符串 s，你需要在字符串中找到字典序最大的字母，
并在该字母的后面插入字符串 “(max)”。如果字符串中有多个相同的最大字母，则在第一个
最大字母后插入。编写一个程序，接受字符串 s 作为输入，并输出在满足要求下得到的新
字符串。

输入：
一个字符串 s，由小写字母构成。
输出：
一个新的字符串，表示在字典序最大的字母后插入 "(max)" 后得到的结果。
输入样例：
s = "competition" 输出样例：
"competit(max)ion

#include "stdio.h"
#include "string.h"
int main()
{
    char string[100];
    int  length;
    char max;
    while (gets(string)!=NULL)
    {
        length= strlen(string);
        max=string[0];
        for (int i = 0; i < length; ++i) {
            if(string[i]>max)
            {
                max=string[i];
            }
        }
        int flag=1;
        for (int i = 0; i < length; ++i) {
            printf("%c",string[i]);

            if(max==string[i])
            {
                printf("(max)");
                flag=flag+1;
            }

        }
        printf("\n");
    }
    return 0;
}

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

void appendMaxToMaxLexicographicChar(char input_str[]) {
    if (strlen(input_str) == 0) {
        return; // 空字符串，不做任何操作
    }

    char max_char = input_str[0]; // 初始化最大字符为字符串的第一个字符
    int max_char_index = 0;

    for (int i = 1; input_str[i] != '\0'; i++) {
        if (input_str[i] > max_char) {
            max_char = input_str[i];
            max_char_index = i;
        }
    }

    // 在最大字符的后面插入"(max)"
    int length = strlen(input_str);
    for (int i = length; i >= max_char_index + 1; i--) {
        input_str[i + 4] = input_str[i];
    }

    input_str[max_char_index + 1] = '(';
    input_str[max_char_index + 2] = 'm';
    input_str[max_char_index + 3] = 'a';
    input_str[max_char_index + 4] = 'x';
    input_str[max_char_index + 5] = ')';
}

int main() {
    char input_str[] = "hello world!";
    appendMaxToMaxLexicographicChar(input_str);
    printf("%s\n", input_str);

    return 0;
}

十四 学生成绩管理系统的结构体

假设你需要设计一个学生信息管理系统，其中包括一个名为“学生”的结构体。每
个学生有学号、姓名、年龄和成绩四项信息。设计一个构造函数，用于创建一个学生结构体
实例并输出其各项信息。

输入：
无输入参数。
输出：
一个学生结构体实例，包含学号、姓名、年龄和成绩信息。
输出格式为：“学号: [学号]，姓名: [姓名]，年龄: [年龄]，成绩: [成绩]”。
示例：
（假设构造函数名为 StudentConstructor）
调用：StudentConstructor()
输出：
学号: 2023001，姓名: 张三，年龄: 18，成绩: 85.5

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

// 定义学生结构体
struct Student {
    int student_id;
    char name[50];
    int age;
    float grade;
};

// 构造函数：初始化学生信息
void StudentConstructor(struct Student *student, int id, const char *name, int age, float grade) {
    student->student_id = id;
    strncpy(student->name, name, sizeof(student->name) - 1);
    student->age = age;
    student->grade = grade;
}

// 输出学生信息
void printStudentInfo(const struct Student *student) {
    printf("学号: %d，姓名: %s，年龄: %d，成绩: %.2f\n", student->student_id, student->name, student->age, student->grade);
}

int main() {
    // 创建学生结构体实例并初始化
    struct Student student1;
    StudentConstructor(&student1, 2023001, "李四", 20, 88.0);

    // 输出学生信息
    printf("学生信息:\n");
    printStudentInfo(&student1);

    return 0;
}

另外一种类似的成绩管理表，输入一组成绩

# include "stdio.h"
/**
 * 输出平均分最高的学生的信息，学生的基本信息包括学号，姓名，四门课程成绩以及个人平均成绩
 * 输出n个学生的成绩
 */
struct student{
    int num;
    char name[10];
    int computer,english,math,policy;
    double average;
};
int main()
{
    struct student max,stu; /*定义结构体变量 */
    int i,n;
    printf("Input n:");
    scanf("%d",&n);
    printf("Input the student's number,name,and cpurse scores: \n");
    for (i = 1; i <=n; i++) {
        printf("No.%d:",i);
        scanf("%d%s%d%d%d%d",&stu.num,&stu.name,&stu.computer,&stu.english,&stu.math,&stu.policy);
        stu.average=(stu.computer+stu.english+stu.math+stu.policy)/4.0;
        if(i==1){
            max=stu;
        }else if(max.average<stu.average){
            max=stu;
        }
    }
    printf("num=%d name=%s averge=%.2f",max.num,max.name,max.average);
    return 0;
}

输入：
3
1 lisi 99 98 97 96
2 wang 87 85 84 82
3 sun  77 74 72 71
输出：
Input n:Input the student's number,name,and cpurse scores: 
No.1:No.2:No.3:num=1 name=lisi averge=97.50

十五 冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历待排序数组，比较相邻的两个元素，并交换它们，直到整个数组都按照升序或降序排列。以下是C语言中的冒泡排序算法示例：

我们首先定义了一个bubbleSort函数，该函数接受一个整数数组和数组的大小作为参数，
然后执行冒泡排序算法。在main函数中，我们创建一个整数数组，
然后调用bubbleSort函数对数组进行排序
，并输出排序前后的数组。

#include <stdio.h>

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    int temp;
    int swapped;

    for (int i = 0; i < n - 1; i++) {
        swapped = 0; // 标记是否发生交换，如果一轮遍历没有交换则数组已排序
        for (int j = 0; j < n - i - 1; j++) {
            // 如果相邻的元素逆序，则交换它们
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1;
            }
        }

        // 如果一轮遍历没有发生交换，说明数组已经有序，提前退出循环
        if (swapped == 0) {
            break;
        }
    }
}

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

    printf("排序前的数组：\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    // 调用冒泡排序函数
    bubbleSort(arr, n);

    printf("\n排序后的数组：\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

十六 二分查找

二分查找（Binary Search）是一种高效的搜索算法，它适用于已排序的数组。

输入：
无输入参数。
输出：
一个学生结构体实例，包含学号、姓名、年龄和成绩信息。
输出格式为：“学号: [学号]，姓名: [姓名]，年龄: [年龄]，成绩: [成绩]”。
示例：
（假设构造函数名为 StudentConstructor）
调用：StudentConstructor()
输出：
学号: 2023001，姓名: 张三，年龄: 18，成绩: 85.5

#include <stdio.h>

// 二分查找函数
int binarySearch(int arr[], int left, int right, int target) {
    while (left <= right) {
        int mid = left + (right - left) / 2; // 计算中间元素的索引

        // 如果找到目标元素，返回其索引
        if (arr[mid] == target) {
            return mid;
        }

        // 如果目标元素比中间元素小，继续在左半部分查找
        if (arr[mid] > target) {
            right = mid - 1;
        }
        // 如果目标元素比中间元素大，继续在右半部分查找
        else {
            left = mid + 1;
        }
    }

    // 如果未找到目标元素，返回 -1 表示未找到
    return -1;
}

int main() {
    int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 10;

    // 调用二分查找函数查找目标元素
    int result = binarySearch(arr, 0, n - 1, target);

    if (result != -1) {
        printf("目标元素 %d 找到在索引 %d 处\n", target, result);
    } else {
        printf("目标元素 %d 未找到\n", target);
    }

    return 0;
}

十七 复数的和与积

二分查找（Binary Search）是一种高效的搜索算法，它适用于已排序的数组。

在这个示例中，我们首先定义了一个Complex结构体，表示复数，包括实部和虚部。
然后，我们设计了两个函数：addComplex用于计算两个复数的和，
multiplyComplex用于计算两个复数的积。
在main函数中，我们输入两个复数的实部和虚部，然后调用这两个函数来计算和与积，并输出结果。

#include <stdio.h>

// 定义复数结构体
struct Complex {
    double real; // 实部
    double imag; // 虚部
};

// 函数：计算两个复数的和
struct Complex addComplex(struct Complex c1, struct Complex c2) {
    struct Complex result;
    result.real = c1.real + c2.real;
    result.imag = c1.imag + c2.imag;
    return result;
}

// 函数：计算两个复数的积
struct Complex multiplyComplex(struct Complex c1, struct Complex c2) {
    struct Complex result;
    result.real = c1.real * c2.real - c1.imag * c2.imag;
    result.imag = c1.real * c2.imag + c1.imag * c2.real;
    return result;
}

int main() {
    struct Complex complex1, complex2, sum, product;

    // 输入第一个复数的实部和虚部
    printf("请输入第一个复数的实部和虚部: ");
    scanf("%lf %lf", &complex1.real, &complex1.imag);

    // 输入第二个复数的实部和虚部
    printf("请输入第二个复数的实部和虚部: ");
    scanf("%lf %lf", &complex2.real, &complex2.imag);

    // 计算两个复数的和
    sum = addComplex(complex1, complex2);

    // 计算两个复数的积
    product = multiplyComplex(complex1, complex2);

    // 输出结果
    printf("两个复数的和: %.2lf + %.2lfi\n", sum.real, sum.imag);
    printf("两个复数的积: %.2lf + %.2lfi\n", product.real, product.imag);

    return 0;
}

十八 统计字符串中各类元素数目

实现一个函数，统计给定字符串中英文字母、空格或回车、数字字符和其他字符的个数。

# include "stdio.h"
int main()
{
    char input_str[100];
    int uppercase=0,digits=0,spaces=0,others=0;

    //输入字符串
    printf("请输入一个字符串：");
    gets(input_str);
    // 遍历字符串并统计各类型元素的数量
    int lowercase=0;
    for (int i = 0; input_str[i] != '\0'; i++) {
        char ch = input_str[i];

        if (ch >= 'A' && ch <= 'Z') {
            uppercase++;
        } else if (ch >= 'a' && ch <= 'z') {
            lowercase++;
        } else if (ch >= '0' && ch <= '9') {
            digits++;
        } else if (ch == ' ' || ch == '\t' || ch == '\n') {
            spaces++;
        } else {
            others++;
        }
    }

    // 输出统计结果
    printf("大写字母数量: %d\n", uppercase);
    printf("小写字母数量: %d\n", lowercase);
    printf("数字数量: %d\n", digits);
    printf("空格数量: %d\n", spaces);
    printf("其他字符数量: %d\n", others);
    return 0;
}

十九 统计数组中的最大元素，和它的最小下标

#include <stdio.h>

int main() {
    int n;

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

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

    // 初始化最大值和最小下标
    int max_value = arr[0];
    int min_index = 0;

    // 查找最大值及其对应的最小下标
    for (int i = 1; i < n; i++) {
        if (arr[i] > max_value) {
            max_value = arr[i];
            min_index = i;
        }
    }

    // 输出结果
    printf("最大值是: %d\n", max_value);
    printf("最小下标是: %d\n", min_index);

    return 0;
}

二十 用户信息的加密校验

为了保护系统安全，采用用户账户和密码登录系统。
系统用户的信息保存在一个文件中，用户的信息保存在一个文件中，用户账号与密码由若干字母与数字字符构成，因为安全需要，在文件中存储的密码不能是明文，必须要经过加密处理。

# include "stdio.h"
# include "string.h"
# include "stdlib.h"


/**
 * 输入六个用户信息，包含账户与密码。
 *
 * 并写入文件 f12-2.dat
 *
 * 要求文件中每个用户信息占一行，账号和加密后的密码用一个空格隔开
 *
 * 其中的密码加密算法，对每个字符ASCII码的低四位求反，高四位保持不变，即将其与15进行异或运算
 *
 *
 */
 /**
  * 定义一个存系统用户账号和密码的结构体
  */
struct sysuser{
    char username[20];
    char password[8];

};
void encrypt(char *pwd);
int main(void)
{
    FILE *fp;  //定义文件指针
    int i;
    struct sysuser su;
    if((fp= fopen("f12-2.txt","w"))==NULL){
        printf("File open error! \n");
        exit(0);
    }
    for (int i = 1; i <=5 ; ++i) {
        printf("Enter %d th sysuser(name password):",i);
        scanf("%s%s",su.username,su.password);
        encrypt(su.password);
        fprintf(fp,"%s %s \n",su.username,su.password);
    }
    if(fclose(fp)){
        printf("Can not close the file!\n");
        exit(0);
    }
    return 0;
}
void encrypt(char * pwd)
{
    int i;
    for (int i = 0; i < strlen(pwd); ++i) {
        pwd[i]=pwd[i]^15;

    }
}

二十一 输入十个学生的信息存入磁盘中

输入示范

zhang 56 room01 45
wang  15 room02 44
sun  17 room03  46
zhang 56 room01 47
wang  15 room02 48
zhang 56 room01 45
wang  15 room02 44
sun  17 room03  46
zhang 56 room01 47
wang  15 room02 48

# include "stdio.h"
# define  SIZE 10
struct Student_type{
    char name[10];
    int  num;
    int age;
    char addr[15];

}stud[SIZE];
void save()
{
    FILE * fp;
    int i;
    if((fp= fopen("stu.dat","wb"))==NULL)
    {
        printf("can not open file\n");
        return;
    }
    for (i = 0; i < SIZE; i++)
    {
        if(fwrite(&stud[i],sizeof (struct Student_type),1,fp)!=1)
            printf("file write error!\n");

    }
    fclose(fp);

}
int main()
{
    int i;
    printf("Please enter data of Student");
    for (int i = 0; i < SIZE; i++)
        scanf("%s%d%s%d",&stud[i].name,&stud[i].num,&stud[i].addr,&stud[i].age);

    save();
    return 0;



}

二十二 用指针方法对十个数进行从大到小排序

有点问题

#include "stdio.h"
void sort(int x[],int n);
int main()
{
    int i,*p,a[10];
    p=a;
    printf("please enter 10 integer number:");
    for (int i = 0; i < 10; i++)
    {
        scanf("%d",p++);
    }
    p=a;
    sort(p,10);
    for (p=a,i = 0; i < 10; i++)
    {
        printf("%d",*p);
    }
    printf("\n");
    return 0;
}
void sort(int x[],int n)
{
    int i,j,k,t;
    for (int i = 0; i < n-1; i++)
    {
        k=i;
        for (int j = 0; j < n; j++)
        {
            if(x[j]>x[k]) k=j;
            if(k!=i)
            {
                t=x[i];
                x[i]=x[k];
                x[k]=t;
            }

        }
    }
}

二十三 输入一个十六进制数，转为一个十进制数

# include "stdio.h"
# include "string.h"
# include "math.h"
void f(char a[])
{
    int i,j=0,k=0,sum=0,n= strlen(a);
    int num[100];
    for (i = 0; i < n; i++)
    {
        switch (a[i])
        {
            case 'A':
                num[j++]=10;
                break;
            case  'B':
                num[j++]=11;
                break;
            case  'C':
                num[j++]=12;
                break;
            case  'D':
                num[j++]=13;
                break;
            case  'E':
                num[j++]=14;
                break;
            case  'F':
                num[j++]=15;
                break;
            default:
                num[j++]=(int)(a[i]-'0');
                break;
        }
    }
    for (i = n-1; i >=0 ; i--)
    {
        sum+=num[i]*pow(16,n-1-i);
    }
    printf("%d",sum);

}
int main()
{
    char a[10];
    gets(a);
    f(a);
    return 0;
}

二十四 用递归法将一个整数n转为一个字符串

用递归法将一个整数n转换成字符串。例如，输入483，应输出字符串“483”。n的位数不确定，可以是任意位数的整数。

# include "stdio.h"
/**
 * 用递归法将一个整数n转化为字符串，比方说输入483，转化为字符串
 * @return
 */
 void convert(int n)
{
     int i;
     if((i=n/10)!=0)
         convert(i);
     putchar(n%10+'0');   // 把余数取出来
}
int main()
{
    int num;
    scanf("%d",&num);
    if(num<0)
    {
        printf("-");
        num=-num;
    }
    convert(num);
    printf("\n");
    return 0;

}

二十五 给出年月日，计算该日是该年第几天

#include<stdio.h>
// 输入某年某月某日，判断这一天是这一年的第几天
int main()
{
	int year,month,day,sum;
	printf("请输入您想查询的日期（年月日使用英文逗号隔开)：\n");
	scanf("%d,%d,%d",&year,&month,&day);
 
	if(month>12||day>31||month<0||day<0||year<0)
	{
		printf("您输入的日期不合法");
		return 0;
	}
	else if((month==4||month==6||month==9||month==11)&&day==31)  // 4 6 9 11 月仅有 30天 
	{
		printf("您输入的日期不合法");
		return 0;
	}
	else if(month==2&&(day==30||day==31))    // 2月最多29天 
	{
		printf("您输入的日期不合法");
		return 0;
	}
	else if(!((year%4==0&&year%100!=0)||year%400==0)&&month==2&&day==29)  //如果不是闰年 输入了 2月29号，报错 
	{
		printf("您输入的日期不合法");
		return 0;
	}
 
 
	switch(month)
	{
		case 1: sum=day;	break;
		case 2: sum=31+day;	break; //29
		case 3: sum=60+day; break;
		case 4: sum=91+day; break;
		case 5: sum=121+day;break;
		case 6: sum=152+day;break;
		case 7: sum=182+day;break;
		case 8: sum=213+day;break;
		case 9: sum=244+day;break;
		case 10:sum=274+day;break;
		case 11:sum=305+day;break;
		case 12:sum=335+day;break;
		default: printf("请输入正确的日期");break;
	}
	if(month<3)
	{
		printf("%d年%d月%d日是这年的第%d天",year,month,day,sum);
	}
	else if((year%4==0&&year%100!=0)||year%400==0) //是四的公倍数，但不是100的公倍数，或者是400的公倍数?
	{
		printf("%d年%d月%d日是这年的第%d天",year,month,day,sum);
	}
	else
		printf("%d年%d月%d日是这年的第%d天",year,month,day,sum-1);
	return 0;
}

二十六 写一个函数，将一个给定的3*3的二维整形数组转置，行列互换

# include "stdio.h"
/**
 * 写一个函数，将3*3的数组，行列交换
 * @return
 */
void a_switch(int a[3][3]);
int main()
{
    int a[3][3];
    int i,j;
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; ++j)
        {
            scanf("%d",&a[i][j]);
        }
    }
    a_switch(a);
    for (i = 0; i <=2 ; i++)
    {
        for (j = 0; j <=2 ; j++)
        {
            printf("%d ",a[i][j]);
            if(j==2)
            {
                printf("\n");
            }
        }
    }

    return 0;

}
void a_switch(int a[3][3])
{
    int i,j;
    int b[3][3];
    for (i = 0; i <=2 ;i++)
    {
        for (j = 0; j < 3; j++)
        {
            b[i][j]=a[j][i];
        }
    }
    for (int k = 0; k < 3; k++) {
        for (int l = 0; l < 3; l++) {
            a[k][l]=b[k][l];
        }
    }
}

二十七 写一个函数，把一个字符串逆序输出

# include <stdio.h>
# include <string.h>
/**
 * 输入一个字符串，在函数中把这个字符串反转，然后输出一个反转后的字符串
 *
 * 难点：1 忘记C中字符串怎么输入
 *      2 搞不清是输入字符串还是字符数组
 *      3 忘记C编译器头文件不能自动导入
 * @return
 */
char *a_switch(char *a);
int main()
{

    /**
     * 输入一个字符串
     */
    char a[100];

    gets(a);
    /**
     * 一个字符串的反转函数，采用操作地址的形式传递 a
     */
    a_switch(a);
    puts(a);
    return 0;
}
char *a_switch(char *a)
{
    int len= strlen(a);
    int i;
    char temp;
    for (i = 0; i < len/2; i++)
    {
        temp=a[len-i-1];
        a[len-i-1]=a[i];
        a[i]=temp;
    }
    return a;
}

输出：

输入：
qwert
输出：
trewq

二十八 写一个函数，将两个字符串连接

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

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

三十一 写一个函数，输入一个4位数字，要求输出这四个数字字符，但是每两个数字之间空一个空格，如输入1990，输出“1 9 9 0”

三十二 写两个函数，分别求两个整数的最大公约数和最小公倍数，用主函数调用这两个函数，并写出程序运行结果

难点：
怎么用程序输出两个结果，怎么求公约数，怎么算公倍数

三十三 求一元二次方程的根

提示：用三个函数分别求

​ bb - 4ac大于0，等于0，小于0的根并算出结果，从主函数输入a,b,c的值

#include <stdio.h>
// 使用开根号 sqrt(d) 函数时，需要添加此头文件
#include <math.h>
 
int main()
{
    // 求一元二次方程的根
    // 代码思想：
    // 手动输入三个系数，分别代表二次项系数、一次项系数、常数项；
    // 判断输入的二次项系数是否为0，如果为0，提示“输入的第一个值不合法，请重新输入！”
    // 如果二次项系数不为0，利用根的判别式，计算一元二次方程是否有根；
    // 如果判别式 Δ >= 0 ,代表方程有两个根，输出根
    // 如果 Δ < 0 ,提示“方程无根”。
 
    float a , b , c, d, x1, x2;
 
    printf("请依次输入三个系数: ");
    scanf("%f %f %f", &a,&b,&c);
 
    if(a != 0)
    {
        d = b * b - 4 * a * c;                        // 根的判别式
        if(d >= 0)
        {
            x1 = ((-b + sqrt(d)) / (2 * a));            // 求根公式
            x2 = ((-b - sqrt(d)) / (2 * a));
 
            printf("x1 = %.2f;x2 = %.2f", x1, x2);
        }
        else
        {
            printf("方程无根");
        }
    }
    else
    {
        printf("输入的第一个值不合法，请重新输入！");
    }
 
 
    return 0;
}

三十四 写一个判断素数的函数，在函数中输入一个整数，输出是否为素数的信息

难点：什么是素数，怎么

三十五 冒泡排序,起泡

#include <stdio.h>
int main(int argc, char* argv[])
{
	int a[10];
	int i, j, t;
	for (i = 0; i < 10; i++)
	{
	scanf_s("%d", &a[i]);
    }
	printf("         \n");

	for (j = 0; j < 9; j++)
		for (i = 0; i < 9 - j; i++)
			if (a[i] > a[i + 1])
			{
				t = a[i];
				a[i] = a[i + 1];
				a[i + 1] = t;
			}

	for (i = 0; i < 10; i++)
		printf("%d ", a[i]);
	return 0;
}

#include <stdio.h>

int main(int argc, char* argv[])
{
	int a[10];
	int i, j, t;
	printf("Input 10 numbers: ");
	for (i = 0; i < 10; i++)
	{
		scanf_s("%d", &a[i]);
	}
	printf("\n");
	for (j = 0; j < 9; j++)
	{
		for (i = 0; i < 9 - j; i++)
		{
			if (a[i] > a[i + 1])
			{
				t = a[i];
				a[i] = a[i + 1];
				a[i + 1] = t;
			}
		}

}
printf("the sorted numbers: \n");
for (i = 0; i < 10; i++)
{
	printf("%d ", a[i]);
}
printf("\n");
return 0;

}

三十六 对10个数组元素依次赋值0,1,2,3,4,5,6,7,8,9，按照要求逆序输出

#include <stdio.h>

int main(int argc, char* argv[])
{
	int i;
	int a[10];
	for (i = 0; i <= 9; i++)
	{
		a[i] = i;
	}
	for (i = 9; i >= 0; i--)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

三十七 建立动态数组，输入五个学生的成绩，另外检测这五个学生的成绩有没有低于60分的，输出不及格的成绩

# include<stdio.h>
# include<stdlib.h>
void  check(int*);
int main()
{
	int* p1, i;
	p1 = (int*)malloc(5 * sizeof(int));
	for ( i = 0; i < 5; i++)
	{
		scanf_s("%d", p1 + i);
	}
	check(p1);
	return 0;
}
void check(int* p)
{
	int i;
	printf("你TM挂了：");
	for (i = 0; i < 5; i++)
	{
		if (p[i] < 60)
		{
			printf("%d", *(p + i));
		}
		printf("\n");

	}
	printf("纯粹用指针输出的方式：\n");
	for ( i = 0; i < 5; i++)
	{
		if (*(p + i) < 60)
		{
			printf("%d", *(p + i));
		}
		printf("\n");

	}

}

三十八 定义一个指针数组，存放指针，引用出指针的指针，输出各个元素的值

# include<stdio.h>
// 指针的指针
int main()
{
	int a[5] = { 1,3,5,7,9 };
	int* num[5] = { &a[0],&a[1],&a[2],&a[3],&a[4]};
	int** p, i;
	p = num;
	for ( i = 0; i < 5; i++)
	{
		printf("%d ", **p);
		p++;
	}
	printf("\n");
	return 0;
}

三十九 将若干字符串按照字母顺讯从小到大输出

1.1 输出策略1

# include<stdio.h>
# include<string.h>
// 指针和字符串结合
void sort(char* name[], int n);
void print(char* name[], int n);
int main()
{
	char * name[] = {"Follow me","BASIC","GREAT WALL","FORTRAN","Computer design"};
	int n = 5;
	sort(name, n);
	print(name, n);
	return 0; 
}
void sort(char* name[], int n)
{
	char* temp;
	int i, j, k;
	for (i = 0; i < n - 1; i++)
	{
		k = i;
		for ( j = i+1; j < n; j++)
		{
			if (strcmp(name[k], name[j]) > 0)
			{
				k = j;
			}
		}
		if (k != i)
		{
			temp = name[i];
			name[i] = name[k];
			name[k] = temp;
		}
	}
	 

}
void print(char* name[], int n)
{
	int i;
	for (i = 0; i < n; i++)
	{
		printf("%s\n", name[i]);
	}

}

1.2 第二种指针样式的输出

# include<stdio.h>
# include<string.h>
// 指针和字符串结合
void sort(char* name[], int n);
void print1(char* name[], int n);
void print(char* name[], int n);
int main()
{
	char * name[] = {"Follow me","BASIC","GREAT WALL","FORTRAN","Computer design"};
	int n = 5;
	sort(name, n);
	print1(name, n);
	print(name, n);
	return 0; 
}
void sort(char* name[], int n)
{
	char* temp;
	int i, j, k;
	for (i = 0; i < n - 1; i++)
	{
		k = i;
		for ( j = i+1; j < n; j++)
		{
			if (strcmp(name[k], name[j]) > 0)
			{
				k = j;
			}
		}
		if (k != i)
		{
			temp = name[i];
			name[i] = name[k];
			name[k] = temp;
		}
	}
	 

}
void print1(char* name[], int n)
{
	int i;
	for (i = 0; i < n; i++)
	{
		printf("%s\n", name[i]);
	}

	printf("\n");

}
void print(char* name[], int n)
{
	int i = 0;
	char* p;
	p = name[0];
	while (i < n)
	{
		p = *(name + i++);
		printf("%s\n", p);

	}
}

1.3 使用指向指针数据类型的变量

# include<stdio.h>
# include<string.h>
// 指针和指针结合
int main()
{
	char * name[] = {"Follow me","BASIC","GREAT WALL","FORTRAN","Computer design"};
	char** p;
	int i;
	for (i = 0; i < 5; i++)
	{
		p = name + i;
		printf_s("%s\n",*p);
	}
	
	return 0; 
}

四十 有a个学生，每个学生有b门成绩，要求在输入这个学生的序号后，输出这个学生的全部成绩，要求用指针函数来实现

1.1 输入序号，输出成绩

# include<stdio.h>
float* search(float (* pointer)[4],int n);
int main()
{
	float score[][4] = { {60,70,80,90},{56,89,67,88},{34,78,90,66} };
	float* p;
	int i, k;
	printf("Enter the number of student:");
	scanf_s("%d", &k);
	p = search(score, k);
	for ( i = 0; i < 4; i++)//4 主要是代表二维数组有四列
	{
		printf("%5.2f\t", *(p + i));
	}
	printf("\n");
	return 0;
}
float* search(float   ( * pointer)[4], int n)//形参pointer是指向一维数组的指针变量
{
	float* pt;
	pt = *(pointer + n);
	return(pt);
}

1.2 判定其中不及格的学生和人数

# include<stdio.h>
float* search(float (* pointer)[4]);
int main()
{
	float score[][4] = { {60,70,80,90},{56,89,67,88},{34,78,90,66} };
	float* p;
	int i,j;
	printf("Enter the number of student:\n");
	for (i = 0; i < 3; i++)
	{
		p = search(score + i);
		if (p == *(score + i))// 输出不符合条件的score[i][0]-socore[i][3]的地址，注意是行指针
		{
			printf("No.%d score", i);
			for (j = 0; j < 4; j++)
			{
				printf("%5.2f", *(p + j));//注意这个二维数组中，指针的写法，相当于强制类型转换，转成指针型
			}
			printf("\n");
		}
	}
	return 0;
}
float* search(float   ( * pointer)[4])//形参pointer是指向一维数组的指针变量
{
	int i = 0;
	float* pt;
	pt = NULL;
	for ( i = 0; i < 4; i++)
	{
		if (*(* pointer+i)<60)
		{
			pt = *pointer;

		}

	}
	return pt;

}

四十一 指针和max，min，sum

1.1 不同选项，输出不同值

# include<stdio.h>
int max(int x, int y);
int min(int x, int y);
int sum(int x, int y);
int fun(int x, int y, int (*p)(int x, int y));
int main()
{
	int (*p)(int, int);
	//定义指向函数的指针p
	int a = 0, b = 0;
	int n=0;
	p = NULL;
	printf("Please enter a and b:");
	scanf_s("%d %d",&a,&b);
	printf("Please enter 1 or 2 or 3:");
	scanf_s("%d", &n);
	if (n == 1)
		fun(a, b, max);
	else if (n == 2)
		fun(a, b, min);
	else if(n==3)
	{
		fun(a, b, sum);
	}
	
	return 0; 
}
int fun(int x, int y, int (*p)(int x, int y))
{
	int result;
	result = (*p)(x, y);
	printf("%d\n", result);
	return 0;
}

int max(int x, int y)
{
	int z;
	if (x > y)
	{
		z = x;
	}
	else
	{
		z = y;
	}
	printf("max= ");
	return z;
}
int min(int x, int y)
{
	int z;
	if (x > y)
	{
		z = y;
	}
	else
	{
		z = x;
	}
	printf("min= ");
	return z;
}

int sum(int x, int y)
{
	int z;
	z = x + y;
	printf("sum= ");
	return z;
}

九十七 写一个一维数组，放十个学生成绩，写一个函数，当主函数调用此函数，输出最高分、最低分、平均分

#include <stdio.h>
float Max = 0, Min = 0;
float average(float array[], int n);
int main(int argc, char* argv[])
{
	float ave, score[10];
	int i;
	printf("please enter 10 scores: ");
	for ( i = 0; i < 10; i++)
	{
		scanf_s("%f", &score[i]);
	}
	ave = average(score, 10);
	printf_s("%6.2f %6.2f %6.2f ", Max, Min, ave);


	return 0;

}

float average(float array[], int n)
{
	int i;
	float aver, sum = array[0];
	Max = array[0];
	Min = array[0];
	for (i = 1; i < n; i++)
	{
		if (array[i] > Max)
			Max = array[i];
		else if(array[i]<Min)
		{
			Min = array[i];
		}
	}
	aver = sum / n;
	return(aver);

}

九十八 求两数中的最大值

#include <stdio.h>
int max(int x, int y)
{
	int z;
	z = x > y ? x : y;
	return z;
}
int main(int argc, char* argv[])
{
	int x;
	int y;
	int t;
	scanf_s("%d  %d", &x,&y);
	t = max(x, y);
	printf_s("最大值是：%d", t);
	return 0;
}