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

世辰辰辰

于 2024-07-22 16:01:14 发布

阅读量629

点赞数 22

文章标签：学习算法

本文链接：https://blog.csdn.net/2301_79600945/article/details/140599239

版权

一、三子棋

game.h

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#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<row;i++)
	{
		//打印数据
		//printf(" %c | %c | %c \n",board[i][0],board[i][1],board[i][2]);
		int j = 0;
		for (j=0;j<col;j++)
		{
			printf(" %c ",board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		//打印分割信息
		//printf("---|---|---\n");
		if (i < row - 1)
		{
			int j = 0;
			for (j=0;j<col;j++)
			{
				printf("---");
				if(j<col-1)
				printf("|");
			}
			printf("\n");
		}
	}
}
//第一个版本，列不能改变
//void dispalyboard(char board[ROW][COL], int row, int col)
//{
//	int i = 0;
//	for (i=0;i<row;i++)
//	{
//		//打印数据
//		printf(" %c | %c | %c \n",board[i][0],board[i][1],board[i][2]);
//		//打印分割信息
//		if (i < row - 1)
//			printf("---|---|---\n");
//	}
//}

//玩家下棋
void playermove(char board[ROW][COL], int row, int col)
{
	printf("玩家下棋");
	int x = 0;
	int y = 0;
	while (1)
	{
		printf("请输入坐标：>");
		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<row;i++)
	{
		if (board[i][0]==board[i][1]&&board[i][0]==board[i][2]&&board[i][0]!= ' ')
		{
			return board[i][0];
		}
	}
	//判断列
	for (j = 0; j< col; j++)
	{
		if (board[0][j] == board[1][j] && board[0][i] == board[2][j] && board[0][j] != ' ')
		{
			return board[0][j];
		}
	}
	//判断斜的
	if (board[0][0] == board[1][1] && board[0][0] == board[2][2] && board[0][0] != ' ')
	{
		return board[0][0];
	}
	if (board[0][2] == board[1][1] && board[0][2] == board[2][0] && board[0][2] != ' ')
	{
		return board[0][2];
	}
	//没人赢，判断平局
	if (is_full(board, row, col))
	{
		return 'Q';
	}
	//游戏继续
	return 'c';
}

二、练习

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<right)
//	{
//		int a = 0;
//		a = arr[left];
//		arr[left] = arr[right];
//		arr[right] = a;
//		left++;
//		right--;
//	}
//	if (left = right)
//	{
//		printf("%s",arr);
//	}
//	return 0;
//}
//第三种方法
//void reverse(char* str)
//{
//	char tmp = *str;
//	int len = strlen(str);
//	*str = *(str + len-1) ;
//	*(str + len-1)  = '\0';
//	if (strlen(str+1)>=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<right)
//	reverse(arr, left + 1, right - 1);
//}
//int main()
//{
//	char arr[] = "abcdefg";
//	int left = 0;
//	int right = strlen(arr) - 1;
//	reverse(arr,left,right);
//	printf("%s",arr);
//	return 0;
//}

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]

结果为16

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

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

10.

结果为10，9

#include <stdio.h>
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;
}

世辰辰辰

关注

22
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
学习C语言第十天（数组练习）

写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19。则值为4的数组元素是( B)定义了一维 int 型数组 a[10] 后，下面错误的引用是:c。根据下面递归的数:调用函数Fun(2)，返回值是多少(16)A.存在限制条件，当满足这个限制条件的时候，递归便不再继续。（3，4）逗号表达式，从左向右以此计算，结果为最右边的。C.数组acx的长度大于数组acY的长度。D.数组acx的长度小于数组acY的长度。
复制链接

扫一扫