学习C语言第十天（数组练习）

一、三子棋

game.h

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#define ROW 3
#define COL 3
//初始化棋盘
void initboard(char board[ROW][COL], int row, int col);
//打印棋盘
void dispalyboard(char board[ROW][COL],int row,int col);
//玩家下棋
void playermove(char board[ROW][COL], int row, int col);
//电脑下棋
void comuptermove(char board[ROW][COL],int row, int col);
//判断输赢
//玩家赢了-*
//电脑赢了-#
//平局-q
//继续-c
char iswin(char board[ROW][COL], int row, int col);

test.c

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"
void menu()  
{
	printf("*********************************\n");
	printf("*****1.开始游戏***0.结束游戏*****\n");
	printf("*********************************\n");
}
void game()
{
	char ret = 0;
	srand((unsigned int)time(NULL));//随机数生成
	char board[ROW][COL] = { 0};
	//初始化棋盘
	initboard(board,ROW,COL);
	//显示棋盘
	dispalyboard(board,ROW,COL);
	//开始下棋
	while (1)
	{
		playermove(board,ROW,COL);
		dispalyboard(board, ROW, COL);
		//判断输赢
		ret =iswin(board,ROW,COL);
		if (ret != 'c')
		{
			break;
		}
		comuptermove(board,ROW,COL);
		dispalyboard(board, ROW, COL);
		//判断输赢
		ret = iswin(board, ROW, COL);
		if (ret != 'c')
		{
			break;
		}
	}
	if (ret == '*')
	{
		printf("你赢了\n");
	}
	else if (ret == '#')
	{
		printf("电脑赢了\n");
	}
	else
	{
		printf("平局\n");
	}
	dispalyboard(board, ROW, COL);
}
int main()
{
	int input = 0;
	do
	{
		//菜单
		menu();
		printf("请选择：<");
		scanf("%d",&input);
		switch (input)
		{
		case 1:
			//游戏主体
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

game.c

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"
//棋盘初始化
void initboard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < ROW; i++)
	{
		for (j = 0; j < COL; j++)
		{
			board[i][j] = ' ';
		}
	}
} 

//显示棋盘
void dispalyboard(char board[ROW][COL], int row, int col)
{
	int i = 0;
	for (i=0;i");
		scanf("%d %d", &x, &y);
		//坐标合法判断
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';
				break;
			}
			else
			{
				printf("该位置已有棋子，请选择其他位置");
			}
		}
		else
		{
			printf("坐标非法");
		}
	}
}

//电脑下棋
//找空白位置随机下棋
void comuptermove(char board[ROW][COL], int row, int col)
{
	printf("电脑下棋\n");
	int x = 0;
	int y = 0;
	while (1)
	{
		x = rand() % row;//生成0-2
		x = rand() % col;
		if (board[x][y] == ' ')
		{
			board[x][y] = '#';
			break;
		}
	}

}

int is_full(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 0;
		}
	}
	return 1;
}
//判断输赢
char iswin(char board[ROW][COL],int row,int col)
{
	//先判断行
	int i = 0;
	int j = 0;
	for (i=0;i

二、练习

1.
关于递归的描述错误的是:C
A.存在限制条件，当满足这个限制条件的时候，递归便不再继续

B.每次递归调用之后越来越接近这个限制条件
C.递归可以无限递归下去
D .递归层次太深，会出现栈溢出现象

2.
根据下面递归的数:调用函数Fun(2)，返回值是多少(16)
int Fun(int n)

{
        if(n==5)

                return 2;
        else
                return 2*Fun(n+1);

}

3.
字符串逆序(递归实现)

编写一个函数 reverse_string(char*string)(递归实现)

实现:将参数字符串中的字符反向排列，不是逆序打印。

要求:不能使用C函数库中的字符串操作函数。
比如:
char arr[]= "abcdef"

进入函数之后变成“fedcba”

//字符串逆序(递归实现)
//编写一个函数 reverse_string(char* string)(递归实现)
//
//实现:将参数字符串中的字符反向排列，不是逆序打印。
//
//要求 : 不能使用C函数库中的字符串操作函数。
//比如 :
//char arr[] = "abcdef"
//
//进入函数之后变成“fedcba”
//第一种方法
//void reverse(char arr[])
//{
//	int left = 0;
//	int len = strlen(arr);
//	int right = strlen(arr)-1;
//	while (left < right)
//	{
//		int a = 0;
//		a = arr[left];
//		arr[left] = arr[right];
//		arr[right] = a;
//		left++;
//		right--;
//	}
//	if (left = right)
//	{
//		printf("%s", arr);
//	}
//}
//int main()
//{
//	char arr[] = { "abcdefg" };
//	reverse(arr);
//	return 0;
//}
// 第二种方法
//int main()
//{
//	char arr[] = { "abcdefg"};
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int left = 0;
//	int right = sz - 2;//或者strlen(arr)-1;
// 	while (left=2)
//		reverse(str + 1);
//	*(str + len - 1) = tmp;
//}
//int main()
//{
//	char arr[] = "abcdefg";
//	reverse(arr);
//	printf("%s",arr);
//	return 0;
//}
//第四种方法
//void reverse(char arr[],int left,int right)
//{
//	char tmp = arr[left];
//	arr[left] = arr[right];
//	arr[right] = tmp;
//	if(left

4.
计算一个数的每位之和(递归实现)

写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19
输入:1729，输出:19

int digitsum(int a)
{
	if (a > 9)
	{
		a= a % 10 + digitsum(a / 10);
		return a;
	}
	else 
		return a;
	
}
int main()
{
	int a = 0;
	scanf("%d",&a);
	int sum= digitsum(a);
	printf("%d",sum);
	return 0;
}

5.
递归实现n的k次方

编写一个函数实现n的k次方，使用递归实现。

//第一种方法
//int k_cifang(int n,int k)
//{
//	if (k > 1)
//	{
//		int i = 0;
//		int a = 1;
//		for (i = 1; i <=k; i++)
//		{
//			a = a * n;
//		}
//		return a;
//	}
//	else if (k ==1)
//		return n;
//	else
//		return 0;
//}
//int main()
//{
//	int n= 0;
//	int k = 0;
//	scanf("%d %d",&n, &k);
//	int b=k_cifang(n,k);
//	printf("%d",b);
//	return 0;
//}
//第二种方法
int k_cifang(int n, int k)
{
	if (k > 1)
	{
		return n * k_cifang(n,k-1);
	}
	else if (k == 1)
		return n;
	else
		return 0;
}
int main()
{
	int n = 0;
	int k = 0;
	scanf("%d %d", &n, &k);
	int b = k_cifang(n, k);
	printf("%d", b);
	return 0;
}

6.关于一维数组初始化，下面哪个定义是错误的C
A .int arr[10] = {1,2,3,4,5,6}
B .int arr[]= {1,2,3,4,5,6};
C .int arr[] =(1,2,3,4,5,6);
D .int arr[10] = (0};

7.
定义了一维 int 型数组 a[10] 后，下面错误的引用是:c
A .a[0] = 1;
B .a[0] = 5*2;
C.a[10] = 2;
D .a[1] = a[2]* a[0];

8.若定义int a[2][3]={1,2,3,4,5,6};则值为4的数组元素是( B)
A .a[0][0]

B .a[1][0]
C .a[1][1]

9.

结果为16

#include 
int main()
{
    int arr[]={1,2,(3,4),5 };
    printf("%d\n",sizeof(arr));
    return 0;
}

（3，4）逗号表达式，从左向右以此计算，结果为最右边的

10.

结果为10，9

#include 
int main()
{
    char str[]="hello bit";
    printf("%d %d\n",sizeof(str),strlen(str));
    return 0;
}

sizeof是操作符        用来计算变量所占内存空间大小        单位是字节

strlen是库函数        专门计算字符串长度        只能计算字符穿长度        从参数给定的地址一直向后找找到\0

11.
给出以下定义:
char acx[]=“abcdefg”;

char acY[] = {'a’,’b’,’c’,'d’,'e’,’f’ ,'g’};
以下说法正确的是(C)
A .数组acX和数组acy等价
B .数组acX和数组acy的长度相同

C.数组acx的长度大于数组acY的长度

D.数组acx的长度小于数组acY的长度

12.

关于一维数组描述不正确的是:(D)
A.数组的下标是从0开始的
B.数组在内存中是连续存放的

C.数组名表示首元素的地址
D .随着数组下标的由小到大，地址由高到低

13.
以下能对二维数组a进行正确初始化的语句是:B
A .int a[2][]={{0,1,2},{3,4,5}};

B int a[][3]={(0,1,2}.(3,4,5}};
C .int a[2][4]={{0,1,2},{3,4}.{5}};
D .int a[][3]={{0.,2}.{}.{3,4,5}}

14.将数组A中的内容和数组B中的内容进行交换。
(数组一样大)

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 5,4,3,2,1 };
	//每个元素交换
	int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	for (i = 0; i <= sz - 1; i++)
	{
		int tmp = arr1[i];
		arr1[i] = arr2[i];
		arr2[i] = tmp;
	}
	for (i = 0; i <= sz - 1; i++)
	{
		printf("%d ",arr1[i]);
	}
	return 0;
}

15.数组操作

创建一个整形数组，完成对数组的操作
1.实现函数intt() 初始化数组为全0
2.实现print()打印数组的每个元素
3.实现reverse()函数完成数组元素的逆置,
要求:自己设计以上函数的参数，返回值

void init(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i <= sz-1; i++)
	{
		arr[i] = 0;
	}
}
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i <= sz - 1; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}
void reverse(int arr[],int sz)
{
	int left = 0;
	int right = sz - 1;
	while (left < right)
	{
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = arr[left];
		left++;
		right--;
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	reverse(arr,sz);
	print(arr,sz);
	init(arr, sz);
	print(arr, sz);
	return 0;
}

三、扫雷

game.h

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 

#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2

#define EASY_COUNT 80

void initboard(char board[ROWS][COLS],int rows,int cols,char set);
void display(char board[ROWS][COLS],int row,int col);
void setmine(char board[ROWS][COLS],int row, int col);
void findmine(char mine[ROWS][COLS],char show[ROWS][COLS], int row, int col);

game.c

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"

//初始化雷区
void initboard(char board[ROWS][COLS], int rows, int cols,char set)
{
	int i = 0;
	int j = 0;
	for (i=0;i");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (show[x][y] != '*')
			{
				printf("该坐标已经排查过");
			}
			else
			{
				//如果是雷
				if (mine[x][y] == '1')
				{
					printf("你被炸死了");
					display(mine, ROW, COL);
					break;
				}
				//不是雷，要统计周围有几个雷
				//'1'-'0'=1
				//'0'-'0'=0
				else
				{
					win++;
					//统计mine数组x，y坐标周围有几个雷
					int count = get_mine_count(mine, x, y);
					show[x][y] = count + '0';//转换成数字字符
					display(show, ROW, COL);
					break;
				}
			}
		}
		else
		{
			printf("请重新输入\n");
		}
	}
	if (win==row*col-EASY_COUNT)
	{
		printf("恭喜你过关了");
		display(mine, ROW, COL);
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"
void menu()
{
	printf("************************\n");
	printf("******1.开始游戏********\n");
	printf("******0.退出游戏********\n");
	printf("************************\n");
	printf("************************\n");
}
void game()
{
	char mine[ROWS][COLS] = { 0 };//存放布置好的雷的信息
	char show[ROWS][COLS] = { 0 };//排查出的雷的信息
	 //初始化mine没有布置雷的时候都是0
	initboard(mine,ROWS,COLS,'0');
	 //初始化show没有布置雷的时候都是*
	initboard(show, ROWS, COLS,'*');
	//设置雷
	setmine(mine, ROW, COL);
	display(mine, ROW, COL);
	display(show, ROW, COL);
	//排查雷
	findmine(mine,show,ROW,COL);

}
int main()
{
	int input = 0;
	//设置随机数生成起点
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择：<");
		scanf("%d",&input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("请重新选择\n");
			break;
		}
	} while (input);
	return 0;
}