首页 > 其他分享 >学习C语言第十天（数组练习）

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

时间：2024-07-23 21:27:52浏览次数：15  
标签：arr 第十天 int C语言 char board 数组 COL ROW

一、三子棋

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]

9.

结果为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;
}

三、扫雷

game.h

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

#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<rows;i++)
	{
		for (j=0;j<cols;j++)
		{
			board[i][j] = set; 
		}
	}
}
//显示雷区
void display(char board[ROW][COL], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("-----------扫雷游戏---------------\n");
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		printf("%d ",i);
		for (j = 1; j <= col; j++)
		{
			printf("%c ",board[i][j]);
		}
		printf("\n");
	}
	printf("-----------扫雷游戏---------------\n");
}

//布置雷
void setmine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		if (board[x][y] == '0')
		{
			board[x][y] ='1';
			count--;
		}
	}
}

//排雷
int get_mine_count(char board[ROWS][COLS], int x,int y)
{
	return board[x - 1][y] +
		board[x - 1][y - 1] +
		board[x][y - 1] +
		board[x + 1][y - 1] +
		board[x + 1][y] +
		board[x + 1][y + 1] +
		board[x][y + 1] +
		board[x - 1][y + 1] - 8 * '0';
}
void findmine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0;//找到非雷的个数
	while (win<row*col-EASY_COUNT)
	{
		printf("输入要排查的坐标:>");
		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;
}

标签：arr,第十天,int,C语言,char,board,数组,COL,ROW
From： https://blog.csdn.net/2301_79600945/article/details/140599239

相关文章

  • 简单理解【指针数组】与【数组指针】
    2024-07-22笔记-42024-07-23补充笔记【指针数组】顾名思义，就是用来存储地址的数组，所有的元素全中存储的全部都是地址，每一个元素都可以理解为是一个指针变量。char*arr[10];int*arr2[10];char**arr3[5];①举例，多种访问方式intarr[5]={1,2,3,4,5},ar......
  • 二分查找（数组的练习）
    一、什么是二分查找    二分查找（又叫折半查找）是一种查找算法，它能使查找的速度更快，但要求查找的序列必须有序。        如果我们按顺序在一个序列中查找一个数，当这个数在靠前的位置，查找的速度还好；那么当这个数在很靠后的位置呢？甚至是一个很长的数组，要查找......
  • day8 字符数组
    字符数组用来存放字符数据的数组叫字符数组。字符数组中每一个元素存放一个字符。字符数组主要用于处理c中字符串的使用。字符串：“helloworld”用双引号引用起来的就是字符串，在双引号中，字符串中的字符不可更改。字符串在内存当中按照先后次序排列起来c语言中，规定了字符串......
  • 用C语言打印杨辉三角形：**
    用C语言打印杨辉三角形：1.杨辉三角形规律：1.每行数字左右对称，由1开始逐渐变大，然后变小，回到1。2.第n行的数字个数等于n，第n行的第一个和最后一个数字都是1。3.对于第i行，除首尾两个1之外，任意位置的数等于它肩上的两个数之和。即第i行第j个数等于第i-1行第j-1个数与第i-1行第......
  • 字符串数组
    一、二分查找法将一个有序的数列取中值，判断数在哪一段，每次筛选原来的一半，重复多次二、字符串数组（容器，用来存放字符）1.初始化内容：chars[100]=“hello”（字符串常量）字符串结束标志：\0（空字符）单一性、连续性、有序性2.输出字符串puts(s)=puts(&s[0])3.输入字符串scanf......
  • 数组和指针的关系，const修饰指针
     数组和指针的关系 const修饰指针总结：const修饰谁谁就不能变      const修饰*（ const在* 前）          不能改变*p的值，可以改变p的指向     const修饰p（const在*后）          不能改变p的指向，可以改......
  • SA & SAM 后缀数组 & 后缀自动机
    终于来到大名鼎鼎的后缀结构了，后缀结果可以解决许多子串问题。后缀结果是字符串经常考察的点，需要重点学习。SA后缀排序，是指这个对字符串\(s\)的每一个后缀字符串进行排序，通过处理每个后缀的前缀来解决子串问题。\(SA\)：排名为\(i\)对应原字符串下标，\(rk\)：下标为\(i\)的后缀排名。......
  • C语言输入输出函数
    输入函数1.scanf函数：用于格式化输入。例如：scanf("%d",&num);用于读取一个整数并存储到变量num中。输出函数：   1.printf函数：    用于格式化输出。例如：printf("Thenumberis%d\n",num);会输出指定的字符串和变量num     的值。   ......
  • C语言100道基础拔高题（1）
    1.有1,2,3,4这几个数字，问能组成多少个互不相同且无重复数字的三位数？    解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请......
  • C语言100道基础拔高题（2）
    1.求两个数的最小公倍数和最大公约数        解题思路：求最小公倍数可以通过两个数的积再除以最大公约数来计算。而最大公约数则可以通过辗转相除法（又名欧几里得算法）来得到。源代码如下：#include<stdio.h>intmain(){ //程序分析：最小公倍数=两个数的积除以......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99