【Nodejs】“快算24”扑克牌游戏算法 1.02
快算24是一种挺好的锻炼孩子算数能力的扑克牌游戏，它的游戏方式是把四张牌的牌面数值通过有限四则运算得到结果24，四张牌必须仅用一次。各地玩法还有点差别，有的只算1-10，其它抽出来；有的地方把整幅牌都算上，把其中J当作11,Q当作12，K当作13，小王当作15，大王当作18. 个人觉得后者不但省了理牌的功夫还更能锻炼人。
绝大多数四张牌的组合都容易算出来，有部分就要费点脑筋了，如5，5，5，1；3，7，3，7；12，12，12，10...，当然也有完全算不出来的，如5，7，8，11；1，1，6，11...从规律上讲，似乎5，7，11，13这样的素数参与越多越是难算。
算24也是有窍门的，那就是逐步缩小范围，具体来说是看三个数运算能否和第四个数通过加减乘除得到24，继而看三个数操作能否得到24和第四个数的四则运算结果，继而看两个数的操作能否得到第三个数和上次结果的四则运算结果。具体比如有2，3，4，12四个数，看到12后想2，3，4是否能组合个2出来，然后想到2*3-4的方案，或者2*（4-3）的方案。
按照这个思维我编了下面的程序。具体思路是这样的，先制作一个C4类(2,3,4,12,24),这个类会形成24种组合（以及六种特殊组合方式），再由24种组合生成6种子方案，子方案又生成六种孙方案，最后挑选出符合条件的结果。
//======================================================
// 算24 C4 1.02
// 整理代码，去掉一些多余冗杂的地方
// 2018年4月23日 完成
// 2019年3月2日修改
//======================================================
//======================================================
// 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.findComputeMethods=function(){
var micro=0.000001 // 定义一个极小量，运算结果绝对值小于它就算相等
var arr=[];
// 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-(op1-op2))<micro){
arr.push(op1+"-"+op2);
}
// op2-op1
if(Math.abs(result-(op2-op1))<micro){
arr.push(op2+"-"+op1);
}
// op1/op2
if(Math.abs(result-op1/op2)<micro){
arr.push(op1+"/"+op2);
}
// op2/op1
if(Math.abs(result-op2/op1)<micro){
arr.push(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.findComputeMethods=function(){
var retArr=[];// 最终返回数组
// 排列数组，三个操作数共有6种排列方式
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],
];
for(var i=0;i<permutationArr.length;i++){
var arr=permutationArr[i];
var op1=arr[0];
var op2=arr[1];
var op3=arr[2];
// [op1,op2]-op3
var c2=new C2(op1,op2,this.result+op3);
var methods=c2.findComputeMethods();
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.findComputeMethods();
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.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push('('+methods[j]+")"+"+"+op3);
}
// op3-[op1,op2]
c2=new C2(op1,op2,op3-this.result);
methods=c2.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push(op3+"-"+'('+methods[j]+")");
}
// [op1,op2]*op3
c2=new C2(op1,op2,this.result/op3);
methods=c2.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push('('+methods[j]+")"+"*"+op3);
}
// op3/[op1,op2]
c2=new C2(op1,op2,op3/this.result);
methods=c2.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push(op3+"/"+'('+methods[j]+")");
}
}
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.findComputeMethods=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];
// [op1,op2,op3]-op4
var c3=new C3(op1,op2,op3,this.result+op4);
var methods=c3.findComputeMethods();
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.findComputeMethods();
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.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push('('+methods[j]+")"+"+"+op4);
}
// op4-[op1,op2,op3]
var c3=new C3(op1,op2,op3,op4-this.result);
var methods=c3.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push(op4+"-"+'('+methods[j]+")");
}
// [op1,op2,op3]*op4
var c3=new C3(op1,op2,op3,this.result/op4);
var methods=c3.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push('('+methods[j]+")"+"*"+op4);
}
// op4/[op1,op2,op3]
var c3=new C3(op1,op2,op3,op4/this.result);
var methods=c3.findComputeMethods();
for(var j=0;j<methods.length;j++){
retArr.push(op4+"/"+'('+methods[j]+")");
}
// 以下为C4中特有的先成对组合再看运算结果的六种情况
// op1*op2-op3*op4
if(op1*op2-op3*op4==result){
retArr.push(op1+"*"+op2+"-"+op3+"*"+op4);
}
// op1*op2+op3*op4
if(op1*op2+op3*op4==result){
retArr.push(op1+"*"+op2+"+"+op3+"*"+op4);
}
// op1/op2-op3/op4
if(op1/op2-op3/op4==result){
retArr.push(op1+"/"+op2+"-"+op3+"/"+op4);
}
// op1/op2+op3/op4
if(op1/op2+op3/op4==result){
retArr.push(op1+"/"+op2+"+"+op3+"/"+op4);
}
// op1*op2-op3/op4
if(op1*op2-op3/op4==result){
retArr.push(op1+"*"+op2+"-"+op3+"/"+op4);
}
// op1*op2+op3/op4
if(op1*op2+op3/op4==result){
retArr.push(op1+"*"+op2+"+"+op3+"/"+op4);
}
}
return retArr;
}
return obj;
}
//======================================================
// 用来得到仅包含不重复元素的数组
// arr:传入的数组
//======================================================
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 RESULT=24 // 定义24这个结果
process.stdin.resume();
process.stdout.write("\033[33m 请输入四个数字，用逗号分隔: \033[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,RESULT);
var arr=getDistinctArray(c4.findComputeMethods());
if(arr.length>0){
for(var i=0;i<arr.length;i++){
console.log(arr[i]+"="+RESULT);
}
}else{
console.log(input+"这四个数无法计算得到24");
}
});
}
// 开始
main();
运行效果是这样的：
C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 12,2,3,8 ((12-8)*2)*3=24 ((12-8)*3)*2=24 ((12/2)-3)*8=24 ((12/3)+8)*2=24 ((3*8)-12)*2=24 ((3*8)/2)+12=24 ((3/2)*8)+12=24 ((8*3)-12)*2=24 ((8*3)/2)+12=24 ((8-2)*12)/3=24 ((8-2)/3)*12=24 ((8/2)*3)+12=24 (12-(8/2))*3=24 (3/(2/8))+12=24 (8-(2*3))*12=24 (8-(3*2))*12=24 (8/(2/3))+12=24 12/(3/(8-2))=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 4,4,4,4 ((4*4)+4)+4=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 9,9,9,9 9,9,9,9这四个数无法计算得到24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 10,10,4,4 ((10*10)-4)/4=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 8,8,8,8 8,8,8,8这四个数无法计算得到24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 6,6,6,6 ((6*6)-6)-6=24 ((6+6)+6)+6=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 5,5,5,5 5*5-5/5=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 3,3,3,3 ((3*3)*3)-3=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 2,2,2,2 2,2,2,2这四个数无法计算得到24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 12,12,12,12 ((12*12)/12)+12=24 ((12+12)*12)/12=24 ((12+12)+12)-12=24 ((12+12)-12)+12=24 ((12+12)/12)*12=24 ((12-12)+12)+12=24 ((12/12)*12)+12=24 (12-(12-12))+12=24 (12/(12/12))+12=24 12-((12-12)-12)=24 12-(12-(12+12))=24 12/(12/(12+12))=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 11,13,4,2 11,13,4,2这四个数无法计算得到24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 12,11,13,1 ((1*13)-11)*12=24 ((13*1)-11)*12=24 ((13-11)*1)*12=24 ((13-11)*12)*1=24 ((13-11)*12)/1=24 ((13-11)/1)*12=24 ((13/1)-11)*12=24 (13-(1*11))*12=24 (13-(11*1))*12=24 (13-(11/1))*12=24 12/(1/(13-11))=24 C:\Users\horn1\Desktop\node.js\56-算24c41.02>node c24.js 请输入四个数字，用逗号分隔: 8,7,9,10 (8/(10-7))*9=24 (9/(10-7))*8=24 8/((10-7)/9)=24 9/((10-7)/8)=24
还有：
各位家长可以在和孩子玩这个游戏实在算不出来时验证下看有没有解决方案。
【Nodejs】“快算24”扑克牌游戏算法 1.02的更多相关文章
- 【Nodejs】“快算24”扑克牌游戏算法
算24是一款扑克牌游戏,它的游戏方式是把四张牌的牌面数值通过四则运算得到结果24,四张牌必须仅用一次.这是一种挺好的锻炼孩子算数能力的扑克牌游戏. 各地玩法还有点差别,有的只算1-10,其它抽出来:有 ...
- 【Nodejs】“快算24”扑克牌游戏算法 1.01
考虑到1.00版本需要改源码变更四个数字,这版修改了一下变成控制台输入了. 先把两个数四则运算得到结果想清楚就是C2代码,三个数就是C3,四个数就是C4.简单的代码简单,却是复杂的基础:复杂的脱胎于简 ...
- php实现 24点游戏算法
php实现 24点游戏算法 一.总结 一句话总结:把多元运算转化为两元运算,先从四个数中取出两个数进行运算,然后把运算结果和第三个数进行运算,再把结果与第四个数进行运算.在求表达式的过程中,最难处理的 ...
- POJ 3983：快算24
快算24 Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 4791 Accepted: 2930 Description ...
- 快算24点，POJ(3983)
题目链接:http://poj.org/problem?id=3983 中文题,就不解释题意了. 类似之前的一篇博客,这里也不上解释了,直接上代码吧. #include <iostream> ...
- POJ3983 快算24
很正常的题目,迷一样的答案. 测试数据只有一组,对没错只有一组. #include<cstdio> int main() { printf("5*(5-(1/5))\n" ...
- python实现算24的算法
1.介绍 给定4个整数,数字范围在1-13之间,任意使用 + - * / ( ) ,构造出一个表达式,使得最终结果为24,这就是常见的算24的游戏.本文介绍用Python语言实现的两种方式.2.实现思 ...
- 用python代替人脑运算24点游戏
前言 文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理. 作者:老方玩编程 PS:如有需要Python学习资料的小伙伴可以加点击下方链 ...
- python实例：解决经典扑克牌游戏 -- 四张牌凑24点 （二）
Hey! 如果你还没有看这篇的上文的话,可以去稍稍瞅一眼,会帮助加速理解这一篇里面涉及到的递归结构哦!(上一篇点这里:<python实例:解决经典扑克牌游戏 -- 四张牌凑24点 (一)> ...
随机推荐
- [BZOJ5302][HAOI2018]奇怪的背包(DP)
由裴蜀定理得,一个集合S能得到w当且仅当gcd(S+{P})|w. 于是f[i][j]表示前i个物品gcd为j的方案数,发现gcd一定是P的因数,故总复杂度$O(n\sqrt{P}\log P)$(需 ...
- 【2017多校训练08 1002】【HDOJ 6134】Battlestation Operational
典型的数列反演题. 运用莫比乌斯反演的一个结论 $[n = 1] = \sum_{d | n} \mu(d)$,将表达式做如下转化: $$ ans = \sum_{i=1}^n \sum_{j=1}^ ...
- python开发_tkinter_获取单选菜单值
在之前的blog中有提到python的tkinter中的菜单操作 python开发_tkinter_窗口控件_自己制作的Python IDEL_博主推荐 python开发_tkinter_窗口控件_自 ...
- Notepad++源代码阅读——窗口封装与继承
引言 近期在看Notepad++的源代码,学习学习Win32 原生API的开发技巧. 本文以Notepad++ 1.0版本的源代码为例讲解如何封装windows窗口,实现面向对象开发,如何通过窗口的继 ...
- echarts3相关的各种定制化
在我刚把项目中的echarts从2.x版本升级到echarts3.x,折腾老久,终于交付了项目的时候,echarts4又出来了,先不管,还是把我echarts3.x遇到的和formatter相关的问题 ...
- MySQLAdmin的用法
mysqladmin 适合于linux和windows系统 linux下:mysqladmin -u[username] -p[password] status windows下:先在安装目录找到my ...
- mysql 5.6 与5.7安装
http://blog.itpub.net/29733787/viewspace-1590891/ http://www.oschina.net/code/snippet_7933_45700
- java classpath作用
环境变量的配置: 1):永久配置方式:JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2):临时配置方式:set path=%path%;C:\Progr ...
- java内存溢出示例(堆溢出、栈溢出)
堆溢出: /** * @author LXA * 堆溢出 */ public class Heap { public static void main(String[] args) { ArrayLi ...
- nsstring 怎么包含”(引号)号
使用转义字符 \ 即可.如下: [NSString *string = @"\"好\""]; NSLog("%@",string); 打印结 ...