老花眼猫

五子棋游戏程序禁手设置算法（C语言源码）

大家都玩过手机的小游戏吧。我是编程爱好者，喜欢动脑筋研究一些算法，编程做出小游戏程序，很有趣很有成就感。在学习VB6编程时就编制过钻石棋和伤脑筋十二块那样的游戏，都是标准Windows图形界面的。现在有空闲时就玩手机上编译手机游戏。

前些天我在站内发布了一款双人对弈版的五子棋游戏程序。接下来在研究人机对战的电脑智能应子算法，参阅很多五子棋书籍棋谱和五子棋竞赛的对抗棋谱。为了摆谱，就在此游戏程序上添加了复盘功能。程序没关闭就能复现出上一次的盘面。另外还加了记录功能和显示下子序号，每盘棋都列印黑白双方下子记录，界面上也显示记录。有一点就是程序关闭记录也就没了。解决的方法是把记录存为文本文件，需要时可作为复盘数据。

后来又发布了五子棋（AI智能版），今新发布五子棋游戏设置禁手的算法，这是基本的算法，供大家参考。

以下是引用的禁手规则（图）

禁手设置算法：
禁手有三种，即三三禁手和四四禁手，以及长连禁手。
三三禁手形态：00 1 0100， 00 1 100， 0 1 0010
四四禁手形态：00 1 1100 ， 00 1 1010， 0 1 0110
用遍历搜索算法按15 * 15 棋盘点位pn ( 1 -225 )，
分四个方向搜索，即左右，上下，右斜，斜左。遇黑子则计算加权分，赋100分值。此方法可减少计算量，无黑子位不计算。三三四四各形态同时搜索查验加权计算，一次遍历加权计分，最后查验加权分情况，超过100分的点位就是禁手点位。如有超过200分的情况就是三三四禁手。
长连禁手设置：在判胜负函数detect()时黑棋超过五连即是长连禁手，判黑负，白棋胜。
有一些特殊的形态如扁担阵暂不设置。此程序是简版，完整版本要全面设置。
代码中有显示计算的分值点标记，黄色是100分的点位，紫色是超过100分的点位，即禁手点位。这是测试算法时用来查看的，应用时可注释掉。
此算法是基本的算法，优点是简单和易于理解。

下面是禁手设置代码：
int js[255]; //禁手设置，遍历搜索225个点位
int jsset ; //有无禁手标志

white_do (){ //白棋下子时设置，检测禁手点位
< ............>
if (jsset==1) restrict_move () ;
//*** scan restricted move and draw mark
}//white_do ()

以下是禁手设置restrict_move () 代码：
restrict_move (){ //禁手设置
//黑棋禁手，加权计算查找
for (i=1;i<=225;i++) {
js[i]=0 ; } //scan init
//三三禁手，01010 此情况0位是可成三三的交点
//此点记100，若有两个三三，此点就计分200，
//超过100就是交叉点，即禁手点位，黑棋若下子即可判负
for (i=1;i<=15;i++){ //遍历scan 黑子
for (j=1;j<=15;j++){
k=(i-1)*15+j ; //pn(n) number
//三三禁手形 0 0 1 010 0, k前后和中间 0位计权
//两边为空中间可成活三，有子是假活三
if (pn[k]==1){ // scan B (k)
if (pn[k-1]==0&&pn[k+1]==0&&pn[k+2]==1&&pn[k+3]==0){
if ( pn[k-2]==0) js[k-1]= js[k-1]+100 ;
if (pn[k+4]==0) js[k+3]= js[k+3]+100 ;
if ( pn[k-2]==0&&pn[k+4]==0) {
js[k+1]= js[k+1]+100 ; } }//左右

if (pn[k-15]==0&&pn[k+15]==0&&pn[k+30]==1&&pn[k+45]==0){
if ( pn[k-30]==0) js[k-15]= js[k-15]+100 ;
if (pn[k+60]==0) js[k+45]= js[k+45]+100 ;
if ( pn[k-30]==0&&pn[k+60]==0) {
js[k+15]= js[k+15]+100 ; } }//上下

if (pn[k-14]==0&&pn[k+14]==0&&pn[k+28]==1&&pn[k+42]==0){
if ( pn[k-28]==0) js[k-14]= js[k-14]+100 ;
if (pn[k+56]==0) js[k+42]= js[k+42]+100 ;
if ( pn[k-28]==0&&pn[k+42]==0) {
js[k+14]= js[k+14]+100 ; } }//斜左

if (pn[k-16]==0&&pn[k+16]==0&&pn[k+32]==1&&pn[k+48]==0){
if ( pn[k-32]==0) js[k-16]= js[k-16]+100 ;
if (pn[k+64]==0) js[k+48]= js[k+48]+100 ;
if ( pn[k-32]==0&&pn[k+64]==0) {
js[k+16]= js[k+16]+100 ; } }//右斜
} //00 1 0100

//三三禁手形 00 1 100 , k前后 0位计权
if (pn[k]==1){ //scan B (k)
if (pn[k-1]==0&&pn[k+1]==1&&pn[k+2]==0){
if (pn[k-2]==0) js[k-2]= js[k-2]+100 ;
if (pn[k-2]==0) js[k-1]= js[k-1]+100 ;
js[k+2]= js[k+2]+100 ;
if (pn[k+3]==0) js[k+3]= js[k+3]+100 ; } //左右

if (pn[k-15]==0&&pn[k+15]==1&&pn[k+30]==0){
if (pn[k-30]==0) js[k-30]= js[k-30]+100 ;
if (pn[k-30]==0) js[k-15]= js[k-15]+100 ;
js[k+30]= js[k+30]+100 ;
if (pn[k+45]==0) js[k+45]= js[k+45]+100 ; } //上下

if (pn[k-14]==0&&pn[k+14]==1&&pn[k+28]==0){
if (pn[k-28]==0) js[k-28]= js[k-28]+100 ;
if (pn[k-28]==0) js[k-14]= js[k-14]+100 ;
if (j<12) js[k+28]= js[k+28]+100 ;
if (pn[k+42]==0) js[k+42]= js[k+42]+100 ; } //斜左

if (pn[k-16]==0&&pn[k+16]==1&&pn[k+32]==0){
if (pn[k-32]==0) js[k-32]= js[k-32]+100 ;
if (pn[k-32]==0) js[k-16]= js[k-16]+100 ;
js[k+32]= js[k+32]+100 ;
if (pn[k+48]==0) js[k+48]= js[k+48]+100 ; } //右斜
} //00 1 100

//三三禁手形 0 1 0010 , 中间 0位计权
if (pn[k]==1){ //scan B (k)
if (pn[k-1]==0&&pn[k+1]==0&&pn[k+2]==0&&pn[k+3]==1&&pn[k+4]==0){
js[k+1]= js[k+1]+100 ;
js[k+2]= js[k+2]+100 ; } //左右
if (pn[k-15]==0&&pn[k+15]==0&&pn[k+30]==0&&pn[k+45]==1&&pn[k+60]==0){
js[k+15]= js[k+15]+100 ;
js[k+30]= js[k+30]+100 ; } //上下
if (pn[k-14]==0&&pn[k+14]==0&&pn[k+28]==0&&pn[k+42]==1&&pn[k+56]==0){
js[k+14]= js[k+14]+100 ;
js[k+28]= js[k+28]+100 ; } //斜左
if (pn[k-16]==0&&pn[k+16]==0&&pn[k+32]==0&&pn[k+48]==1&&pn[k+64]==0){
js[k+16]= js[k+16]+100 ;
js[k+32]= js[k+32]+100 ; } //右斜
} //010010

//四四禁手算法同三三禁手
//四四禁手形 0 1 110 , 前后 0 位计权
if (pn[k]==1){ //scan B (k)
if (pn[k+1]==1&&pn[k+2]==1){
if (pn[k-2]==0&&pn[k-1]==0) js[k-1]= js[k-1]+100 ;
if (pn[k+3]==0&&pn[k+4]==0)js[k+3]= js[k+3]+100 ;
} //左右

if (pn[k+15]==1&&pn[k+30]==1){
if(pn[k-30]==0&&pn[k-15]==0) js[k-15]=js[k-15]+100 ;
if (pn[k+45]==0&&pn[k+60]==0)js[k+45]= js[k+45]+100 ;
} //上下

if (pn[k-14]==0&&pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==0){
if (pn[k-28]==0) js[k-14]= js[k-14]+100 ;
if (pn[k+56]==0)js[k+42]= js[k+42]+100 ;
if (pn[k+56]==0)js[k+56]= js[k+56]+100 ; } //斜左

if (pn[k-16]==0&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==0){
if (pn[k-32]==0) js[k-16]= js[k-16]+100 ;
if (pn[k+64]==0)js[k+48]= js[k+48]+100 ;
if (pn[k+64]==0)js[k+64]= js[k+64]+100 ; } //右斜
} //01110

//四四禁手形 0 1 1010 , 0 1 0110 前后 0 位计权
if (pn[k]==1){ //scan B (k)
if (pn[k-1]==0&&pn[k+1]==0&&pn[k+3]==1&&pn[k+4]==0){
if (pn[k+1]==0&&pn[k+2]==1)js[k+1]= js[k+1]+100 ;
if (pn[k+1]==1&&pn[k+2]==0)js[k+2]= js[k+2]+100 ;
} //左右

if (pn[k-15]==0&&pn[k+15]==0&&pn[k+45]==1&&pn[k+60]==0){
if (pn[k+15]==0&&pn[k+30]==1)js[k+15]= js[k+15]+100 ;
if (pn[k+15]==1&&pn[k+30]==0)js[k+30]= js[k+30]+100 ;
} //上下

if (pn[k-14]==0&&pn[k+14]==0&&pn[k+42]==1&&pn[k+56]==0){
if (pn[k+14]==0&&pn[k+28]==1)js[k+14]= js[k+14]+100 ;
if (pn[k+14]==1&&pn[k+28]==0)js[k+28]= js[k+28]+100 ;
} //斜左

if (pn[k-16]==0&&pn[k+16]==0&&pn[k+48]==1&&pn[k+64]==0){
if (pn[k+16]==0&&pn[k+32]==1)js[k+16]= js[k+16]+100 ;
if (pn[k+16]==1&&pn[k+32]==0)js[k+32]= js[k+32]+100 ;
} //右斜
} //0 1 1010 0 1 0110

//禁手的基本设置就这样，其他有些特殊的情况暂不设置，
// AI完整智能版需全设置。上述设置是个示例。
//长连禁手设置：在判胜负函数 detect () 时
// 黑棋超过五连即是长连禁手，判黑负，白棋胜。
} }//scan i , j
//****** 依据计权分标记禁手点位
cs.SetTextSize (16);
cs.SetTextStyle (0);
for (i=1;i<=225;i++){ //test restrict_move
if (js[i] !=0) { //Mark it
s=intToString ( js[i]) ;
dx=(i-(i/15*15))*40;
dy=(i/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
cs.SetColor (255,250,250,0) ;
cs.DrawCircle (dx,dy,3) ; //draw mark
if (js[i]>100){
cs.SetColor (255,180,0,180) ;
// cs.DrawText (s,dx-15,dy) ; //put js(i)
cs.DrawCircle (dx,dy,5) ; //draw mark
}
} }
cs.Update () ;
}//restrict_move ()

测试图例：

（以上是禁手设置算法设计和测试图）

下面提供五子棋游戏程序完整代码：

下面的游戏程序代码是用MySpringC写的，v2.7是目前最新版本。我是在安卓手机上编写的，可制作成安卓手机桌面app应用程序。此样例可复制黏贴到编译器直接使用，亦可用 VB6 ，VC，java 改写。

以下提供程序完整的源码：
// 最简单的 C 语言编程
// myspringc v2.7 可编译安卓本机 app 应用
// 此样例可复制黏贴到 myspringc 编译
// 此文档可用 VB6，VC ， java 改写
//**********************************
//**** 五子棋 Gobang AI ********
//**** 人机对战双人对奕 ********
//**********************************
Canvas cs; //画布
string sBarDes[10]; //按钮
int nBarId[10];
string sMenu[50]; //菜单
int nMenu[50];
float src[4]; //ClearDraw (cls) clear screen
int size[2]; //load picture size
string s1,s2,s3,s4,s5,s6,s7,s8 ; //显示
string s,ss,ss1,ss2,ss3,ss4;
int dx,dy; //draw X, Y
FileInput filebox; //file Input box
string fname; //filename
int i,j,t,a; //t = times
int pn[225]; // pn 0=" " , 1=black , 2=white
int n; // 225 棋子编码号
int px,py; // piece x,y
int context; //canvasProc 触控
int obj;
int id;
int event;
int dn,dn1 ; //下子计数
int isDo; //游戏操作控制 1=可下子，0=不可下
int B,W,k; //detect win Black White
string cordp,cordp1; //record pn & G9
int cord; //record switch
int mode; //0=人人，1=人机
int wn;
int sn;
int dwn[120]; //记录，下子60回合120子为和棋
int col,row ;
int cn,kn; //show record num
int gn ; //game round number
int fudat[200]; //复盘数据
int fusum; //复盘记录总数
int sd; //复盘
int jqn[255]; //计权数
int jqf,jqfn ; //计权分，优选点位码
int js[255]; //禁手设置
int jsset ; //s8 show restrict mark
//**********

main(){
setDisplay(1);
cs.SetBackground(200,200,200);
cs.Active();
sBarDes[0]="开始游戏";
nBarId[0]=100;
sBarDes[1]="选择模式";
nBarId[1]=101;
sBarDes[2]="黑棋下子";
nBarId[2]=102;
sBarDes[3]="白棋下子";
nBarId[3]=103;
sBarDes[4]="退出程序";
nBarId[4]=104;
sBarDes[5]="记录v";
nBarId[5]=105;
setToolBarHeight(6);
setButtonTextSize(13);
setToolBarBackgroundColor(255,220,220,220);
setButtonColor(255,0,0,240);
setButtonTextColor(255,255,255,0);
setToolBar(100,myToolBarProc,sBarDes,nBarId,6);

sMenu[0]="开始游戏";
nMenu[0]=200;
sMenu[1]="选择模式";
nMenu[1]=201;
sMenu[2]="悔棋";
nMenu[2]=202;
sMenu[3]="复盘";
nMenu[3]=203;
sMenu[4]="禁手设置";
nMenu[4]=204;
sMenu[5]="查看记录";
nMenu[5]=205;
sMenu[6]="显示棋板";
nMenu[6]=206;
sMenu[7]="退出";
nMenu[7]=207;
setMenu(200,myMenuProc,sMenu,nMenu,8);

setTitle("五子棋 (AI智能版) V.2.1.6 ");
//*************************
cs.SetProc (context, mycanvasProc);
mode=0 ;
s7="游戏模式：双人对奕";
wn=0 ; //测试演示
gn=0; //round number
jsset= 0 ; s8="无禁手" ;
gamestart (); //游戏初始界面
//draw title ****
ss3="五子棋 (AI智能版)";
cs.SetTextSize (60);
cs.SetTextStyle (1);
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor(255,160,60,40);
cs.DrawText (ss3,104,504);
cs.SetColor(255,0,250,0);
cs.DrawText (ss3,100,500);
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor(255,250,0,0);
cs.DrawText (ss3,100,500);
cs.Update();
while (){}
}//main ()

mycanvasProc (int context,int obj,int id,int event,float x,float y){
if (isDo==0) return ; //结束标志
kn=kn+1; //延时, 减少闪屏
if ((kn-kn/2*2)==0){ kn=0; }else{ return; }
board (); //redraw board
//** get chess pieces position X , Y
if (x>40&&x<610&&y>40&&y<610){
px=(int)(x/40)*40; //棋盘区棋位取整数
py=(int)(y/40)*40;
s=intToString (px);
s1= "px = "+s;
s=intToString (py);
s2= "py = "+s;
dx=px/40; dy=py/40;
s=intToString (dx);
s3= "dx = "+s;
s=intToString (dy);
s4= "dy = "+s;
n=(dy-1)*15+dx; //pn number
s5="选定落子位 >> "+intToString (n);
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor (255,250,0,0); //chess flag选子标记
cs.DrawRect (px-20,py-20,px+20,py+20);
}
//复盘和悔棋按钮
if (x>40&&x<180&&y>900&&y<960){
replay () ; } //复盘
if (x>210&&x<350&&y>900&&y<960){
undo () ; } //悔棋
if (x>380&&x<520&&y>900&&y<960){
if (mode==0) autotest () ; } //算法测试

cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,230,230,230); //clear n
cs.DrawRect (525,770,600,810);
// cs.SetColor(255,255,0,0);
// cs.SetTextSize (24);
//cs.DrawText (s1,50,700); //测试 dx , dy
//cs.DrawText (s2,50,740);
//cs.DrawText (s3,200,700);
//cs.DrawText (s4,200,740);
cs.SetColor(255,0,0,180);
cs.SetTextSize (30);
cs.DrawText (s5,330,800);
cs.Update ();
}//mycanvasProc

//AI智能下子算法求解方案：
//(一) 四连情况，黑棋下子，黑冲四嵌五，白必应子，若白无活四 022220 冲四 22220 02222 和嵌五 22022 22202 20222 则必应，有则先着取胜

//(二) 三连情况，黑棋下子，黑成活三嵌四，
// 若白无活三 02220 嵌四 2022 2202 则必应，
// 有则先着下子成活四

//(三) 二连情况，黑棋下子，
// 有活二 01100 嵌三 01010 基本都是这样，
// 二连应子：抢先手原则，白棋先找自己的活二嵌三
// 先下子成活三嵌四

//(四) 开局应首子，定标黑子 pn113，白应首子
// 大多棋谱是应上 pn98，上右 pn99，暂定此
// 白应起首三子：按棋谱法

//黑白双方博弈，加权计分，黑攻方进攻点就是白守方
//防守点。计分累加标记此点，乃此算法要点。
//将下面 testAIq ()算法分二部分，来测试一下

autotest (){
//用于检测AI智能下子算法 testAIq ()
//黑白棋用同一个算法下子很难区分算法的优劣，
//要设计二种算法分别以黑棋VS白棋才能显示出
//算法的优劣。下面代码只可检测算法的可行性。
s7="游戏模式：对战演示";
if (isDo==0||dn>120) return ; //结束标志,测试120子
if (mode==1) return ; //双人模式可演示
wn=wn+1 ;
if (dn==0) { //设定首子黑先天元位
n=113; black_do () ;
n=82 ; wn=0 ; //变换n 加以检测
white_do () ;
cs.Update () ; }
testAIq () ; //智能计权取得下子点位
if (wn>1) wn=0 ; //轮流下子
if (wn==1) white_do () ; //白棋下子
if (wn==0) black_do () ; //黑棋下子
detect () ;
}//autotest ()

restrict_set (){
jsset=jsset+1 ;
if (jsset>1) jsset=0 ;
if (jsset==0) s8="无禁手" ;
if (jsset==1) s8="有禁手" ;
board () ;
}//restrict_set()

restrict_move (){ //禁手
//黑棋禁手，加权计算查找
for (i=1;i<=225;i++) {
js[i]=0 ; } //scan init
//三三禁手，01010 此情况中间为可成三三的交点
//此点记100，若有两个三三，此点就计分200，
//即禁手点位，黑棋若下子即可判负
for (i=1;i<=15;i++){ //遍历scan 黑子
for (j=1;j<=15;j++){
k=(i-1)*15+j ; //pn(n) number
//三三禁手形 0 0 1 010 0, k前后 0位计权
//两边为空中间可成活三，有子是假活三
if (pn[k]==1){ // scan B (k)
if (pn[k-1]==0&&pn[k+1]==0&&pn[k+2]==1&&pn[k+3]==0){
if ( pn[k-2]==0) js[k-1]= js[k-1]+100 ;
if (pn[k+4]==0) js[k+3]= js[k+3]+100 ;
if ( pn[k-2]==0&&pn[k+4]==0) {
js[k+1]= js[k+1]+100 ; } }//左右

if (pn[k-15]==0&&pn[k+15]==0&&pn[k+30]==1&&pn[k+45]==0){
if ( pn[k-30]==0) js[k-15]= js[k-15]+100 ;
if (pn[k+60]==0) js[k+45]= js[k+45]+100 ;
if ( pn[k-30]==0&&pn[k+60]==0) {
js[k+15]= js[k+15]+100 ; } }//上下

} //00 1 0100

//禁手形 00 1 100 , k前后 0位计权
if (pn[k]==1){ //scan B (k)
if (pn[k-1]==0&&pn[k+1]==1&&pn[k+2]==0){
if (pn[k-2]==0) js[k-2]= js[k-2]+100 ;
if (pn[k-2]==0) js[k-1]= js[k-1]+100 ; //**
js[k+2]= js[k+2]+100 ;
if (pn[k+3]==0) js[k+3]= js[k+3]+100 ; } //左右

//禁手形 0 1 0010 , 中间 0位计权
if (pn[k]==1){ //scan B (k)
if (pn[k-1]==0&&pn[k+1]==0&&pn[k+2]==0&&pn[k+3]==1&&pn[k+4]==0){
js[k+1]= js[k+1]+100 ;
js[k+2]= js[k+2]+100 ; } //左右
if (pn[k-15]==0&&pn[k+15]==0&&pn[k+30]==0&&pn[k+45]==1&&pn[k+60]==0){
js[k+15]= js[k+15]+100 ;
js[k+30]= js[k+30]+100 ; } //上下
if (pn[k-14]==0&&pn[k+14]==0&&pn[k+28]==0&&pn[k+42]==1&&pn[k+56]==0){
js[k+14]= js[k+14]+100 ;
js[k+28]= js[k+28]+100 ; } //斜左
if (pn[k-16]==0&&pn[k+16]==0&&pn[k+32]==0&&pn[k+48]==1&&pn[k+64]==0){
js[k+16]= js[k+16]+100 ;
js[k+32]= js[k+32]+100 ; } //右斜
} //010010

if (pn[k+15]==1&&pn[k+30]==1){
if(pn[k-30]==0&&pn[k-15]==0) js[k-15]=js[k-15]+100 ;
if (pn[k+45]==0&&pn[k+60]==0)js[k+45]= js[k+45]+100 ;
} //上下

if (pn[k-14]==0&&pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==0){
if (pn[k-28]==0) js[k-14]= js[k-14]+100 ;
if (pn[k+56]==0)js[k+42]= js[k+42]+100 ;
if (pn[k+56]==0)js[k+56]= js[k+56]+100 ; } //斜左

if (pn[k-15]==0&&pn[k+15]==0&&pn[k+45]==1&&pn[k+60]==0){
if (pn[k+15]==0&&pn[k+30]==1)js[k+15]= js[k+15]+100 ;
if (pn[k+15]==1&&pn[k+30]==0)js[k+30]= js[k+30]+100 ;
} //上下

} //0 1 1010 0 1 0110

//禁手的基本设置就这样，其他有些特殊的情况暂不
//设置，AI完整智能版需全设置。上述设置是个示例。
//长连禁手设置：在判胜负函数 detect () 时
// 黑棋超过五连即判黑负，白棋胜。
} }//scan i , j
//**********
cs.SetTextSize (16);
cs.SetTextStyle (0);
for (i=1;i<=225;i++){ //test restrict_move
if (js[i] !=0) { //Mark it
s=intToString ( js[i]) ;
dx=(i-(i/15*15))*40;
dy=(i/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
cs.SetColor (255,250,250,0) ;
cs.DrawCircle (dx,dy,3) ; //draw mark
if (js[i]>100){
cs.SetColor (255,180,0,180) ;
// cs.DrawText (s,dx-15,dy) ; //put js(i)
cs.DrawCircle (dx,dy,5) ; //draw mark
}
} }
cs.Update () ;
}//restrict_move ()

testAIq (){
//人机对战AI选子，加权计算
for (i=1;i<=225;i++) {
jqn[i]=0 ; } //scan init
//遍历加权
for (i=1;i<=15;i++){ //遍历scan B & W 子
for (j=1;j<=15;j++){
k=(i-1)*15+j ; //pn(n) number
//独子左右上下二对角八方
if (pn[k]==2){
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+20 ;
if (pn[k+1]==0) jqn[k+1]= jqn[k+1]+20 ;
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+20 ;
if (pn[k+15]==0) jqn[k+15]= jqn[k+15]+20 ;
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+20 ;
if (pn[k+16]==0) jqn[k+16]= jqn[k+16]+20 ;
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+20 ;
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+20 ;
}//pn
//连二
if (pn[k]==2&&pn[k+1]==2){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+520 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+520 ; }

if (pn[k]==2&&pn[k+15]==2){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+520 ;
if (pn[k+30]==0) jqn[k+30]= jqn[k+30]+520 ; }

if (pn[k]==2&&pn[k+14]==2){ //左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+520 ;
if (pn[k+28]==0) jqn[k+28]= jqn[k+28]+520 ; }

if (pn[k]==2&&pn[k+16]==2){ //右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+520 ;
if (pn[k+32]==0) jqn[k+32]= jqn[k+32]+520 ; }

//嵌三 02020 +1020 为活三冲四进攻点
if (pn[k]==2&&pn[k+1]==0&&pn[k+2]==2){ //左右
jqn[k+1]= jqn[k+1]+520 ;
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+1020 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+1020 ; }

if (pn[k]==2&&pn[k+15]==0&&pn[k+30]==2){ //上下
jqn[k+15]= jqn[k+15]+520 ;
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+1020 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+1020 ; }

if (pn[k]==2&&pn[k-14]==0&&pn[k-28]==2){//左对角
jqn[k-14]= jqn[k-14]+520 ;
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+1020 ;
if (pn[k-42]==0) jqn[k-42]= jqn[k-42]+1020 ; }

if (pn[k]==2&&pn[k+16]==0&&pn[k+32]==2){//右对角
jqn[k+16]= jqn[k+16]+520 ;
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+1020 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+1020 ; }

//三连，眠三抢冲四 12220 02221
if (pn[k]==2&&pn[k+1]==2&&pn[k+2]==2){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+2320 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+2320 ; }
if (pn[k]==2&&pn[k+15]==2&&pn[k+30]==2){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+2320 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+2320 ; }
if (pn[k]==2&&pn[k-14]==2&&pn[k-28]==2){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+2320 ;
if (pn[k-42]==0) jqn[k-42]= jqn[k-42]+2320 ; }
if (pn[k]==2&&pn[k+16]==2&&pn[k+32]==2){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+2320 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+2320 ; }

//三连，活三变活四，必杀 0022200 +2000
if ( pn[k-2]==0&&pn[k-1]==0&&pn[k]==2&&pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==0&&pn[k+4]==0){ //左右
jqn[k-1]= jqn[k-1]+3500 ;
jqn[k+3]= jqn[k+3]+3500 ; }

if (pn[k-30]==0&&pn[k-15]==0&&pn[k]==2&&pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==0&&pn[k+60]==0){ //上下
jqn[k-15]= jqn[k-15]+3500 ;
jqn[k+45]= jqn[k+45]+3500 ; }

if(pn[k-28]==0&&pn[k-14]==0&&pn[k]==2&&pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==0&&pn[k+56]==0){//左对角
jqn[k-14]= jqn[k-14]+3500 ;
jqn[k+42]= jqn[k+42]+3500 ; }

if (pn[k-32]==0&&pn[k-16]==0&&pn[k]==2&&pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==0&&pn[k+64]==0){//右对角
jqn[k-16]= jqn[k-16]+3500 ;
jqn[k+48]= jqn[k+48]+3500 ; }
//*********
//白子算杀，做杀，找活三嵌四交点 +2500

//嵌四类做冲四 2022 2202 布杀点 +1800
// 120220 122020 020221 022021
if (j<12){
if (pn[k]==2&&pn[k+1]==0&&pn[k+2]==2&&pn[k+3]==2){ //左右
if (pn[k-1]==0||pn[k+4]==0){ jqn[k+1]= jqn[k+1]+1800 ; } }
if (pn[k]==2&&pn[k+1]==2&&pn[k+2]==0&&pn[k+3]==2){ //左右
if (pn[k-1]==0||pn[k+4]==0){ jqn[k+2]= jqn[k+2]+1800 ; } }
} //j<12

if (i<12){
if (pn[k]==2&&pn[k+15]==0&&pn[k+30]==2&&pn[k+45]==2){ //上下
if (pn[k-15]==0||pn[k+60]==0){ jqn[k+15]= jqn[k+15]+1800 ; } }
if (pn[k]==2&&pn[k+15]==2&&pn[k+30]==0&&pn[k+45]==2){ //上下
if (pn[k-15]==0||pn[k+60]==0){ jqn[k+30]= jqn[k+30]+1800 ; } }
} //i<12

if(j>4&&i<12){
if (pn[k]==2&&pn[k+14]==0&&pn[k+28]==2&&pn[k+42]==2){ //斜左
if (pn[k-14]==0||pn[k+56]==0){ jqn[k+14]= jqn[k+14]+1800 ; } }
if (pn[k]==2&&pn[k+14]==2&&pn[k+28]==0&&pn[k+42]==2){ //斜左
if (pn[k-14]==0||pn[k+56]==0){jqn[k+28]= jqn[k+28]+1800 ; } }
} //j>4, i<12

if (j<12&&i<12){
if (pn[k]==2&&pn[k+16]==0&&pn[k+32]==2&&pn[k+48]==2){ //右斜
if (pn[k-16]==0||pn[k+64]==0){ jqn[k+16]= jqn[k+16]+1800 ; } }
if (pn[k]==2&&pn[k+16]==2&&pn[k+32]==0&&pn[k+48]==2){ //右斜
if (pn[k-16]==0||pn[k+64]==0){ jqn[k+32]= jqn[k+32]+1800 ; } }
} //i<12&&j<12

//嵌四 020220 022020 必杀点+3500 j<12 防越界
if (j<12){
if ( pn[k-1]==0&&pn[k]==2&&pn[k+1]==0&&pn[k+2]==2&&pn[k+3]==2&&pn[k+4]==0){ //左右
jqn[k+1]= jqn[k+1]+3500 ; }
if ( pn[k-1]==0&&pn[k]==2&&pn[k+1]==2&&pn[k+2]==0&&pn[k+3]==2&&pn[k+4]==0){ //左右
jqn[k+2]= jqn[k+2]+3500 ; } }

if (i<12){
if ( pn[k-15]==0&&pn[k]==2&&pn[k+15]==0&&pn[k+30]==2&&pn[k+45]==2&&pn[k+60]==0){ //上下
jqn[k+15]= jqn[k+15]+3500 ; }
if ( pn[k-15]==0&&pn[k]==2&&pn[k+15]==2&&pn[k+30]==0&&pn[k+45]==2&&pn[k+60]==0){ //上下
jqn[k+30]= jqn[k+30]+3500 ; } }

if (j>4&&i<12){
if ( pn[k-14]==0&&pn[k]==2&&pn[k+14]==0&&pn[k+28]==2&&pn[k+42]==2&&pn[k+56]==0){ //斜左
jqn[k+14]= jqn[k+14]+3500 ; }
if ( pn[k-14]==0&&pn[k]==2&&pn[k+14]==2&&pn[k+28]==0&&pn[k+42]==2&&pn[k+56]==0){ //斜左
jqn[k+28]= jqn[k+28]+3500 ; } }

if (j<12&&i<12){
if ( pn[k-16]==0&&pn[k]==2&&pn[k+16]==0&&pn[k+32]==2&&pn[k+48]==2&&pn[k+64]==0){ //右斜
jqn[k+16]= jqn[k+16]+3500 ; }
if ( pn[k-16]==0&&pn[k]==2&&pn[k+16]==2&&pn[k+32]==0&&pn[k+48]==2&&pn[k+64]==0){ //右斜
jqn[k+32]= jqn[k+32]+3500 ; } }

//活四冲四 022220 122220 022221
//此是必杀点 +9000 j<12 防越界
if (pn[k]==2&&pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==2){ //左右
if (j>1&&pn[k-1]==0) jqn[k-1]= jqn[k-1]+9000 ;
if (j<12&&pn[k+4]==0) jqn[k+4]= jqn[k+4]+9000 ; }

if (pn[k]==2&&pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==2){ //上下
if (i>1&&pn[k-15]==0) jqn[k-15]= jqn[k-15]+9000 ;
if (i<12&&pn[k+60]==0) jqn[k+60]= jqn[k+60]+9000 ; }

if(pn[k]==2&&pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==2){//左对角
if (i>4&&j<14&&pn[k-14]==0) jqn[k-14]= jqn[k-14]+9000 ;
if (i<12&&j>4&&pn[k+56]==0) jqn[k+56]= jqn[k+56]+9000 ; }

if (pn[k]==2&&pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==2){//右对角
if (j>1&&i<12&&pn[k-16]==0) jqn[k-16]= jqn[k-16]+9000 ;
if (j<12&&i<12&&pn[k+64]==0) jqn[k+64]= jqn[k+64]+9000 ; }

//嵌五，此是必杀点 20222 22022 22202 +9000
if (j<12){ // j<12 防越界
if ( pn[k]==2&&pn[k+1]==0&&pn[k+2]==2&&pn[k+3]==2&&pn[k+4]==2){ //左右 20222
jqn[k+1]= jqn[k+1]+9000 ; }
if ( pn[k]==2&&pn[k+1]==2&&pn[k+2]==0&&pn[k+3]==2&&pn[k+4]==2){ //左右 22022
jqn[k+2]= jqn[k+2]+9000 ; }
if ( pn[k]==2&&pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==0&&pn[k+4]==2){ //左右 22202
jqn[k+3]= jqn[k+3]+9000 ; } } //j<12

if (i<12){
if ( pn[k]==2&&pn[k+15]==0&&pn[k+30]==2&&pn[k+45]==2&&pn[k+60]==2){ //上下 20222
jqn[k+15]= jqn[k+15]+9000 ; }
if ( pn[k]==2&&pn[k+15]==2&&pn[k+30]==0&&pn[k+45]==2&&pn[k+60]==2){ //上下 22022
jqn[k+30]= jqn[k+30]+9000 ; }
if ( pn[k]==2&&pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==0&&pn[k+60]==2){ //上下 22202
jqn[k+45]= jqn[k+45]+9000 ; } } //i<12

if (j>4&&i<12){
if ( pn[k]==2&&pn[k+14]==0&&pn[k+28]==2&&pn[k+42]==2&&pn[k+56]==2){ //斜左 20222
jqn[k+14]= jqn[k+14]+9000 ; }
if ( pn[k]==2&&pn[k+14]==2&&pn[k+28]==0&&pn[k+42]==2&&pn[k+56]==2){ //斜左 22022
jqn[k+28]= jqn[k+28]+9000 ; }
if ( pn[k]==2&&pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==0&&pn[k+56]==2){ //斜左 22202
jqn[k+42]= jqn[k+42]+9000 ; } }

if (j<12&&i<12){
if ( pn[k]==2&&pn[k+16]==0&&pn[k+32]==2&&pn[k+48]==2&&pn[k+64]==2){ //右斜 20222
jqn[k+16]= jqn[k+16]+9000 ; }
if ( pn[k]==2&&pn[k+16]==2&&pn[k+32]==0&&pn[k+48]==2&&pn[k+64]==2){ //右斜 22022
jqn[k+32]= jqn[k+32]+9000 ; }
if ( pn[k]==2&&pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==0&&pn[k+64]==2){ //右斜 22202
jqn[k+48]= jqn[k+48]+9000 ; } }

//****************************
//以下是黑棋估权计分
//独子左右上下二对角八方
if (pn[k]==1){
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+20 ;
if (pn[k+1]==0) jqn[k+1]= jqn[k+1]+20 ;
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+20 ;
if (pn[k+15]==0) jqn[k+15]= jqn[k+15]+20 ;
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+20 ;
if (pn[k+16]==0) jqn[k+16]= jqn[k+16]+20 ;
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+20 ;
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+20 ;
}//pn
//连二
if (pn[k]==1&&pn[k+1]==1){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+500 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+500 ; }
if (pn[k]==1&&pn[k+15]==1){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+500 ;
if (pn[k+30]==0) jqn[k+30]= jqn[k+30]+500 ; }
if (pn[k]==1&&pn[k+14]==1){ //左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+500 ;
if (pn[k+28]==0) jqn[k+28]= jqn[k+28]+500 ; }
if (pn[k]==1&&pn[k+16]==1){ //右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+500 ;
if (pn[k+32]==0) jqn[k+32]= jqn[k+32]+500 ; }
//嵌三 02020
if (pn[k]==1&&pn[k+1]==0&&pn[k+2]==1){ //左右
jqn[k+1]= jqn[k+1]+500 ; }
if (pn[k]==1&&pn[k+15]==0&&pn[k+30]==1){ //上下
jqn[k+15]= jqn[k+15]+500 ; }
if (pn[k]==1&&pn[k+14]==0&&pn[k+28]==1){//左对角
jqn[k+14]= jqn[k+14]+500 ; }
if (pn[k]==1&&pn[k+16]==0&&pn[k+32]==1){//右对角
jqn[k+16]= jqn[k+16]+500 ; }

//三连，眠三12220 02221 逢三必堵
if (pn[k]==1&&pn[k+1]==1&&pn[k+2]==1){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+3000 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+3000 ; }
if (pn[k]==1&&pn[k+15]==1&&pn[k+30]==1){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+3000 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+3000 ; }

if (pn[k]==1&&pn[k-14]==1&&pn[k-28]==1){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+3000 ;
if (pn[k-42]==0) jqn[k-42]= jqn[k-42]+3000 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+3050 ;
if (pn[k-30]==0) jqn[k-30]= jqn[k-30]+3050 ;
} //破梅花阵
if (pn[k]==1&&pn[k+16]==1&&pn[k+32]==1){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+3000 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+3000 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+3050 ;
if (pn[k+30]==0) jqn[k+30]= jqn[k+30]+3050 ;
} //破梅花阵

//三连，活三 01110 逢三必堵
if ( pn[k-1]==0&&pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==0){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+3300 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+3300 ; }

if (pn[k-15]==0&&pn[k]==1&&pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==0){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+3300 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+3300 ; }

if (pn[k-14]==0&&pn[k]==1&&pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==0){//左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+3300 ;
if (pn[k+42]==0) jqn[k+42]= jqn[k+42]+3300 ; }

if (pn[k-16]==0&&pn[k]==1&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==0){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+3300 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+3300 ; }

//嵌四 010110 011010 必杀点 +3500
if ( pn[k-1]==0&&pn[k]==1&&pn[k+1]==0&&pn[k+2]==1&&pn[k+3]==1&&pn[k+4]==0){ //左右
jqn[k+1]= jqn[k+1]+3500 ; }
if ( pn[k-1]==0&&pn[k]==1&&pn[k+1]==1&&pn[k+2]==0&&pn[k+3]==1&&pn[k+4]==0){ //左右
jqn[k+2]= jqn[k+2]+3500 ; }

if ( pn[k-15]==0&&pn[k]==1&&pn[k+15]==0&&pn[k+30]==1&&pn[k+45]==1&&pn[k+60]==0){ //上下
jqn[k+15]= jqn[k+15]+3500 ; }
if ( pn[k-15]==0&&pn[k]==1&&pn[k+15]==1&&pn[k+30]==0&&pn[k+45]==1&&pn[k+60]==0){ //上下
jqn[k+30]= jqn[k+30]+3500 ; }

if ( pn[k-14]==0&&pn[k]==1&&pn[k+14]==0&&pn[k+28]==1&&pn[k+42]==1&&pn[k+56]==0){ //斜左
jqn[k+14]= jqn[k+14]+3500 ; }
if ( pn[k-14]==0&&pn[k]==1&&pn[k+14]==1&&pn[k+28]==0&&pn[k+42]==1&&pn[k+56]==0){ //斜左
jqn[k+28]= jqn[k+28]+3500 ; }

if ( pn[k-16]==0&&pn[k]==1&&pn[k+16]==0&&pn[k+32]==1&&pn[k+48]==1&&pn[k+64]==0){ //右斜
jqn[k+16]= jqn[k+16]+3500 ; }
if ( pn[k-16]==0&&pn[k]==1&&pn[k+16]==1&&pn[k+32]==0&&pn[k+48]==1&&pn[k+64]==0){ //右斜
jqn[k+32]= jqn[k+32]+3500 ; }

//活四冲四此是必杀点 211110 011112 +6000
//黑有此白必堵，此是必杀点如白无连五则必应
if ( pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==1){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+7000 ;
if (pn[k+4]==0) jqn[k+4]= jqn[k+4]+7000 ; }

if (pn[k]==1&&pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==1){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+7000 ;
if (pn[k+60]==0) jqn[k+60]= jqn[k+60]+7000 ; }
if(pn[k]==1&&pn[k-14]==1&&pn[k-28]==1&&pn[k-42]==1){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+7000 ;
if (pn[k-56]==0) jqn[k-56]= jqn[k-56]+7000 ; }

if (pn[k]==1&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==1){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+7000 ;
if (pn[k+64]==0) jqn[k+64]= jqn[k+64]+7000 ; }

//嵌五 10111 11011 11101 +6000
//此是必杀点如白无连五则必应
if ( pn[k]==1&&pn[k+1]==0&&pn[k+2]==1&&pn[k+3]==1&&pn[k+4]==1){ //左右 10111
jqn[k+1]= jqn[k+1]+7000 ; }
if ( pn[k]==1&&pn[k+1]==1&&pn[k+2]==0&&pn[k+3]==1&&pn[k+4]==1){ //左右 11011
jqn[k+2]= jqn[k+2]+7000 ; }
if ( pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==0&&pn[k+4]==1){ //左右 11101
jqn[k+3]= jqn[k+3]+7000 ; }

if ( pn[k]==1&&pn[k+15]==0&&pn[k+30]==1&&pn[k+45]==1&&pn[k+60]==1){ //上下 10111
jqn[k+15]= jqn[k+15]+7000 ; }
if ( pn[k]==1&&pn[k+15]==1&&pn[k+30]==0&&pn[k+45]==1&&pn[k+60]==1){ //上下 11011
jqn[k+30]= jqn[k+30]+7000 ; }
if ( pn[k]==1&&pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==0&&pn[k+60]==1){ //上下 11101
jqn[k+45]= jqn[k+45]+7000 ; }

if ( pn[k]==1&&pn[k+14]==0&&pn[k+28]==1&&pn[k+42]==1&&pn[k+56]==1){ //斜左 10111
jqn[k+14]= jqn[k+14]+7000 ; }
if ( pn[k]==1&&pn[k+14]==1&&pn[k+28]==0&&pn[k+42]==1&&pn[k+56]==1){ //斜左 11011
jqn[k+28]= jqn[k+28]+7000 ; }
if ( pn[k]==1&&pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==0&&pn[k+56]==1){ //斜左 11101
jqn[k+42]= jqn[k+42]+7000 ; }

if ( pn[k]==1&&pn[k+16]==0&&pn[k+32]==1&&pn[k+48]==1&&pn[k+64]==1){ //右斜 10111
jqn[k+16]= jqn[k+16]+7000 ; }
if ( pn[k]==1&&pn[k+16]==1&&pn[k+32]==0&&pn[k+48]==1&&pn[k+64]==1){ //右斜 11011
jqn[k+32]= jqn[k+32]+7000 ; }
if ( pn[k]==1&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==0&&pn[k+64]==1){ //右斜 11101
jqn[k+48]= jqn[k+48]+7000 ; }

} } //test i , j pn(225) 棋盘点位

//******************************
//测试：显示加权计分情况，最高分白下子
if (isDo==0) return ;
cs.SetTextSize (16);
cs.SetTextStyle (0);
cs.SetColor (255,0,150,0) ;
for (i=1;i<=225;i++){ //test scan
if (jqn[i] !=0) {
//print i," qn= ",jqn[i] ; //测试
s=intToString ( jqn[i]) ;
dx=(i-(i/15*15))*40;
dy=(i/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
cs.DrawText (s,dx,dy) ; //draw jqn(i)
} }

//计算最高分
jqf=0 ;
for (i=1;i<=225;i++){
k= jqn[i] ;
if ( k>jqf) { jqf=k ; jqfn=i ; }
} //计算最高分

sn=jqfn ; //计权最高分点位转坐标
if (dn==1) {
if (gn==1) sn=98 ;
if (gn==2) sn=97 ;
if (gn==3) sn=99 ; }
// print " sn= ",jqfn ," jqf= ",jqf ;
dx=(sn-(sn/15*15))*40;
dy=(sn/15)*40+40;
if (dx==0) {dx=15*40; dy=dy-40; }
cs.SetColor (255,250,250,0);
cs.DrawCircle (dx,dy,5); //标记下子点
cs.Update () ;
// sleep (500) ;
n=sn ; //下子点号sn转换为n, draw board
px=dx ; py=dy ; //board ()标记下子点
//**** AI 走子 **********************
}//testAIq ()

swapabc (){
string abc$ ;
abc$="sABCDEFGHIJKLMNO" ;
ss=subString (abc$,col,1) ;
}//swapabc ()

black_do (){ //黑棋下子
pn[n]=1;
s6="白棋选子";
row=15-(n/15) ;
col=(n-(n/15*15)) ;
if (col==0){ col=15 ; row=row+1 ; }
swapabc () ; //return ss
cordp=" B "+intToString (n); //走子记录
cordp1=" B "+ss+intToString (row) ;
if (cordp != ss2) { //不重复记录
dn=dn+1; //print dn;
print dn," ",cordp," " , ss,row ; //打印记录
ss2=cordp;
dwn[dn]=n ; //print play number
fudat[dn]=n; fusum=dn; //复盘数据
s5="选定落子位 >> "+intToString (n);
board ();
}
testAIq (); //test AI 计权白子点位下子 **

if (mode==1) { //人机模式下子
white_do () ; } // AI Do 白下子
}//black_do ()

white_do (){ //白棋下子
if (isDo==0) return ;
pn[n]=2;
s6="黑棋选子";
row=15-(n/15) ;
col=(n-(n/15*15)) ;
if (col==0){ col=15 ; row=row+1 ; }
swapabc () ; //return ss
cordp=" W "+intToString (n); //走子记录
cordp1="W "+ss+intToString (row) ;
if (cordp != ss2) {
dn=dn+1;
print dn," ",cordp," " , ss,row ; //打印记录
ss2=cordp;
dwn[dn]=n ; //print play number
fudat[dn]=n; fusum=dn; //复盘数据
s5="选定落子位 >> "+intToString (n);
board () ;
}
if (jsset==1) restrict_move () ;
//scan restricted move and draw mark
}//white_do ()

board (){
if (isDo==0) return ; //结束标志
// draw board grids 棋盘方格
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,250,250,250); //backcolor
cs.DrawRect (0,0,650,850);
cs.SetColor (255,110,110,110); //pad
cs.DrawRect (10,10,637,638);
cs.SetColor (255,220,150,50); //pad
cs.DrawRect (8,8,632,632);
cs.SetColor (255,250,180,100); //pad
cs.DrawRect (20,20,620,620);
cs.SetFillMode (0);//0不填色，1填色
for (i=1;i<15;i++){ //draw grids
for (j=1;j<15;j++){
cs.SetColor (255,150,150,150); //grid color
cs.DrawRect(i*40-1,j*40-1,i*40+39,j*40+39);
cs.SetColor (255,250,250,250); //grid color
cs.DrawRect(i*40,j*40,i*40+40,j*40+40);
} }
cs.SetColor (255,0,0,0); // rectangle line
cs.DrawRect (21,21,620,620);
cs.DrawRect (20,20,620,620);

//draw flag points
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,140,140,140); //
cs.DrawCircle(160,160,5); //星
cs.DrawCircle(480,160,5);
cs.DrawCircle(160,480,5);
cs.DrawCircle(480,480,5);
cs.DrawCircle(320,320,5); //中元
cs.SetColor (255,240,240,240); //
cs.DrawCircle(161,161,5); //星
cs.DrawCircle(481,161,5);
cs.DrawCircle(161,481,5);
cs.DrawCircle(481,481,5);
cs.DrawCircle(321,321,5); //中元
// 绘出棋盘坐标编码
cs.SetColor (255,180,80,50);
cs.SetTextStyle (1);
cs.SetTextSize (14);
string abc$ ;
abc$="sABCDEFGHIJKLMNO" ;
a=0 ; //set print tab
for (i=1;i<=15;i++){
ss1=intToString (i) ;
if (i>9) a=4 ; //tab for print number
cs.DrawText (ss1,25-a,645-i*40) ;
ss=subString (abc$,i,1) ;
cs.DrawText (ss,i*40-4,615) ; }
//draw button 绘制按钮
cs.SetColor (255,250,250,250);
cs.DrawRect (40,900,181,961);
cs.DrawRect (210,900,351,961);
cs.DrawRect (380,900,521,961);
cs.SetColor (255,250,0,0);
for (i=1;i<60;i++){ //按钮渐变色
cs.SetColor (255,240-i*4,240-i*3,250-i*4);
cs.DrawLine (41,900+i,180,900+i);
cs.DrawLine (211,900+i,350,900+i);
cs.DrawLine (381,900+i,520,900+i);
}
cs.SetColor(255,255,250,0);
cs.SetTextStyle (1);
cs.SetTextSize (32);
cs.DrawText ("复盘",72,940);
cs.DrawText ("悔棋",242,940);
cs.DrawText ("演示",412,940);
//print title
cs.SetTextSize (80);
cs.SetTextStyle (1);
cs.SetColor (255,100,100,100);
cs.DrawText ("五子棋",50,770);
cs.DrawText ("Gobang",50,870);
cs.SetColor (255,220,220,220);
cs.DrawText ("五子棋",52,772);
cs.DrawText ("Gobang",52,872);

for (i=1;i<=225;i++){
//draw chess pieces 画出已下黑白子
dx=(i-(i/15*15))*40;
dy=(i/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
if ( pn[i]==2){ //white
cs.SetColor (255,140,80,40); //piecesW
cs.DrawCircle(dx+2,dy+2,17);
cs.SetColor (255,220,220,220); //pieceW
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,250,250,250); //pieceW
cs.DrawCircle(dx-6,dy-6,2); }
if (pn[i]==1){ //black
cs.SetColor (255,220,100,40); //piecesB
cs.DrawCircle(dx+1,dy+1,17);
cs.SetColor (255,0,0,0); //pieceB
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,200,200,200); //pieceB
cs.DrawCircle(dx-6,dy-6,2); }
} //draw chess pieces
cs.SetColor (255,240,0,0); //刚落子标记
cs.DrawCircle(px,py,5);
//提示选子
cs.SetTextSize (42);
cs.SetColor(255,255,120,250);
cs.DrawRect (390,670,600,740);
cs.SetColor(255,255,250,0);
cs.DrawText (s6,415,720); //pn(n) num

cs.SetTextSize (36);
if (mode==0) cs.SetColor(255,205,200,80);
if (mode==1) cs.SetColor(255,250,150,0);
cs.DrawText (s7,20,680); //mode
cs.SetTextSize (24);
cs.SetColor(255,220,120,80);
cs.DrawText (s8,530,840); //restrict
cs.SetTextStyle (0);
cs.SetTextSize (16);
cs.SetColor(255,255,250,250);
cs.DrawText (cordp1,665,dn*15); //record _G8

//draw pieces number 画出下子序号*****
for (i=1;i<=dn;i++){
cn=i ;
s=intToString(cn) ;
kn=dwn[i] ;
dx=(kn-(kn/15*15))*40;
dy=(kn/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
cs.SetTextSize (16);
cs.SetColor (255,0,160,0);
cs.DrawText (s,dx-5,dy+11);
}
cs.Update ();
detect (); //检测胜负
}//board ()

detect (){
//detect Black chess 判胜 ******
for (i=1;i<16;i++){ // B 黑子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==1&&pn[k+4]==1){
if (pn[k+5]==1) pn[k]=2 ; //超五连，禁手白胜
goto showwin ; } //右
} } }
for (i=1;i<12;i++){ // B 黑子
for (j=1;j<16;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==1&&pn[k+60]==1){
if (pn[k+75]==1) pn[k]=2 ; //超五连，禁手白胜
goto showwin ; } //下
} } }
for (i=1;i<12;i++){ // B 黑子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==1&&pn[k+64]==1){
if (pn[k+80]==1) pn[k]=2 ; //超五连，禁手白胜
goto showwin ; } //右斜
} } }
for (i=1;i<12;i++){ // B 黑子
for (j=5;j<16;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==1&&pn[k+56]==1){
if (pn[k+70]==1) pn[k]=2 ; //超五连，禁手白胜
goto showwin ; } //斜左
} } }

//********************************
//detect White chess 判胜 ******
for (i=1;i<16;i++){ // W 白子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==2&&pn[k+4]==2){ goto showwin ; } //右
} } }
for (i=1;i<12;i++){ // W 白子
for (j=1;j<16;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==2&&pn[k+60]==2){ goto showwin ; } //下
} } }
for (i=1;i<12;i++){ // W 白子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==2&&pn[k+64]==2){ goto showwin ; } //右斜
} } }
for (i=1;i<12;i++){ // W 白子
for (j=5;j<16;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==2&&pn[k+56]==2){ goto showwin ; } //斜左
} } }
//*****************************
if (pn[n]==1&&js[n]==200){ //禁手，判白棋胜
ss="白棋胜 !"; goto heqi; }
if (dn>100) {
ss="( 和棋 )"; goto heqi; }
return;
//show win flag 判胜负
showwin:
cs.SetTextStyle (0);
cs.SetTextSize (16);
if (pn[k]==1) {
ss="黑棋胜 !"; print ss;
cs.SetColor(255,255,250,250);
cs.DrawText (ss,655,(dn+2)*16); }
if (pn[k]==2) {
ss="白棋胜 !"; print ss;
cs.SetColor(255,255,250,250);
cs.DrawText (ss,655,(dn+2)*16); }
isDo=0; //结束标志

heqi: //和棋 drawngame
cs.SetTextSize (60);
cs.SetTextStyle (1);
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor(255,180,90,40);
cs.DrawText (ss,214,544);
cs.SetColor(255,255,0,0);
cs.DrawText (ss,210,540);
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor(255,250,250,0);
cs.DrawText (ss,210,540);
print ss ;
cs.Update ();
isDo=0; //结束标志
}//detect ()

gamestart (){
setDisplay (1);
cord=1 ; //记录开关
for (i=1;i<=225;i++){ pn[i]=0; } //init pn (n)下子位
for (i=0;i<=120;i++){ dwn[i]=0; } //init dwn (n)复盘
for (i=1;i<=225;i++){ js[i]=0 ; } //init js (n)禁手
isDo=1; //游戏操作控制
s6="黑棋选子"; //init
px=320 ; py=320 ; //标记
dn=0; wn=0 ; n=0 ; //计数清零
gn=gn+1; //game round + 1
clearOutput(); //清除记录
cs.SetBackground(200,200,200); //清记录
board (); //绘出棋板
}//gamestart ()

undo(){ //悔棋，可选子连续清除
if (isDo==1) {
pn[n]=0; fudat[dn]=0;
//print "悔 "+intToString (n);
cs.SetTextStyle (0);
cs.SetTextSize (16);
cs.SetColor(255,250,0,0);
cs.DrawText ("悔",652,dn*15);
//dn=dn-1 ; //序号减 1
cs.Update ();
board (); }
}//undo ()

replay (){ //复盘
gamestart ();
setDisplay (1);
print "fusum= " ,fusum;
for (i=1;i<=fusum;i++){
//draw chess pieces 画出复盘黑子白子
kn=fudat[i] ; //取得数据
sd=i-i/2*2 ; //mod 0=白棋， 1=黑棋
dx=(kn-(kn/15*15))*40;
dy=(kn/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
if ( sd==0){ //white
ss=intToString (kn);
cordp=" W "+ss;
row=15-(kn/15) ;
col=(kn-(kn/15*15)) ;
swapabc () ;
print i," ",cordp," " , ss,row ; //打印记录
ss4="W "+ss+intToString (row) ;
cs.SetColor (255,140,80,40); //piecesW
cs.DrawCircle(dx+2,dy+2,17);
cs.SetColor (255,220,220,220); //pieceW
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,250,250,250); //pieceW
cs.DrawCircle(dx-6,dy-6,2); }
if ( sd==1){ //black
ss=intToString (kn);
cordp=" B "+ss;
row=15-(kn/15) ;
col=(kn-(kn/15*15)) ;
swapabc () ;
print i," ",cordp," " , ss,row ; //打印记录
ss4=" B "+ss+intToString (row) ;
cs.SetColor (255,220,100,40); //piecesB
cs.DrawCircle(dx+1,dy+1,17);
cs.SetColor (255,0,0,0); //pieceB
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,200,200,200); //pieceB
cs.DrawCircle(dx-6,dy-6,2); }

if (i==fusum){
cs.SetColor (255,0,250,0); //标志最末胜子点
cs.DrawCircle(dx,dy,5);
cs.SetTextStyle (1);
cs.SetTextSize (60);
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,160,70,40);
cs.DrawText ("复盘",253, 553) ;
cs.SetColor (255,250,250,0);
cs.DrawText ("复盘",250, 550) ;
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor (255,50,250,0);
cs.DrawText ("复盘",250, 550) ;
if ( sd==0) print "白棋胜！ " ;
if ( sd==1) print "黑棋胜！ " ;
} //=fusum
cs.SetFillMode (1);//0不填色，1填色
cs.SetTextStyle (0);
cs.SetTextSize (16);
s=intToString (i); //标记序号
cs.SetColor (255,250,0,0);
cs.DrawText (s,dx-2,dy+5);
//界面显示记录
cs.SetTextSize (16);
cs.SetColor(255,255,250,250);
cs.DrawText (ss4,665,i*16); //界面显示记录
cs.Update ();
sleep (1000);
} //draw replay chess pieces
isDo=0 ; //结束标志
}//replay ()

myToolBarProc(int nBtn,int nContext)
{
if(nBtn==100){//开始游戏
gamestart ();
}
if(nBtn==101){//选择模式
mode=mode+1; //0=人人, 1= 人机
if (mode>1) mode=0 ;
if (mode==0) s7="游戏模式：双人对弈 ";
if (mode==1) s7="游戏模式：人机模式 ";
gamestart ();
}
if(nBtn==102){//黑棋下子
if ( pn[n]==0) black_do() ;
}
if(nBtn==103){//白棋下子，双人对弈模式
if (mode==0&&pn[n]==0) white_do () ;
}
if(nBtn==104){//退出程序
clearOutput();
cs.ClearDraw (0,src);
setDisplay (0);
exit (0);
}
if(nBtn==105){//查看记录
cord=cord+1;
if (cord>1) cord=0 ;
if (cord==0) setDisplay (0); //查看记录
if (cord==1) setDisplay (1); //显示棋板
}
}//myToolBar ()

myMenuProc(int nMen,int nContext)
{
if(nMen==200){ //开始游戏
gamestart (); }
if(nMen==201){ //选择模式
mode=mode+1; //0=人人, 1= 人机
if (mode>1) mode=0 ;
if (mode==0) s7="游戏模式：双人对弈 ";
if (mode==1) s7="游戏模式：人机模式 ";
gamestart ();
}
if(nMen==202){ //悔棋
undo ();
}
if (nMen==203){ //复盘
replay ();
}
if (nMen==204){ //禁手设置
restrict_set () ;
}
if(nMen==205){ //查看记录
setDisplay (0);
}
if(nMen==206){ //显示棋板
setDisplay (1);
}
if (nMen==207){ //Exit
clearOutput();
cs.ClearDraw (0,src);
setDisplay (0);
exit (0);
}
}//myMenu()

loadpic (){ //可用于装载预设棋盘底图
//use filebox open a file and load a picture
filebox.SetTitle("装载图片(*.bmp;*.jpg;*.png)");
filebox.SetFilter(".bmp;.jpg;.png");
filebox.Show();
if(filebox.GetCount()==1){
fname=filebox.GetFileName(0);
if(getPicSize(fname,size)<0){
return; }
cs.ClearDraw (0,src);
cs.DrawBitmap(fname,0,2);
cs.Update ();
}
}//loadpic ()

//**** End ********

你可能感兴趣的:(c语言,经验分享)

OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
C语言判断回文数 Y雨何时停T c语言学习
一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
C语言代码练习（第十九天）小小框架 C语言 C语言重点练习 c语言
今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
C语言---程序设计练习题目及学习方法1 Wanyu677 C语言 c语言学习方法算法
学习方法要多练习在这些题目中的代码和题目自己动手去敲练习也是在熟悉语法，写代码第一步就是熟悉语法练习是在锻炼编程思维，把实际问题转换为代码的能力学会画图画图去理解内存，理解指针这些比较难懂的知识画图可以更好的理清思路辅助理解，强化理解学会调试借助调试，更好的理解代码和感知代码找出代码中的bug和程序逻辑（1）自增自减运算符inta=5,b,c,i=10;b=a++;c=++b;printf("a=
【C语言】- 自定义类型：结构体、枚举、联合 Cavalier_01 C语言
【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
华南农业大学C语言oj第八章黑兔子撒 C语言 C语言华南农业大学编程程序
18058一年的第几天时间限制:1000MS内存限制:65535K提交次数:0通过次数:0题型:填空题语言:G++;GCC;VCDescription定义一个结构体类型表示日期类型（包括年、月、日）。程序中定义一个日期类型的变量，输入该日期的年、月、日，计算并输出该日期是一年的第几天。#include struct DATE { _______________________ }; int da
linux gcc 格式,Linux下gcc与gdb简介神奇的战士 linux gcc 格式
gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表英雄哪里出来《LeetCode算法全集》算法数据结构链表 c++归并排序
饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述将两个不降序链表合并为一个新的不降
PAT Advanced 1015. Reversible Primes (C语言实现) OliverLew
我的PAT系列文章更新重心已移至Github，欢迎来看PAT题解的小伙伴请到GithubPages浏览最新内容。此处文章目前已更新至与GithubPages同步。欢迎star我的repo。题目Areversibleprimeinanynumbersystemisaprimewhose"reverse"inthatnumbersystemisalsoaprime.Forexampleinthedec
c语言双向链表清空,C语言实现链表之双向链表（四）清空链表火龙果和哈密瓜 c语言双向链表清空
/*==============================================================================*操作：清空链表，释放结点内存，将链表重置为空表*操作前：ppHeadNode为链表头指针的二级指针*操作后：(*ppHeadNode)所指链表中的所有结点的内存被释放，重置为空表==============================
【C语言】C语言中的构造类型（自定义类型）写代码也摆烂 #C语言笔记 c语言
构造类型：也称自定义类型，构造类型是由基本数据类型组成的复合类型。一般用于存储较为复杂的数据。常见的构造类型有结构体（struct）、共用体（union）和枚举（enum）。目录正文一、结构体(struct)1、结构体概念：2、定义结构体类型与结构体变量3、结构体变量的初始化与引用3、结构体数组4、结构体指针*二、共用体（union）三、枚举类型四、用typedef声明新的类型名1、常用的方法有：
打开C语言常用内存函数的大门(一) —— memcpy()函数（内含讲解用法和模拟实现）埋头编程~ C语言 c语言开发语言 visual studio 算法
文章目录1.前言2.memcpy函数2.1memcpy函数的原型2.2memcpy函数的形参和返回值详解3.memcpy函数的演示4.memcpy函数的模拟实现5.总结1.前言在之前写的文章中，我介绍了几个比较常用的字符串函数strlen、strcmp、strcpy。它们作用的对象只能是形如字符串类型的数据。那这难免会引起我们心中一泡浓厚的求知欲——C语言有没有给我们提供一些类似于字符串函数的功能
详解C语言中的循环语句埋头编程~ C语言 c语言开发语言
文章目录1.前言2.while循环2.1if和whlie的对比2.2while语句的工作机制2.3while循环的实践3.for循环3.1for循环语法3.2for循环的工作机制3.3for循环实践4dowhile循环4.1dowhlie循环语法4.2dowhile循环的工作机理4.3dowhile循环实践5.break和continue语句5.1break举例5.2continue举例6.got
C语言指针（2）星霜旅人 c语言开发语言
目录数组名使用指针访问数组一维数组传参的本质二级指针数组指针数组名数组名是数组首元素的地址。intmain(){intarr1[]={1,2,3,4,5};printf("%p\n",&arr1[0]);printf("%p\n",arr1);}//都是传入数组首元素地址但是有两点例外：sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。&（数组名），这里的数组名也表示整个数
9.15初识指针西科Monesy c语言开发语言
初识指针什么是指针？指针是一种数据类型，它存储了变量的内存地址。通过指针，程序可以直接访问和操作内存中的数据，而不是通过变量的名称。这使得C语言在内存管理和性能优化方面具有很大的灵活性。内存是什么？内存是电脑上的存储器，计算机中程序的运行都是在内存中进行的。程序中如果有数据需要存储也会申请内存空间。为了有效的使用内存，就把内存划分成一个小小的内存单元，每个内存单元的大小是一个字节。为了能够有效的访
C语言：冒泡排序的注意事项及具体实现 z_鑫 c语言算法数据结构开发语言
一、注意事项1、函数声明为：voidbubble_sort(void*base,size_tnum,size_twidth,int(*cmp)(constvoid*e1,constvoid*e2));2、base指向所要排序的数组3、num为数组的元素个数4、width为一个元素占多少个字节的空间5、cmp为函数指针，指向用来进行比较的函数6、每趟排序都会把当前未排序部分的最大值移到正确的位置二、
C语言学习 - continue跳转语句 Hyso
continue跳转语句的使用用于for循环语句、while循环语句、dowhile循环语句中，跳过本次循环中剩余的语句而执行下一次循环。continue跳转语句的实例：#includeintmain(coid){intsum=0;inti=1;while(i<=100){sum+=i;i++;if(i==50){continue;}printf("i=%d\n",i);}printf("sum=
C语言实现一个简单的点歌系统鹿屿二向箔 c语言开发语言
创建一个简单的点歌系统可以用C语言实现，这里提供一个基本的框架。这个系统可以包括歌曲列表、用户选择歌曲的功能以及播放歌曲的功能。以下是一个示例代码：#include#include#defineMAX_SONGS100#defineMAX_LENGTH100typedefstruct{charname[MAX_LENGTH];charartist[MAX_LENGTH];}Song;typedef
学习C语言第十天（数组练习）世辰辰辰学习算法
一、三子棋game.h#define_CRT_SECURE_NO_WARNINGS#include#include#include#defineROW3#defineCOL3//初始化棋盘voidinitboard(charboard[ROW][COL],introw,intcol);//打印棋盘voiddispalyboard(charboard[ROW][COL],introw,intcol)
浅谈大模型 SFT 的实践落地：十问十答大模型与自然语言处理 NLP与大模型人工智能大数据深度学习多模态大模型 SFT
节前，我们星球组织了一场算法岗技术&面试讨论会，邀请了一些互联网大厂朋友、参加社招和校招面试的同学.针对算法岗技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何准备、面试常考点分享等热门话题进行了深入的讨论。汇总合集：《大模型面试宝典》(2024版)发布！今天给大家带来一篇大模型SFT的实践落地经验总结SFT现在往往被称为“低端”工作，但它与业务紧密相连。相较于难以实施且多数公司没资源训
51单片机：P3.3口输入/P 1口输出实验 li星野单片机
51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
C语言刷题-day4 从前慢，现在也慢 2023寒假C语言刷题 c语言算法开发语言
一、选择题1、以下程序的输出结果为（）#includeinti;voidprt(){for(i=5;i0;min--)if(x%min=0&&y%min=0)returnmin;}A:参数类型不对B:循环变量min初值不对C:判断等于的符号不对D:返回类型不对答案解析：正确答案：ABC1.函数实参是int，形参用char不对，会发生截断丢失数据；2.min在for循环开始时更新为0，不再是两个形参
C语言暑假学习刷题——Day4 奋斗小温 C语言 c语言学习 java
目录选择题考点一：for循环的理解考点二：while循环和循环嵌套的理解考点三：break在switch语句中的应用考点四：升序插入排序算法的应用考点五：循环嵌套的理解编程题【leetcode题号：645.错误的集合】【难度：简单】【牛客网题号：OR141密码检查】【难度：简单】选择题考点一：for循环的理解1、设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是（）A：n
C++快速入门扫盲总结六竹书生__wa C/C++Qt
C++快速入门扫盲总结C++语言新特性C++的新特性C++的输入输出方式C++之命名空间namespaceC++面向对象类和对象构造函数与析构函数this指针继承重载函数重载运算符重载多态数据封装数据抽象接口（抽象类）C++语言新特性C++的新特性C++比C语言新增的数据类型是布尔类型（bool）。但是在新的C语言标准里已经有布尔类型了，但是在旧的C语言标准里是没有布尔类型的，编译器也无法解释布尔
类与对象（上） zkydxj c++
目录一、认识面向过程与面向对象二、类的引入三、类的定义1、类有两种定义方式：1.定义与声明全部放在类体中。2.类声明在.h文件中，成员函数定义在.cpp文件中。2、成员变量命名规则的建议四、类的访问限定符与封装1.封装2.访问限定符五、类的实例化一、认识面向过程与面向对象我们之前学过的c语言是一种面向过程的语言，面向过程指代码关注的是过程，分析求解解决问题的步骤，通过函数调用逐步解决问题。而c++
解线性方程组 qiuwanchi
package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
在mysql内部存储代码 annan211 性能 mysql 存储过程触发器
在mysql内部存储代码在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
Asynchronous Http Client是android中非常好的异步请求工具除了异步之外还有很多封装比如json的处理，cookie的处理引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
java面试题 Array_06 java 面试
java面试题第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
网站加速 oloz 网站加速
前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩； GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
正确书写单例模式随意而生 java 设计模式单例
　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。　　懒汉式，线程不安全　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
单例模式香水浓 java
懒汉调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apache http server
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它（譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
如何在android 文件选择器中选择多个图片或者视频？ aijuans android
我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传但是android原生态的sdk中，只能一个一个的进行选择和上传。我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个处理方法官方的图片选择器(但是不支持所有版本的androi，只支持API Level
mysql中查询生日提醒的日期相关的sql baalwolf mysql
SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(), dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。解决方案：使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
Javascript Promise bijian1013 JavaScript Promise
Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。一.认识Promises “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
[Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是 public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
【Java命令三】jstack bit1129 jstack
jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
jboss 5.1启停脚本　动静分离部署 ronin47
以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename -b ip -g clustername -u broatcast jboss.messaging.ServerPeerID=int -Djboss.service.binding.set=p
UI之如何打磨设计能力? brotherlamp UI ui教程 ui自学 ui资料 ui视频
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
三色旗算法 bylijinnan java 算法
import java.util.Arrays; /** 问题：假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。网上的解法大多类似：在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
警告:No configuration found for the specified action: \'s chiangfai configuration
1.index.jsp页面form标签未指定namespace属性。  <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redis hash
使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑 #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255 /* Return th
select into outfile access deny问题 daizj mysql txt 导出数据到文件
本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。授权的语句如下： grant select on armory.* to rn
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
<?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
美国电影超短200句 dcj3sjt126com 电影
1. I see．我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too．我也是。5. My god! 天哪!6. No way! 不行!7. Come on．来吧(赶快)8. Hold on．等一等。9. I agree。我同意。10. Not bad．还不错。11. Not yet．还没。12. See you．再见。13. Shut up!
Java访问远程服务 dyy_gusi httpclient webservice get post
随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
Maven的settings.xml配置 geeksun settings.xml
settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
ubuntu的init与系统服务设置 hongtoushizi ubuntu
转载自： http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。运行
跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginx lua
使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。目录第一章安装Nginx+Lua开发环境第二章 Nginx+Lua开发入门第三章 Redis/SSDB+Twemproxy安装与使用第四章 L
php位运算符注意事项 home198979 位运算 PHP &
$a = $b = $c = 0; $a & $b = 1; $b | $c = 1 问a,b,c最终为多少? 当看到这题时，我犯了一个低级错误，误以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b; 这样a,b的值不会有任何改变
Linux shell数组建立和使用技巧 pda158 linux
1.数组定义　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。　　 2.数组读取与赋值　　得到长度：　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
hotspot源码(JDK7) ol_beta java HotSpot jvm
源码结构图，方便理解： ├─agent Serviceab
Oracle基本事务和ForAll执行批量DML练习 vipbooks oracle sql
基本事务的使用：从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam