pongo题解之24点扑克牌游戏--C++实现

最新推荐文章于 2024-02-05 20:23:18 发布
最新推荐文章于 2024-02-05 20:23:18 发布
阅读量9.2k 收藏
点赞数
分类专栏： C++语言 数据结构与算法 面试题解 CSDN英雄会题解 文章标签： 庞果网 pongo 英雄会 24点扑克牌游戏 题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhu_eternalcc/article/details/9878713
版权

24点扑克牌游戏，就是用a，b，c，d（1<=a,b,c,d<=13 ,正整数）和运算符op1，op2，op3（+、-、×、/  注意：此处/不是整除）以及括号来拼凑出24，首先考虑枚举（蛮力）a，b，c，d的排列和op1，op2，op3的排列进行一一尝试，其中只需计算下面5个式子（将运算符看作中间结点，操作数看作叶子结点的树只有5种形状，其他式子可有运算符的不同排列转换为这5种之一）：

(1)        ((a op1 b) op2 c) op3 d

(2)        (a op1 (b op2 c)) op3 d

(3)        (a op1 b) op2 (c op3 d)

(4)        a op1 ((b op2 c) op3 d)

(5)        a op1 (b op2 (c op3 d))

生成运算符的排列：考虑到三个减号时不成立，可以由{+++,--,***,///}中随意选择三个的组合再生成排列，共 A4,3+ A4,2 * A3,3/A2,2 +3=63中运算符排列，这个排列的生成可以通过静态变量只在第一调运函数时生成（当然这个可以打表）。

操作数排列（johnson-trotter算法）：如果将a，b，c，d的排列全部生成出来再和运算符的排列通过双层循环一一尝试的话，效率不高，所以没得到a，b，c，d的一个新排列就尝试上面5个式子在运算符排列下是否成立。

i5+4G内存下：测试所有用例（1820个）有1362个成立，时间是1.7s左右

在pongo的hero在线测试0.5s左右

部分源代码如下：

#include<iostream>
#include<vector>
#include<stack>
#include<algorithm>
#include<set>
#include<cmath>
#include<fstream>
#include<ctime>
const double pre=0.0001;
const double N=24;
std::set<std::vector<char>> resOp;//+-*/的所有排列
void combination(size_t n,std::vector<char> & v,std::vector<std::vector<char>>&res){//组合Cm,n m=v.size()
	if(n<=0||n>v.size())return;
	std::vector<size_t> pos;
	std::vector<char>r;
	for(size_t i=0;i<n;i++){
		pos.push_back(i);
		r.push_back(v[i]);
	}
	while(true){
		res.push_back(r);
		while(pos[n-1]!=v.size()-1){
			pos[n-1]++;
			r[n-1]=v[pos[n-1]];
			res.push_back(r);
		}//while
		int i=1;
		while(pos[n-1-i]==v.size()-1-i){
			if(i==n-1) return;
			i++;
		}//while
		pos[n-1-i]++;
		r[n-1-i]=v[pos[n-1-i]];
		size_t k=1;
		for(size_t j=n-i;j<=n-1;j++){
			pos[j]=pos[n-1-i]+k;
			k++;
			r[j]=v[pos[j]];
		}
	}//while (true)
}//combination()
template<typename dType >
void permutation(std::vector<dType> & v,std::set<std::vector<dType>>&resV){//由v生成排列
	if(v.size()<=0)return;
	std::vector<size_t> mid;//
	std::vector<int>direct;
	for(size_t i=0;i<v.size();i++){
		mid.push_back(i);
		direct.push_back(-1);
	}//for
	resV.insert(v);
	size_t moveEle=v.size()-1;
	size_t midP;
	size_t midMax;
	while(mid[moveEle]>0){//其实用不到	
		midP=mid[moveEle];
		mid[moveEle]=mid[moveEle+direct[midP]];
		mid[moveEle+direct[midP]]=midP;
		char midV=v[moveEle];
		v[moveEle]=v[moveEle+direct[midP]];
		v[moveEle+direct[midP]]=midV;
		resV.insert(v);
		midMax=midP;
		for(std::vector<size_t>::const_iterator cit=mid.begin();cit!=mid.end();cit++){
			if(*cit>midP){
				direct[*cit]*=-1;
				if(direct[*cit]==1&&cit+1!=mid.end()||direct[*cit]==-1&&cit!=mid.begin()){
					if(*cit>*(cit+direct[*cit])&&*cit>midMax){
						midMax=*cit;
						moveEle=cit-mid.begin();
					}//if
				}//if
			}//if
		}//for
		if(midMax==midP){
			size_t i=midP;
			for(i=midP;i>0;i--){
				std::vector<size_t>::iterator it=std::find(mid.begin(),mid.end(),i);
				if(direct[i]==1&&it+1!=mid.end()||direct[i]==-1&&it!=mid.begin()){
					if(i>*(it+direct[i])){
						moveEle=it-mid.begin();
						break;
					}//
				}//
			}//for
			if(i==0) break;
		}//if
	}//while
}//permutation
inline double comp(double a,double b,char op){
	if('+'==op)
		return a+b;
	if('-'==op)
		return a-b;
	if('*'==op)
		return a*b;
	else if('/'==op)
		return a/b;
	else 
		exit(1);
}
inline bool op1(int a,int b,int c,int d,char op1,char op2,char op3){//1
	if(std::fabs(comp(comp(comp(a,b,op1),c,op2),d,op3)-N)<=pre) return true;
	else return false;
}
inline bool op2(int a,int b,int c,int d,char op1,char op2,char op3){//2
	if(std::fabs(comp(comp(a,comp(b,c,op2),op1),d,op3)-N)<=pre) return true;
	else return false;
}
inline bool op3(int a,int b,int c,int d,char op1,char op2,char op3){//3
	if(std::fabs(comp(comp(a,b,op1),comp(c,d,op3),op2)-N)<=pre) return true;
	else return false;
}
inline bool op4(int a,int b,int c,int d,char op1,char op2,char op3){//4
	if(std::fabs(comp(a,comp(comp(b,c,op2),d,op3),op1)-N)<=pre) return true;
	else return false;
}
inline bool op5(int a,int b,int c,int d,char op1,char op2,char op3){//5
	if(std::fabs(comp(a,comp(b,comp(c,d,op3),op2),op1)-N)<=pre) return true;
	else return false;
}

void compOp(){
	std::vector<char> v;
	std::vector<std::vector<char>> res;
	v.push_back('+');
	v.push_back('+');
	v.push_back('-');
	v.push_back('-');
	v.push_back('*');
	v.push_back('*');
	v.push_back('/');
	v.push_back('/');
	v.push_back('/');
	combination(3,v,res);//C9,3
	for(std::vector<std::vector<char>>::iterator cit=res.begin();cit!=res.end();cit++)
		permutation(*cit,resOp);
}
int can24(int a,int b, int c,int d){//1=<a,b,c,d<=13
	//static bool firstTime=true; 
	int midVal =a+b+c+d;
	if(midVal==N){
		//std::cout<<a<<"+"<<b<<"+"<<c<<"+"<<d<<std::endl;
		return 1;	
	}
	midVal=a*b*c*d;
	if(midVal==N){
		//std::cout<<a<<"*"<<b<<"*"<<c<<"*"<<d<<std::endl;
		return 1;
	}
	/*if(firstTime){
		compOp();
		firstTime=false;
	}*/
	int flag=0;
	char ops [][3]={{'*','*','+'},{'*','*','-'},{'*','*','/'},{'*','+','*'},{'*','+','+'},{'*','+','-'},{'*','+','/'},{'*','-','*'},{'*','-','+'},{'*','-','-'},{'*','-','/'},{'*','/','*'},{'*','/','+'},{'*','/','-'},{'*','/','/'},{'+','*','*'},{'+','*','+'},{'+','*','-'},{'+','*','/'},{'+','+','*'},{'+','+','-'},{'+','+','/'},{'+','-','*'},{'+','-','+'},{'+','-','-'},{'+','-','/'},{'+','/','*'},{'+','/','+'},{'+','/','-'},{'+','/','/'},{'-','*','*'},{'-','*','+'},{'-','*','-'},{'-','*','/'},{'-','+','*'},{'-','+','+'},{'-','+','-'},{'-','+','/'},{'-','-','*'},{'-','-','+'},{'-','-','/'},{'-','/','*'},{'-','/','+'},{'-','/','-'},{'-','/','/'},{'/','*','*'},{'/','*','+'},{'/','*','-'},{'/','*','/'},{'/','+','*'},{'/','+','+'},{'/','+','-'},{'/','+','/'},{'/','-','*'},{'/','-','+'},{'/','-','-'},{'/','-','/'},{'/','/','*'},{'/','/','+'},{'/','/','-'},{'/','/','/'}};
	std::vector<int> vData;
	vData.push_back(a);
	vData.push_back(b);
	vData.push_back(c);
	vData.push_back(d);
	std::set<std::vector<int>> resData;
	//permutation(vData,resData);

	std::vector<size_t> mid;//
	std::vector<int>direct;
	for(size_t i=0;i<vData.size();i++){
		mid.push_back(i);
		direct.push_back(-1);
	}//for
	//resPos.push_back(mid);
	resData.insert(vData);
	std::vector<int>::iterator abcdIt=vData.begin();
	a=*abcdIt;
	abcdIt++;
	b=*abcdIt;
	abcdIt++;
	c=*abcdIt;
	abcdIt++;
	d=*abcdIt;
	for(int opi=0;opi<=60;opi++){
		if(op1(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
			///std::cout<<"method 1:"<<std::ends;
			//std::cout<<"(("<<(*citj)[0]<<(*cit)[0]<<(*citj)[1]<<")"<<(*cit)[1]<<(*citj)[2]<<")"<<(*cit)[2]<<(*citj)[3]<<std::endl;
			flag=1;
			return flag;
		}//if1
		if(op2(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
			///std::cout<<"method 2:"<<std::ends;
			//std::cout<<"("<<(*citj)[0]<<(*cit)[0]<<"("<<(*citj)[1]<<(*cit)[1]<<(*citj)[2]<<")"<<")"<<(*cit)[2]<<(*citj)[3]<<std::endl;
			flag=1;
			return flag;
		}//if2
		if(op3(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
			///std::cout<<"method 3:"<<std::ends;
			//std::cout<<"("<<(*citj)[0]<<(*cit)[0]<<(*citj)[1] <<")"<<(*cit)[1]<<"("<<(*citj)[2]<<(*cit)[2]<<(*citj)[3]<<")"<<std::endl;
			flag=1;
			return flag;
		}//if3
		if(op4(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
			///std::cout<<"method 4:"<<std::ends;
			//std::cout<<(*citj)[0]<<(*cit)[0]<<"("<<"("<<(*citj)[1]<<(*cit)[1]<<(*citj)[2]<<")"<<(*cit)[2]<<(*citj)[3]<<")"<<std::endl;
			flag=1;
			return flag;
		}//if4
		if(op5(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
			///std::cout<<"method 5:"<<std::ends;
			//std::cout<<(*citj)[0]<<(*cit)[0]<<"("<<(*citj)[1] <<(*cit)[1]<<"("<<(*citj)[2]<<(*cit)[2]<<(*citj)[3]<<")"<<")"<<std::endl;
			flag=1;
			return flag;
		}//if5
	}//for(int opi=0;opi<=60;opi++)
	size_t moveEle=vData.size()-1;
	size_t midP;
	size_t midMax;
	while(mid[moveEle]>0){
		midP=mid[moveEle];
		mid[moveEle]=mid[moveEle+direct[midP]];
		mid[moveEle+direct[midP]]=midP;
		//resPos.push_back(mid);
		char midV=vData[moveEle];
		vData[moveEle]=vData[moveEle+direct[midP]];
		vData[moveEle+direct[midP]]=midV;
		if(resData.find(vData)==resData.end())	{
			abcdIt=vData.begin();
			a=*abcdIt;
			abcdIt++;
			b=*abcdIt;
			abcdIt++;
			c=*abcdIt;
			abcdIt++;
			d=*abcdIt;
			for(int opi=0;opi<=60;opi++){
				if(op1(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
					///std::cout<<"method 1:"<<std::ends;
					//std::cout<<"(("<<(*citj)[0]<<(*cit)[0]<<(*citj)[1]<<")"<<(*cit)[1]<<(*citj)[2]<<")"<<(*cit)[2]<<(*citj)[3]<<std::endl;
					flag=1;
					return flag;
				}//if1
				if(op2(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
					///std::cout<<"method 2:"<<std::ends;
					//std::cout<<"("<<(*citj)[0]<<(*cit)[0]<<"("<<(*citj)[1]<<(*cit)[1]<<(*citj)[2]<<")"<<")"<<(*cit)[2]<<(*citj)[3]<<std::endl;
					flag=1;
					return flag;
				}//if2
				if(op3(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
					///std::cout<<"method 3:"<<std::ends;
					//std::cout<<"("<<(*citj)[0]<<(*cit)[0]<<(*citj)[1] <<")"<<(*cit)[1]<<"("<<(*citj)[2]<<(*cit)[2]<<(*citj)[3]<<")"<<std::endl;
					flag=1;
					return flag;
				}//if3
				if(op4(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
					///std::cout<<"method 4:"<<std::ends;
					//std::cout<<(*citj)[0]<<(*cit)[0]<<"("<<"("<<(*citj)[1]<<(*cit)[1]<<(*citj)[2]<<")"<<(*cit)[2]<<(*citj)[3]<<")"<<std::endl;
					flag=1;
					return flag;
				}//if4
				if(op5(a,b,c,d,ops [opi][0],ops [opi][1],ops [opi][2])){
					///std::cout<<"method 5:"<<std::ends;
					//std::cout<<(*citj)[0]<<(*cit)[0]<<"("<<(*citj)[1] <<(*cit)[1]<<"("<<(*citj)[2]<<(*cit)[2]<<(*citj)[3]<<")"<<")"<<std::endl;
					flag=1;
					return flag;
				}//if5
			}//for(int opi=0;opi<=60;opi++)
			resData.insert(vData);
		}/
		midMax=midP;
		for(std::vector<size_t>::const_iterator cit=mid.begin();cit!=mid.end();cit++){
			if(*cit>midP){
				direct[*cit]*=-1;
				if(direct[*cit]==1&&cit+1!=mid.end()||direct[*cit]==-1&&cit!=mid.begin()){
					if(*cit>*(cit+direct[*cit])&&*cit>midMax){
						midMax=*cit;
						moveEle=cit-mid.begin();
					}//if
				}//if
			}//if
		}//for
		if(midMax==midP){
			size_t i=midP;
			for(i=midP;i>0;i--){
				std::vector<size_t>::iterator it=std::find(mid.begin(),mid.end(),i);
				if(direct[i]==1&&it+1!=mid.end()||direct[i]==-1&&it!=mid.begin()){
					if(i>*(it+direct[i])){
						moveEle=it-mid.begin();
						break;
					}//
				}//
			}//for
			if(i==0) break;
		}//if
	}//while
	return flag;
}//can24()


 

Enockipp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c/c++算法之“24点”经典问题
hjkhjk007的专栏
06-03 8119
24点游戏是一种使用扑克牌来进行的益智类游戏，游戏内容是：从一副扑克牌中抽去大小王剩下52张，任意抽取4张牌，把牌面上的数（A代表1）运用加、减、乘、除和括号进行运算得出24。每张牌都必须使用一次，但不能重复使用。 有些组合有不同种算法，例如要用2，4，6，12四张牌组合成24点，可以有如下几种组合方法： 2 + 4 + 6 + 12 = 24  4 × 6 ÷ 2 + 12 = 24  12 ÷
c++输出24点所有情况（1-13）
bluedarker的博客
04-14 1180
一、题目描述 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 二、问题分析 使用枚举就能解决问题，难点在于如何减少重复枚举的条件和输出带括号的表达式，这里使用了枚举来输出。 三、算法设计 四、代码实现 函数实现 int main() { add(); system("pause"); } void ...
C++程序计算24点
最新发布
gxgdcyy的博客
02-05 1730
本文用C++编写了一个24点程序，对于能算出24点的，输出一种计算表达式，如不能算也说明。
C++ 实现计算24点
热门推荐
落叶秋风早的博客
02-17 1万+
原理 暴力枚举所有的情况，运算符号4个，加减乘除 + - * / ，整数数字4个。所需要枚举的次数： 数字顺序：4个数的全排列，4! = 24。 运算符号：4个数需要3个符号，每个可选4种，43 = 64。 加括号方式：((AB)C)D、(A(BC))D、(AB)(CD)、A((BC)D)、A(B(CD))，共5种。 枚举次数 24*64*5 实现细节 全排列枚举由库函数 next_perm...
算二十四点
baokeyuan1的博客
08-28 1140
计算24点
24点扑克牌游戏
qq_54079095的博客
05-10 821
这里写自定义目录标题 算法分析 题目： 24点游戏是经典的纸牌益智游戏。 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 提高要求：用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌
Go-pongo2-一个类似Django语法的Go模板引擎
08-13
9. **flosch/pongo2**：这个库（可能是在GitHub上的项目名）提供了Pongo2的实现，版本号为ca73590。你可以通过这个库来集成Pongo2到你的Go项目中。 在实际开发中，Go-pongo2可以帮助你构建高效的Web应用，提供优雅...
Go-Packagepongo2为Macaron提供pongo2模板引擎的支持
08-14
本文将深入探讨如何使用`pongo2`模板引擎为Macaron添加强大的视图渲染功能。 `pongo2`是Go语言中一个灵感来源于Django模板语言的模板库，它提供了丰富的语法特性，使得开发者可以更方便地处理动态数据并生成HTML或...
Pongo-开源
04-30
而"pongo-im-17.im"则可能是Pongo的一个特定版本，其中".im"可能是"Instant Messaging"的缩写，暗示这包含的是与即时通讯相关的程序文件或配置信息。用户可以通过解压这个文件，按照指导在各自的系统上安装和使用...
sls-express-mongo-pongo
05-08
项目文件名为“sls-express-mongo-pongo-master”，暗示这是一个Git仓库的主分支克隆。在实际项目中，你可能会找到以下结构： - `serverless.yml`：Serverless框架的配置文件，定义了Lambda函数、事件触发器和其他...
一款C++游戏源码
07-06
这个是从github中找到的一个c++游戏源码，这个游戏很没意思。个人感觉这个源码不值10分，下了之后表后悔。
斗地主源代码
02-25
简单的多人斗地主代码，界面简洁，需获取IP地址方可连接 最多3人一起玩
24点算法实现
04-24
给定4个整数，其中每个数字只能使用一次；任意使用 + - * / ( ) ，构造出一个表达式，使得最终结果为24，这就是常见的算24点的游戏。这方面的程序很多，一般都是穷举求解。本程序通过递归算法实现实现24点计算，
蜘蛛纸牌VC++源代码最新之作
04-27
蜘蛛纸牌VC++源代码最新之作
blackjack1.0德州21点扑克牌HTML5源码.zip
11-01
html5源代码源代码《德州21点扑克牌》德克萨斯扑克全称Texas Hold’em poker，中文简称德州扑克。它是一种玩家对玩家的公共牌类游戏。一张台面至少2人，最多22人，一般是由2-10人参加。德州扑克一共有52张牌，没有王牌。每个玩家分两张牌作为“底牌”，五张由荷官陆续朝上发出的公共牌。开始的时候，每个玩家会有两张面朝下的底牌。经过所有押注圈后，若仍不能分出胜负，游戏会进入“摊牌”阶段，也就是让所剩的玩家亮出各自的底牌以较高下，持大牌者获胜。有兴趣的童鞋快快下载吧~
gin-pongo2:用于Gin框架的pongo2中间件
05-21
gin-pongo2 用于Gin框架的pongo2中间件。 ＃＃例子： package main import ( "os" "github.com/gin-gonic/gin" "github.com/rainbowism/gin-pongo2" ) func main () { switch os . Getenv ( "MODE" ) { ...
用C++实现24点小游戏 ( 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏
qq_44703629的博客
04-13 2097
一：题目要求 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 ...
c语言第三章编程题,计算机二级C语言教程第三章课后编程题
weixin_29572661的博客
05-23 135
关于课后编程3.16课后练习改错#includemain(){double a,b,c,s,v;printf("input a, b, c:");scanf("%lf%lf%lf",&a,&b,&c);s=a*b;v=a*b*c;printf("a=%.6f,b=%.6f,c=%.6f\n",a,b,c);printf("s=%.6f,v=%.6f\n",s,v);}3.1...
C++实现24点游戏
轩辕逸小白博客
04-12 1万+
1.   算法思路 (1)首先穷举的可行性问题。我把表达式如下分成三类 1、 无括号的简单表达式。 2、 有一个括号的简单表达式。 3、 有两个括号的较复4,杂表达式。 穷举的开始我对给出的四个数进行排列，其可能的种数为4*3*2*1=24。我利用一个嵌套函数实现四个数的排列      (2)那么作为栈的著名应用，表达式的计算可以有两种方法。 第一种方法:   首先建立两个栈，操
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值