扑克24点游戏JAVA源代码
1. 游戏规则简介
拿出一副扑克，随机发出四张扑克，要求游戏者随意组合使用+、-、×、÷四种算数方法，寻能计算出结果为24的方案。
2. 源码说明
本源码由本人单独完成，使用JAVA作为编码语言，其中使用泛型、枚举，JDK版本你懂的。
下列部分截图：
1. 类的内部结构图：
2. 部分方法截图：
3. 测试方法截图
4. 结果展示：
99478方片7+方片6*方片3-方片1=24.0
99479方片7+方片5+方片4*方片3=24.0
99480方片7+方片5*方片4-方片3=24.0
99481方片7+方片5*方片3+方片2=24.0
99482方片7*方片4-方片3-方片1=24.0
99483方片7*方片3+方片2+方片1=24.0
99484方片6+方片5*方片4-方片2=24.0
99485方片6*方片5-方片4-方片2=24.0
99486方片5*方片4+方片3+方片1=24.0
99487方片4*方片3*方片2*方片1=24.0
99488方片4*方片3*方片2/方片1=24.0
134********53
3. 源码
附带正文：
st.puke;
/**
*
* @author GuanChi
*    BUG说明：
*    1.应该优先计算乘法(10+7/4*8)或(7/4*8+10)两种情况
*    2.组合重复情况是否需要过滤，如上面
*/
public class Puke24Test
{
    public static void serviceExce()
    {
        int count = 0;
        Puke24Test puke24 =  new Puke24Test();
        PokerContainer PokerContainer = w PokerContainer();
        java.util.TreeSet<Poker> sPokers = Pokers();
        java.util.TreeMap<String, Poker> mPokers = TreeMapPokersByTreeSet(sPokers);
        Poker[] Pokers4 = new Poker[4];
        for (int i = 1; i <= mPokers.size(); i++)
        {
            Pokers4[0] = (""+i);
            for (int j = i+1; j <= mPokers.size(); j++)
            {
                Pokers4[1] = (""+j);
                for (int k = j+1; k <= mPokers.size(); k++)
                {
                    Pokers4[2] = (""+k);
                    for (int l = k+1; l <= mPokers.size(); l++)
                    {
                        Pokers4[3] = (""+l);
                        Expression24[] exps = calcBy4Pokers(Pokers4);
                        for (int m = 0; m < exps.length; m++)
                        {
                            if (null != exps[m] && 24 == exps[m].getResult())
手机游戏源码论坛
                            {
                                System.out.println(""+ ++count+exps[m]);
                            }
                        }
                    }
                }
            }
        }
       
        // 按次序获取四张牌，轮询所有组合方式，轮询所有计算方式，获取结果为24的
    }
   
    public static Expression24[] calcBy4Pokers(Poker[] pokers4)
    {
        Expression24[] exps = new Expression24[4*4*4*4*4*4*4];
        int n=0;
        // 第一个计算符号
        for (byte i = 1; i <= 4; i++)
        {
            // 第二个计算符号
            for (byte j = 1; j <= 4; j++)
            {
                // 第三个计算符号
                for (byte k = 1; k <= 4; k++)
                {
                    // 第一个计算扑克牌
                    for (int a = 1; a <= 4; a++)
                    {
                        // 第二个计算扑克牌
                        for (int b = a+1; b <= 4; b++)
                        {
                            // 第二张拍的脚码不能大于4，并且不能和前面牌重复
                            if (b>4)
                            {
                                b=-4;
                            }
                            // 第三个计算扑克牌
                            for (int c = b+1; c <= 4; c++)
                            {
                                // 第三张拍的脚码不能大于4，并且不能和前面牌重复
                                if (c>4)
                                {
                                    c=-4;
                                }
                                // 第四个计算扑克牌
                                for (int d = c+1; d <= 4; d++)
                                {
                                    // 第四张拍的脚码不能大于4，并且不能和前面牌重复
                                    if (d>4)
                                    {
                                        d=-4;
                                    }
                                    // 计算单个算式的值
                                    exps[n++] = calcByExp(
                                            pokers4[a-1],
                                            vertByteType2CS(i),
                                            pokers4[b-1],
                                            vertByteType2CS(j),
                                            pokers4[c-1],
                                            vertByteType2CS(k),
                                            pokers4[d-1]
                                                    );
                                }
                            }
                        }
                    }
                }
            }
        }
        return exps;
    }
   
   
   
   
   
   
   
    /**
    * 给定三个计算符号的顺序，把四张牌轮流各个位置，计算出结果
    * @param poker 第一张扑克
    * @param j 第一个计算符号
    * @param poker2 第二张扑克
    * @param k 第二个计算符号
    * @param poker3 第三张扑克
    * @param l 第三个计算符号
    * @param poker4 第四张扑克
    * @return 表达式
    * @attention ?代表未知符号在该方法注释里面
    */
    private static Expression24 calcByExp(Poker poker, Math.CountSymbol j, Poker poker2,
            Math.CountSymbol k, Poker poker3, Math.CountSymbol l, Poker poker4)

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。