C语言简单练习题网站首页 技术交流

C语言简单练习题

隼玉 2025-07-11 12:01:04

简介C语言简单练习题

文章目录

练习题

练习题

一、计算n的阶乘

//计算n的阶乘
#include<stdio.h>
int main()
{
	while (1)
	{
		printf("阶乘：");
		int i = 0;
		int n = 0;
		scanf("%d", &n);
		int T = 1;
		i = n;
		if (i > 0)
		{
			for (i = n; i > 0; i--)
			{
				T = T * i;			
			}
			printf("%d!=%d
", n, T);
		}
		else if (i == 0)
			printf("%d的阶乘为：0
", n);
		else
			printf("输入错误
");
	}
	return 0;
}

输出：

  阶乘：5
  5!=120
  阶乘：6
  6!=720

//导入 stdbool.h 来使用布尔类型
#include <stdbool.h>
#include <stdio.h>

//计算n!,n的值在main中定义
int main(void)
{
    int n = 0;
    scanf("%d", &n);
    int sum = 1; //用来存放阶乘的结果
    bool flag = false;    //阶乘标记

    int num = n;    //循环次数
    while (!flag)
    {
        sum = sum * (num--);
        //当num=1时结束循环
        if (num == 1)
        {
            flag = true;
        }
    }
    printf("%d的阶乘值为 %d 
", n, sum);
    return 0;
}

输出：
```
5
5的阶乘值为 120
```
bool类型
- C 语言标准(C99)解决了布尔类型的问题
- C99 提供了 Bool 型
- Bool 依然仍是整数类型，但与一般整型不同的是，Bool 变量只能赋值为 0 或 1，非 0 的值都会被存储为 1
- C99还提供了一个头文件 <stdbool.h> 定义了 bool 代表 _Bool，true 代表 1，false 代表 0

二、计算1!+2!+3!+…+10!

//计算1!+2!+3!+...+10!
#include<stdio.h>
int main()
{
	int i = 1;
	int n = 0;
	int Temp = 1;
	int sum = 0;
	for (i = 1; i <= 10; i++)
	{
		for (n = i; n > 0; n--)
		{
			Temp = Temp * n;
		}
		sum = sum + Temp;
		Temp = 1;
	}
	printf("%d", sum);
	return 0;
}

输出：
```
  4037913
```

//计算1!+2!+3!+...+10!（函数调用）
#include<stdio.h>
int main()
{
	int i = 1;
	int sum = 0;
	for (i = 1; i <= 10; i++)
	{
		sum = sum + Get(i);
	}
	printf("%d
", sum);
	return 0;
}

int Get(int n)//返回n的阶乘
{
	int a = 0;
	for (a=1; n > 0; n--)
	{
		a = a * n;
	}
	return a;
}

输出：
```
  4037913
```

三、计算数组arr中的元素个数

//计算数组arr中的元素个数
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("%d
", sz);
	return 0;
}

输出：
```
  6
```

二分法查找

//二分法查找
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 };
	int a = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int left = 0;//最左侧元素下标
	int right = sz - 1;//最右侧元素下标
	while (1)
 {
		int left = 0;//最左侧元素下标
		int right = sz - 1;//最右侧元素下标
		scanf("%d", &a);
		while(left <= right)
		{ 
			int mid = left + (right - left) / 2;//中间元素下标（防止运算数值过大导致越界）
			if (a > arr[mid])
				left = mid + 1;
			else if (a < arr[mid])
			{
				right = mid - 1;
			}
			else if (a == arr[mid])
			{
				printf("%d的下标是：%d
", a, mid);
				break;
			}
		}
		if (left > right)
			printf("数组里没有这个数！
");
	}
	return 0;
}

输出：

  12
  12的下标是：11
  3
  3的下标是：2

四、动态打印字符

//动态打印字符
#include<stdio.h>
#include<Windows.h>
#include<stdlib.h>
int main()
{
	char arr1[] = "Hello World!!!";
	char arr2[] = "##############";
	
	int Left = 0;
	int Right = strlen(arr1)-1;// sizeof(arr1) / sizeof(arr1[0]) - 1;
	while (Left <= Right)
	{
		arr2[Left] = arr1[Left];
		arr2[Right] = arr1[Right];
		printf("%s
", arr2);
		Sleep(1000);//包含于<Windows.h>中，延时函数ms
		//清屏
		system("cls");//system是一个库函数，可执行系统文件；包含于<stdlib.h>中
		Left++;
		Right--;
	}
	printf("%s
", arr2);
	return 0;
}

Sleep()ms延时函数

包含于<Windows.h>头文件中

system(“cls”)清屏函数

包含于<stdlib.h>头文件中
system是一个库函数，可执行系统文件

五、模拟用户登录

//编写代码实现，模拟用户登录，并且只能登录三次
//（只允许登录三次密码，如果密码正确，则提示登录成功，如果三次均输入错误，则退出程序）
#include<stdio.h>
#include<string.h>
int main()
{
	int i = 0;
	int pass[20] = { 0 };

	for (i = 0; i < 3; i++)
	{
		printf("请输入密码：");
		scanf("%s", pass);
		if (strcmp(pass, "abc123") == 0)
		{
			printf("登录成功！
");
			break;
		}
    else
			printf("密码错误！
");

	}
	if (i == 3)
	{
		printf("三次输入错误，退出程序");
	}
	return 0;
}

输出：

  请输入密码：132
  密码错误！
  请输入密码：asc
  密码错误！
  请输入密码：abc123
  登录成功！

strcmp()函数

包含于<string.h>头文件中
用于判断两个字符串（字符数组） 是否相等
使用方法
- 若strcmp(字符串1,字符串2) == 0，则字符串1与字符串2相等，反之则不相等

六、猜数字小游戏

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include<Windows.h>
//猜数字小游戏
void star()
{
	printf("**************************
");
	printf("********  1.Play  ********
");
	printf("********  2.Exit  ********
");
	printf("**************************
");
}
void game()
{
	system("cls");//清屏
	//猜数字游戏
	int guess = 0;
	//1、生成一个1-100的随机数（利用时间戳）
	int number = rand()%100+1;//如此guess的范围就被限制在了<1-100>之间
	//2、猜数字
	while (1)
	{
		printf("你猜的数是：");
		scanf("%d", &guess);
		if (guess > number)
		{
			printf("猜大了！
");
		}
		else if (guess < number)
		{
			printf("猜小了！
");
		}
		else
		{
			printf("恭喜你，猜对了！
");
			break;
		}
	}
}
int main()
{
	srand((unsigned int)time(NULL));
	int mode = 0;
	do
	{
		star();
		printf("输入游戏模式<1/2>：");
		scanf("%d", &mode);
		switch (mode)
		{
			case 1:
				game();
			case 2:
			{
				printf("退出游戏
");
				break;
			}
			default:
				printf("输入错误
");
		}

	} while (2-mode);
	return 0;
}

产生一个随机数

rand

定义于头文件 `<stdlib.h>`
`rand();`

返回 0 与【RAND_MAX】之间的伪随机整数值（包含 0 与 RAND_MAX ）

参数	返回值
（无）	`0` 与 `RAND_MAX`间（包含边界）的伪随机整数值。

srand

在使用前需要使用srand()“播种”

srand

定义于头文件 <stdlib.h>
void srand( unsigned seed );

以值 seed为种子 “播种” rand() 所用的随机数生成器

注：若在 srand() 的调用前使用 rand() ，则 rand() 表现为如同它被以 srand(1) 播种

以相同的 seed(srand(seed))播种 rand() 时，它会产生相同的值数列

参数返回值
seed--种子值 （无）

注意： 每次使用rand()产生伪随机数时，都只需用srand()播种一次，不应重复播种

通常使用时间戳来充当srand()的种子值，种子值的不断变化以保证产生的伪随机数值列不同

定义于头文件 `<stdlib.h>`
`void srand( unsigned seed );`

参数	返回值
`seed--种子值`	（无）

RAND_MAX

展开成等于函数rand()最大返回值的整数常量表达式。此值为实现定义。标准保证此值至少为 32767

时间戳time()

返回自纪元 Epoch（1970-01-01 00:00:00 UTC）起经过的时间，以秒为单位。如果 seconds 不为空，则返回值也存储在变量 seconds 中
头文件以及函数声明
- <time.h>
- ```
  time_t time( time_t *arg );
```

参数	返回值
`arg`—>指向将存储时间的 `time_t 对象的指针`，或`空指针`	成功时返回编码成`time_t`对象的当前日历时间。错误时返回 `(time_t)(-1)` 。若`arg`不是空指针，则返回值也会存储于 `arg` 所指向的对象

返回编码成time_t对象的当前日历时间，并将其存储于 arg 指向的time_t对象（除非 arg 为空指针）

示例：

#include <stdio.h>
#include <time.h>
 
int main ()
{
  time_t seconds;
 
  seconds = time(NULL);
  printf("自 1970-01-01 起的小时数 = %ld
", seconds/3600);
  
  return(0);
}

运行上面的程序，产生以下结果：

自 1970-01-01 起的小时数 = 373711

示例

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

int main(void)
{
   srand(time(NULL)); // 以当前时间为随机生成器的种子
   int random_variable = rand();
   printf("Random value on [0,%d]: %d
", RAND_MAX, random_variable);

   // 扔 6 面色子 20 次
   for (int n = 0; n != 20; ++n) {
       int x = 7;
       while(x > 6) 
           x = 1 + rand() / ((RAND_MAX + 1u) / 6); // 注意： 1 + rand() % 6 有偏差！
       printf("%d ", x); 
   }
}

可能的输出：

Random value on [0,2147483647]: 448749574
3 1 3 1 4 2 2 1 3 6 4 4 3 1 6 2 3 2 6 1

七、关机程序

//关机程序
//运行程序后，电脑60s后自动关机
//如果输入：你好  则取消关机
#include <stdio.h>
#include <time.h>
#include<Windows.h>
int main()
{
   char input[20] = { 0 };
   printf("电脑将在60s后关机，输入“你好”后取消关机！！
");
   int time0 = (unsigned int)time(NULL);
   system("shutdown -s -t 60");
again:
   scanf("%s", input);
   if (strcmp(input, "你好") == 0)
   {
   	system("shutdown -a");
   	printf("成功取消关机！
");
   }
   else
   {
   	int time1 = 60-(((unsigned int)time(NULL))-time0);
   	printf("电脑将在%d后关机，输入“你好”后取消关机！！
",time1);
   	goto again;
   }
   return 0;
}

运行结果：

电脑将在60s后关机，输入“你好”后取消关机！！
a
电脑将在55后关机，输入“你好”后取消关机！！
b
电脑将在51后关机，输入“你好”后取消关机！！
c
电脑将在48后关机，输入“你好”后取消关机！！
你好
成功取消关机！

控制电脑关机： shutdown -s -t 60
取消电脑关机： shutdown -a

Windows 10 shutdown 命令详解

八、修改字符串

memset()的使用

#include <stdio.h>
int main()
{
   char str[] = "Hello World!";
   printf("%s
", str);
   memset(str, 'A', 5);
   printf("%s
", str);
   return 0;
}

输出结果：
```
  Hello World!
  AAAAA World!
```

#include <stdio.h>
int main()
{
	char str[] = "Hello World!";
	printf("%s
", str);
	memset(str+4, 'A', 1);
	printf("%s
", str);
	return 0;
}

输出结果：
```
  Hello World!
  HellA World!
```

九、使用函数实现质数的判断

质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数（规定1既不是质数也不是合数）

#include <stdio.h>
//使用函数判断一个数是不是素数（质数）
#include <math.h>
//sqrt()开平方，返回值为double类型
int Prime(int A)
{
	int i = 0;
	for (i = 2; i <= (int)sqrt(A); i++)
	{
		if (A % i == 0)
		{
			return 0;//不是质数
		}
	}
	return 1;//是质数
}
int main()
{
	int a = 0;
	while (1)
	{
		scanf("%d", &a);
		if (Prime(a) == 1)
			printf("%d->是质数
", a);
		else printf("%d->不是质数
", a);
	}
	return 0;
}

输出：
```
3
3->是质数
4
4->不是质数
5
5->是质数
6
6->不是质数
```
sqrt()的使用

doubel sqrt(double A)
- 包含在头文件include <math.h>中
- 返回值是其中参数的开平方（double类型）
十、利用函数打印1000 - 2000年之间的闰年

#include <stdio.h>
//打印1000-2000年之间的闰年
//闰年：1、能被四整除且不能被100整除；2、能被100整除
int main()
{
   int i = 0;
   for (i = 1000; i <= 2000; i++)
   {
   	if (((i % 4 == 0) && (i % 100 != 0)) || (i % 400 == 0))
   	{
   		printf("%d ", i);
   	}
   }
   return 0;
}

输出：

1004 1008 1012 1016 1020 1024 1028 1032 1036 1040 1044 1048 1052 1056 1060 1064 1068 1072 1076 1080 1084 1088 1092 1096 1104 1108 1112 1116 1120 1124 1128 1132 1136 1140 1144 1148 1152 1156 1160 1164 1168 1172 1176 1180 1184 1188 1192 1196 1200 1204 1208 1212 1216 1220 1224 1228 1232 1236 1240 1244 1248 1252 1256 1260 1264 1268 1272 1276 1280 1284 1288 1292 1296 1304 1308 1312 1316 1320 1324 1328 1332 1336 1340 1344 1348 1352 1356 1360 1364 1368 1372 1376 1380 1384 1388 1392 1396 1404 1408 1412 1416 1420 1424 1428 1432 1436 1440 1444 1448 1452 1456 1460 1464 1468 1472 1476 1480 1484 1488 1492 1496 1504 1508 1512 1516 1520 1524 1528 1532 1536 1540 1544 1548 1552 1556 1560 1564 1568 1572 1576 1580 1584 1588 1592 1596 1600 1604 1608 1612 1616 1620 1624 1628 1632 1636 1640 1644 1648 1652 1656 1660 1664 1668 1672 1676 1680 1684 1688 1692 1696 1704 1708 1712 1716 1720 1724 1728 1732 1736 1740 1744 1748 1752 1756 1760 1764 1768 1772 1776 1780 1784 1788 1792 1796 1804 1808 1812 1816 1820 1824 1828 1832 1836 1840 1844 1848 1852 1856 1860 1864 1868 1872 1876 1880 1884 1888 1892 1896 1904 1908 1912 1916 1920 1924 1928 1932 1936 1940 1944 1948 1952 1956 1960 1964 1968 1972 1976 1980 1984 1988 1992 1996 2000

使用函数：

#include <stdio.h>
//利用函数打印1000 - 2000年之间的闰年
int Get_Leap_Year(int year)
{
   //是闰年返回1
   //不是闰年返回0
   if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
   	return 1;
   else 
   	return 0;
}
int main()
{
   int i = 0;
   for (i = 1000; i <= 2000; i++)
   {
   	if(Get_Leap_Year(i))
   		printf("%d ", i);		
   }
   return 0;
}

输出：

1004 1008 1012 1016 1020 1024 1028 1032 1036 1040 1044 1048 1052 1056 1060 1064 1068 1072 1076 1080 1084 1088 1092 1096 1104 1108 1112 1116 1120 1124 1128 1132 1136 1140 1144 1148 1152 1156 1160 1164 1168 1172 1176 1180 1184 1188 1192 1196 1200 1204 1208 1212 1216 1220 1224 1228 1232 1236 1240 1244 1248 1252 1256 1260 1264 1268 1272 1276 1280 1284 1288 1292 1296 1304 1308 1312 1316 1320 1324 1328 1332 1336 1340 1344 1348 1352 1356 1360 1364 1368 1372 1376 1380 1384 1388 1392 1396 1404 1408 1412 1416 1420 1424 1428 1432 1436 1440 1444 1448 1452 1456 1460 1464 1468 1472 1476 1480 1484 1488 1492 1496 1504 1508 1512 1516 1520 1524 1528 1532 1536 1540 1544 1548 1552 1556 1560 1564 1568 1572 1576 1580 1584 1588 1592 1596 1600 1604 1608 1612 1616 1620 1624 1628 1632 1636 1640 1644 1648 1652 1656 1660 1664 1668 1672 1676 1680 1684 1688 1692 1696 1704 1708 1712 1716 1720 1724 1728 1732 1736 1740 1744 1748 1752 1756 1760 1764 1768 1772 1776 1780 1784 1788 1792 1796 1804 1808 1812 1816 1820 1824 1828 1832 1836 1840 1844 1848 1852 1856 1860 1864 1868 1872 1876 1880 1884 1888 1892 1896 1904 1908 1912 1916 1920 1924 1928 1932 1936 1940 1944 1948 1952 1956 1960 1964 1968 1972 1976 1980 1984 1988 1992 1996 2000

十一、函数实现整形有序数组的二分查找

#include <stdio.h>
//函数实现整形有序数组的二分查找
int Search_Array(int *arr, int a, int sz)
{
   int left = 0;
   int right = sz - 1;
 //找到了返回下标
 //找不到返回-1（数组第一个元素下标为0）
   while (left <= right)
   {
   	int mid = left + (right - left) / 2;
   	if (arr[mid] > a)
   		right = mid - 1;
   	else if (arr[mid] < a)
   		left = mid + 1;
   	else
   		return mid;
   }
   return -1;
}
int main()
{
   int arr[] = { 1,3,4,6,7,8,9,10,11,12,13,15,16,17,19,20 };
   int a = 6;
   int sz = sizeof(arr) / sizeof(arr[0]);
   int Sub = Search_Array(arr, a, sz);
   if (Sub == -1)
   	printf("数组中没有这个数
");
   else
   	printf("%d在数组中的下标是%d
", a, Sub);
   return 0;
}

输出：
```
  6在数组中的下标是3
```

十二、将三个整数按从大到小输出

//将三个整数按从大到小输出
void swap(int* x, int* y)
{
	int temp = 0;
	temp = *x;
	*x = *y;
	*y = temp;
}
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	while (1)
	{
		//输入
		scanf("%d %d %d", &a, &b, &c);
		//交换
		if (a < b)
			swap(&a, &b);
		if (a <  c)
			swap(&a, &c);
		if (b < c)
			swap(&b, &c);
		//输出
		printf("%d %d %d
", a, b, c);
	}
	return 0;
}

输出：
```
  6 8 3
  8 6 3
```

十三、求两个数的最大公约数

//求两个数的最大公约数
int main()
{
	int a = 0;
	int b = 0;
	while (1)
	{
		scanf("%d %d", &a, &b);
		int min = (a < b ? a : b);
		while (1)
		{
			if (a % min == 0 && b % min == 0)
				break;
			min--;
		}
		printf("%d和%d的最大公约数是：%d
", a, b, min);
	}
	return 0;
}

输出：

  18 24
  18和24的最大公约数是：6

辗转相除法

欧几里得算法是用来求两个正整数最大公约数的算法

古希腊数学家欧几里得在其著作《The Elements》中最早描述了这种算法，所以被命名为欧几里得算法。扩展欧几里得算法可用于RSA加密等领域

假如需要求 1997 和 615 两个正整数的最大公约数，用欧几里得算法，是这样进行的：

至此，最大公约数为1以除数和余数反复做除法运算，当余数为 0 时，取当前算式除数为最大公约数，所以就得出了 1997 和 615 的最大公约数 1

//辗转相除法
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	while(1)
	{
		scanf("%d %d", &a, &b);
		while (c = a % b)
		{
			a = b;
			b = c;
		}
		printf("最大公约数是：%d
", b);
	}
	return 0;
}

输出：
```
  18 24
  最大公约数是：6
```

十四、求1-100的整数之间出现了多少个数字9

//求1-100的整数之间出现了多少个数字9
int main()
{
	int i = 1;
	int count = 0;
	for (i = 1; i < 100; i++)//不用计算100
	{
		if (i % 10 == 9)//判断个位是不是9
			count++;
		if (i / 10 == 9)//判断十位是不是9
			count++;
	}
	printf("%d个9
", count);
	return 0;
}

输出：
```
  20个9
```

十五、打印99乘法表

//打印99乘法表
int main()
{
	int i = 0;
	int j = 0;
	for (i = 1; i <= 9; i++)//9行
	{
		for (j = 1; j <= i; j++)
		{
			printf("%d*%d=%2d ", j, i, i * j);
      //%-2d打印两位整数左对齐
		  // %2d打印两位整数右对齐
		}
		printf("
");
	}
	return 0;
}

输出：

  1*1=1
  1*2=2 2*2=4
  1*3=3 2*3=6  3*3=9
  1*4=4 2*4=8  3*4=12 4*4=16
  1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
  1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
  1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
  1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
  1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

十六、递归实现字符串逆序

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

void change(char* str, int left, int right)
{
	char temp = 0;
	if (left < right)
	{
		temp = str[left];
		str[left] = str[right];
		str[right] = temp;
		change(str, left + 1, right - 1);
	}
}

int main()
{
	char str[] = "abcdefg";
	int left = 0;
	int right = strlen(str) - 1;
	change(str, left, right);
	printf("%s", str);
	return 0;
}

输出：
```
  gfedcba
```

十七、模拟实现strlen()

使用临时变量

//模拟实现strlen()，返回字符串个数

//int my_strlen(char str[])//参数部分写成指针的形式
int my_strlen(char str[])  //参数部分写成数组的形式
{
	int count = 0;//计数，使用临时变量
	while (*str != '')
	{
		count++;
		str++;//找下一个字符
	}
	return count;
}
int main()
{
	char str[] = "abcd";//[a b c d ]
	printf("%d", my_strlen(str));
	return 0;
}

输出：
```
  4
```
使用递归，不创建临时变量

//不创建临时变量使用递归
int my_strlen(char* str)
{
	if (*str != '')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}
int main()
{
	char str[] = "abcd";//[a b c d ]
	printf("%d", my_strlen(str));
	return 0;
}

输出：
```
  4
```

在这里插入图片描述

十八、三子棋

test.c：测试游戏的逻辑

game.c：游戏代码的实现

game.h：游戏代码的声明（函数定义，符号定义）

test.c

  #define _CRT_SECURE_NO_WARNINGS
                      
  #include "game.h"
  //***************************************************************
  //游戏菜单
  void menu()
  {
  	printf("================================
");
  	printf("==-----------1.Play-----------==
");
  	printf("==-----------2.Exit-----------==
");
  	printf("================================
");
  }
  //***************************************************************
  void game()
  {
  	char board[ROW][COL] = { 0 };
  	char ret = 0;//输赢判断标志位
  	Init_Board(board);//棋盘初始化
  	while (1)
  	{	
  		Print_Board(board);//打印棋盘
  		Player_Chess(board);//玩家回合
                      
  		ret = IsWin(board);//判断输赢
  		if (ret != 'C')
  			break;
                      
  		Print_Board(board);//打印棋盘
  		Computer_Chess(board);//电脑回合
                      
  		ret = IsWin(board);//判断输赢
  		if (ret != 'C')
  			break;
  	}
  	if (ret == '*')
  		printf("你赢得了游戏！
");
  	else if (ret == '#')
  		printf("你输了。。。
");
  	else if (ret == 'P')
  		printf("+++平局+++
");
  	Print_Board(board);//打印棋盘
  	printf("<------------------------------>
");
  	printf("<----------$回合结束$---------->
");
  	printf("<------------------------------>
");
  	printf("

");
  }
  //***************************************************************
  void test()
  {
  	int mode = 0;
  	do
  	{
  		menu();
  		printf("<输入游戏模式>：");
  		scanf("%d", &mode);
  		switch (mode)
  		{
  		case 1:
  			game();
  			break;
  		case 2:
  			break;
  		default:
  			printf("<输入错误！>
");
  			break;
  		}
  	} while (mode != 2);
  }
  //***************************************************************
  int main()
  {
  	srand((unsigned int)time(NULL));//设置随机数的生成起点
  	test();
  	return 0;
  }

game.c

  #define _CRT_SECURE_NO_WARNINGS
  #include "game.h"
  //***************************************************************
  //棋盘初始化函数
  void Init_Board(char board[ROW][COL])
  {
  	int i = 0;
  	for (i = 0; i < ROW; i++)
  	{
  		int j = 0;
  		for (j = 0; j < COL; j++)
  			board[i][j] = ' ';
  	}
  }
  //***************************************************************
  //打印棋盘
  void Print_Board(char board[ROW][COL])
  {
  	int i = 0;
  	for (i = 0; i < ROW; i++)
  	{
  		int j = 0;
  		//数据打印
  		for (j = 0; j < COL; j++)
  		{
  			printf(" %c ", board[i][j]);
  			if (j < COL - 1)
  				printf("|");
  			else
  				printf("
");
  		}
  		//分割信息打印
  		if (i < ROW - 1)
  		{
  			int j = 0;
  			for (j = 0; j < COL; j++)
  			{
  				printf("---");
  				if (j < COL - 1)
  					printf("|");
  				else
  					printf("
");
  			}
  		}
  	}
  }
  //***************************************************************
  //玩家下棋
  void Player_Chess(char board[ROW][COL])
  {
  	printf("<玩家回合>：
");
  	int x = 0;
  	int y = 0;
  	while (1)
  	{
  		scanf("%d %d", &x, &y);
  		if (1 <= x && x <= ROW && 1 <= y && y <= COL)//数据验证
  		{
  			if (board[x - 1][y - 1] == ' ')
  			{
  				board[x - 1][y - 1] = '*';
  				break;
  			}
  			else
  				printf("<此处已被占用！>
请重新输入：");
  		}
  		else
  			printf("<超出棋盘范围！>
请重新输入：");
  	}
  }
  //***************************************************************
  //电脑下棋
  void Computer_Chess(char board[ROW][COL])
  {
  	printf("<电脑回合>：
");
  	Sleep(1000);//延时一秒
  	int x = 0;
  	int y = 0;
  	while (1)
  	{
  		x = rand() % ROW;//产生0~(ROW-1)之间的随机数
  		y = rand() % COL;//0~2
  		if (board[x][y] == ' ')
  		{
  			board[x][y] = '#';
  			break;
  		}
  	}
  }
  //***************************************************************
  //判断棋盘是否满了
  int Board_Full(char board[ROW][COL])
  {
  	int i = 0;
  	for (i = 0; i < ROW; i++)
  	{
  		int j = 0;
  		for (j = 0; j < COL; j++)
  		{
  			if (board[i][j] == ' ')
  				return 0;//棋盘没满时返回0
  		}
  	}
  	return 1;//棋盘满了，返回1
  }
  //***************************************************************
  //继续---->'C'
  //玩家赢-->'*'
  //电脑赢-->'#'
  //平局---->'P'
  char IsWin(char board[ROW][COL])
  {
  	//行row
  	int i = 0;
  	for (i = 0; i < ROW; i++)
  	{
  		if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')
  			return board[i][1];
  	}
                      
  	//列column
  	int j = 0;
  	for (j = 0; j < COL; j++)
  	{
  		if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[1][j] != ' ')
  			return board[1][j];
  	}
                      
  	//对角线
  	if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
  		return board[1][1];
  	if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
  		return board[1][1];
                      
  	//平局
  	if (Board_Full(board))//返回1-->满了；此时为平局
  		return 'P';
                      
  	//继续
  	return 'C';
  }

game.h

  #pragma once
  #include <stdio.h>
  #include <stdlib.h>
  #include <time.h>
  #include <Windows.h>
                      
  #define ROW 3
  #define COL 3
                      
  //棋盘初始化
  void Init_Board();
                      
  //打印棋盘
  void Print_Board(char board[ROW][COL]);
                      
  //玩家回合
  void Player_Chess(char board[ROW][COL]);
                      
  //电脑回合
  void Computer_Chess(char board[ROW][COL]);
                      
  //输赢判断
  char IsWin(char board[ROW][COL]);

结果：

  ================================
  ==-----------1.Play-----------==
  ==-----------2.Exit-----------==
  ================================
  <输入游戏模式>：3
  <输入错误！>
  ================================
  ==-----------1.Play-----------==
  ==-----------2.Exit-----------==
  ================================
  <输入游戏模式>：1
     |   |
  ---|---|---
     |   |
  ---|---|---
     |   |
  <玩家回合>：
  2 2
     |   |
  ---|---|---
     | * |
  ---|---|---
     |   |
  <电脑回合>：
     |   |
  ---|---|---
     | * |
  ---|---|---
     | # |
  <玩家回合>：
  1 1
   * |   |
  ---|---|---
     | * |
  ---|---|---
     | # |
  <电脑回合>：
   * |   |
  ---|---|---
     | * |
  ---|---|---
   # | # |
  <玩家回合>：
  3 3
  你赢得了游戏！
   * |   |
  ---|---|---
     | * |
  ---|---|---
   # | # | *
  <------------------------------>
  <----------$回合结束$---------->
  <------------------------------>

================================
==-----------1.Play-----------==
==-----------2.Exit-----------==
================================
<输入游戏模式>：2
                                        
D:文档新建文件夹 (2)C语言程序设计源码C_Code_1game_1Debuggame_1.exe (进程 9740)已退出，代码为 0。
按任意键关闭此窗口. . .

十九、扫雷

test.c：测试游戏的逻辑

game.c：游戏代码的实现

game.h：游戏代码的声明（函数定义，符号定义）

test.c

  #include "game.h"
                      
  void game()
  {
  	//创建数组，布置雷的信息，初始化时放入'0'
  	char mine[ROWS][COLS] = { 0 };
  	//创建数组，排查雷的信息，初始化时放入'*'
  	char show[ROWS][COLS] = { 0 };
  	//数组初始化
  	InitBoard(mine, ROWS, COLS, Kong);
  	InitBoard(show, ROWS, COLS, View);
  	//随机放置雷
  	Place_Mine(mine, ROW, COL);
                      
  	//打印棋盘
  	//PrintBoard(mine, ROW, COL);
  	PrintBoard(show, ROW, COL); 
                      
  	Game_Run(mine, show, ROW, COL);
  }
                      
  int main()
  {
    //设置产生随机数的初始值
    srand((unsigned int)time(NULL));
    int mode = 0;
    do
    {
      menu();//初始化游戏菜单
      printf("输入游戏模式：");//游戏模式选择
      scanf("%d", &mode);
      switch (mode)
      {
        case 1:
          printf("开始游戏
");
          game();
          break;
        case 2:
          printf("退出游戏
");
          break;
        default :
          printf("输入错误！
");
          break;
      }
    } while (mode != 2);
    return 0;
  }

game.c

  #define _CRT_SECURE_NO_WARNINGS
  #include "game.h"
                      
  void menu()
  {
  	//游戏菜单
  	printf("====--------------------------====
");
  	printf("====--------- 1.Play ---------====
");
  	printf("====--------- 2.Exit ---------====
");
  	printf("====--------------------------====
");
  }
                      
  //初始化雷盘
  void InitBoard(char arr[ROWS][COLS], int rows, int cols, char set)
  {
  	int i = 0;
  	int j = 0;
  	for (i = 0; i < rows; i++)
  	{
  		for (j = 0; j < cols; j++)
  		{
  			arr[i][j] = set;
  		}
  	}
  }
  //打印雷盘
  void PrintBoard(char arr[ROWS][COLS], int row, int col)
  {
  	int i = 1;
  	int j = 1;
  	printf("=------扫-雷------=
");
  	//显示出列号(|)
  	for (j = 0; j <= col; j++)
  	{
  		printf("%d ", j);
  	}
  	printf("
");
  	for (i = 1; i <= row; i++)
  	{
  		printf("%d ", i);//显示出行号(—)
  		for (j = 1; j <= col; j++)
  		{
  			printf("%c ", arr[i][j]);
  		}
  		printf("
");
  	}
  }
                      
  //放置雷
  void Place_Mine(char arr[ROWS][COLS], int row, int col)
  {
  	int count = 0;
  	while (count < Set_of_Mine)
  	{	
  		//产生1~9之间的随机数
  		int x = rand() % row + 1;
  		int y = rand() % col + 1;
  		if (arr[x][y] == Kong)
  		{
  			arr[x][y] = Lei;
  			count++;
  		}
  	}	
  }
                      
  //扫雷主逻辑
  void Game_Run(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  {
  	int count = 0;
  	while (count < row * col - Set_of_Mine)
  	{
  		int x = 0;
  		int y = 0;
  		printf("请选择位置排雷：>");
  		scanf("%d %d", &x, &y);
  		if (x > 0 && x <= row && y > 0 && y <= col)
  		{
  			if (mine[x][y] != Lei)
  			{
  				show[x][y] = Count_of_Mine(mine, x, y);//计算出(x,y)周围雷的数量
  				if (show[x][y] == '0')
  				{
  					Find_Zero_Mine(mine, show, row, col, x, y);
  				}
  				system("cls");//清屏
  				PrintBoard(show, ROW, COL);
  				Mark_Mine(show);
  				count++;
  			}
  			else if (mine[x][y] == Lei)
  			{
  				system("cls");//清屏
  				printf("你碰到了雷，游戏结束！
");
  				PrintBoard(mine, ROW, COL);
  				printf("====--------------------------====
");
  				printf("====--------Game  Over--------====
");
  				printf("====--------------------------====

");
  				break;
  			}			
  		}
  		else
  		{
  			printf("非法坐标，请重新输入！

");
  		}
  	}
  	if (count == row * col - Set_of_Mine)
  	{
  		printf("恭喜你，排雷成功！！！

");
  		PrintBoard(mine, ROW, COL);
  	}
  }
                      
  //计算周围雷的数量
  char Count_of_Mine(char arr[ROWS][COLS], int x, int y)
  {
  	char count = 0;
  	int i = 0;
  	int j = 0;
  	for (i = -1; i < 2; i++)
  	{
  		for (j = -1; j < 2; j++)
  		{
  			if (arr[x + i][y + j] == Lei)
  				count++;
  			else
  				continue;
  		}
  	}
  	return count + '0';
  	//数字+'0'可将其转换成字符串
  	//字符串-'0'可将其转换成数字
  }
                      
  //如果检测到该坐标周围雷的数量为0，就显示出该坐标
  /*
  条件：
  1.该坐标不是雷
  2.该坐标周围没有雷
  3.不能重复排查
  */
  //展开一片没有雷的区域（函数递归）
  void Find_Zero_Mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
  {
  	if (Count_of_Mine(mine, x, y) == '0')
  	{
  		show[x][y] = ' ';
  		int i = 0;
  		int j = 0;
  		for (i = -1; i < 2; i++)
  		{
  			for (j = -1; j < 2; j++)
  			{
  				if (x + i > 0 && x + i <= row && y + j > 0 && y + j <= col && show[x + i][y + j] == View)
  				{
  					Find_Zero_Mine(mine, show, row, col, x + i, y + j);
  				}
  			}
  		}
  	}
  	//显示区域边缘雷的数量
  	else
  		show[x][y] = Count_of_Mine(mine, x, y);
  }
                      
  void Mark_Mine(char show[ROWS][COLS])
  {
  	int Flag = 1;
  	int x = 0;
  	int y = 0;
                      
  	while (Flag)
  	{
  		printf("是否需要标记（1/0）：");
  		scanf("%d", &Flag); 
  		if (Flag == 1)
  		{
  			printf("请输入要标记的位置：>");
  			scanf("%d %d", &x, &y);
  			if (x > 0 && x <= ROW && y > 0 && y <= COL)
  			{
  				show[x][y] = Sign;
  				PrintBoard(show, ROW, COL);
  			}
  			else
  			{
  				printf("非法坐标！
");
  				continue;
  			}
  		}
  		else
  			break;
  	}
  	system("cls");//清屏
  	PrintBoard(show, ROW, COL);
  }

game.h

  #pragma once
  #define _CRT_SECURE_NO_WARNINGS
  #include <stdio.h>
  #include <time.h>
  #include <stdlib.h>
  #include <Windows.h>
                      
  //设置扫雷棋盘界面的大小
  #define ROW 9
  #define COL 9
  //为了方便棋盘边缘的计算
  #define ROWS ROW+2
  #define COLS COL+2
                      
  //设置样式
  #define Lei '1'		//雷
  #define Kong '0'	//Mine数组中没有雷的部分
  #define View '*'	//Show数组中显示部分
  #define Sign '#'	//Show数组中用于标记雷
                      
  //设置雷的数量
  #define Set_of_Mine 10
                      
  void menu();
  void InitBoard(char arr[ROWS][COLS], int rows, int cols, char set);
  void PrintBoard(char arr[ROWS][COLS], int row, int col);
  void Place_Mine(char arr[ROWS][COLS], int row, int col);
  void Game_Run(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
  char Count_of_Mine(char arr[ROWS][COLS], int x, int y);
  void Find_Zero_Mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y);
  void Mark_Mine(char show[ROWS][COLS]);

结果：

  ====--------------------------====
  ====--------- 1.Play ---------====
  ====--------- 2.Exit ---------====
  ====--------------------------====
  输入游戏模式：1
  开始游戏
  =------扫-雷------=
  0 1 2 3 4 5 6 7 8 9
  1 * * * * * * * * *
  2 * * * * * * * * *
  3 * * * * * * * * *
  4 * * * * * * * * *
  5 * * * * * * * * *
  6 * * * * * * * * *
  7 * * * * * * * * *
  8 * * * * * * * * *
  9 * * * * * * * * *
  请选择位置排雷：>6 8
                                          
  =------扫-雷------=
  0 1 2 3 4 5 6 7 8 9
  1 * * * * * * * * *
  2 * * * * * * * * *
  3 * * * * * * * * *
  4 * * * * * * * * *
  5 * * * * * * * * *
  6 * * * * * * * 1 *
  7 * * * * * * * * *
  8 * * * * * * * * *
  9 * * * * * * * * *
  是否需要标记（1/0）：0
                                          
  =------扫-雷------=
  0 1 2 3 4 5 6 7 8 9
  1 * * * * * * * * *
  2 * * * * * * * * *
  3 * * * * * * * * *
  4 * * * * * * * * *
  5 * * * * * * * * *
  6 * * * * * * * 1 *
  7 * * * * * * * * *
  8 * * * * * * * * *
  9 * * * * * * * * *
  请选择位置排雷：>2 4
                                          
  =------扫-雷------=
  0 1 2 3 4 5 6 7 8 9
  1 * * 1         1 *
  2 * * 1     1 2 3 *
  3 * * 2 1   1 * * *
  4 * * * 2   1 2 2 1
  5 * * * 2
  6 * * 1 1       1 1
  7 * * 1   1 1 1 1 *
  8 * * 1   1 * * * *
  9 * * 1   1 * * * *
  是否需要标记（1/0）：1
  请输入要标记的位置：>1 9
  =------扫-雷------=
  0 1 2 3 4 5 6 7 8 9
  1 * * 1         1 #
  2 * * 1     1 2 3 *
  3 * * 2 1   1 * * *
  4 * * * 2   1 2 2 1
  5 * * * 2
  6 * * 1 1       1 1
  7 * * 1   1 1 1 1 *
  8 * * 1   1 * * * *
  9 * * 1   1 * * * *
  是否需要标记（1/0）：0
                                          
  请输入要标记的位置：>3 7
  你碰到了雷，游戏结束！
  =------扫-雷------=
  0 1 2 3 4 5 6 7 8 9
  1 0 0 0 0 0 0 0 0 1
  2 0 1 0 0 0 0 0 0 0
  3 0 0 0 0 0 0 1 1 0
  4 0 0 1 0 0 0 0 0 0
  5 0 0 1 0 0 0 0 0 0
  6 0 0 0 0 0 0 0 0 0
  7 0 0 0 0 0 0 0 0 1
  8 1 1 0 0 0 1 0 0 0
  9 0 0 0 0 0 0 0 0 0
  ====--------------------------====
  ====--------Game  Over--------====
  ====--------------------------====

二十、求一个整数存储在内存中二进制1的个数

//编写代码实现：求一个整数存储在内存中二进制1的个数
//求补码的二进制1的个数
int main() {
	int a = 7;
	//0000 0000 0000 0000 0000 0000 0000 0111
	//0000 0000 0000 0000 0000 0000 0000 0001
//&	  0000 0000 0000 0000 0000 0000 0000 0001
	int i = 0;
	int count = 0;
	for (i = 0; i < 32; i++) {
		if ((a & (1 << i)) == (1 << i))
			count++;
	}

	printf("%d
", count);
	return 0;
}

二十一、青蛙跳台阶问题（斐波那契数列）

n阶台阶，每次可走1阶或两阶，问有多少种走法

//n阶台阶，每次可走1阶或两阶，有多少种走法
int Fib(int n) {
	if (n == 1)
		return 1;
	else if (n == 2)
		return 2;
	else
		return Fib(n - 1) + Fib(n - 2);
}
int main() {
	int n = 0;
	scanf("%d", &n);
	int count = 0;
	count = Fib(n);
	printf("%d", count);
	return 0;
}

```
  10
  89
```

$\\ 1, & ext{n=2} \\ Fib(n-1)+Fib(n-2), & ext{n>2} end{cases}$

二十二、序列中删除指定数字

int main() {
	int arr[20] = { 0 };
	int n = 0;
	int i = 0;
	printf("输入数字的个数：");
	scanf("%d", &n);
	
	for (i = 0; i < n; i++) {
		scanf("%d ", &arr[i]);
	}
	//删除
	int del = 0;
	int j = 0;
	scanf("%d", &del);
	for (j = 0; j < n; j++) {
		if (del != arr[j])
			printf("%d ", arr[j]);
	}
	return 0;
}

  输入数字的个数：5
  1 2 3 4 5
  2
  1 3 4 5

二十三、模拟实现strcpy

//模拟实现strcpy
#include <assert.h>

//将字符数组Source的内容复制到Goal中
char* my_strcpy(char* Goal, const char* Source) {//之所以返回char*是为了实现链式访问
  //const可确保Source不会被改变
  char* ret = Goal;
	//断言
	assert(Source != NULL);
	//如果不满足条件，程序将直接中断运行，并抛出异常
	assert(Goal != NULL);
	while (*Goal++ = *Source++);
  return ret;//返回目标数据的首地址
}

int main() {
	char arr1[20] = { 0 };
	char arr2[] = "For YOU!";
	my_strcpy(arr1, arr2);
	printf("arr1：%s
", arr1);
	printf("arr1：%s
", my_strcpy(arr1, arr2));
	printf("arr2：%s
", arr2); 
	return 0;
}

  arr1：For YOU!//arr1
  arr1：For YOU!//my_strcpy(arr1, arr2)
  arr2：For YOU!//arr2

assert（断言）的使用

在 C 语言中，assert 是一个宏定义，它定义在 assert.h 头文件中。assert 宏用于在程序执行期间测试某个条件是否为真。如果条件为假（即表达式计算结果为0），则 assert 宏会终止程序的执行，并输出一个错误消息

使用 assert 宏可以帮助开发者在开发和测试阶段发现错误，但它通常不用于生产环境，因为可以通过定义 NDEBUG 宏来禁用所有的 assert 检查

如何使用 assert

包含头文件：首先，需要包含 assert.h 头文件

使用 assert 宏：在代码中使用 assert 宏来检查条件

定义 NDEBUG：如果定义了 NDEBUG 宏，则所有的 assert 检查都会被禁用

示例代码：
#include <stdio.h>
#include <assert.h>

int main() {
    int a = 10;
    int b = 0;

    // 检查除数是否为0
    assert(b != 0); // 如果 b 为0，程序将终止并输出错误信息

    printf("结果是: %d
", a / b);

    return 0;
}
禁用 assert

如果你想要禁用 assert 检查，可以在编译时定义 NDEBUG 宏。这可以通过编译器的命令行选项来实现：
gcc -DNDEBUG program.c
或者在代码中定义：
#define NDEBUG
#include <stdio.h>
#include <assert.h>

int main() {
    int a = 10;
    int b = 0;

    // 这个 assert 检查将被禁用
    assert(b != 0);

    printf("结果是: %d
", a / b);

    return 0;
}
使用 assert 宏时，应该谨慎选择要检查的条件，避免在性能敏感的代码路径中使用，因为即使条件总是为真，assert 宏也会进行计算。此外，assert 宏不应该用于检查程序的正常运行逻辑，而应该用于捕获不可能发生的情况

const的使用

在 C 语言中，const 关键字用于定义常量值，即值在程序执行过程中不能被修改的变量。使用 const 可以提高代码的可读性和可维护性，同时帮助编译器进行优化

基本用法：
定义常量：使用 const 关键字可以定义一个常量，这意味着一旦初始化后，其值不能被改变
const int MAX_USERS = 100;
定义常量指针：你可以定义指向常量的指针，这有两种情况：

指针本身是常量（不能改变指向）
指针指向的值是常量（不能通过这个指针改变值）
const int *ptr;  // 指针本身是常量
int *const ptr2 = &someInt;  // 指针指向的地址是常量
const int *const ptr3 = &someInt;  // 指针本身和指向的值都是常量
常量数组：

你可以定义一个数组为常量，这意味着数组中的元素不能被修改
const int days[] = {1, 2, 3, 4, 5};
函数参数：

使用 const 修饰函数参数可以保证函数内部不会修改这些参数
void printArray(const int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("
");
}
在这个例子中，printArray 函数接收一个整数数组和数组的大小。由于数组被声明为 const，函数内部不能修改数组的元素

常量成员函数：

在 C++ 中（C 语言的超集），你可以定义一个成员函数为常量成员函数，这意味着该函数不会修改对象的任何成员变量
class Counter {
public:
    int value;

    void increment() {
        value++;
    }

    int getValue() const {  // 常量成员函数
        return value;
    }
};
在这个例子中，getValue 函数被声明为常量成员函数，这意味着它不会修改对象的任何成员变量

注意事项：

使用 const 可以提高代码的安全性，防止意外修改变量
在数组或结构体中使用 const 时，需要小心处理，因为 const 只保护直接访问，不保护间接访问
在使用指针时，明确 const 的位置非常重要，因为它影响指针的行为

二十四、菱形打印

//4____*____1 1
//3___***___2 3 
//2__*****__3 5
//1_*******_4 7 
//0*********5 9
//1_*******_1 7
//2__*****__2 5 
//3___***___3 3
//4____*____4 1

void print_star(int line) {
	int i = 0;
	
	for (i = 0; i < line; i++) {//上部分line
		int j = 0;
		for (j = 0; j < (line - 1 - i); j++) {//空格
			printf(" ");
		}
		for (j = 0; j < 2 * i + 1; j++) {//*
			printf("*");
		}
		printf("
");
	}
	for (i = 0; i < (line - 1); i++) {//下部分line-1
		int j = 0;
		for (j = 0; j <= i; j++) {//空格
			printf(" ");
		}
		for (j = 0; j < 2 * (line - 1 - i) - 1; j++) {//*
			printf("*");
		}
		printf("
");
	}


}
int main() {
	int n = 0;
	while (1) {
		scanf("%d", &n);
		print_star(n);
		
	}
	return 0;
}

  5
      *
     ***
    *****
   *******
  *********
   *******
    *****
     ***
      *
  9
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
   ***************
    *************
     ***********
      *********
       *******
        *****
         ***
          *

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

上一篇
Windows 10 YOLOV8 TensorRT C++如何部署...

下一篇
LeetCode-13.罗马数字转整数（C/C++）...

站长推荐

U8W/U8W-Mini使用与常见问题解决
U8W/U8W-Mini使用与常见问题解决
分享几个国内免费的ChatGPT镜像网址(亲测有效)
分享几个国内免费的ChatGPT镜像网址(亲测有效)
stm32使用HAL库配置串口中断收发数据（保姆级教程）
stm32使用HAL库配置串口中断收发数据（保姆级教程）
QT多线程的5种用法，通过使用线程解决UI主界面的耗时操作代码，防止界面卡死。
QT多线程的5种用法，通过使用线程解决UI主界面的耗时操作代码，防止界面卡死。...
SpringSecurity实现前后端分离认证授权
SpringSecurity实现前后端分离认证授权

您现在的位置是：首页 >技术交流 >C语言简单练习题网站首页技术交流

C语言简单练习题

文章目录

练习题

一、计算n的阶乘

bool类型

二、计算1!+2!+3!+…+10!

三、计算数组arr中的元素个数

二分法查找

四、动态打印字符

Sleep()ms延时函数

system(“cls”)清屏函数

五、模拟用户登录

strcmp()函数

六、猜数字小游戏

产生一个随机数

rand

srand

RAND_MAX

时间戳time()

示例

七、关机程序

八、修改字符串

memset()的使用

九、使用函数实现质数的判断

sqrt()的使用

十、利用函数打印1000 - 2000年之间的闰年

十一、函数实现整形有序数组的二分查找

十二、将三个整数按从大到小输出

十三、求两个数的最大公约数

辗转相除法

十四、求1-100的整数之间出现了多少个数字9

十五、打印99乘法表

十六、递归实现字符串逆序

十七、模拟实现strlen()

十八、三子棋

十九、扫雷

二十、求一个整数存储在内存中二进制1的个数

二十一、青蛙跳台阶问题（斐波那契数列）

二十二、序列中删除指定数字

二十三、模拟实现strcpy

assert（断言）的使用

const的使用

二十四、菱形打印

上一篇 Windows 10 YOLOV8 TensorRT C++如何部署...

下一篇 LeetCode-13.罗马数字转整数（C/C++）...

站长推荐

上一篇
Windows 10 YOLOV8 TensorRT C++如何部署...

下一篇
LeetCode-13.罗马数字转整数（C/C++）...