c语言魔法阵代码

❶ c语言程序代码

C语言源代码，就是依据C语言规则所写出的程序代码，常见的存储文件扩展名为.c文件和.h文件，分别对应C源文件(source file)和C头文件(header file)。

C语言是一门编程语言，简单点说，就是由人类书写按照一定规范书写的字符，通过一定手段（编译链接）转换后，可以让电脑或者其它电子芯片＂读懂＂，并按照其要求工作的语言。在所有的编程语言中，C语言是相对古老而原始的，同时也是在同类语言中更接近硬件，最为高效的编程语言。

相关内容：

C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。

C语言描述问题比汇编语言迅速、工作量小、可读性好、易于调试、修改和移植，而代码质量与汇编语言相当。C语言一般只比汇编语言代码生成的目标程序效率低10%-20%。因此，C语言可以编写系统软件。

当前阶段，在编程领域中，C语言的运用非常之多，它兼顾了高级语言和汇编语言的优点，相较于其它编程语言具有较大优势。计算机系统设计以及应用程序编写是C语言应用的两大领域。同时，C语言的普适较强，在许多计算机操作系统中都能够得到适用，且效率显着。

C语言拥有经过了漫长发展历史的完整的理论体系，在编程语言中具有举足轻重的地位。

❷ C语言迷宫，要完整代码的

#include<stdio.h>
#include<conio.h>
intmigong[10][10]=//设置迷宫，最外围1为墙里边0为可走路径1为障碍
{
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,0,0,0,0,1,1,1},
{1,0,1,1,1,1,1,0,0,1},
{1,0,1,0,0,0,0,0,0,1},
{1,0,0,0,1,0,1,1,1,1},
{1,1,1,1,0,0,1,1,1,1},
{1,0,0,0,0,1,1,1,1,1},
{1,0,1,1,0,0,1,1,1,1},
{1,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}
};
intnum;
struct
{
	intx,y,d;
}lj[100];//x,y分别为垂直和水平方向

voidstart()
{
	inttop=0,x,y,d,find;//d为设置方向，上下左右。find为设置找不找得到路
	lj[top].x=1;
	lj[top].y=1;
	migong[1][1]=-1;
	find=0;d=-1;
	
	while(top>-1){
		if(lj[top].x==8&&lj[top].y==8)
		{
			printf("迷宫路径如下：
");
			printf("start->");
			for(x=0;x<=top;x++)
			{
				printf("(%d,%d)->",lj[x].x,lj[x].y);//把找到的路径输出
				num++;
				if(num%8==0)
					printf("
");
			}
			printf("->end!
");
		}
		
		while(d<4&&find==0){
			d++;
			switch(d){
			case0:x=lj[top].x-1;y=lj[top].y;break;//方向为上
			case1:x=lj[top].x;y=lj[top].y+1;break;//方向为右
			case2:x=lj[top].x+1;y=lj[top].y;break;//方向为下
			case3:x=lj[top].x;y=lj[top].y-1;}//方向为左
			if(migong[x][y]==0)
				find=1;
		}
		
		if(find==1){//判断是否找得到
			lj[top].d=d;
			top++;
			lj[top].x=x;
			lj[top].y=y;
			d=-1;find=0;//重新调整方向
			migong[x][y]=-1;}
		else{
			migong[lj[top].x][lj[top].y]=0;
			top--;d=lj[top].d;//找不到的话退栈
		}
	}
}

voidmain()
{
	start();
	getch();
}

❸ 诚求用C语言编一个实现走迷宫问题的代码。

全部程序分几个文件，看清楚了，每段程序放入一个文件，每段程序前面都有文件名：
//stackoperation.cpp

Status InitStack(SqStack &S)
{ //构造一个空栈S
S.base = (SElemType *)malloc(RANGE*sizeof(SElemType));
if(!S.base) exit(OVERFLOW); //存储分配失败
S.top = S.base;
S.stacksize = RANGE;
return OK;
}//Initstack

Status Push(SqStack &S,SElemType e)
{ //插入元素e为新的栈顶元素
if(S.top - S.base >= S.stacksize){//栈满，追加存储空间
S.base = (SElemType*)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(SElemType));
if(!S.base) exit(OVERFLOW); //存储分配失败
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}//Push

Status Pop(SqStack &S,SElemType &e){
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；
否则返回ERROR*/
if(S.top == S.base) return ERROR;
e = * --S.top;
return OK;
}//Pop

bool StackEmpty(SqStack S)
{ //判断栈是否为空并返回TURN或FALSE
if(S.top == S.base) return TURE;
return FALSE;
}//StackEmpty

void PrintStack()
{
SqStack ST;
SElemType e;
InitStack(ST);
do{
Pop(SqS,e);
Push(ST,e);
}while(!StackEmpty(SqS));
do{
Pop(ST,e);
printf("(%d,%d,%d)",e.seat.i,e.seat.j,e.di);
}while(!StackEmpty(ST));
}

//migong.cpp

#include "Basetype.h"
#include "stackoperation.cpp"
#include "Mazeoperation.cpp"

void main()
{

char filename[15];
FILE *fp;
printf("请输入迷宫数据文件名（长度不超过15个字符）：");
scanf("%s",&filename);
//如找不到文件，则要求重新输入（最多三次机会）
for(int i=0;i<3;i++){
if((fp = fopen(filename,"r")) == NULL)
{printf("不能打开文件,请重新输入文件名（长度不超过15个字符）：\n");
scanf("%s",filename);
}//if
break;
}//for
//读取迷宫的行数和列数
int rnum,cnum;
fscanf(fp,"%d,%d",&rnum,&cnum);
printf("这个迷宫有%d行，%d列\n",rnum,cnum);
if(rnum>RANGE-2 || cnum>RANGE-2)
{ printf("迷宫太大，无法求解\n");
return;
}//判断迷宫的大小是否符合要求
//初始化一个迷宫变量
MazeType maze;
for(i=0;i<=rnum+1;i++)
for(int j=0;j<=cnum+1;j++)
maze.arr[i][j] = '#';
CreatMaze(maze,rnum,cnum,fp);//创建迷宫
fclose(fp);//关闭迷宫文件
//打印当前迷宫
printf("当前迷宫为：\n");
for(i=0;i<=rnum+1;i++)
{ for(int j=0;j<=cnum+1;j++)
printf("%c",maze.arr[i][j]);
printf("\n");
}
printf("其中'#'表示障碍,外围一圈'#'为围墙\n");
//读取入口及出口位置
PosType startp,endp;
printf("请输入入口位置（两数中间以逗号相隔）：");
scanf("%d,%d",&startp.i,&startp.j);
printf("请输入出口位置（两数中间以逗号相隔）：");
scanf("%d,%d",&endp.i,&endp.j);
if(MazePath(maze,startp,endp))
{ PrintMaze(maze,rnum,cnum);//将求解的迷宫输出到文件保存，并打印到屏幕
PrintStack();//如果存在路径则打印之
}
else printf("此迷宫不存在路径\n");
}//main

//Mazeoperation.cpp

bool Pass(MazeType maze,PosType curpos)
{ //判断当前位置是否可通，并返回值
switch(char ch = maze.arr[curpos.i][curpos.j])
{ case' ': return(FALSE);
case'#':
case'@':
case'*': return(TURE);
default: { printf("迷宫中第%d行,第%d列出现不明字符%c\n",
curpos.i,curpos.j,ch);exit(0);}
}//switch
}//pass

void FootPrint(MazeType &maze,PosType curpos)
{
maze.arr[curpos.i][curpos.j] = '*';
}//FootPrint

void MarkPrint(MazeType &maze,PosType curpos)
{
maze.arr[curpos.i][curpos.j] = '@';
}//MarkPrint

void NextPos(PosType &curpos,int di)
{
switch(di)
{ case 1: curpos.j++;break;
case 2: curpos.i++;break;
case 3: curpos.j--;break;
case 4: curpos.i--;break;
default: printf("当前方向%d无效\n",di);
exit(0);
}//switch
}//NextPos

bool MazePath(MazeType &maze,PosType start,PosType end){
SElemType e;
InitStack(SqS);
PosType curpos = start;
int curstep = 1;
do{
if(!Pass(maze,curpos)){
FootPrint(maze,curpos);
e.order = curstep;
e.seat.i = curpos.i;e.seat.j = curpos.j;
e.di = 1;
Push(SqS,e);
if(curpos.i == end.i && curpos.j == end.j) return(TURE);
NextPos(curpos,1);
curstep++;
}//if
else{
if(!StackEmpty(SqS)){
Pop(SqS,e);
while(e.di == 4 && !StackEmpty(SqS)){
MarkPrint(maze,e.seat); Pop(SqS,e);
}//while
if(e.di<4){
e.di++; Push(SqS,e);
NextPos(e.seat,e.di);
curpos.i = e.seat.i;curpos.j = e.seat.j;
}//if
}//if
}//else
}while(!StackEmpty(SqS));
return(FALSE);
}//Mazepath

void CreatMaze(MazeType &maze,int row,int col,FILE *fp){
//建立迷宫
char ch = fgetc(fp);
for(int i=1;i<=row;i++)
{
for(int j=1;j<=col;j++)
{switch( ch = fgetc(fp))
{
case'0': maze.arr[i][j]=' ';break;
case'1': maze.arr[i][j]='#';break;
default: printf("迷宫第%d行第%d列数据为%c有错误",i,j,ch);exit(0);
}//switch

}//for

fseek(fp,2,1);
}//for
fclose(fp);
}//CreatMaze

void PrintMaze(MazeType maze,int row,int col)
{ //打印结果并输出到文件保存
FILE *out;
if((out = fopen("outfile","w"))==NULL)
{ printf("不能打开文件\n");
exit(0);
}//if
for(int i=0;i<=row+1;i++)
{for(int j=0;j<=col+1;j++)
{ fputc(maze.arr[i][j],out);
printf("%c",maze.arr[i][j]);
}
printf("\n");
}
printf("其中'*'号代表路径，'#'代表障碍,'@'代表死胡同\n");
fclose(out);//关闭文件
}

//Basetype.h

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

#define RANGE 30 //栈的存储空间初始分配量，
//以及用来存放迷宫的字符数组的最大维数
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define STACKINCREMENT 5 //栈的存储空间分配增量

typedef struct{
int i; //行坐标
int j; //列坐标
}PosType; //迷宫中坐标位置类型

//栈的定义
typedef struct{
int order; //通道块在路径上的“方向”
PosType seat; //通道块在迷宫中的“坐标位置”
int di; //从此通道块走向下一通道块的“方向”
}SElemType; //栈的元素类型
typedef struct{
SElemType *base; //栈底指针
SElemType *top; //栈顶指针
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack;

//迷宫的定义
typedef struct{
int m,n;
char arr[RANGE][RANGE];
}MazeType;

typedef int Status;

SqStack SqS; //定义一个栈

❹ C语言如何编写旋转矩阵源代码

这里以顺时针旋转90°为例：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#defineN4
voidmain()
{
	inti,j;
	inta[N*N],b[N][N];//这里设置旋转为4*4的矩形，自己在这里改成其它的矩形
	int*p=a;//用指针来指向这个一维数组。这样在旋转赋值的时候会轻松很多
	srand(time(NULL));
	for(i=0;i<N*N;i++)
	{
		a[i]=rand()%100;//随机生成0~99
		printf("%d	",a[i]);
		if((i+1)%4==0)
			printf("
");
	}

	for(i=N-1;i>=0;i--)	//旋转赋值，这里可修改旋转的方向和角度
		for(j=0;j<N;j++,p++)
			b[j][i]=*p;

	printf("顺时针旋转90度后：
");
	for(i=0;i<N;i++)	
	{for(j=0;j<N;j++)
			printf("%d	",b[i][j]);
		printf("
");
	}


}

这种旋转矩形的，个人建议生成一维数组，用指针指向改数组，再用指针来赋值；也可生成二维数组，再定义数组指针来指向，这样稍麻烦一些些。

❺ 谁有C语言，生成随机迷宫的代码

#include<stdio.h>
#include<conio.h>
#include<windows.h>
#include<time.h>
#defineHeight31//迷宫的高度，必须为奇数
#defineWidth25//迷宫的宽度，必须为奇数
#defineWall1
#defineRoad0
#defineStart2
#defineEnd3
#defineEsc5
#defineUp1
#defineDown2
#defineLeft3
#defineRight4
intmap[Height+2][Width+2];
voidgotoxy(intx,inty)//移动坐标
{
COORDcoord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord);
}
voidhidden()//隐藏光标
{
HANDLEhOut=GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFOcci;
GetConsoleCursorInfo(hOut,&cci);
cci.bVisible=0;//赋1为显示，赋0为隐藏
SetConsoleCursorInfo(hOut,&cci);
}
voidcreate(intx,inty)//随机生成迷宫
{
intc[4][2]={0,1,1,0,0,-1,-1,0};//四个方向
inti,j,t;
//将方向打乱
for(i=0;i<4;i++)
{
j=rand()%4;
t=c[i][0];c[i][0]=c[j][0];c[j][0]=t;
t=c[i][1];c[i][1]=c[j][1];c[j][1]=t;
}
map[x][y]=Road;
for(i=0;i<4;i++)
if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall)
{
map[x+c[i][0]][y+c[i][1]]=Road;
create(x+2*c[i][0],y+2*c[i][1]);
}
}
intget_key()//接收按键
{
charc;
while(c=getch())
{
if(c==27)returnEsc;//Esc
if(c!=-32)continue;
c=getch();
if(c==72)returnUp;//上
if(c==80)returnDown;//下
if(c==75)returnLeft;//左
if(c==77)returnRight;//右
}
return0;
}
voidpaint(intx,inty)//画迷宫
{
gotoxy(2*y-2,x-1);
switch(map[x][y])
{
caseStart:
printf("入");break;//画入口
caseEnd:
printf("出");break;//画出口
caseWall:
printf("※");break;//画墙
caseRoad:
printf("");break;//画路
}
}
voidgame()
{
intx=2,y=1;//玩家当前位置，刚开始在入口处
intc;//用来接收按键
while(1)
{
gotoxy(2*y-2,x-1);
printf("☆");//画出玩家当前位置
if(map[x][y]==End)//判断是否到达出口
{
gotoxy(30,24);
printf("到达终点，按任意键结束");
getch();
break;
}
c=get_key();
if(c==Esc)
{
gotoxy(0,24);
break;
}
switch(c)
{
caseUp://向上走
if(map[x-1][y]!=Wall)
{
paint(x,y);
x--;
}
break;
caseDown://向下走
if(map[x+1][y]!=Wall)
{
paint(x,y);
x++;
}
break;
caseLeft://向左走
if(map[x][y-1]!=Wall)
{
paint(x,y);
y--;
}
break;
caseRight://向右走
if(map[x][y+1]!=Wall)
{
paint(x,y);
y++;
}
break;
}
}
}
intmain()
{
inti,j;
srand((unsigned)time(NULL));//初始化随即种子
hidden();//隐藏光标
for(i=0;i<=Height+1;i++)
for(j=0;j<=Width+1;j++)
if(i==0||i==Height+1||j==0||j==Width+1)//初始化迷宫
map[i][j]=Road;
elsemap[i][j]=Wall;

create(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1));//从随机一个点开始生成迷宫，该点行列都为偶数
for(i=0;i<=Height+1;i++)//边界处理
{
map[i][0]=Wall;
map[i][Width+1]=Wall;
}

for(j=0;j<=Width+1;j++)//边界处理
{
map[0][j]=Wall;
map[Height+1][j]=Wall;
}
map[2][1]=Start;//给定入口
map[Height-1][Width]=End;//给定出口
for(i=1;i<=Height;i++)
for(j=1;j<=Width;j++)//画出迷宫
paint(i,j);
game();//开始游戏
getch();
return0;
}

❻ C语言 游戏 代码

“坑人的无限”（一）：

#include<iostream>
#include<windows.h>
#include<ctime>
#include<cstdlib>
#include<conio.h>
using namespace std;
int a;
class Screen
{
private:
int n;
public:
Screen()
{
n=5;
}
void move1()//注意只是循环输出各个数字，不能对循环输出再进行循环（如果对循环输出0123456789再进行循环，则move1就变成一个无限循环的函数，则下面的screen循环就进行不下去了）
{
for(int i=0;i<10;++i)
{
cout<<char(1)<<" ";
}
}
void move2()
{
char i;
for(i='a';i<='z';++i)
{
cout<<char(1)<<" ";
}
}
void screen()
{
int t;
while(!kbhit())
{
t=time(0)%(2*n);//如果是放在循环外面的话，time（0）的值就一直不变，放在循环里面，一秒钟进行一次判断，一秒钟进行一次循环
if(t<n)
move1();
else
move2();
}
}
};
int main(){
cout<<"欢迎来到“无限 ”游戏"<<char(1)<<endl;
cout<<"下面会输出无限个笑脸"<<char(1)<<endl;
cout<<"按'enter'取消"<<endl;
Sleep(4000);
Screen s;
s.screen();
cout<<endl<<"哈哈！！控制不住了吧！"<<char(1)<<endl;
cout<<"接下来会更让你丧心病狂的!"<<char(1)<<endl;
cout<<"但是坚持过后必有彩蛋！！！！！！加油！！";
cout<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;
Sleep(10000);
for(int as=0;as<=50;as++){
for(int i=0;i<=100;i++){
for(int j=0;j<=10;j++){
cout<<char(2)<<" ";
}
cout<<endl;
}
for(int i=0;i<=100;i++){
for(int j=0;j<=10;j++){
cout<<char(1)<<" ";
}
cout<<endl;
}
}
cout<<"你居然坚持下来了！"<<char(1)<<" "<<char(2)<<endl<<"不可思议呀！"<<endl;
for(int i=0;i<=10;i++){
cout<<"-----------------------------------------------"<<endl;
}
cout<<"敬请期待！等待无限游戏（二）！";
return 0;
}