【Nodejs】“快算24”扑克牌游戏算法 1.01

考虑到1.00版本需要改源码变更四个数字，这版修改了一下变成控制台输入了。

先把两个数四则运算得到结果想清楚就是C2代码，三个数就是C3，四个数就是C4.简单的代码简单，却是复杂的基础；复杂的脱胎于简单，但还有自己的特性。

新代码如下：

//======================================================
// 算24 C4 1.01
// 增加控制台输入，避免改源码了
// 2018年4月18日
//======================================================

var micro=0.000001 // 定义一个极小量，运算结果绝对值小于它就算相等

//======================================================
// C2类，用于判断两个数通过加减乘除运算能否得到某个结果
// C代表Caculate，2代表两个操作数
// op1:操作数1,op2:操作数2,result,结果
//======================================================
function C2(op1,op2,result){
    var obj=new Object();
    obj.op1=op1;
    obj.op2=op2;
    obj.result=result;

    obj.findComputationMethods=function(){
        var arr=[];

        if(Math.abs(result-(op1+op2))<micro){
            arr.push(op1+"+"+op2);    // op1+op2
        }
        
        if(Math.abs(result-op1*op2)<micro){
            arr.push(op1+"*"+op2);    // op1*op2
        }
        
        if(Math.abs(result-(op1-op2))<micro){
            arr.push(op1+"-"+op2);    // op1-op2
        }
        
        if(Math.abs(result-(op2-op1))<micro){
            arr.push(op2+"-"+op1);    // op2-op1
        }
        
        if(Math.abs(result-op1/op2)<micro){
            arr.push(op1+"/"+op2);    // op1/op2
        }
        
        if(Math.abs(result-op2/op1)<micro){
            arr.push(op2+"/"+op1);    // op2/op1
        }

        return arr;
    }

    return obj;
}

//======================================================
// C3类，用于判断三个数通过加减乘除运算能否得到某个结果
// C代表Caculate，3代表两个操作数
// op1:操作数1,op2:操作数2,op3:操作数3,result,结果
//======================================================
function C3(op1,op2,op3,result){
    var obj=new Object();
    obj.op1=op1;
    obj.op2=op2;
    obj.op3=op3;
    obj.result=result;

    obj.findComputationMethods=function(){
        var retArr=[];// 返回数组

        var permutationArr=[ [this.op1,this.op2,this.op3],
                        [this.op1,this.op3,this.op2],
                        [this.op2,this.op1,this.op3],
                        [this.op2,this.op3,this.op1],
                        [this.op3,this.op2,this.op1],
                        [this.op3,this.op1,this.op2], ]; // 排列数组，三个操作数共有6种排列方式

        for(var i=0;i<permutationArr.length;i++){
            var arr=permutationArr[i];
            var op1=arr[0];
            var op2=arr[1];
            var op3=arr[2];

            var c2=new C2(op1,op2,this.result+op3);
            var methods=c2.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"-"+op3);// [op1,op2]-op3
                }
            }

            c2=new C2(op1,op2,this.result*op3);
            methods=c2.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"/"+op3);// [op1,op2]/op3
                }
            }

            c2=new C2(op1,op2,this.result-op3);
            methods=c2.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"+"+op3);// [op1,op2]+op3
                }
            }

            c2=new C2(op1,op2,op3-this.result);
            methods=c2.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push(op3+"-"+'('+methods[j]+")");// op3-[op1,op2]
                }
            }

            c2=new C2(op1,op2,this.result/op3);
            methods=c2.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"*"+op3);// [op1,op2]*op3
                }
            }

            c2=new C2(op1,op2,op3/this.result);
            methods=c2.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push(op3+"/"+'('+methods[j]+")");// op3/[op1,op2]
                }
            }
        }

        

        return retArr;
    };

    return obj;
}

//======================================================
// C4类，用于判断三个数通过加减乘除运算能否得到某个结果
// C代表Caculate，4代表两个操作数
// op1:操作数1,op2:操作数2,op3:操作数3,op4:操作数4,result,结果
//======================================================
function C4(op1,op2,op3,op4,result){
    var obj=new Object();
    obj.op1=op1;
    obj.op2=op2;
    obj.op3=op3;
    obj.op4=op4;
    obj.result=result;

    obj.findComputationMethods=function(){
        var retArr=[];// 返回数组

        var permutationArr=[    [this.op1,this.op2,this.op3,this.op4],
                             [this.op1,this.op2,this.op4,this.op3],
                             [this.op1,this.op3,this.op2,this.op4],
                             [this.op1,this.op3,this.op4,this.op2],
                             [this.op1,this.op4,this.op2,this.op3],
                             [this.op1,this.op4,this.op3,this.op2], 
                                [this.op2,this.op1,this.op3,this.op4],
                             [this.op2,this.op1,this.op4,this.op3],
                             [this.op2,this.op3,this.op1,this.op4],
                             [this.op2,this.op3,this.op4,this.op1],
                             [this.op2,this.op4,this.op1,this.op3],
                             [this.op2,this.op4,this.op3,this.op1], 
                                [this.op3,this.op1,this.op2,this.op4],
                             [this.op3,this.op1,this.op4,this.op2],
                             [this.op3,this.op2,this.op1,this.op4],
                             [this.op3,this.op2,this.op4,this.op1],
                             [this.op3,this.op4,this.op1,this.op2],
                             [this.op3,this.op4,this.op2,this.op1], 
                                [this.op4,this.op1,this.op2,this.op3],
                             [this.op4,this.op1,this.op3,this.op2],
                             [this.op4,this.op2,this.op1,this.op3],
                             [this.op4,this.op2,this.op3,this.op1],
                             [this.op4,this.op3,this.op1,this.op2],
                             [this.op4,this.op3,this.op2,this.op1], 
                           ]; // 排列数组，四个操作数共有24种排列方式

        for(var i=0;i<permutationArr.length;i++){
            var arr=permutationArr[i];
            
            var op1=arr[0];
            var op2=arr[1];
            var op3=arr[2];
            var op4=arr[3];            

            var c3=new C3(op1,op2,op3,this.result+op4);
            var methods=c3.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"-"+op4);// [op1,op2,op3]-op4
                }
            }

            var c3=new C3(op1,op2,op3,this.result*op4);
            var methods=c3.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"/"+op4);// [op1,op2,op3]/op4
                }
            }

            var c3=new C3(op1,op2,op3,this.result-op4);
            var methods=c3.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"+"+op4);// [op1,op2,op3]+op4
                }
            }

            var c3=new C3(op1,op2,op3,op4-this.result);
            var methods=c3.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push(op4+"-"+'('+methods[j]+")");// op4-[op1,op2,op3]
                }
            }

            var c3=new C3(op1,op2,op3,this.result/op4);
            var methods=c3.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push('('+methods[j]+")"+"*"+op4);// [op1,op2,op3]*op4
                }
            }

            var c3=new C3(op1,op2,op3,op4/this.result);
            var methods=c3.findComputationMethods();
            if(methods.length>0){
                for(var j=0;j<methods.length;j++){
                    retArr.push(op4+"/"+'('+methods[j]+")");// op4/[op1,op2,op3]
                }
            }

            if(op1*op2-op3*op4==result){
                retArr.push(op1+"*"+op2+"-"+op3+"*"+op4);// op1*op2-op3*op4,这是c3里不曾有的
            }

            if(op1*op2+op3*op4==result){
                retArr.push(op1+"*"+op2+"+"+op3+"*"+op4);// op1*op2+op3*op4,这是c3里不曾有的
            }

            if(op1/op2-op3/op4==result){
                retArr.push(op1+"/"+op2+"-"+op3+"/"+op4);// op1/op2-op3/op4,这是c3里不曾有的
            }

            if(op1/op2+op3/op4==result){
                retArr.push(op1+"/"+op2+"+"+op3+"/"+op4);// op1/op2+op3/op4,这是c3里不曾有的
            }

            if(op1*op2-op3/op4==result){
                retArr.push(op1+"*"+op2+"-"+op3+"/"+op4);// op1*op2-op3/op4,这是c3里不曾有的
            }

            if(op1*op2+op3/op4==result){
                retArr.push(op1+"*"+op2+"+"+op3+"/"+op4);// op1*op2+op3/op4,这是c3里不曾有的
            }
        }

        return retArr;
    }

    return obj;
}

//======================================================
// 用来得到仅包含不重复元素的数组
//======================================================
function getDistinctArray(arr){
    var returnArr=new Array();

    var sortedArr=arr.sort();
    for(var i=0;i<sortedArr.length;i++){
        if(returnArr[returnArr.length-1]!=sortedArr[i]){
            returnArr.push(sortedArr[i]);
        }
    }

    return returnArr;
}

//======================================================
// 程序入口
//======================================================
function main(){
    /*var c4=new C4(6,7,10,10,24);
    var arr=getDistinctArray(c4.findComputationMethods());

    for(var i=0;i<arr.length;i++){
        console.log(arr[i]+"=24");    
    }    */

    process.stdin.resume();    
    process.stdout.write("33[33m 请输入四个数字，用逗号分隔: 33[39m");// 草黄色
    process.stdin.setEncoding('utf8');
    
    process.stdin.on('data',function(text){
        var input=text.trim();
        process.stdin.end();// 退出输入状态  

        var arrTemp=input.split(",");
        var op1=parseInt(arrTemp[0],10);
        var op2=parseInt(arrTemp[1],10);
        var op3=parseInt(arrTemp[2],10);
        var op4=parseInt(arrTemp[3],10);

        var c4=new C4(op1,op2,op3,op4,24);
        var arr=getDistinctArray(c4.findComputationMethods());

        if(arr.length>0){
            for(var i=0;i<arr.length;i++){
                console.log(arr[i]+"=24");    
            }
        }else{
            console.log(input+"这四个数无法计算得到24");
        }
    });
}

// 开始
main();

控制台输出示例如下：

C:Usershorn1Desktop
ode.js54-算24c41.01>node c24.js
 请输入四个数字，用逗号分隔: 4,8,13,2
((13*8)/4)-2=24
((13/4)*8)-2=24
((8*13)/4)-2=24
((8/4)*13)-2=24
(13/(4/8))-2=24
(8/(4/13))-2=24
13*2-8/4=24
2*13-8/4=24

C:Usershorn1Desktop
ode.js54-算24c41.01>node c24.js
 请输入四个数字，用逗号分隔: 2,7,5,11
((11*2)+7)-5=24
((11*2)-5)+7=24
((11*5)-7)/2=24
((2*11)+7)-5=24
((2*11)-5)+7=24
((5*11)-7)/2=24
((7-5)*11)+2=24
2-((5-7)*11)=24
7-(5-(11*2))=24
7-(5-(2*11))=24

C:Usershorn1Desktop
ode.js54-算24c41.01>node c24.js
 请输入四个数字，用逗号分隔: 13,11,1,3
13,11,1,3这四个数无法计算得到24

C:Usershorn1Desktop
ode.js54-算24c41.01>node c24.js
 请输入四个数字，用逗号分隔: 8,11,1,3
((11*3)-1)-8=24
((11*3)-8)-1=24
((3*11)-1)-8=24
((3*11)-8)-1=24