编程语言实现的程序

程序代码

2048小游戏

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <conio.h>

int a[4][4]={
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0
};

/*在一个为0的位置，随机生成一个2/4*/
void random_produce(void)
{
 //记录二维数组中为0的元素

	int zero1[32]={0}; //这个数组记录二维数组中，元素为0的值的下标
	int i,j,num=0,k=0; //num表示为二维数组0的个数
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			if(a[i][j] == 0)
			{
				num++;
				zero1[k++]=i;
				zero1[k++]=j;
			}
		}
	}
	srand((unsigned int)time(NULL)); //设置随机因子
	int b = rand()%num; //b用来确定随机到哪一个位置

	int c = rand()%3; //c确定随机到的值是2还是4
	if(c == 2) // 2的概率是2/3，4的概率是1/3
	{
		a[zero1[2*b]] [zero1[2*b+1]] =4;
	}
	else
	{
		a[zero1[2*b]] [zero1[2*b+1]] =2;
	}
}
/*
	左划合并更新数组
		返回值：
			0：代表无效滑动
			1：代表有效滑动
*/
int move_left(void)
{
	int i,j,k;
	int flag = 0; //有效滑动的标志位
	for(i=0;i<4;i++) //遍历行
	{
		//先合并
		for(j=0;j<3;j++)
		{
			//1， 找到第一个不为0的数字
			if(a[i][j] !=0)
			{
				//从第一个不为0的数字往后找
				for(k=j+1;k<4;k++)
				{
					//后面为0，忽略
					if(a[i][k] == 0)
					{
						continue;
					}
					//后面相等，合并
					else if(a[i][k] == a[i][j])
					{
						flag = 1; 
						a[i][j]*=2;
						a[i][k] = 0; //清0
						break; //只合并一次
					}
					//后面不相等，并且不为0
					else if(a[i][k] != a[i][j])
					{
						break; //退出
					}
				}
			}	
		}
		//再向左并拢
		k = 0; //并拢的位置
		for(j=0;j<4;j++)
		{
			if(a[i][j] !=0)
			{
				a[i][k]= a[i][j];
				if(k != j) //自己的位置和要并拢的位置不一样 
				{
					flag = 1;
					a[i][j]=0; //将自己清0
				}
				k++; //并拢的位置往后移动
			}
		}
	}
	return flag;
}

int move_right(void)
{
	 int i,j,k;
    int flag = 0; //有效滑动的标志位
    for(i=0;i<4;i++) //遍历行
    {
        //先合并
        for(j=3;j>0;j--)
        {
            //1， 找到第一个不为0的数字
            if(a[i][j] !=0)
            {
                //从第一个不为0的数字往前找
                for(k=j-1;k>=0;k--)
                {
                    //前面为0，忽略
                    if(a[i][k] == 0)
                    {
                        continue;
                    }
                    //前面相等，合并
                    else if(a[i][k] == a[i][j])
                    {
                        flag = 1; 
                        a[i][j]*=2;
                        a[i][k] = 0; //清0
                        break; //只合并一次
                    }
                    //前面不相等，并且不为0
                    else if(a[i][k] != a[i][j])
                    {
                        break; //退出
                    }
                }
            }   
        }
        //再向右并拢
        k = 3; //并拢的位置
        for(j=3;j>=0;j--)
        {
            if(a[i][j] !=0)
            {
                a[i][k]= a[i][j];
                if(k != j) //自己的位置和要并拢的位置不一样 
                {
                    flag = 1;
                    a[i][j]=0; //将自己清0
                }
                k--; //并拢的位置往前移动
            }
        }
    }
    return flag;
}

int move_up(void)
{
    int i,j,k;
    int flag = 0; //有效滑动的标志位
    for(j=0;j<4;j++) //遍历列
    {
        //先合并
        for(i=0;i<3;i++)
        {
            //1， 找到第一个不为0的数字
            if(a[i][j] !=0)
            {
                //从第一个不为0的数字往后找
                for(k=i+1;k<4;k++)
                {
                    //后面为0，忽略
                    if(a[k][j] == 0)
                    {
                        continue;
                    }
                    //后面相等，合并
                    else if(a[k][j] == a[i][j])
                    {
                        flag = 1; 
                        a[i][j]*=2;
                        a[k][j] = 0; //清0
                        break; //只合并一次
                    }
                    //后面不相等，并且不为0
                    else if(a[k][j] != a[i][j])
                    {
                        break; //退出
                    }
                }
            }   
        }
        //再向上并拢
        k = 0; //并拢的位置
        for(i=0;i<4;i++)
        {
            if(a[i][j] !=0)
            {
                a[k][j]= a[i][j];
                if(k != i) //自己的位置和要并拢的位置不一样 
                {
                    flag = 1;
                    a[i][j]=0; //将自己清0
                }
                k++; //并拢的位置往后移动
            }
        }
    }
    return flag;
}

int move_down(void)
{
    int i,j,k;
    int flag = 0; //有效滑动的标志位
    for(j=0;j<4;j++) //遍历列
    {
        //先合并
        for(i=3;i>0;i--)
        {
            //1， 找到第一个不为0的数字
            if(a[i][j] !=0)
            {
                //从第一个不为0的数字往前找
                for(k=i-1;k>=0;k--)
                {
                    //前面为0，忽略
                    if(a[k][j] == 0)
                    {
                        continue;
                    }
                    //前面相等，合并
                    else if(a[k][j] == a[i][j])
                    {
                        flag = 1; 
                        a[i][j]*=2;
                        a[k][j] = 0; //清0
                        break; //只合并一次
                    }
                    //前面不相等，并且不为0
                    else if(a[k][j] != a[i][j])
                    {
                        break; //退出
                    }
                }
            }   
        }
        //再向下并拢
        k = 3; //并拢的位置
        for(i=3;i>=0;i--)
        {
            if(a[i][j] !=0)
            {
                a[k][j]= a[i][j];
                if(k != i) //自己的位置和要并拢的位置不一样 
                {
                    flag = 1;
                    a[i][j]=0; //将自己清0
                }
                k--; //并拢的位置往后移动
            }
        }
    }
    return flag;
}

void print_chessboard(void)
{
	int i,j;
	printf("____________________________________\n");
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			printf("%d\t",a[i][j]);
		}
		printf("\n");
	}
	printf("____________________________________\n");
}
/*
	判断游戏是否结束
	结束返回1
	未结束返回0
*/
int gamester(void)
{
	int i,j;
	for(i=0;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			if(a[i][j] == 0)//游戏继续的条件3,有0
			return 0;
		}
	}
		
	for(i=0;i<3;i++)
	{
		for(j=0;j<4;j++)
		{
			if(a[i][j] == a[i+1][j] )//游戏继续的条件1，和下面相同	
			return 0;
		}
	}
	for(i=0;i<4;i++)
	{
		for(j=0;j<3;j++)
		{
			if(a[i][j] == a[i][j+1])//游戏继续的条件2，和右边相同	
			return 0;
		}
	}

	return 1;
}
/*
	游戏运行逻辑函数
*/
void start()
{
	//第一步，随机在两个空白处生成2或者4
	random_produce();
	random_produce();
	print_chessboard();
	char defection;
	while(!gamester())
	{
		defection=getch();
		switch(defection)
		{
			case 'w': 
				if(move_up())
				{
					random_produce();
				}
				print_chessboard();
				break;
			case 's': 
				if(move_down())
				{
					random_produce();
				}
				print_chessboard();
				break;
			case 'a':
				if(move_left())
				{
					random_produce();
				}
				print_chessboard();
				break;
			case 'd': 
				if(move_right())
				{
					random_produce();
				}
				print_chessboard();
				break;
		}
	}
	printf("游戏结束！\n");
	int sum=0;
	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			if(a[i][j]>sum){
				sum=a[i][j];
			}
		}
	}
	printf("Your scrod\n");
	printf("%d\n",sum);
}
int main()
{
	start();
	system("pause");
	return 0;
}

随机时钟

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
 {
    int n,m,i=1,flag;
    srand(time(0));
    m=rand()%100+1;
    flag=0;
    while(i<=10){
        scanf("%d",&n);
        i++;
        if(n==m){ 
            printf("Luky you!");
            flag==1;
            break;
        }else if(n>m){ 
            printf("%d is big\n",n);
        }else{ 
            printf("%d is small\n",n);
        }
    }
    if(flag==0){ 
        printf("game over!");
    }
    system("pause");
    return 0;
}

学生管理系统

#include <stdio.h>
#include <stdlib.h>
#define MAXM 100
void input_array(int a[], int n);
void select(int option, int a[], int value, int n);
void printf_array(int a[], int n);
void insert(int option, int a[], int value, int n);
void remov(int a[], int value, int n);
void query(int a[], int value, int n);

int main()
{
  int a[MAXM], option, value, n;
  printf("Input the number of array elements:");
  scanf("%d", &n);
  printf("Input an ordered array element:");
  input_array(a, n);
  printf("[1]Insert\n");
  printf("[2]Delete\n");
  printf("[3]Query\n");
  printf("[Other option] End\n");
  printf("Input option:");
  scanf("%d", &option);
  while (1)
  {
    if (option >= 1 && option <= 3)
    {
      printf("Input an element:");
      scanf("%d", &value);
      select(option, a, value, n);
      if (option == 1)
      {
        n = n + 1;
      }
      else if (option == 2)
      {
        n = n - 1;
      }
      printf("Input option:");
      scanf("%d", &option);
    }
    else
    {
      break;
    }
  }
  printf("Thank you");
  system("pause");
  return 0;
}
void input_array(int a[], int n)
{
  int i;
  for (i = 0; i < n; i++)
  {
    scanf("%d", &a[i]);
  }
}
void printf_array(int a[], int n)
{
  int i;
  printf("The ordered array a is:");
  for (i = 0; i < n; i++)
  {
    printf("%4d", a[i]);
  }
  printf("\n");
}
void select(int option, int a[], int value, int n)
{
  switch (option)
  {
  case 1:
    insert(option, a, value, n);
    break;
  case 2:
    remov(a, value, n);
    break;
  case 3:
    query(a, value, n);
    break;
  }
}
void insert(int option, int a[], int value, int n)
{
  int i, x;
  for (i = 0; i < n; i++)
  {
    if (a[i] > value)
    {
      x = i;
      break;
    }
  }
  for (i = n; i > x; i--)
  {
    a[i] = a[i - 1];
  }
  a[x] = value;
  n++;
  printf_array(a, n);
}
void remov(int a[], int value, int n)
{
  int i, x;
  for (i = 0; i < n; i++)
  {
    if (a[i] == value)
    {
      x = i;
      break;
    }
  }
  for (i = x; i < n - 1; i++)
  {
    a[i] = a[i + 1];
  }
  n--;
  printf_array(a, n);
}
void query(int a[], int value, int n)
{
  int mid, low = 0, hight = n - 1;
  mid = (low + hight) / 2;
  while (low <= hight)
  {
    mid = (low + hight) / 2;
    if (a[mid] == value)
    {
      printf("The index is:%d", mid);
      printf("\n");
      return;
    }
    else if (a[mid] < value)
    {
      low = low + 1;
    }
    else
    {
      hight = hight - 1;
    }
  }
  printf("This elements does not exist\n");
}

反转字符串里的单词

char* reverseWords(char* s) {
    int len=strlen(s);
    int i=0,j=0;
    int flag=0;
    //将多余的空格除去
    for(j=0;j<len;j++){
        
        if(s[j]==' '){
            if(flag==0&&i!=0){
                s[i++]=' ';
                flag=1;
            }
        }else{
            s[i++]=s[j];
            flag=0;
        }
        
    }
    if(i>=1&&s[i-1]==' '){
        s[i-1]='\0';
    }else{
        s[i]='\0';
    }
    //将整个字符串反转
    len=strlen(s);
    i=0,j=len-1;
    while(i<j){
        char temp=s[i];
        s[i++]=s[j];
        s[j--]=temp;
    }
    //
    //将每个单词进行反转
    i=0,j=0;
    while(s[j]){
        if(s[j]!=' '){
            j++;
        }else{
            int t=j-1;
        while(i<t){
            char temp=s[i];
            s[i++]=s[t];
            s[t--]=temp;
            }
            i=++j;
        }
    }
    int t=j-1;
    while(i<t){
        char temp=s[i];
        s[i++]=s[t];
        s[t--]=temp;
    }
    //
    return s;
    
}

小学口算练习系统

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void t_jia(int a, int b, int c, int d);
void t_jian(int a, int b, int c, int d);
void t_cheng(int a, int b, int c, int d);
void t_chu(int a, int b, int c1, int c2, int d, int e);
void Jia();
void Jian();
void Cheng();
void Chu();
int selectDifficulty();                    // 选着练习难度级别
void viewPracticeRecord();                 // 查看练习记录
void viewAccuracy(int total, int correct); // 查看正确率
void printLog();                           // 做题时间

struct sys
{
    char name[10]; // 名字
    int x;         // 学号
    int year;      // 年级
    int clas;      // 班级
};
int main()
{
    struct sys who;
    int inputErrorCount = 0;
    printf("请输入你的名字:");
    scanf("%s", &who.name);
    getchar(); // 清除输入缓冲区

    do
    {
        printf("请输入你的学号:");
        if (scanf("%d", &who.x) == 1)
        {
            getchar(); // 清除输入缓冲区
            break;
        }
        else
        {
            printf("无效输入，请重新输入。\n");
            getchar(); // 清除输入缓冲区
            inputErrorCount++;
        }
    } while (inputErrorCount < 4);

    if (inputErrorCount >= 4)
    {
        printf("输入错误次数过多，程序退出。\n");
        return 0;
    }

    inputErrorCount = 0;
    do
    {
        printf("请输入你的年纪:");
        if (scanf("%d", &who.year) == 1)
        {
            getchar(); // 清除输入缓冲区
            break;
        }
        else
        {
            printf("无效输入，请重新输入。\n");
            getchar(); // 清除输入缓冲区
            inputErrorCount++;
        }
    } while (inputErrorCount < 4);

    if (inputErrorCount >= 4)
    {
        printf("输入错误次数过多，程序退出。\n");
        return 0;
    }

    inputErrorCount = 0;
    do
    {
        printf("请输入你的班级:");
        if (scanf("%d", &who.clas) == 1)
        {
            getchar(); // 清除输入缓冲区
            break;
        }
        else
        {
            printf("无效输入，请重新输入。\n");
            getchar(); // 清除输入缓冲区
            inputErrorCount++;
        }
    } while (inputErrorCount < 4);

    if (inputErrorCount >= 4)
    {
        printf("输入错误次数过多，程序退出。\n");
        return 0;
    }
    int n;
    int difficulty = 0;
    do
    {
        printf("欢迎进入练习系统！\n");
        printf("请选择你想要进行的练习:\n");
        printf("1. 加法练习\n");
        printf("2. 减法练习\n");
        printf("3. 乘法练习\n");
        printf("4. 除法练习\n");
        int result = scanf("%d", &n);
        while (getchar() != '\n')
            ; // 清除输入缓冲区
        if (result == 1 && (n == 1 || n == 2 || n == 3 || n == 4))
        {
            difficulty = selectDifficulty();
            break;
        }
        else
        {
            printf("无效输入，请重新输入。\n");
        }
    } while (1);

    srand(time(NULL));
    switch (n)
    {
    case 1:
        Jia(difficulty);
        break;
    case 2:
        Jian(difficulty);
        break;
    case 3:
        Cheng(difficulty);
        break;
    case 4:
        Chu(difficulty);
        break;
    }
    printLog();
    char cu;
    char cm;
    while (1)
    {
        int flag = 0;
        while(flag == 0)
        {
            printf("你是否想要查看练习记录输入Y或N: ");
            fflush(stdin);
            char cm = getchar();
            if(cm == 'Y' || cm == 'y')
            {
                viewPracticeRecord();
                flag = 1;
            }
            else if(cm == 'N' || cm == 'n')
            {
                flag = 1;
            }
            else
            {
                printf("非法输入，请重新输入！\n");
                while(getchar() != '\n');
            }
        }
               printf("你是否想要继续答题,输入Y或任意键退出: ");
        scanf(" %c", &cu);
    
        if (cu == 'Y'|| cu=='y')
        {
            do
            {
                printf("欢迎进入练习系统！\n");
                printf("请选择你想要进行的练习:\n");
                printf("1. 加法练习\n");
                printf("2. 减法练习\n");
                printf("3. 乘法练习\n");
                printf("4. 除法练习\n");
                int result = scanf("%d", &n);
                while (getchar() != '\n')
                    ; // 清除输入缓冲区
                if (result == 1 && (n == 1 || n == 2 || n == 3 || n == 4))
                {
                    difficulty = selectDifficulty();
                    break;
                }
                else
                {
                    printf("无效输入，请重新输入。\n");
                }
            } while (1);

            srand(time(NULL));
            switch (n)
            {
            case 1:
                Jia(difficulty);
                break;
            case 2:
                Jian(difficulty);
                break;
            case 3:
                Cheng(difficulty);
                break;
            case 4:
                Chu(difficulty);
                break;
            }
            printLog();
        }
        else
        {
            printf("退出练习");
            break;
        }
    }
}
void t_jia(int a, int b, int c, int d) // 储存加法
{
    FILE *fp = fopen("练习记录.txt", "a+");               // 创建一个指针
    fprintf(fp, "%d + %d = %d 正确答案%d\n", a, b, c, d); // 将算式存入文件中
    fclose(fp);
}
void t_jian(int a, int b, int c, int d) // 储存减法
{
    FILE *fp = fopen("练习记录.txt", "a+");
    fprintf(fp, "%d - %d = %d 正确答案%d \n", a, b, c, d);
    fclose(fp);
}
void t_cheng(int a, int b, int c, int d) // 储存乘法
{
    FILE *fp = fopen("练习记录.txt", "a+");
    fprintf(fp, "%d x %d = %d 正确答案%d\n", a, b, c, d);
    fclose(fp);
}
void t_chu(int a, int b, int c1, int c2, int d, int e) // 储存除法
{
    FILE *fp = fopen("练习记录.txt", "a+");
    fprintf(fp, "%d / %d = %d  余 %d  正确答案 %d  余 %d\n", a, b, c1, c2, d, e);
    fclose(fp);
}
void Jia(int difficulty) // 加法
{
    int a, b, c, answer, n, t = 0, f = 0;
    int lower_bound, upper_bound;
    // 根据难度级别设置题目范围
    switch (difficulty)
    {
    case 1:
        lower_bound = 1;
        upper_bound = 10;
        break;
    case 2:
        lower_bound = 10;
        upper_bound = 100;
        break;
    case 3:
        lower_bound = 100;
        upper_bound = 1000;
        break;
    default:
        printf("无效的难度级别！\n");
        return;
    }
    printf("请输入你想要练习的题数：\n");
    scanf("%d", &n);
    printf("开始练习：\n\n");
    for (int i = 0; i < n; i++)
    {
        a = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        b = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        answer = a + b;
        printf("%d + %d = ", a, b);
        scanf("%d", &c);
        getchar();
        t_jia(a, b, c, answer);
        // ...
        if (c == answer)
        {
            printf("恭喜你，回答正确!\n\n");
            t++;
        }
        else
        {
            printf("很遗憾，回答错误！正确答案是 %d\n\n", answer);
            f++;
        }
    }
    printf("你做对的题数为%d,做错的题数为%d\n\n", t, f);
    viewAccuracy(n, t);
    printf("============================================\n\n");
}
void Jian(difficulty) // 减法
{
    int a, b, c, answer, n, t = 0, f = 0;
    int lower_bound, upper_bound;
    // 根据难度级别设置题目范围
    switch (difficulty)
    {
    case 1:
        lower_bound = 1;
        upper_bound = 10;
        break;
    case 2:
        lower_bound = 10;
        upper_bound = 100;
        break;
    case 3:
        lower_bound = 100;
        upper_bound = 1000;
        break;
    default:
        printf("无效的难度级别！\n");
        return;
    }
    printf("请输入你想要练习的题数：\n");
    scanf("%d", &n);
    printf("开始练习：\n\n");
    for (int i = 0; i < n; i++)
    {
        a = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        b = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        answer = a - b;
        printf("%d - %d = ", a, b);
        scanf("%d", &c);
        getchar();
        t_jian(a, b, c, answer);
        if (c == answer)
        {
            printf("恭喜你，回答正确！\n\n");
            t++;
        }
        else
        {
            printf("很遗憾，回答错误！正确答案是 %d\n\n", answer);
            f++;
        }
    }
    printf("你做对的题数为%d,做错的题数为%d\n\n", t, f);
    viewAccuracy(t, n);
    printf("============================================\n\n");
}
void Cheng(difficulty) // 乘法
{
    int a, b, c, answer, n, t = 0, f = 0;
    int lower_bound, upper_bound;
    // 根据难度级别设置题目范围
    switch (difficulty)
    {
    case 1:
        lower_bound = 1;
        upper_bound = 10;
        break;
    case 2:
        lower_bound = 10;
        upper_bound = 100;
        break;
    case 3:
        lower_bound = 100;
        upper_bound = 1000;
        break;
    default:
        printf("无效的难度级别！\n");
        return;
    }
    printf("请输入你想要练习的题数：\n\n");
    scanf("%d", &n);
    printf("开始练习：\n\n");
    for (int i = 0; i < n; i++)
    {
        a = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        b = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        answer = a * b;
        printf("%d x %d = ", a, b);
        scanf("%d", &c);
        getchar();
        t_cheng(a, b, c, answer);
        if (c == answer)
        {
            printf("恭喜你，回答正确！\n\n");
            t++;
        }
        else
        {
            printf("很遗憾，回答错误！正确答案是 %d\n\n", answer);
            f++;
        }
    }
    printf("你做对的题数为%d,做错的题数为%d\n\n", t, f);
    viewAccuracy(n, t);
    printf("============================================\n\n");
}
void Chu(difficulty) // 除法
{
    int a, b, c, answer, n, t = 0, f = 0, answer1, answer2, c1, c2;
    int lower_bound, upper_bound;
    // 根据难度级别设置题目范围
    switch (difficulty)
    {
    case 1:
        lower_bound = 1;
        upper_bound = 10;
        break;
    case 2:
        lower_bound = 10;
        upper_bound = 100;
        break;
    case 3:
        lower_bound = 100;
        upper_bound = 1000;
        break;
    default:
        printf("无效的难度级别！\n");
        return;
    }
    int temp;
    printf("请输入你想要练习的题数：\n");
    scanf("%d", &n);
    printf("开始练习：\n\n");
    for (int i = 0; i < n; i++)
    {
        a = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        b = rand() % (upper_bound - lower_bound + 1) + lower_bound;
        if (b > a)
        {
            temp = b;
            b = a;
            a = temp;
        }
        answer1 = a / b;
        answer2 = a % b;
        printf("%d / %d = \t", a, b);
        scanf("%d", &c1);
        printf("余 ");
        scanf("%d", &c2);
        getchar();
        t_chu(a, b, c1, c2, answer1, answer2);
        if (c1 == answer1 && c2 == answer2)
        {
            printf("恭喜你，回答正确！\n");
            t++;
        }
        else
        {
            printf("很遗憾，回答错误！正确答案是 %d  余  %d\n\n", answer1, answer2);
            f++;
        }
    }
    printf("你做对的题数为%d,做错的题数为%d\n\n", t, f);
    viewAccuracy(t, n);
    printf("============================================\n\n");
}
void viewPracticeRecord() // 练习记录
{
    FILE *fp = fopen("练习记录.txt", "r");
    char line[256];

    printf("练习记录：\n");
    while (fgets(line, sizeof(line), fp))
    {
        printf("%s", line);
    }

    fclose(fp);
}
void viewAccuracy(int total, int correct) // 查看正确率
{
    float accuracy = (float)correct / total * 100;
    printf("您的正确率为：%.1f%%\n\n", accuracy);
}
int selectDifficulty()
{
    int difficulty;
    printf("请选择难度级别：\n");
    printf("1. 简单\n");
    printf("2. 中等\n");
    printf("3. 困难\n");
    while (scanf("%d", &difficulty) != 1 || difficulty < 1 || difficulty > 3)
    {
        printf("非法输入，请重新输入：\n");
        while (getchar() != '\n')
            ;
    }
    return difficulty;
}

#include <stdio.h>

void printLog()
{
    FILE *fp = fopen("练习记录.txt", "a");
    if (fp == NULL)
    {
        printf("无法打开文件 %s！\n", "练习记录.txt");
        return;
    }
    time_t now = time(NULL);
    struct tm *t = localtime(&now);
    fprintf(fp, "做题时间 %d-%02d-%02d %02d:%02d:%02d\n", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
    fclose(fp);
}

扫雷

# -*-coding:utf8-*-
from threading import *
from time import *
from sys import *
from tkinter import *
from random import *
from string import ascii_lowercase

class game:
    def __init__(self):
        self.all = []  # 所有未扫区域的列表
        self.mine = []  # 雷所在区域的列表
        self.sweptlist = []  # 储存已经扫过的区域
        self.mark = []  # 储存已标记区域
        self.state = 'reading'  # 当前游戏状态
        self.timeused = 0

    def size(self, row, column, mine):  # 创建游戏的函数
        self.row = row  # 游戏行数
        self.column = column  # 游戏列数
        self.minenum = mine  # 游戏雷数
        self.root = Tk()
        self.root.title('扫雷迷你版')
        # 显示总雷数与已标记雷数之差
        # 计时器
        self.minecount = StringVar()
        self.timecount = StringVar()
        self.label1 = Label(self.root, bg='black', height=2,
                            fg='red', width=6, textvariable=self.timecount).grid(row=0, column=0, columnspan=2)
        self.label2 = Label(self.root, bg='black',
                            fg='red', height=2, width=6, textvariable=self.minecount).grid(row=0,
                                                                                           column=self.column - 2,
                                                                                           columnspan=2)
        self.minecount.set(self.minenum)
        self.timecount.set('%03d' % 0)

        for i in range(3, self.row + 3):
            for j in range(self.column):
                self.all.append([i, j])
        for i in sample(self.all, self.minenum):
            self.mine.append(i)
        for i in self.mine:
            mine_bt = Button(self.root, width=2, height=1)
            mine_bt.bind('<Button-1>', self.left_key1)
            mine_bt.bind('<Button-3>', self.right_key)
            mine_bt.grid(row=i[0], column=i[1])

        for i in self.all:
            if (i in self.mine) == False:
                self.bt = Button(self.root, width=2, height=1)
                self.bt.bind('<Button-1>', self.left_key)
                self.bt.bind('<Button-3>', self.right_key)
                self.bt.grid(row=i[0], column=i[1])

        menubar = Menu(self.root)
        for x in [['新游戏', self.new],
                  ['初级', self.beginner]]:
            menubar.add_command(label=x[0], command=x[1])
        self.root['menu'] = menubar
        self.root.mainloop()

    def beginner(self):
        self.root.destroy()
        self.__init__()
        self.size(10, 10, 25)

    def new(self):
        self.root.destroy()
        self.__init__()
        if self.column == 9:
            self.size(self.row, self.column, 10)

    def quiz(self):
        self.root.destroy()

    def start(self):
        self.size(10, 10, 25)

    def right_key(self, event):
        w = event.widget
        t = w.cget('text')
        g = w.grid_info()
        x = int(g['row'])
        y = int(g['column'])
        if t == '?':
            self.mark.remove([x, y])
            w.config(text='')
            self.minenum += 1
            self.minecount.set(self.minenum)
        else:
            self.mark.append([x, y])
            w.config(text='?')
            self.minenum -= 1
            self.minecount.set(self.minenum)

    def left_key1(self, event):
        w = event.widget
        g = w.grid_info()
        x = int(g['row'])
        y = int(g['column'])
        if w.cget('text') != '?':
            self.state = 'fail'
            Button(self.root, text='X', fg='red', relief=SUNKEN).grid(row=x, column=y)
            tl = Toplevel()
            Label(tl, text='很抱歉，您输了。', width=50).pack()
            Button(tl, text='新游戏', command=self.new, width=6).pack()
            Button(tl, text='退出', command=self.quiz, width=6).pack()

    def fail(self):
        tl = Toplevel()
        Label(tl, text='很抱歉，您输了。', width=50).pack()
        Button(tl, text='新游戏', command=self.new, width=6).pack()
        Button(tl, text='退出', command=self.quiz, width=6).pack()

    def win(self):
        if len(self.all) == len(self.mine):
            self.state = 'win'
            tl = Toplevel()
            bt = Label(tl, text='恭喜，您赢了！您所用时间为%d秒。' % self.timeused, width=50).pack()
            Button(tl, text='再来一局', command=self.new, width=6).pack()
            Button(tl, text='退出', command=self.quiz, width=6).pack()

    def left_key(self, event):
        w = event.widget
        g = w.grid_info()
        x = int(g['row'])
        y = int(g['column'])
        if w.cget('text') != '?':
            self.sweptlist.append([x, y])
            self.count(x, y)
        if self.state == 'reading':
            self.state = 'begin'
            self.f = Thread(target=self.time, args=(), name='thread-')
            self.f.start()

    def count(self, i, j):
        self.n = 0
        a = max(i - 1, 3)
        b = min(i + 2, self.row + 3)
        c = max(0, j - 1)
        d = min(j + 2, self.column)
        for r in range(i - 1, i + 2):
            for s in range(j - 1, j + 2):
                if ([r, s] in self.mine) == True:
                    self.n += 1
        if self.n == 0:
            Button(self.root, width=2, height=1, state='disabled', relief=SUNKEN).grid(row=i, column=j)
            if [i, j] in self.all:
                self.all.remove([i, j])
            self.win()
            for r in range(a, b):
                for s in range(c, d):
                    if ([r, s] in self.sweptlist) == False:
                        self.sweptlist.append([r, s])
                        self.count(r, s)
        else:
            a = ['#0000FF', '#008000', '#FF0000', '#00008B', '#8B0000', '#20B2AA', '#000000', '#808080']
            x = a[self.n - 1]
            bt = Button(self.root, width=2, height=1, fg=x, text=self.n, relief=SUNKEN)
            bt.bind('<Double-Button-1>', self.doubleleft_key)
            bt.grid(row=i, column=j)
            if [i, j] in self.all:
                self.all.remove([i, j])
            self.win()

    def doubleleft_key(self, event):
        mark = 0
        w = event.widget
        g = w.grid_info()
        x = int(g['row'])
        y = int(g['column'])
        a = max(x - 1, 3)
        b = min(x + 2, self.row + 3)
        c = max(0, y - 1)
        d = min(y + 2, self.column)
        for r in range(a, b):
            for s in range(c, d):
                if [r, s] in self.mark:
                    mark += 1
        if mark == w.cget('text'):
            for r in range(a, b):
                for s in range(c, d):
                    if ([r, s] in self.mark) == False:
                        if [r, s] in self.mine:
                            Button(self.root, text='X', fg='red', relief=SUNKEN).grid(row=r, column=s)
                            self.state = 'fail'
                        else:
                            if self.state != 'win':
                                self.sweptlist.append([r, s])
                                self.count(r, s)
        if self.state == 'fail':
            self.fail()


def time(self):
    for i in range(1, 1000):
        if self.state == 'begin':
            self.timeused = i
            self.timecount.set('%03d' % self.timeused)
            stdout.flush()
            sleep(1)


newgame = game()
newgame.start()

企业员工信息管理系统的设计与实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>
struct worker
{
    char name[20];//姓名
    char age[5];//年龄
    char worktime[5];//工龄
    char sex[5];//性别
    char grade[5];//级别
    char marrige[5];//婚姻状况
    char wage[10];//工资
    char tired[5];//是否在职
}work[100];
int n ;
void tz(char a[],char g[],char w[])
{
    int i,q,e,o;
    q=atoi(g);
    e=atoi(a);
    o=atoi(w);
    switch(q)
    {
        case 1:o=o+20;break;
        case 2:o=o+40;break;
        case 3:o=o+60;break;
        case 4:o=o+80;break;
        case 5:o=o+100;break;
    }
    if(e>=65) o=o+50;
    itoa(o,w,10);
}


//文件读写模块
void read()//读入数据
{
  FILE *fp;
  int i = 0;
  if( (fp = fopen("date.txt","r")) == NULL )
  {
    printf("请在D盘根目录下新建一个文本文件，文件名为date\n\n\n");
    system("pause");
    system("cls");
    return ;
  }
  fscanf(fp,"%d\n",&n);
  while(i < n)
  {
    fscanf(fp,"%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",work[i].name,work[i].age,work[i].worktime,work[i].sex,work[i].grade,work[i].marrige,work[i].wage,work[i].tired);
    i ++;
  }
  fclose(fp);
}
void write()//写入数据
{
  FILE *fp;
  int i = 0;
  if( (fp = fopen("date.txt","w")) == NULL )
  {
    printf("无法打开文件！\n");
    return ;
  }
  fprintf(fp,"%d\n",n);
  while(i < n)
  {
    fprintf(fp,"%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",work[i].name,work[i].age,work[i].worktime,work[i].sex,work[i].grade,work[i].marrige,work[i].wage,work[i].tired);
    i ++;
  }
  fclose(fp);
}

//输入模块
void input()// 从键盘输入
{
 int i;
 char W;
  int flag;//标记工号是否已存在
  char c;//指令Y?N
  read();//输入数据前先将文件中原有的数据读入
  do
  {
    flag = 0;
    printf("\t\t请输入职工的姓名:               \n\t\t");
    scanf("%s",work[n].name);
    for(i = 0 ; i < n ; i ++)
    {
      if(strcmp(work[i].name,work[n].name) == 0)
      {
        flag = 1;
        break;
      }
    }
    if(flag)
    {
      printf("该工号已存在！\n\n");
      printf("\t\t是否继续输入?(Y/N): ");
      scanf("%*c%c",&c);
      if(c == 'N' || c == 'n') break;
      continue;
    }

    printf("\t\t请输入职工的年龄:               \n\t\t");
    scanf("%s",work[n].age);
    printf("\t\t请输入职工的工龄:             \n\t\t");
    scanf("%s",work[n].worktime);
    printf("\t\t请输入职工的性别:               \n\t\t");
    scanf("%s",work[n].sex);
    printf("\t\t请输入职工的婚姻状况:               \n\t\t");
    scanf("%s",work[n].marrige);
    printf("\t\t请输入职工的级别:               \n\t\t");
    scanf("%s",work[n].grade);
    printf("\t\t请输入职工的工资:               \n\t\t");
    scanf("%s",work[n].wage);
    printf("\t\t请输入职工的是否在职:               \n\t\t");
    scanf("%s",work[n].tired);
    printf("\t\t是否继续输入?(Y/N): ");
    scanf("%*c%c",&c);
    n ++;
  }while( c != 'N' && c != 'n');

  write();
  printf("\n\n数据已保存！\n\n");
  for(i=0;i<n;i++)
  {
    tz(work[i].age,work[i].grade,work[i].wage);
  }
}

//显示模块
void output_inf(int id)
{
  printf("\t\t  姓名: %s\n",work[id].name);
  printf("\t\t  年龄: %s\n",work[id].age);
  printf("\t\t  工龄: %s\n",work[id].worktime);
  printf("\t\t  性别: %s\n",work[id].sex);
  printf("\t\t  婚姻状况: %s\n",work[id].marrige);
  printf("\t\t  级别: %s\n",work[id].grade);
  printf("\t\t  工资: %s\n",work[id].wage);
  printf("\t\t  是否在职: %s\n",work[id].tired);
  printf("\n\n\n");
}
void show()//显示所有职工信息
{
   int i;
  read();
  if(n == 0) printf("无记录!\n\n");
  else
    for(i = 0 ; i < n ; i ++)
    {
      output_inf(i);
    }
}




void statistics_age()//按照年龄统计
{
    int choice;
    printf("请选择统计方式：\n");
    printf("1. 按照年龄上下限统计\n");
    printf("2. 按照年龄段统计\n");
    scanf("%d", &choice);
    switch (choice)
    {
    case 1:
        {
            int age_min, age_max;
            printf("请输入年龄下限：\n");
            scanf("%d", &age_min);
            printf("请输入年龄上限：\n");
            scanf("%d", &age_max);
            int count = 0;
            for (int i = 0; i < n; i++)
            {
                int age = atoi(work[i].age);
                if (age >= age_min && age <= age_max)
                {
                    count++;
                }
            }
            printf("年龄在%d到%d之间的员工有%d人\n", age_min, age_max, count);
            break;
        }
    case 2:
        {
            int age_range[10] = {0};
            for (int i = 0; i < n; i++)
            {
                int age = atoi(work[i].age);
                if (age < 20)
                {
                    age_range[0]++;
                }
                else if (age < 30)
                {
                    age_range[1]++;
                }
                else if (age < 40)
                {
                    age_range[2]++;
                }
                else if (age < 50)
                {
                    age_range[3]++;
                }
                else if (age < 60)
                {
                    age_range[4]++;
                }
                else
                {
                    age_range[5]++;
                }
            }
            printf("年龄在20岁以下的员工有%d人\n", age_range[0]);
            printf("年龄在20岁到30岁之间的员工有%d人\n", age_range[1]);
            printf("年龄在30岁到40岁之间的员工有%d人\n", age_range[2]);
            printf("年龄在40岁到50岁之间的员工有%d人\n", age_range[3]);
            printf("年龄在50岁到60岁之间的员工有%d人\n", age_range[4]);
            printf("年龄在60岁以上的员工有%d人\n", age_range[5]);
            break;
        }
    default:
        printf("输入有误！\n");
        break;
    }
}






//查询模块
void que()//查询信息
{
  char num;
  int flag,i;
  char q_name[20] ;//查询姓名
  char q_worktime[20] ;//查询工龄
  char q_grade[20] ; //查询级别
  char c;//指令Y?N
  read();//打开程序后，要查询以前的数据，要先读入
  while(1)
  {
    system("cls");
    printf("\t\t******************查询********************\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       1.按姓名查询        *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       2.按工龄查询        *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       3.按级别查询        *\n");
    printf("\t\t*                    *\n");
    printf("\t\t******************************************\n");
    printf("\t\t请输入指令(1-3):");
    scanf("%*c%c",&num);
    if(num<'1'||num>'3')
    {
      printf("错误指令！\n\n");
      system("pause");
      continue;
    }
    system("cls");
    flag = 0;//用来标记职工信息是否存在
    if(num == '1')//按工号查询
    {
      printf("\t\t请输入您要查询职工的姓名：");
      scanf("%s",q_name);
      for(i = 0 ; i < n ;i ++)
      {
        if( strcmp(work[i].name,q_name) == 0)
        {
          output_inf(i);
          flag = 1;//标记
          break;
        }
      }
    }
    else if(num == '2')//按工龄查询
    {
      printf("\t\t请输入您要查询职工的工龄：");
      scanf("%s",q_worktime);
      for(i = 0 ; i < n ;i ++)
      {
        if( strcmp(work[i].worktime,q_worktime) == 0)
        {
          output_inf(i);
          flag = 1;//标记
        }
      }
    }
    else if(num == '3')//按级别查询
    {
      printf("\t\t请输入您要查询职工的级别：");

      scanf("%s",q_grade);
      for(i = 0 ; i < n ;i ++)
      {
        if( strcmp(work[i].grade,q_grade) == 0)
        {
          output_inf(i);
          flag = 1;//标记
        }
      }
    }
    if(!flag)//判断是否有该职工信息
    {
      printf("\n\n无该职工信息!\n\n");
    }
    printf("\n\n是否继续查询(Y/N):");

    scanf("%*c%c",&c);
    if(c == 'N' || c == 'n') break;
  }
}

//修改信息模块
void mod()//修改职工信息
{
char change_name[20];//需修改的职工的姓名
  int number;//职工信息在数据中的位置
  char num;//指令
  char message[100];//修改的信息
  char c;//指令Y?N
  int W;
  int flag;
  int i;
  read();
  while(1)
  {
    flag = 0;
    system("cls");
    printf("请输入需修改的职工的姓名：");
    scanf("%s",change_name);
    for(i=0;i<n; i++)
    {
      if(strcmp(work[i].name,change_name) == 0 )
      {
        number = i;
        flag = 1;
        break;
      }
    }
    if(!flag)
    {
      printf("\n\n无此员工信息！！\n\n");
      printf("\n\n是否继续修改(Y/N):");
      scanf("%*c%c",&c);
      if(c == 'N' || c == 'n') break;
      continue;
    }
    printf("\n\n\t\t******************修改********************\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       1.修改姓名         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       2.修改年龄         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       3.修改工龄         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       4.修改性别         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       5.修改婚姻状况         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       6.修改级别         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       7.修改工资        *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*       8.修改是否在职         *\n");
    printf("\t\t*                    *\n");
    printf("\t\t*    输入其他任意键退出本模块     *\n");
    printf("\t\t******************************************\n");
    printf("\t\t请输入指令(1-8):");
    scanf("%*c%c",&num);
    if(num < '1' || num > '8')
    {
      printf("错误指令！\n\n");
      system("pause");
      continue;
    }
    system("cls");
    printf("请输入修改后的信息：");
    scanf("%s",message);
    switch(num)
    {
        case '1' : strcpy(work[number].name,message); break;
        case '2' : strcpy(work[number].age,message); break;
        case '3' : strcpy(work[number].worktime,message); break;
        case '4' : strcpy(work[number].sex,message); break;
        case '5' : strcpy(work[number].marrige,message); break;
        case '6' : strcpy(work[number].grade,message); break;
        case '7' : strcpy(work[number].wage,message); break;
        case '8' : strcpy(work[number].tired,message); break;
    }
    system("cls");
    printf("\n\n是否继续修改(Y/N):");
    scanf("%*c%c",&c);
    if(c == 'N' || c == 'n') break;
  }
  write();
}


//删除信息模块
void del()//删除职工信息
{
  char delete_name[20];//删除职工姓名
  int i,j;
  int flag;//标记是否有该职工信息
  char c;
  read();
  while(1)
  {
    system("cls");
    flag = 0;
    printf("请输入需删除职工信息的姓名：");
    scanf("%s",delete_name);
    for(i = 0 ; i < n ; i ++)
    {
      if( strcmp(work[i].name,delete_name) == 0)
      {
        n --;
        flag = 1;
        for(j = i ; j < n ; j ++)
        {
          work[j] =work[j + 1];
        }
        break;
      }
    }
    if(!flag) printf("\n\n无此员工信息！\n\n");
    else printf("\n\n删除成功！\n");
    printf("\n\n是否继续删除(Y/N):");
    scanf("%*c%c",&c);
    if(c == 'N' || c == 'n') break;
  }
  write();
}

void output_all()
{
    int i;
    read();
    if(n == 0) printf("无记录!\n\n");
    else
        for(i = 0 ; i < n ; i ++)
        {
            printf("\t\t  姓名: %s\n",work[i].name);
            printf("\t\t  年龄: %s\n",work[i].age);
            printf("\t\t  工龄: %s\n",work[i].worktime);
            printf("\t\t  性别: %s\n",work[i].sex);
            printf("\t\t  婚姻状况: %s\n",work[i].marrige);
            printf("\t\t  级别: %s\n",work[i].grade);
            printf("\t\t  工资: %s\n",work[i].wage);
            printf("\t\t  是否在职: %s\n",work[i].tired);
            printf("\n\n\n");
        }
}


void sort()
{
    int i,j;
    struct worker temp;
    printf("请选择排序方式：\n");
    printf("1.按工龄排序\n");
    printf("2.按年龄排序\n");
    printf("3.按姓名排序\n");
    int choice;
    scanf("%d",&choice);
    switch(choice)
    {
        case 1:
            for(i=0;i<n-1;i++)
            {
                for(j=0;j<n-i-1;j++)
                {
                    if(atoi(work[j].worktime)>atoi(work[j+1].worktime))
                    {
                        temp=work[j];
                        work[j]=work[j+1];
                        work[j+1]=temp;
                    }
                }
            }
            break;
        case 2:
            for(i=0;i<n-1;i++)
            {
                for(j=0;j<n-i-1;j++)
                {
                    if(atoi(work[j].age)>atoi(work[j+1].age))
                    {
                        temp=work[j];
                        work[j]=work[j+1];
                        work[j+1]=temp;
                    }
                }
            }
            break;
        case 3:
            for(i=0;i<n-1;i++)
            {
                for(j=0;j<n-i-1;j++)
                {
                    if(strcmp(work[j].name,work[j+1].name)>0)
                    {
                        temp=work[j];
                        work[j]=work[j+1];
                        work[j+1]=temp;
                    }
                }
            }
            break;
        default:
            printf("输入有误！\n");
            break;
    }
    printf("排序结果如下：\n");
    for(i=0;i<n;i++)
    {
        output_inf(i);
    }
}





//菜单模块
void menu()//菜单
{
    printf("****************************************************************\n");
    printf("*                                                              *\n");
    printf("*                    欢迎使用本职工信息管理系统                *\n");
    printf("*    1。创建职工信息                     2。查询职工信息       *\n");
    printf("*    3。修改职工信息                     4。员工信息统计       *\n");
    printf("*    5。删除职工信息                     6。输出所有员工信息              *\n");
    printf("*    7。员工信息排序                     8。退出               *\n");
    printf("*                                                              *\n");
    printf("*                       请输入相应编号：                       *\n");
    printf("*                                                              *\n");
    printf("****************************************************************\n");
  printf("\t\t请输入指令(1-6): ");
}




int main()
{
  int kl0,kl1,jh;
  kl0=147;
  for(jh=0;;jh++)
{
  printf("请输入口令:  ");
  scanf("%d",&kl1);
  if(kl1==kl0)
{
  printf("你是合法用户！\n");break;}
  else if(jh<2) continue;
  else printf("你是非法用户!");return 0;
}
  int num;
  n = 0;
  system("color 0B");
  while(1)
  {
    menu();
    scanf("%d",&num);
    system("cls");
    switch(num)
    {
      case 1: input(); break;
      case 2: que(); break;
      case 3: mod();  break;
      case 4: statistics_age();  break;
      case 5: del();  break;
      case 6: output_all(); break;
      case 7: sort();break;

      case 8: printf("谢谢使用！\n\n"); return 0;
      default :printf("\n--->无效的指令!\n\n\n");
    }
    system("pause");
    system("cls");
  }
}

音像图书信息管理系统

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <string.h>

// 音像图书信息结构体
typedef struct {
    char number[10];
    char name[100];
    float price;
    int original_quantity;
    int remaining_quantity;
} AVItem;

// 租借者信息结构体
typedef struct {
    char number[10];
    char borrow_date[20];
    float deposit;
    int borrow_days;
    float rent;
} Borrower;

// 链表节点结构体
typedef struct Node {
    void *data;
    struct Node *next;
} Node;

// 链表结构体
typedef struct {
    Node *head;
    int length;
} LinkedList;

// 创建链表
LinkedList* createLinkedList() {
    LinkedList *list = (LinkedList*)malloc(sizeof(LinkedList));
    list->head = NULL;
    list->length = 0;
    return list;
}

// 向链表尾部添加节点
void appendNode(LinkedList *list, void *data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;

    if (list->head == NULL) {
        list->head = newNode;
    } else {
        Node *currentNode = list->head;
        while (currentNode->next != NULL) {
            currentNode = currentNode->next;
        }
        currentNode->next = newNode;
    }

    list->length++;
}

// 根据编号查找节点
Node* findNodeByNumber(LinkedList *list, const char *number) {
    Node *currentNode = list->head;
    while (currentNode != NULL) {
        AVItem *item = (AVItem*)currentNode->data;
        if (strcmp(item->number, number) == 0) {
            return currentNode;
        }
        currentNode = currentNode->next;
    }
    return NULL;
}

// 根据编号删除节点
void deleteNodeByNumber(LinkedList *list, const char *number) {
    Node *previousNode = NULL;
    Node *currentNode = list->head;

    while (currentNode != NULL) {
        AVItem *item = (AVItem*)currentNode->data;
        if (strcmp(item->number, number) == 0) {
            if (previousNode == NULL) {
                list->head = currentNode->next;
            } else {
                previousNode->next = currentNode->next;
            }
            free(item);
            free(currentNode);
            list->length--;
            break;
        }
        previousNode = currentNode;
        currentNode = currentNode->next;
    }
}

// 销毁链表
void destroyLinkedList(LinkedList *list) {
    Node *currentNode = list->head;
    while (currentNode != NULL) {
        Node *tempNode = currentNode;
        AVItem *item = (AVItem*)currentNode->data;
        free(item);
        currentNode = currentNode->next;
        free(tempNode);
    }
    free(list);
}

// 显示音像图书信息
void displayAVItem(AVItem *item) {
    printf("编号：%s\n", item->number);
    printf("名称：%s\n", item->name);
    printf("原价：%.2f\n", item->price);
    printf("原数量：%d\n", item->original_quantity);
    printf("剩余数量：%d\n", item->remaining_quantity);
    printf("-------------------------\n");
}

// 显示租借者信息
void displayBorrower(Borrower *borrower) {
    printf("编号：%s\n", borrower->number);
    printf("租借日期：%s\n", borrower->borrow_date);
    printf("押金：%.2f\n", borrower->deposit);
    printf("租借天数：%d\n", borrower->borrow_days);
    printf("租金：%.2f\n", borrower->rent);
    printf("-------------------------\n");
}

// 创建音像图书
void createAVItem(LinkedList *list) {
    AVItem *item = (AVItem*)malloc(sizeof(AVItem));
    printf("请输入编号：");
    scanf("%s", item->number);
    printf("请输入名称：");
    scanf("%s", item->name);
    printf("请输入原价：");
    scanf("%f", &item->price);
    printf("请输入原数量：");
    scanf("%d", &item->original_quantity);
    item->remaining_quantity = item->original_quantity;

    appendNode(list, item);

    printf("音像图书创建成功！\n");
}

// 租借音像图书
void borrowAVItem(LinkedList *list, LinkedList *borrowedList) {
    char number[10];
    char borrow_date[20];
    printf("请输入音像图书编号：");
    scanf("%s", number);
    printf("请输入租借日期：");
    scanf("%s", borrow_date);

    Node *avNode = findNodeByNumber(list, number);
    if (avNode == NULL) {
        printf("无此音像图书！\n");
        return;
    }

    AVItem *item = (AVItem*)avNode->data;
    if (item->remaining_quantity <= 0) {
        printf("此音像图书已全部借出！\n");
        return;
    }

    Borrower *borrower = (Borrower*)malloc(sizeof(Borrower));
    strcpy(borrower->number, item->number);
    strcpy(borrower->borrow_date, borrow_date);
    borrower->deposit = item->price * 3;
    borrower->borrow_days = 0;
    borrower->rent = 0.0;

    appendNode(borrowedList, borrower);

    item->remaining_quantity--;

    printf("应缴押金：%.2f\n", borrower->deposit);
    printf("音像图书租借成功！\n");
}

int calculateDays(const char* date1, const char* date2) {
    int year1, month1, day1;
    int year2, month2, day2;

    sscanf(date1, "%d-%d-%d", &year1, &month1, &day1);
    sscanf(date2, "%d-%d-%d", &year2, &month2, &day2);

    struct tm tm1 = {0};
    tm1.tm_year = year1 - 1900;
    tm1.tm_mon = month1 - 1;
    tm1.tm_mday = day1;

    struct tm tm2 = {0};
    tm2.tm_year = year2 - 1900;
    tm2.tm_mon = month2 - 1;
    tm2.tm_mday = day2;

    time_t time1 = mktime(&tm1);
    time_t time2 = mktime(&tm2);

    double diff = difftime(time2, time1);
    int days = (int)(diff / (60 * 60 * 24));

    return days;
}


// ...

// 归还音像图书
void returnAVItem(LinkedList* list, LinkedList* borrowedList) {
    char number[10];
    char return_date[20];
    printf("请输入音像图书编号：");
    scanf("%s", number);
    printf("请输入归还日期：");
    scanf("%s", return_date);

    Node* borrowerNode = findNodeByNumber(borrowedList, number);
    if (borrowerNode == NULL) {
        printf("无此租借者！\n");
        return;
    }

    Borrower* borrower = (Borrower*)borrowerNode->data;
    printf("音像图书名称：%s\n", borrower->number);

    float rent_rate;
    Node* avNode = findNodeByNumber(list, number);

    if (avNode == NULL) {
        printf("无此音像图书！\n");
        return;
    }

    AVItem* item = (AVItem*)avNode->data;
    if (strcmp(item->number, "B") == 0) {
        rent_rate = 1.0;
    } else if (strcmp(item->number, "V") == 0) {
        rent_rate = 2.0;
    } else if (strcmp(item->number, "R") == 0) {
        rent_rate = 3.0;
    } else {
        printf("无此音像图书！\n");
        return;
    }

    // 计算租借天数
    int borrow_days = calculateDays(borrower->borrow_date, return_date);

    borrower->borrow_days = borrow_days;
    borrower->rent = borrow_days * rent_rate;

    printf("租借天数：%d\n", borrower->borrow_days);
    printf("应退押金：%.2f\n", borrower->deposit - borrower->rent);

    item->remaining_quantity++;

    deleteNodeByNumber(borrowedList, borrower->number);

    printf("音像图书归还成功！\n");
}
// 购进音像图书
void purchaseAVItem(LinkedList *list) {
    char number[10];
    int additional_quantity;
    printf("请输入音像图书编号：");
    scanf("%s", number);
    printf("请输入增加数量：");
    scanf("%d", &additional_quantity);

    Node *avNode = findNodeByNumber(list, number);
    if (avNode == NULL) {
        AVItem *item = (AVItem*)malloc(sizeof(AVItem));
        strcpy(item->number, number);
        printf("请输入名称：");
        scanf("%s", item->name);
        printf("请输入原价：");
        scanf("%f", &item->price);
        item->original_quantity = additional_quantity;
        item->remaining_quantity = additional_quantity;

        appendNode(list, item);
    } else {
        AVItem *item = (AVItem*)avNode->data;
        item->original_quantity += additional_quantity;
        item->remaining_quantity += additional_quantity;
    }

    printf("音像图书购进成功！\n");
}

// 报废音像图书
void scrapAVItem(LinkedList *list) {
    char number[10];
    int quantity;
    printf("请输入音像图书编号：");
    scanf("%s", number);
    printf("请输入报废数量：");
    scanf("%d", &quantity);

    Node *avNode = findNodeByNumber(list, number);
    if (avNode == NULL) {
        printf("无此音像图书！\n");
        return;
    }

    AVItem *item = (AVItem*)avNode->data;
    if (item->original_quantity != item->remaining_quantity) {
        printf("已借出的音像图书不能报废！\n");
        return;
    }

    item->original_quantity -= quantity;
    item->remaining_quantity -= quantity;

    printf("音像图书报废成功！\n");
}

int main() {
    LinkedList *avList = createLinkedList();
    LinkedList *borrowedList = createLinkedList();
    int option;

    while (1) {
        printf("|----------------------------|\n");
        printf("|请输入选项编号(0－－5):     |\n");
        printf("|----------------------------|\n");
        printf("| 1---创建音像图书           |\n");
        printf("| 2---租借音像图书           |\n");
        printf("| 3---归还音像图书           |\n");
        printf("| 4---购进音像图书           |\n");
        printf("| 5---报废音像图书           |\n");
        printf("| 0---退出系统               |\n");
        printf("|----------------------------|\n");

        scanf("%d", &option);

        switch (option) {
            case 1:
                createAVItem(avList);
                break;
            case 2:
                borrowAVItem(avList, borrowedList);
                break;
            case 3:
                returnAVItem(avList, borrowedList);
                break;
            case 4:
                purchaseAVItem(avList);
                break;
            case 5:
                scrapAVItem(avList);
                break;
            case 0:
                destroyLinkedList(avList);
                destroyLinkedList(borrowedList);
                exit(0);
                break;
            default:
                printf("无效的选项！\n");
                break;
        }
    }

    return 0;
}

用链表构建学生信息库

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct stud_node *Create_Stu_Doc();
struct stud_node *InsertDoc(struct stud_node *head, struct stud_node *stud);
struct stud_node *DeleteDco(struct stud_node *head, int num);
void Print_Stu_Doc(struct stud_node *head);

struct stud_node
{
    int num;
    char name[20];
    int score;
    struct stud_node *next;
};

int main()
{
    struct stud_node *head, *p;
    int choice, num, score;
    char name[20];
    int size = sizeof(struct stud_node);
    do{
        printf("1:Create 2:Insert 3:Delete 4:Print 0:Exit \n");
        scanf("%d", &choice);
        switch(choice) {
         case 1:
              head= Create_Stu_Doc();
              break;
         case 2:
              printf("Input num,name and score\n");
              scanf("%d%s%d", &num, name, &score);
              p = (struct stud_node *)malloc(size);
              p->num = num;
              strcpy(p->name, name);
              p->score = score;
              head = InsertDoc(head, p);
              break;
         case 3:
              printf("Input num:\n");
              scanf("%d",&num);
              head = DeleteDco(head, num);
              break;
         case 4:
              Print_Stu_Doc(head);
              break;
         case 0:
              break;
        }
    } while (choice != 0);
    system("pause");
    return 0;
}
/*新建链表*/
struct stud_node *Create_Stu_Doc()
{
    int num, score;
    char name[20];
    struct stud_node *head,*p;
    head = NULL;
    printf("Input num,name and score:\n");
    scanf("%d%s%d", &num, name, &score);
    while(num!=0)
    {
        p = (struct stud_node *)malloc(sizeof(struct stud_node));
        p->num = num;
        strcpy(p->name, name);
        p->score = score;
        p->next = NULL;
        head = InsertDoc(head, p);
        printf("Input num,name and score:\n");
        scanf("%d%s%d", &num, name, &score);
    }
    return head;
}
/*插入操作*/
struct stud_node *InsertDoc(struct stud_node *head, struct stud_node *stud)
{
    struct stud_node *ptr, *ptr1, *ptr2;
    ptr2 = head;
    ptr = stud;
    if(head==NULL)
    {
        head = ptr;
        head->next == NULL;
    }
    else
    {
        while((ptr->num>ptr2->num)&&(ptr2->next!=NULL))
        {
              ptr1 = ptr2;
              ptr2 = ptr2->next;
        }
        if(ptr->num<=ptr2->num)
        {
            if(head==ptr2)
                head = ptr;
            else
                ptr1->next = ptr;
                ptr->next = ptr2;
        }
        else
        {
            ptr2->next = ptr;
            ptr->next = NULL;
        }
    }
    return head;
}
/*删除操作*/
struct stud_node *DeleteDco(struct stud_node *head,int num)
{
    struct stud_node *ptr1, *ptr2;
    while(head!=NULL&&head->num==num)
    {
        ptr2 = head;
        head = head->next;
        free(ptr2);
    }
    if(head==NULL){
        return NULL;
    }
    ptr1 = head;
    ptr2 = head->next;
    while(ptr2!=NULL){
        if(ptr2->num==num){
            ptr1->next = ptr2->next;
            free(ptr2);
        }else{
            ptr1 = ptr2;
            ptr2 = ptr2->next;
        }
    }
    return head;    
}
/*遍历操作*/
void Print_Stu_Doc(struct stud_node *head)
{
    struct stud_node *ptr;
    if(head==NULL){
        printf("\nNo Records");
        return;
    }
    printf("\nThe Students Records Are:\n");
    printf("Num\t Name\t Score\n");
    for (ptr = head; ptr!= NULL; ptr = ptr->next){
        printf("%d\t%s\t%d\n", ptr->num, ptr->name, ptr->score);
    }
}

流水灯

/*******************************************************************
 *@title LED system
 *@brief flight light
 *@brief 
 *@time  2016.10.19
 *@editor小南&zin
 *飞控爱好QQ群551883670,邮箱759421287@qq.com
 ******************************************************************/
#include "stm32f10x.h"
#include "LED.h"
#include "ALL_DATA.h"
#include "delay.h"
//机身前灯				 
#define fLED_H()  GPIOB->BRR = GPIO_Pin_0|GPIO_Pin_1
#define fLED_L()  GPIOB->BSRR = GPIO_Pin_0|GPIO_Pin_1
#define fLED_Toggle()  GPIOB->ODR ^= GPIO_Pin_0|GPIO_Pin_1
#define fLED_H1()  GPIOB->BRR = GPIO_Pin_0
#define fLED_H2()  GPIOB->BRR = GPIO_Pin_1
#define fLED_L1()  GPIOB->BSRR = GPIO_Pin_0
#define fLED_L2()  GPIOB->BSRR = GPIO_Pin_1


//-------------------------------------------------
//机身后灯				 
#define bLED_H()  GPIOA->BRR = GPIO_Pin_6|GPIO_Pin_7
#define bLED_L()  GPIOA->BSRR  = GPIO_Pin_6|GPIO_Pin_7
#define bLED_Toggle()  GPIOA->ODR ^= GPIO_Pin_6|GPIO_Pin_7
#define bLED_H1()  GPIOA->BRR = GPIO_Pin_6
#define bLED_H2()  GPIOA->BRR = GPIO_Pin_7
#define bLED_L1()  GPIOA->BSRR  = GPIO_Pin_6
#define bLED_L2()  GPIOA->BSRR  = GPIO_Pin_7

//-------------------------------------------------
//---------------------------------------------------------
/*     you can select the LED statue on enum contains            */
sLED LED = {100,AllFlashLight};  //LED initial statue is off;
                             //default 300ms flash the status
/**************************************************************
 *  LED Init
 * @param[in] 
 * @param[out] 
 * @return     
 ***************************************************************/
void LEDInit(void)	
{	
	GPIO_InitTypeDef GPIO_InitStructure;

	 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOA , ENABLE);
  	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;		   
  	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;		     
  	GPIO_Init(GPIOB, &GPIO_InitStructure);	
	fLED_L();//暗
	bLED_L();
}

/**************************************************************
 *  LED system
 * @param[in] 
 * @param[out] 
 * @return     
 ***************************************************************/	
void PilotLED() //flash 300MS interval
{
	static uint32_t LastTime = 0;

	if(SysTick_count - LastTime < LED.FlashTime)
	{

		return;
	}
	else
		LastTime = SysTick_count;
	switch(LED.status)
	{
		case AlwaysOff:      //常暗   
			bLED_L();
			fLED_L();
			break;
		case AllFlashLight:				  //全部同时闪烁
			fLED_H1();
			fLED_L1();
			delay_ms(1000);
			bLED_H1();
			bLED_L1();
			delay_ms(1000);
			bLED_H2();
			bLED_L2();
			delay_ms(1000);
			fLED_H2();
			fLED_L2();
			delay_ms(1000);
		  break;
		case AlwaysOn:  //常亮
			bLED_H();
			fLED_H();
		  break;
		case AlternateFlash: //交替闪烁
			bLED_H();
			fLED_L();
			LED.status = AllFlashLight;
			break;
		case WARNING:
			fLED_L();
			bLED_Toggle();
			LED.FlashTime = 100;
			break;
		case DANGEROURS:
			bLED_L();
			fLED_Toggle();
			LED.FlashTime = 70;
			break;
		default:
			LED.status = AlwaysOff;
			break;
	}
}

/**************************END OF FILE*********************************/

EDA作业

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY BIJIAOQI IS
PORT(A : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
     B : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
     LT : OUT STD_LOGIC;
     GT : OUT STD_LOGIC;
     EQ : OUT STD_LOGIC);
END ENTITY BIJIAOQI;

ARCHITECTURE BHV OF BIJIAOQI IS
    PROCESS(A, B)   BEGIN
        IF A < B THEN
            LT <= '1';
            GT <= '0';
            EQ <= '0';
        ELSIF A > B THEN
            LT <= '0';
            GT <= '1';
            EQ <= '0';
        ELSE
            LT <= '0';
            GT <= '0';
            EQ <= '1';
        END IF;  
    END PROCESS; 
END ARCHITECTURE BHV;


// 设计一个比较电路，当输入的8421BCD码大于5时输出1，否则输出0
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY COMPARE_CIRCUIT IS
    PORT(INPUT : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
         OUTPUT : OUT STD_LOGIC);  
END ENTITY COMPARE_CIRCUIT;

ARCHITECTURE BEHAVIOR OF COMPARE_CIRCUIT IS
    PROCESS(INPUT)   BEGIN
        IF INPUT > "0101" THEN
            OUTPUT <= '1';
        ELSE
            OUTPUT <= '0';
        END IF;           
    END PROCESS; 
END ARCHITECTURE BEHAVIOR;


//设计一个4位乘法器，为此首先设计一个加法器，用列化语句调用这个加法器，用移位相加的方式完成乘法。并以此项设计为基础，
//使用GENERIC参数传递的功能，设计一个16乘法器

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY ADD_CIRCUIT IS  
    PORT(A : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
         B : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
         SUM : OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
         CARRY : OUT STD_LOGIC);
         
END ENTITY ADD_CIRCUIT;

ARCHITECTURE BEHAVIOR OF ADD_CIRCUIT IS
    FUNCTION ADD(A : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
         B : IN STD_LOGIC_VECTOR(3 DOWNTO 0)) RETURN STD_LOGIC_VECTOR(3 DOWNTO 0) IS
         BEGIN
             RETURN (A + B);
         END ADD;  
    BEGIN
        SUM <= ADD(A, B);
        CARRY <= (A(3) AND B(3)) OR (A(2) AND B(2)) OR (A(1) AND B(1)) OR (A(0) AND B(0));
    END PROCESS;
END ARCHITECTURE BEHAVIOR;


//设计一个4位4输入最大数值检测电路
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY MAX_DETECT_CIRCUIT IS
    PORT(INPUT : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
         OUTPUT : OUT STD_LOGIC);
         
END ENTITY MAX_DETECT_CIRCUIT;

ARCHITECTURE BEHAVIOR OF MAX_DETECT_CIRCUIT IS
    FUNCTION MAX(A : IN STD_LOGIC_VECTOR(3 DOWNTO 0)) RETURN STD_LOGIC IS
    BEGIN
        IF A > "0101" THEN
            RETURN '1';
            ELSE
            RETURN '0';
            END IF;     
    END MAX;
    BEGIN
        OUTPUT <= MAX(INPUT);
        END PROCESS;
END ARCHITECTURE BEHAVIOR;


//设计VHDL程序，实现两个8位二进制数相加，然后将和左移或右移4位，并分别将移位后的值存入变量A和B中
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;

ENTITY SHIFT_CIRCUIT IS
    PORT(A : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         B : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         CARRY : IN STD_LOGIC;
         SHIFT_AMOUNT : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
         SUM : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);
         CARRY_OUT : OUT STD_LOGIC);
         
END ENTITY SHIFT_CIRCUIT;

ARCHITECTURE BEHAVIOR OF SHIFT_CIRCUIT IS
    FUNCTION SHIFT(A : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         B : IN STD_LOGIC_VECTOR(7 DOWNTO 0);  
         CARRY : IN STD_LOGIC;
         SHIFT_AMOUNT : IN STD_LOGIC_VECTOR(3 DOWNTO 0)) RETURN STD_LOGIC_VECTOR(7 DOWNTO 0) IS
         BEGIN
             RETURN (A + B + CARRY) << SHIFT_AMOUNT;
             END SHIFT;
     
    BEGIN
        SUM <= SHIFT(A, B, CARRY, SHIFT_AMOUNT);
        CARY_OUT <= (A + B + CARRY) >> SHIFT_AMOUNT;
        END PROCESS;
END ARCHITECTURE BEHAVIOR;

create schema
create table
create view
create index