1,4,5,6
3,8,3,8
能不能呀，好象不能嘛

1,4,5,6
3,8,3,8
需要用小数才能计算出来

我已从百度上搜到24点程序
4/(1-(5/6))=24
6/((5/4)-1)=24
-----------------
8/(3-(8/3))=24
------
呵呵，分数计算

#include "stdio.h"

bool    div0=false;      // 是否被0除的标志
double  cal(double a,double b,int op)
{
      switch (op)
        {
          case 0:   return(a+b);
          case 1:   return(a-b);
          case 2:   return(a*b);
        }
      if (b==0.0)
        {
          div0=true;          // 分母为0
          return(0);
        }
      return(a/b);
}
bool  isEqual(double d1,double d2)  // 两个浮点数是否近似相等
{
      if (div0)
        {
           div0=false;       // 清div0
           return(false);
        }
      double d=d1-d2;
      if (d<0)
          d=-d;             // 求绝对值
      return(d<=1e-3);
}

void __fastcall TForm1::Button4Click(TObject *Sender)
{
      char op[]={'+','-','*','/'};         //  +:0  -:1 *:2  /:3

      int v[4];
      v[0]=Edit1->Text.ToInt();            // 存四个数
      v[1]=Edit2->Text.ToInt();
      v[2]=Edit3->Text.ToInt();
      v[3]=Edit4->Text.ToInt();

      int count=0;
      for (int i1=0;i1<4;i1++)
      for (int i2=0;i2<4;i2++)
      for (int i3=0;i3<4;i3++)
      for (int i4=0;i4<4;i4++)
          if (i1!=i2 && i1!=i3 && i1!=i4 &&
              i2!=i3 && i2!=i4 &&
              i3!=i4)                        // 产生数的排列
         {
           int a,b,c,d;                      // 存放四张牌的一次排列
           a=v[i1];
           b=v[i2];
           c=v[i3];
           d=v[i4];                         // 四张牌的值a,b,c,d
           for (int f1=0;f1<4;f1++)            // 对运算符组合
           for (int f2=0;f2<4;f2++)
           for (int f3=0;f3<4;f3++)         // 运算符 f1,f2,f3
               {
                    double t1,t2,t3;        // 存放计算的中间值
                    // 第1种情况  ((a 。b)。c)。d  ：
                    div0=false;
                    t1=cal(a,b,f1);
                    t2=cal(t1,c,f2);
                    t3=cal(t2,d,f3);
                    if (isEqual(t3,24))
                       {
                         char buf[50];
                         sprintf(buf,"((%d%c%d)%c%d)%c%d=24",a,op[f1],b,op[f2],c,op[f3],d);
                         Memo1->Lines->Add(buf);
                         count++;
                       }
                    // 第2种情况(a 。b)。(c。 d)  ：
                    div0=false;
                    t1=cal(a,b,f1);
                    t2=cal(c,d,f3);
                    t3=cal(t1,t2,f2);
                    if (isEqual(t3,24))
                       {
                         char buf[50];
                         sprintf(buf,"(%d%c%d)%c(%d%c%d)=24",a,op[f1],b,op[f2],c,op[f3],d);
                         Memo1->Lines->Add(buf);
                         count++;
                       }
                    // 第3种情况 (a。(b。c))。d  ：
                    div0=false;
                    t1=cal(b,c,f2);
                    t2=cal(a,t1,f1);
                    t3=cal(t2,d,f3);
                    if (isEqual(t3,24))
                       {
                         char buf[50];
                         sprintf(buf,"(%d%c(%d%c%d))%c%d=24",a,op[f1],b,op[f2],c,op[f3],d);
                         Memo1->Lines->Add(buf);
                         count++;
                       }
                    // 第4种情况  a。((b。c)。d )  ：
                    div0=false;
                    t1=cal(b,c,f2);
                    t2=cal(t1,d,f3);
                    t3=cal(a,t2,f1);
                    if (isEqual(t3,24))
                       {
                          char buf[50];
                          sprintf(buf,"%d%c((%d%c%d)%c%d)=24",a,op[f1],b,op[f2],c,op[f3],d);
                          Memo1->Lines->Add(buf);
                          count++;
                       }
                    // 第5种情况 a。(b。(c。d))  ：
                    div0=false;
                    t1=cal(c,d,f3);
                    t2=cal(b,t1,f2);
                    t3=cal(a,t2,f1);
                    if (isEqual(t3,24))
                       {
                          char buf[50];
                          sprintf(buf,"%d%c(%d%c(%d%c%d))=24",a,op[f1],b,op[f2],c,op[f3],d);
                          Memo1->Lines->Add(buf);
                          count++;
                       }
                }
           }
        if (count==0)
           {
               String s=String(v[0])+","+String(v[1])+","+
                        String(v[2])+","+String(v[3])+" 不能算出24";
               Memo1->Lines->Add(s);
           }    
}
//---------------------------------------------------------------------------

用多重循环采用穷举法，这程序绝对简单，没有什么高深的东西。

先试下，惊喜中。。。。。

百度看了许多文章，昨天试了一个晚上，这个穷举法简单方法很满意，也没有用什么堆栈，
也没有用高深的东东，可以很快的列出计算24点的各种可能性，简单快速。
四个数排列的穷举次数：4!=24种
三个运算符的穷举次数：4X4X4=64次
用括号决定的运算优先级： 3！-1=5次，
所以。穷举总次数  24*64*5=7680次 不到1秒钟就执行完