24点游戏咋玩的啊

1利用3×8=24、4×6=24求解

把牌面上的四个数想办法凑成3和8、4和6，再相乘求解如3、3、6、10可组成(10-6÷3)×3=24等又如2、3、3、7可组成(7+3-2)×3=24等实践证明，这种方法是利用率最大、命中率最高的一种方法

2利用0、11的运算特性求解

如3、4、4、8可组成3×8+4-4=24等又如4、5、J、K可组成11×(5-4)+13=24等

3在有解的牌组中，用得最为广泛的是以下六种解法：(我们用a、b、c、d表示牌面上的四个数)

①(a-b)×(c+d) 如(10-4)×(2+2)=24等 ②(a+b)÷c×d 如(10+2)÷2×4=24等 ③(a-b÷c)×d 如(3-2÷2)×12=24等 ④(a+b-c)×d 如(9+5—2)×2=24等 ⑤a×b+c—d 如11×3+l—10=24等

⑥(a-b)×c+d 如(4-l)×6+6=24等 游戏时，同学们不妨按照上述方法试一试

需要说明的是：经计算机准确计算，随机的4个1-13的整数(数字可重复)中，能够算得24的概率约为74835%

“巧算24点”能极大限度地调动眼、脑、手、口、耳多种感官的协调活动，对于培养我们快捷的心算能力和反应能力很有帮助。

扩展资料：

利用计算程序来完成这个计算二十四点的程序

方法如下：

首先穷举的可行性问题。把表达式如下分成三类——

1、 无括号的简单表达式。

2、 有一个括号的简单表达式。

3、 有两个括号的较复杂表达式。

在栈中，元素的插入称为压入（push）或入栈，元素的删除称为d出（pop）或退栈。

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

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

第一种方法：

首先建立两个栈， *** 作数栈OVS和运算符栈OPS。其中， *** 作数栈用来记忆表达式中的 *** 作数，其栈顶指针为topv，初始时为空，即topv=0；运算符栈用来记忆表达式中的运算符，其栈顶指针为topp，初始时，栈中只有一个表达式结束符，即topp=1，且OPS（1）=‘；’。此处的‘；’即表达式结束符。

然后自左至右的扫描待处理的表达式，并假设当前扫描到的符号为W，根据不同的符号W做如下不同的处理：

1、 若W为 *** 作数

2、 则将W压入 *** 作数栈OVS

3、 且继续扫描下一个字符

4、 若W为运算符

5、 则根据运算符的性质做相应的处理：

6、若运算符为左括号或者运算符的优先级大于运算符栈栈顶的运算符(即OPS(top))，则将运算符W压入运算符栈OPS，并继续扫描下一个字符。

7、若运算符W为表达式结束符‘；’且运算符栈栈顶的运算符也为表达式结束符（即OPS(topp)=’;’），则处理过程结束，此时， *** 作数栈栈顶元素（即OVS（topv））即为表达式的值。

8、若运算符W为右括号且运算符栈栈顶的运算符为左括号（即OPS（topp）=’(‘)，则将左括号从运算符栈谈出，且继续扫描下一个符号。

9、若运算符的右不大于运算符栈栈顶的运算符（即OPS(topp)），则从 *** 作数栈OVS中d出两个 *** 作数，设先后d出的 *** 作数为a、b，再从运算符栈OPS中d出一个运算符，设为+，然后作运算a+b，并将运算结果压入 *** 作数栈OVS。本次的运算符下次将重新考虑。

参考资料：

#include<stdioh>

#include <memoryh>

//中间数据，用于生成算式

int g_Order[3][4];//调用顺序

int g_Operator[3];//三次计算的运行符,1-加 2-减 3-倒减 4-乘 5-除 6-倒除

bool Is24(double fNum)

{

double fDif=fNum-24;

if(fDif<0)

fDif=-fDif;

if(fDif<000001)

return true;

else

return false;

}

bool Cal2(double fNum1,double fNum2)

{//看2个数是否满足条件

g_Operator[2]=1;

if(Is24(fNum1+fNum2))

return true;

g_Operator[2]=2;

if(Is24(fNum1-fNum2))

return true;

g_Operator[2]=4;

if(Is24(fNum1fNum2))

return true;

g_Operator[2]=5;

if(fNum2!=0&&Is24(fNum1/fNum2))

return true;

return false;

}

bool Order2(double fNum1,double fNum2)

{

double fTemp[2];

int i,j;

fTemp[0]=fNum1;

fTemp[1]=fNum2;

for(i=0;i<2;i++)

{//数字1从3个中选择一个

for(j=0;j<2;j++)

{//数字2从余下的2个中选一个

if(i!=j)

{

g_Order[2][0]=i;g_Order[2][1]=j;

if(Cal2(fTemp[i],fTemp[j]))

return true;

}

}

}

return false;

}

bool Cal3(double fNum1,double fNum2,double fNum3)

{//看3个数是否满足条件

g_Operator[1]=1;

if(Order2(fNum1+fNum2,fNum3))

return true;

g_Operator[1]=2;

if(Order2(fNum1-fNum2,fNum3))

return true;

g_Operator[1]=4;

if(Order2(fNum1fNum2,fNum3))

return true;

g_Operator[1]=5;

if(fNum2!=0&&Order2(fNum1/fNum2,fNum3))

return true;

return false;

}

bool Order3(double fNum1,double fNum2,double fNum3)

{

double fTemp[3];

int i,j,k;

fTemp[0]=fNum1;

fTemp[1]=fNum2;

fTemp[2]=fNum3;

for(i=0;i<3;i++)

{//数字1从3个中选择一个

for(j=0;j<3;j++)

{//数字2从余下的2个中选一个

if(i!=j)

{

for(k=0;k<3;k++)

{

if(k!=i&&k!=j)

{

g_Order[1][0]=i;g_Order[1][1]=j;g_Order[1][2]=k;

if(Cal3(fTemp[i],fTemp[j],fTemp[k]))

return true;

}

}

}

}

}

return false;

}

bool Cal4(double fNum1,double fNum2,double fNum3,double fNum4)

{//看4个数是否满足条件

g_Operator[0]=1;

if(Order3(fNum1+fNum2,fNum3,fNum4))

return true;

g_Operator[0]=2;

if(Order3(fNum1-fNum2,fNum3,fNum4))

return true;

g_Operator[0]=4;

if(Order3(fNum1fNum2,fNum3,fNum4))

return true;

g_Operator[0]=5;

if(fNum2!=0&&Order3(fNum1/fNum2,fNum3,fNum4))

return true;

return false;

}

bool Order4(double fNum1,double fNum2,double fNum3,double fNum4)

{//i,j,k,l四个数字进行组合调用（因为在Cal4中没有考虑到计算的先后，所以在这里面要进行。）

double fTemp[4];

int i,j,k,l;

fTemp[0]=fNum1;

fTemp[1]=fNum2;

fTemp[2]=fNum3;

fTemp[3]=fNum4;

for(i=0;i<4;i++)

{//数字1从4个中选择一个

for(j=0;j<4;j++)

{//数字2从余下的三个中选一个

if(i!=j)

{

for(k=0;k<4;k++)

{//数字3从余下的二个中选一个

if(k!=i&&k!=j)

{

for(l=0;l<4;l++)

{

if(l!=i&&l!=j&&l!=k)

{

g_Order[0][0]=i;g_Order[0][1]=j;g_Order[0][2]=k;g_Order[0][3]=l;

if(Cal4(fTemp[i],fTemp[j],fTemp[k],fTemp[l]))

return true;

}

}

}

}

}

}

}

return false;

}

char GetOper(int nOperator)

{

switch(nOperator)

{

case 1:

return '+';

case 2:

return '-';

case 4:

return '';

case 5:

return '/';

}

return '\0';

}

void GetCalString(char cBuf,int i,int j,int k,int l)

{//生成算式

//int g_Order[3][4];//调用顺序

//int g_Operator[3];//三次计算的运行符,1-加 2-减 3-倒减 4-乘 5-除 6-倒除

int nNum[4];

int nTemp[4];

nTemp[0]=i;nTemp[1]=j;nTemp[2]=k;nTemp[3]=l;

nNum[0]=nTemp[g_Order[0][0]];

nNum[1]=nTemp[g_Order[0][1]];

nNum[2]=nTemp[g_Order[0][2]];

nNum[3]=nTemp[g_Order[0][3]];

char cTemp[3][100];

memset(cTemp[0],0,100);

sprintf(cTemp[0],"(%d%c%d)",nNum[0],GetOper(g_Operator[0]),nNum[1]);

nNum[0]=nNum[g_Order[1][0]+1];

nNum[1]=nNum[g_Order[1][1]+1];

nNum[2]=nNum[g_Order[1][2]+1];

memset(cTemp[1],0,100);

if(g_Order[1][0]==0)

sprintf(cTemp[1],"(%s%c%d)",cTemp[0],GetOper(g_Operator[1]),nNum[1]);

else if(g_Order[1][1]==0)

sprintf(cTemp[1],"(%d%c%s)",nNum[0],GetOper(g_Operator[1]),cTemp[0]);

else//g_Order[1][2]==0

sprintf(cTemp[1],"(%d%c%d)",nNum[0],GetOper(g_Operator[1]),nNum[1]);

memset(cTemp[2],0,100);

nNum[0]=nNum[g_Order[2][0]+1];

nNum[1]=nNum[g_Order[2][1]+1];

if(g_Order[1][2]==0)

{//型如:(a+b)-(c+d)

if(g_Order[2][0]==0)

{//没有倒序

sprintf(cTemp[2],"%s%c%s",cTemp[1],GetOper(g_Operator[2]),cTemp[0]);

}

else

{

sprintf(cTemp[2],"%s%c%s",cTemp[0],GetOper(g_Operator[2]),cTemp[1]);

}

}

else

{//其它

if(g_Order[2][0]==0)

{//没有倒序

sprintf(cTemp[2],"%s%c%d",cTemp[1],GetOper(g_Operator[2]),nNum[1]);

}

else

{

sprintf(cTemp[2],"%d%c%s",nNum[0],GetOper(g_Operator[2]),cTemp[1]);

}

}

sprintf(cBuf,"%s=24",cTemp[2]);

}

void main()

{

int i,j,k,l;

int nCount=0,nLossCount=0;

FILE pFile=::fopen("resulttxt","w+");

for(i=1;i<=10;i++)

{

for(j=i;j<=10;j++)

{

for(k=j;k<=10;k++)

{

for(l=k;l<=10;l++)

{

if(Order4(i,j,k,l))

{

//组织运算式

char cTemp[100];//生成运算串

::memset(cTemp,0,100);

GetCalString(cTemp,i,j,k,l);

printf("%2d,%2d,%2d,%2d %s ",i,j,k,l,cTemp);

::fprintf(pFile,"%2d,%2d,%2d,%2d %s ",i,j,k,l,cTemp);

nCount++;

if(nCount%2==0)

{

printf("\r\n");

fprintf(pFile,"\r\n");

}

}

else

nLossCount++;

}

}

}

}

printf("\r\n%d\r\n%d\r\n",nCount,nLossCount);

fprintf(pFile,"\r\n%d\r\n%d\r\n",nCount,nLossCount);

fclose(pFile);

}

可以，公式是：（1+7）x（6÷2）=24。

解题思路：利用3×8=24、4×6=24、12×2=24求解。

把牌面上的四个数想办法凑成3和8、4和6，再相乘求解，如3、3、6、10可组成（10-6÷3）×3=24等，又如2、3、3、7可组成（7+3-2）×3=24等，这种方法是利用率最大、命中率最高的一种方法。

24点具体玩法：

24点具体的玩法是：拿一副牌，抽去大小王后（初练也可以把J/Q/K/大小王也拿走），剩下1～10这40张牌，用1代替A。

任意抽取4张牌，用加、减、乘、除把牌面上的数算成24。每张牌必须用且只能用一次。如抽出的牌是3、8、8、9，那么算式为(9-8)×8×3=24。

program E1_1; {knight}

const

dx:array[18] of integer=(-2,-1,1,2,2,1,-1,-2);

dy:array[18] of integer=(1,2,2,1,-1,-2,-2,-1);

这个就是传说中的增量矩阵。其实也没那么神秘，就是一张表，有8种变化状态，每种状态对应了一个delta

x和y，比如第一种变化，x坐标减小2，y坐标加1。表示在棋盘上的8种行走方式。

var

n,m,x,y,i,j: byte;

g:array[020,020] of 01;

c:longint;

infile,outfile:text;

//这边是关键步骤

procedure sol(x,y:integer);

var i:integer;

begin

if (x=n) and (y=m) then c:=c+1（当前x,y坐标都为目标坐标，那么总路径c +1，c为统计的路径条数） else

begin//深搜，只有2个法则，向上y+1,向左x+1。并且判断有没有出界。

if (y<m) and (g[x,y+1]=0) then sol(x,y+1);

if (x<n) and (g[x+1,y]=0) then sol(x+1,y);

end;

end;

begin

assign(infile,'knightin');

assign(outfile,'knightout');

reset(infile);

readln(infile,n,m,x,y);

close(infile);

g[x,y] := 1;

for i:=1 to 8 do

if (x+dx[i]>=0) and (x+dx[i]<=n) and (y+dy[i]>=0) and (y+dy[i]<=m) then

g[x+dx[i],y+dy[i]]:=1;//给地图赋值，0为可走，1为被马控制，如g[1,1]=1说明坐标（1，1）点被控制了。

sol(0,0);//从坐标（0，0）开始走。

rewrite(outfile);

writeln(outfile,c);

close(outfile);

end

/----------------------------------------------------/

type arr=array [14] of integer;

var i,result,n,len:integer;

d:arr;

r:array [13,14] of integer;

procedure print; //打答案用的，r[i,1],r[i,3]为运算数字,r[i,2]为运算符，r[i,4]为答案

var i,j:integer;

begin

assign(output,'pointout'); rewrite(output);

for i:=1 to 3 do

begin

for j:=1 to 3 do

if j<>2 then write(r[i,j])

else case r[i,j] of

1:write('+');

2:write('-');

3:write('');

4:write('/')

end;

writeln('=',r[i,4])

end;

close(output);

end;

procedure try(k:integer;var d:arr); //枚举，d数组暂存结果

var a,b,i,j,l,t:integer;

e:arr;

begin

if k=1 then

if d[1]=24 then begin print;halt end

else

else begin

for i:=1 to k-1 do

for j:=i+1 to k do

begin

a:=d[i]; b:=d[j]; //枚举要用的两个数

if a<b then begin t:=a;a:=b;b:=t end;

t:=0;

for l:=1 to k do if (l<>i) and (l<>j) then begin t:=t+1;e[t]:=d[l] end; //将剩下的数放好

r[5-k,1]:=a;

r[5-k,3]:=b;

r[5-k,4]:=-1;

for l:=1 to 4 do //枚举运算符

begin

case l of

1:r[5-k,4]:=a+b;

2:r[5-k,4]:=a-b;

3:r[5-k,4]:=ab;

4:if b<>0 then if a mod b=0 then r[5-k,4]:=a div b

end;

r[5-k,2]:=l;

if r[5-k,4]<>-1 then

begin

e[t+1]:=r[5-k,4];

try(k-1,e)

end

end

end

end;

end;

begin

assign(input,'pointin');reset(input);

for i:=1 to 4 do read(d[i]);

close(input);

try(4,d);

assign(output,'pointout');rewrite(output);

writeln('No answer!');

close(output);

end

第1、3、5、7的空格是放牌的(每空一张牌),而第2、4、6的空格是放加减乘除的符号的(每空一个符号)

好,那么根据数学中的排列组合,4张牌放到4个空格里面有24种不同的排列,把4个符号放到3个空格里面也是有24种不同的排列,那么再把这两个排列再排列的话,就有2424=576种排列,那么你的程序要做的就是把这576种排列全部算过,结果是不是等于24就OK了,我想程序循环576下应该只要不到1秒的时间吧

以上就是关于24点游戏咋玩的啊全部的内容，包括:24点游戏咋玩的啊、怎样用c++编写24点游戏答案、1267你能用这4张牌凑出24吗等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！