随机分组小程序源码

A. C语言：随机生成100个数，要求分成两组，一组50个数，让这两组的和相差尽量小。

以下函数通过系统时间随机生成1-1000之间的随机数，分成两组后使其总和差值最小。
算法分析：见源程序中的桐咐毕注释，算法可能有些许额误差，共参考。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

//******************产生长度为length的不为0的可重复随机数组******************//
void radomArray(int *array,int length)
{
srand((unsigned)time(NULL));//使用系统时间作为随机数的种子产生随机数
int i=0,j=0;
while(j<length)
{
i=rand()%1000;/简斗/0-1000的随机数，可做修改
if(i!=0)//随机数不为0
{
array[j]=i;
j++;
}
}
}

//******************给数组排序，从大到小******************//
void sequence(int * array,int len)
{
int tmp=0;
for(int m=0;m<len;m++)
{
for(int n=0;n<len;n++)
{
if(array[m]>array[n])
{
tmp=array[n];array[n]=array[m];array[m]=tmp;
}
else continue;
}
}
}

//******************将数组拆分为长度为len_01和长度为len_02的两列并总和差值最小******************//
/*算法分析：将有序数组(大到小)中数据依次分别放入数组1、数组2中，并分别统计其现有数据的总和，分别存入dat_01,dat_02中，

初始化判断标准dat_01,dat_02为0；
根据数组现有数据总和dat_01和dat_02的关系，确定数据存入数组1还是数组2。
判断过程：如果数组1现有数据总和小于数组2，同时数组1未到上限，将下一个数据存入数组1；
如果数组1现有数据综合不小于数组2，同时数组2未局芹到上限，将下一个数据存入数组2。
可能漏洞：数组1或数组2提前到达数组上限，导致原数组中剩余数据直接转入另一数组中，出现异常结果。*/
void seperate(int *arr,int * arr_01,int *arr_02,int len_01,int len_02)
{
int i=0,j=0,dat_01=0,dat_02=0;
for(int k=0;k<len_01+len_02;k++)
{
if(dat_01<dat_02&&i<len_01)//如果数组1数据总和小于数组2，同时数组1未到上限，将下一个数据存入数组1
{
arr_01[i]=arr[k];
dat_01+=arr[k];
i++;
}
else if(dat_01>=dat_02&&j<len_02)//如果数组1数据不小于数组2，同时数组2未到上限，将下一个数据存入数

组2
{
arr_02[j]=arr[k];
dat_02+=arr[k];
j++;
}

}
}

//******************计算并返回长度为length的数组的数字总和******************//
int sum(int a[],int length)
{
int total=0;
for(int i=0;i<length;i++)
{
total+=a[i];
}
return total;
}

//******************主函数开始******************//
void main()
{
int data1=0,data2=0,tmp=0;
int len=100,len_01=50,len_02=50;//修改此处len,len_01,len_02即可修改初始数组长度，注意len_01+len_02=len，同

时最好len_01=len_02，防止出现异常。
int data[100],data_1[50],data_2[50];//上述len，len_01，len_02修改后，此处数组长度应相应修改。
radomArray(data,len);//产生100个数据的随机数组
sequence(data,len);//给随机数组从小到大排序

printf("产生的随机数组从小到大排列为：\n");
for(tmp=0;tmp<len;tmp++)//输出随机数组
printf("%d\t",data[tmp]);
printf("\n");

seperate(data,data_1,data_2,len_01,len_02);//将数组分为两块，使其总和差值最小

printf("第一块数组为：\n");
for(tmp=0;tmp<len_01;tmp++)
{
printf("%d\t",data_1[tmp]);
}
printf("\n");
printf("第二块数组为：\n");
for(tmp=0;tmp<len_02;tmp++)
{
printf("%d\t",data_2[tmp]);
}
printf("\n");

printf("最原始数组的数据总和为：%d\n",sum(data,len));
printf("拆分后数组的数据总和为：%d\n",sum(data_1,len_01)+sum(data_2,len_02));
printf("第一块数组的数据总和为：%d\n",sum(data_1,len_01));
printf("第二块数组的数据总和为：%d\n",sum(data_2,len_02));
printf("两块数组数据的的差值为：%d\n",sum(data_1,len_01)-sum(data_2,len_02));
}
运行结果：
产生的随机数组从小到大排列为：
993 979 970 962 957 935 914 902 888 883
871 866 862 859 843 840 829 827 824 815
810 808 805 796 784 768 738 730 725 722
721 712 711 709 704 702 693 670 670 650
631 627 623 623 614 607 606 598 577 574
547 498 495 495 481 478 451 448 447 429
410 388 383 381 380 379 377 364 344 337
308 271 266 257 233 208 204 200 189 165
162 155 150 145 143 119 117 114 114 110
108 69 64 61 48 45 22 16 11 3

第一块数组为：
979 970 957 902 883 871 859 840 829 815
810 805 768 738 725 721 709 702 670 670
631 623 607 606 574 498 495 481 451 447
410 383 379 377 337 271 266 233 200 189
155 145 119 117 114 108 61 45 11 3

第二块数组为：
993 962 935 914 888 866 862 843 827 824
808 796 784 730 722 712 711 704 693 650
627 623 614 598 577 547 495 478 448 429
388 381 380 364 344 308 257 208 204 165
162 150 143 114 110 69 64 48 22 16

最原始数组的数据总和为：51116
拆分后数组的数据总和为：51116
第一块数组的数据总和为：25559
第二块数组的数据总和为：25557
两块数组数据的的差值为：2
Press any key to continue

B. 如何使用c语言对数据随机分组

#include枣郑<stdio.h>
#include<stdlib.h>
#include档岩漏<time.h>

intmain()
{
	inta[50];//存放50个球
	inti,cnt;
	for(i=0;i<50;i++)//标号
		a[i]=i+1;
	cnt=0;
	srand(time(NULL));
	while(cnt<25)//随机取25个
	{
		i=rand()%50;
		if(a[i]!=0)//防止重复计数
		{
			cnt++;
			a[i]=0;//标记为已取
		}
	}
	//以下为输出分组结果
	printf("array1:
"行烂);
	cnt=0;
	for(i=0;i<50;i++)
	{
		if(a[i]==0)
		{
			cnt++;
			printf("%3d",i+1);
			if(cnt%5==0)//每输出5个一换行
				printf("
");
		}
	}
	printf("
");
	printf("array2:
");
	for(i=0;i<50;i++)
	{
		if(a[i])
		{
			cnt++;
			printf("%3d",a[i]);
			if(cnt%5==0)
				printf("
");
		}
	}
	printf("
");
	return0;
}

C. 用c# 编写一个随机分组的程序

这么写就行了，下图是运行结果

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

usingSystem.Threading;

namespaceConsoleApplication

{

classProgram

{

staticvoidMain(string[]args)

{

intnumber=42;//人数

intgroups=7;//组数

唯皮枯string[]strArr=Group(number,groups);

for(inti=0;i<strArr.Length;i++)

Console.WriteLine("第"+(i+1)+"组"+strArr[i]);

Console.ReadKey();

}

staticstring[]Group(intnumber,intgroups)

{

List<int>list=newList<int>();

intnum=number/7;

string[]strArr=newstring[groups];

for(inti=1;i<=number;i++)

list.Add(i);

for(inti=0;i<groups;i++)

{

for(intj=0;j<num;j++)

{

intvalue=list[newRandom((int)DateTime.Now.Ticks).Next(0,list.Count)];

list.Remove(value);

握亮strArr[i]+=value.ToString("D2")+"";

指洞Thread.Sleep(20);

}

}

returnstrArr;

}

}

}

D. 用vb：编一个随机分组程序

我想了一下，编了个满足你要求的，并加上详细的注解，运行的结果是对的，如图雀卖，我运行了三次，每次编排的结果都不一样。

PrivateSubCommand1_Click()

List1.Clear

Randomize'随机数初始化，这个非常重要！

DimXX(1To8)AsInteger,YY(1To8,1To6)AsInteger

Fori=1To48'对人进行循环

Z=False'此人未分配

DoWhile(Z=False)'只要此人未分配，就一直循环

A=Rnd(1)

B=Int(7*A+1+0.5)'先把i分配到B组,B的值肯定在1，2，3，。。。8之间

If橘胡XX(B)<6Then'当B组的人数不足6人时，就分给B组

XX(B)=XX(B)+1'这个组的人数+1

YY(B,XX(B))=i

顷伍逗Z=True'此人已分配

EndIf

Loop

Nexti

Fori=1To8

List1.AddItem"第"&Str(i)&"组："

Forj=1To6

List1.AddItemYY(i,j)

Nextj

Nexti

EndSub

E. 用C语言编写一个随机分组的程序

int main(){
time_t ts;
srand((unsigned int)time(&ts));
scanf("%d",n);
for(int i=0;i<n;i++){
int a=rand()%100;
if(条没橘件){

}
if(条答察物清液件){

}
if(条件){

}
}
}

F. 微信随机分组小程序技巧

1、使用微信小程序的接口来获取用户的openid，然后根据openid来生成一个随机的分组；
2、可以使用微信小程序的消息推送功能，将用户分组的信息推送给用户；
3、可以使弯腔用微信小程序的数据库功能，将用户的openid和分组信息存储起来，以便以后使用；
4、可以使用微信小程序的云函数功能，实现定时自动分组，以及定时自动推送分组信息；
5、可以使用微信小程序的客服消息功能，实现用户主动查询自己的分组信息；
6、可以使用微信小程序的客服消息功能，实现用户主动申请更改分组信息；
7、可以使用微信小程序的客服消息功能，实现用户主动申请取消分组信息；槐闹碧
8、可以使用微信小程序的客服消息功能，实现用户主动申请查看其他用户铅举的分组信息；
9、可以使用微信小程序的客服消息功能，实现用户主动申请查看某一分组的所有用户信息；
10、可以使用微信小程序的客服消息功能，实现用户主动申请查看某一分组的所有用户的openid。

G. C#:设计一个程序，能够随机分组，并输出分组名单。

这类似于数组..首先用声明一个数组和list在使用行滚游两个for循环用数组添加每个的元素在用list把数组添加进去（数组也可用list代替）最后备源用list循环显示到控制台我只提供思路具体应该你可以实现的档销

H. 50个人怎么随机分组python

1、首先在python程序上输入总人数50人（N），和所需要的分组数n，即可进行随机分组。
2、如果N不是n的整数倍，则n个小组中的人数会不相同。以上就是50个人在python程序随机分组的方法。

I. 求C语言小程序源代码，300行左右

黑白棋游戏
#include "graphics.h" /*图形系统头文件*/
#define LEFT 0x4b00 /*光标左键值*/
#define RIGHT 0x4d00 /*光标右键值*/
#define DOWN 0x5000 /*光标下键值*/
#define UP 0x4800 /*光标上键值*/
#define ESC 0x011b /* ESC键值*/
#define ENTER 0x1c0d /* 回车键值*/
int a[8][8]={0},key,score1,score2;/*具体分数以及按键与存放棋子的变量*/
char playone[3],playtwo[3];/*两个人的得分转换成字符串输出*/
void playtoplay(void);/*人人对战函数*/
void DrawQp(void);/*画棋盘函数*/
void SetPlayColor(int x);/*设置棋子第一次的颜色*/
void MoveColor(int x,int y);/*恢复原来棋盘状态*/
int QpChange(int x,int y,int z);/*判断棋盘的变化*/
void DoScore(void);/*处理分数*/
void PrintScore(int n);/*输出成绩*/
void playWin(void);/*输出胜利者信息*/
/******主函数*********/
void main(void)
{
int gd=DETECT,gr;
initgraph(&gd,&gr,"c:\\tc"); /*初始化图形系统*/
DrawQp();/*画棋盘*/
playtoplay();/*人人对战*/
getch();
closegraph();/*关闭图形系统*/
}
void DrawQp()/*画棋盘*/
{
int i,j;
score1=score2=0;/*棋手一开始得分都为0*/
setbkcolor(BLUE);
for(i=100;i<=420;i+=40)
{
line(100,i,420,i);/*画水平线*/
line(i,100,i,420); /*画垂直线*/
}
setcolor(0);/*取消圆周围的一圈东西*/
setfillstyle(SOLID_FILL,15);/*白色实体填充模式*/
fillellipse(500,200,15,15); /*在显示得分的位置画棋*/
setfillstyle(SOLID_FILL,8); /*黑色实体填充模式*/
fillellipse(500,300,15,15);
a[3][3]=a[4][4]=1;/*初始两个黑棋*/
a[3][4]=a[4][3]=2;/*初始两个白棋*/
setfillstyle(SOLID_FILL,WHITE);
fillellipse(120+3*40,120+3*40,15,15);
fillellipse(120+4*40,120+4*40,15,15);
setfillstyle(SOLID_FILL,8);
fillellipse(120+3*40,120+4*40,15,15);
fillellipse(120+4*40,120+3*40,15,15);
score1=score2=2; /*有棋后改变分数*/
DoScore();/*输出开始分数*/
}
void playtoplay()/*人人对战*/
{
int x,y,t=1,i,j,cc=0;
while(1)/*换棋手走棋*/
{
x=120,y=80;/*每次棋子一开始出来的坐标,x为行坐标,y为列坐标*/
while(1) /*具体一个棋手走棋的过程*/
{
PrintScore(1);/*输出棋手1的成绩*/
PrintScore(2);/*输出棋手2的成绩*/
SetPlayColor(t);/*t变量是用来判断棋手所执棋子的颜色*/
fillellipse(x,y,15,15);
key=bioskey(0);/*接收按键*/
if(key==ESC)/*跳出游戏*/
break;
else
if(key==ENTER)/*如果按键确定就可以跳出循环*/
{
if(y!=80&&a[(x-120)/40][(y-120)/40]!=1
&&a[(x-120)/40][(y-120)/40]!=2)/*如果落子位置没有棋子*/
{
if(t%2==1)/*如果是棋手1移动*/
a[(x-120)/40][(y-120)/40]=1;
else/*否则棋手2移动*/
a[(x-120)/40][(y-120)/40]=2;
if(!QpChange(x,y,t))/*落子后判断棋盘的变化*/
{
a[(x-120)/40][(y-120)/40]=0;/*恢复空格状态*/
cc++;/*开始统计尝试次数*/
if(cc>=64-score1-score2) /*如果尝试超过空格数则停步*/
{
MoveColor(x,y);
fillellipse(x,y,15,15);
break;
}
else
continue;/*如果按键无效*/
}
DoScore();/*分数的改变*/
break;/*棋盘变化了，则轮对方走棋*/
}
else/*已经有棋子就继续按键*/
continue;
}
else /*四个方向按键的判断*/
if(key==LEFT&&x>120)/*左方向键*/
{
MoveColor(x,y);
fillellipse(x,y,15,15);
SetPlayColor(t);
x-=40;
fillellipse(x,y,15,15);
}
else
if(key==RIGHT&&x<400&&y>80)/*右方向键*/
{
MoveColor(x,y);
fillellipse(x,y,15,15);
SetPlayColor(t);
x+=40;
fillellipse(x,y,15,15);
}
else
if(key==UP&&y>120)/*上方向键*/
{
MoveColor(x,y);
fillellipse(x,y,15,15);
SetPlayColor(t);
y-=40;
fillellipse(x,y,15,15);
}
else
if(key==DOWN&&y<400)/*下方向键*/
{
MoveColor(x,y);
fillellipse(x,y,15,15);
SetPlayColor(t);
y+=40;
fillellipse(x,y,15,15);
}
}
if(key==ESC)/*结束游戏*/
break;
if((score1+score2)==64||score1==0||score2==0)/*格子已经占满或一方棋子为0判断胜负*/
{
playWin();/*输出最后结果*/
break;
}
t=t%2+1; /*一方走后，改变棋子颜色即轮对方走*/
cc=0; /*计数值恢复为0*/
} /*endwhile*/
}
void SetPlayColor(int t)/*设置棋子颜色*/
{
if(t%2==1)
setfillstyle(SOLID_FILL,15);/*白色*/
else
setfillstyle(SOLID_FILL,8);/*灰色*/
}
void MoveColor(int x,int y)/*走了一步后恢复原来格子的状态*/
{
if(y<100)/*如果是从起点出发就恢复蓝色*/
setfillstyle(SOLID_FILL,BLUE);
else/*其他情况如果是1就恢复白色棋子,2恢复黑色棋子,或恢复蓝色棋盘*/
switch(a[(x-120)/40][(y-120)/40])
{
case 1:
setfillstyle(SOLID_FILL,15);break; /*白色*/
case 2:
setfillstyle(SOLID_FILL,8);break; /*黑色*/
default:
setfillstyle(SOLID_FILL,BLUE); /*蓝色*/
}
}
int QpChange(int x,int y,int t)/*判断棋盘的变化*/
{
int i,j,k,kk,ii,jj,yes;
yes=0;
i=(x-120)/40; /*计算数组元素的行下标*/
j=(y-120)/40; /*计算数组元素的列下标*/
SetPlayColor(t);/*设置棋子变化的颜色*/
/*开始往8个方向判断变化*/
if(j<6)/*往右边*/
{
for(k=j+1;k<8;k++)
if(a[i][k]==a[i][j]||a[i][k]==0)/*遇到自己的棋子或空格结束*/
break;
if(a[i][k]!=0&&k<8)
{
for(kk=j+1;kk<k&&k<8;kk++)/*判断右边*/
{
a[i][kk]=a[i][j]; /*改变棋子颜色*/
fillellipse(120+i*40,120+kk*40,15,15);
}
if(kk!=j+1) /*条件成立则有棋子改变过颜色*/
yes=1;
}
}
if(j>1)/*判断左边*/
{
for(k=j-1;k>=0;k--)
if(a[i][k]==a[i][j]||!a[i][k])
break;
if(a[i][k]!=0&&k>=0)
{
for(kk=j-1;kk>k&&k>=0;kk--)
{
a[i][kk]=a[i][j];
fillellipse(120+i*40,120+kk*40,15,15);
}
if(kk!=j-1)
yes=1;
}
}
if(i<6)/*判断下边*/
{
for(k=i+1;k<8;k++)
if(a[k][j]==a[i][j]||!a[k][j])
break;
if(a[k][j]!=0&&k<8)
{
for(kk=i+1;kk<k&&k<8;kk++)
{
a[kk][j]=a[i][j];
fillellipse(120+kk*40,120+j*40,15,15);
}
if(kk!=i+1)
yes=1;
}
}
if(i>1)/*判断上边*/
{
for(k=i-1;k>=0;k--)
if(a[k][j]==a[i][j]||!a[k][j])
break;
if(a[k][j]!=0&&k>=0)
{
for(kk=i-1;kk>k&&k>=0;kk--)
{
a[kk][j]=a[i][j];
fillellipse(120+kk*40,120+j*40,15,15);
}
if(kk!=i-1)
yes=1;
}
}
if(i>1&&j<6)/*右上*/
{
for(k=i-1,kk=j+1;k>=0&&kk<8;k--,kk++)
if(a[k][kk]==a[i][j]||!a[k][kk])
break;
if(a[k][kk]&&k>=0&&kk<8)
{
for(ii=i-1,jj=j+1;ii>k&&k>=0;ii--,jj++)
{
a[ii][jj]=a[i][j];
fillellipse(120+ii*40,120+jj*40,15,15);
}
if(ii!=i-1)
yes=1;
}
}
if(i<6&&j>1)/*左下*/
{
for(k=i+1,kk=j-1;k<8&&kk>=0;k++,kk--)
if(a[k][kk]==a[i][j]||!a[k][kk])
break;
if(a[k][kk]!=0&&k<8&&kk>=0)
{
for(ii=i+1,jj=j-1;ii<k&&k<8;ii++,jj--)
{
a[ii][jj]=a[i][j];
fillellipse(120+ii*40,120+jj*40,15,15);
}
if(ii!=i+1)
yes=1;
}
}
if(i>1&&j>1)/*左上*/
{
for(k=i-1,kk=j-1;k>=0&&kk>=0;k--,kk--)
if(a[k][kk]==a[i][j]||!a[k][kk])
break;
if(a[k][kk]!=0&&k>=0&&kk>=0)
{
for(ii=i-1,jj=j-1;ii>k&&k>=0;ii--,jj--)
{
a[ii][jj]=a[i][j];
fillellipse(120+ii*40,120+jj*40,15,15);
}
if(ii!=i-1)
yes=1;
}
}
if(i<6&&j<6)/* 右下*/
{
for(k=i+1,kk=j+1;kk<8&&kk<8;k++,kk++)
if(a[k][kk]==a[i][j]||!a[k][kk])
break;
if(a[k][kk]!=0&&kk<8&&k<8)
{
for(ii=i+1,jj=j+1;ii<k&&k<8;ii++,jj++)
{
a[ii][jj]=a[i][j];
fillellipse(120+ii*40,120+jj*40,15,15);
}
if(ii!=i+1)
yes=1;
}
}
return yes;/*返回是否改变过棋子颜色的标记*/
}
void DoScore()/*处理分数*/
{
int i,j;
score1=score2=0;/*重新开始计分数*/
for(i=0;i<8;i++)
for(j=0;j<8;j++)
if(a[i][j]==1)/*分别统计两个人的分数*/
score1++;
else
if(a[i][j]==2)
score2++;
}
void PrintScore(int playnum)/*输出成绩*/
{
if(playnum==1)/*清除以前的成绩*/
{
setfillstyle(SOLID_FILL,BLUE);
bar(550,100,640,400);
}
setcolor(RED);
settextstyle(0,0,4);/*设置文本输出样式*/
if(playnum==1)/*判断输出哪个棋手的分,在不同的位置输出*/
{
sprintf(playone,"%d",score1);
outtextxy(550,200,playone);
}
else
{
sprintf(playtwo,"%d",score2);
outtextxy(550,300,playtwo);
}
setcolor(0);
}
void playWin()/*输出最后的胜利者结果*/
{
settextstyle(0,0,4);
setcolor(12);
if(score2>score1)/*开始判断最后的结果*/
outtextxy(100,50,"black win!");
else
if(score2<score1)
outtextxy(100,50,"white win!");
else
outtextxy(60,50,"you all win!");
}

五子棋游戏
/*五子棋*/
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
#include<bios.h>
#include<conio.h>

#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b
#define SPACE 0x3920

#define BILI 20
#define JZ 4
#define JS 3
#define N 19

int box[N][N];
int step_x,step_y ;
int key ;
int flag=1 ;

void draw_box();
void draw_cicle(int x,int y,int color);
void change();
void judgewho(int x,int y);
void judgekey();
int judgeresult(int x,int y);
void attentoin();

void attention()
{
char ch ;
window(1,1,80,25);
textbackground(LIGHTBLUE);
textcolor(YELLOW);
clrscr();
gotoxy(15,2);
printf("游戏操作规则：");
gotoxy(15,4);
printf("Play Rules:");
gotoxy(15,6);
printf("1、按左右上下方向键移动棋子");
gotoxy(15,8);
printf("1. Press Left,Right,Up,Down Key to move Piece");
gotoxy(15,10);
printf("2、按空格确定落棋子");
gotoxy(15,12);
printf("2. Press Space to place the Piece");
gotoxy(15,14);
printf("3、禁止在棋盘外按空格");
gotoxy(15,16);
printf("3. DO NOT press Space outside of the chessboard");
gotoxy(15,18);
printf("你是否接受上述的游戏规则（Y/N）");
gotoxy(15,20);
printf("Do you accept the above Playing Rules? [Y/N]:");
while(1)
{
gotoxy(60,20);
ch=getche();
if(ch=='Y'||ch=='y')
break ;
else if(ch=='N'||ch=='n')
{
window(1,1,80,25);
textbackground(BLACK);
textcolor(LIGHTGRAY);
clrscr();
exit(0);
}
gotoxy(51,12);
printf(" ");
}
}
void draw_box()
{
int x1,x2,y1,y2 ;
setbkcolor(LIGHTBLUE);
setcolor(YELLOW);
gotoxy(7,2);
printf("Left, Right, Up, Down KEY to move, Space to put, ESC-quit.");
for(x1=1,y1=1,y2=18;x1<=18;x1++)
line((x1+JZ)*BILI,(y1+JS)*BILI,(x1+JZ)*BILI,(y2+JS)*BILI);
for(x1=1,y1=1,x2=18;y1<=18;y1++)
line((x1+JZ)*BILI,(y1+JS)*BILI,(x2+JZ)*BILI,(y1+JS)*BILI);
for(x1=1;x1<=18;x1++)
for(y1=1;y1<=18;y1++)
box[x1][y1]=0 ;
}

void draw_circle(int x,int y,int color)
{
setcolor(color);
setlinestyle(SOLID_LINE,0,1);
x=(x+JZ)*BILI ;
y=(y+JS)*BILI ;
circle(x,y,8);
}

void judgekey()
{
int i ;
int j ;
switch(key)
{
case LEFT :

if(step_x-1<0)
break ;
else
{
for(i=step_x-1,j=step_y;i>=1;i--)
if(box[i][j]==0)
{
draw_circle(step_x,step_y,LIGHTBLUE);
break ;
}
if(i<1)break ;
step_x=i ;
judgewho(step_x,step_y);
break ;
}
case RIGHT :

if(step_x+1>18)
break ;
else
{
for(i=step_x+1,j=step_y;i<=18;i++)
if(box[i][j]==0)
{
draw_circle(step_x,step_y,LIGHTBLUE);
break ;
}
if(i>18)break ;
step_x=i ;
judgewho(step_x,step_y);
break ;
}
case DOWN :

if((step_y+1)>18)
break ;
else
{
for(i=step_x,j=step_y+1;j<=18;j++)
if(box[i][j]==0)
{
draw_circle(step_x,step_y,LIGHTBLUE);
break ;
}
if(j>18)break ;
step_y=j ;
judgewho(step_x,step_y);
break ;
}
case UP :

if((step_y-1)<0)
break ;
else
{
for(i=step_x,j=step_y-1;j>=1;j--)
if(box[i][j]==0)
{
draw_circle(step_x,step_y,LIGHTBLUE);
break ;
}
if(j<1)break ;
step_y=j ;
judgewho(step_x,step_y);
break ;
}
case ESC :
break ;

case SPACE :
if(step_x>=1&&step_x<=18&&step_y>=1&&step_y<=18)
{
if(box[step_x][step_y]==0)
{
box[step_x][step_y]=flag ;
if(judgeresult(step_x,step_y)==1)
{
sound(1000);
delay(1000);
nosound();
gotoxy(30,4);
if(flag==1)
{
setbkcolor(BLUE);
cleardevice();
setviewport(100,100,540,380,1);
/*定义一个图形窗口*/
setfillstyle(1,2);
/*绿色以实填充*/
setcolor(YELLOW);
rectangle(0,0,439,279);
floodfill(50,50,14);
setcolor(12);
settextstyle(1,0,5);
/*三重笔划字体, 水平放?5倍*/
outtextxy(20,20,"The White Win !");
setcolor(15);
settextstyle(3,0,5);
/*无衬笔划字体, 水平放大5倍*/
outtextxy(120,120,"The White Win !");
setcolor(14);
settextstyle(2,0,8);
getch();
closegraph();
exit(0);
}
if(flag==2)
{
setbkcolor(BLUE);
cleardevice();
setviewport(100,100,540,380,1);
/*定义一个图形窗口*/
setfillstyle(1,2);
/*绿色以实填充*/
setcolor(YELLOW);
rectangle(0,0,439,279);
floodfill(50,50,14);
setcolor(12);
settextstyle(1,0,8);
/*三重笔划字体, 水平放大8倍*/
outtextxy(20,20,"The Red Win !");
setcolor(15);
settextstyle(3,0,5);
/*无衬笔划字体, 水平放大5倍*/
outtextxy(120,120,"The Red Win !");
setcolor(14);
settextstyle(2,0,8);
getch();
closegraph();
exit(0);
}
}
change();
break ;
}
}
else
break ;
}
}

void change()
{
if(flag==1)
flag=2 ;
else
flag=1 ;
}

void judgewho(int x,int y)
{
if(flag==1)
draw_circle(x,y,15);
if(flag==2)
draw_circle(x,y,4);
}

int judgeresult(int x,int y)
{
int j,k,n1,n2 ;
while(1)
{
n1=0 ;
n2=0 ;
/*水平向左数*/
for(j=x,k=y;j>=1;j--)
{
if(box[j][k]==flag)
n1++;
else
break ;
}
/*水平向右数*/
for(j=x,k=y;j<=18;j++)
{
if(box[j][k]==flag)
n2++;
else
break ;
}
if(n1+n2-1>=5)
{
return(1);
break ;
}

/*垂直向上数*/
n1=0 ;
n2=0 ;
for(j=x,k=y;k>=1;k--)
{
if(box[j][k]==flag)
n1++;
else
break ;
}
/*垂直向下数*/
for(j=x,k=y;k<=18;k++)
{
if(box[j][k]==flag)
n2++;
else
break ;
}
if(n1+n2-1>=5)
{
return(1);
break ;
}

/*向左上方数*/
n1=0 ;
n2=0 ;
for(j=x,k=y;j>=1,k>=1;j--,k--)
{
if(box[j][k]==flag)
n1++;
else
break ;
}
/*向右下方数*/
for(j=x,k=y;j<=18,k<=18;j++,k++)
{
if(box[j][k]==flag)
n2++;
else
break ;
}
if(n1+n2-1>=5)
{
return(1);
break ;
}

/*向右上方数*/
n1=0 ;
n2=0 ;
for(j=x,k=y;j<=18,k>=1;j++,k--)
{
if(box[j][k]==flag)
n1++;
else
break ;
}
/*向左下方数*/
for(j=x,k=y;j>=1,k<=18;j--,k++)
{
if(box[j][k]==flag)
n2++;
else
break ;
}
if(n1+n2-1>=5)
{
return(1);
break ;
}
return(0);
break ;
}
}

void main()
{
int gdriver=VGA,gmode=VGAHI;
clrscr();
attention();
initgraph(&gdriver,&gmode,"c:\\tc");
/* setwritemode(XOR_PUT);*/
flag=1 ;
draw_box();
do
{
step_x=0 ;
step_y=0 ;
/*draw_circle(step_x,step_y,8); */
judgewho(step_x-1,step_y-1);
do
{
while(bioskey(1)==0);
key=bioskey(0);
judgekey();
}
while(key!=SPACE&&key!=ESC);
}
while(key!=ESC);
closegraph();
}

J. 求一个c++网球比赛计分程序的 随机分组 的代码 从32个人当中随机分成四组 求！！！！！

#include<iostream>
#include<deque>
#include<vector>
#include<stdlib.h>

usingnamespacestd;

#defineTeamCount4
#defineNumberCount8

voidRandGroup(deque<int>&deqSrc,vector<vector<int>>&rVecDec)
{
	srand(time(NULL));
	intnSrcSize=deqSrc.size();
	vector<int>vecSample;
	for(inti=0;i<nSrcSize;i++)
	{
		//取队员
		intnPlayer=deqSrc.front();
		deqSrc.pop_front();

		vecSample.clear();
		//获取不满NumberCount的队伍集合
		for(intj=0;j亏派<TeamCount;j++)
		{
			if(rVecDec[j].size()<NumberCount)
				vecSample.push_back(j);
		}
		//获取该队员的随机队列编号
		intnTmp=销兄贺rand();
		nTmp=rand()%(vecSample.size());
		rVecDec[vecSample[nTmp]].push_back(nPlayer);
	}
}

intmain()
{
	//生成32个队员
	deque<int>deq;
	for(inti=0;i<TeamCount*NumberCount;i++)
	{
		intnPlayer=0;
		cin>>尘庆nPlayer;
		deq.push_back(nPlayer);
	}
	//随机分组
	vector<vector<int>>vecRes;
	for(inti=0;i<TeamCount;i++)
	{
		vector<int>vecTmp;
		vecRes.push_back(vecTmp);
	}
	RandGroup(deq,vecRes);

	return0;
}

朋友，请【采纳答案】，您的采纳是我答题的动力，如果没有明白，请追问。谢谢。