面：24点游戏

最新推荐文章于 2021-05-21 15:43:12 发布
最新推荐文章于 2021-05-21 15:43:12 发布
阅读量540 收藏
点赞数 1
分类专栏： 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hunter___/article/details/90481445
版权 
输入4个数，求解得到24点，并输出相应的表达式。
使用面向对象开发，只能用整形，比如输入6 6 6 6 ，则输出6+6+6+6=24

 

测试的时候我会用3 3 8 8，也可能会有5 5 5 1 来测试

3 3 8 8
(((3+8)/3)*8) = 24

 

3,3,8,8算24点的算法有：

1，8/(3-8/3)=24

2，8/(3-(8/3))=24

 

8÷(3-8÷3)=8÷1/3=24

 

 

 

5 5 5 1
((5-(1/5))*5) = 24

 

 

 

加减乘除24点（难度系数：2颗星）

计算24点有什么窍门或技巧吗?

用穷举法列出24点的解

 

24点游戏算法（C语言实现）

"速算24"算法思路

 

关于24点游戏的编程思路与基本算法

https://blog.csdn.net/r1254/article/details/46914431 48行计算24点C语言代码

https://blog.csdn.net/tigerisland45/article/details/81905291 dfs

 

 

 

4X6=24

3X8=24

 

a  _   b  _   c   _   d:

 

C41 * C41 *C41 * A44这就是错的原因，没有考虑全部的排列方式？

 

 

最新版本，

#include <iostream>
#include <stdio.h>
#include <string.h>


using namespace std;
#define OP(o)   do { a[1].n = a[0].n o a[1].n; \
	sprintf(a[1].s, "(%s"#o"%s)", a[0].s, strcpy(t.s, a[1].s)); \
	if (dfs(n - 1, a + 1, r)) return 1; \
	a[1] = temp; } while (0)


typedef struct data {
	double n;//存中间结果
	char s[8 * 7];//存表达式 
} data;
typedef int Ptype;//para type

data num[4], t;

class Solution{
public:
	Solution();
	~Solution();
	int dfs(int n, data a[], int r);//TODO
};


Solution::Solution(){
	//sth
}

Solution::~Solution(){
	//sth
}

int 
Solution::dfs( int n, data a[], int r ) 
{// n,数字个数； a[] 存输入的n个数，r 要得到的结果
	int i, j;
	if ( n == 1 )
		if ( a[0].n-r > 1e-8 || a[0].n-r < -1e-8 ) return 0;//　!=0
		else return 1;
	for ( i = 0; i < n; ++i ) {
		swap(a[i], a[0] );
		for ( j = 1; j < n; ++j ) {
			swap(a[j], a[1] );//指定为data类型
			data temp = a[1];
			OP( + );
			OP( - );
			OP( * );
			if ( a[1].n > 1e-8 || a[1].n < -1e-8 )
				OP( / );
			swap(a[j], a[1] );
		}
		swap(a[i], a[0] );
	}
	return 0;
}


int main()
{

	int r = 24, i;
	printf("输入4个数字，以空格隔开：\n");
	for ( i = 0; i < 4; ++i ) {
		scanf( "%s", num[i].s );
		sscanf( num[i].s, "%lf", &num[i].n );
	}

	Solution* ans=new Solution;
	if (ans->dfs( 4, num, r ) )
		printf( "%s = %d\n", num[3].s, r );
	else
		printf( "不存在相应的24点的组合\n" );
	return 0;
}

 

混合：可正常测试出3 3 8 8和 5 5 5 1了。

又被说，，，

#include <iostream>
#include <stdio.h>
#include <string.h>


using namespace std;
#define SWAP(tp, a, b) do {tp v=a; a=b; b=v;} while (0)
#define OP(o)   do { a[1].n = a[0].n o a[1].n; \
	sprintf(a[1].s, "(%s"#o"%s)", a[0].s, strcpy(t.s, a[1].s)); \
	if (dfs(n - 1, a + 1, r)) return 1; \
	a[1] = temp; } while (0)


typedef struct data {
	double n;//用int存的话会得不出正常答案
	char s[8 * 7];//存表达式 
} data;
typedef int Ptype;//para type

data num[4], t;

class Solution{
public:
	Solution();
	~Solution();
	int dfs(int n, data a[], int r);//TODO

	int TotalCount(Ptype a, Ptype b, Ptype c, Ptype d);//C4 1 
private:
	void Calculate(int fl,Ptype n,Ptype &sum, char &s);//A3 3
	int Is24(Ptype a, Ptype b, Ptype c, Ptype d);
	int Count(Ptype a, Ptype b, Ptype c, Ptype d);
protected:
	//data num[4], t;
};


Solution::Solution(){
	//sth
}

Solution::~Solution(){
	//sth
}

void
Solution::Calculate(int fl,Ptype n,Ptype &sum, char &s)
{ //+-*/   1234
	switch (fl)
	{//flag
	case 1:
		sum += n;
		s='+';
		break;
	case 2:
		sum -= n;
		s='-';
		break;
	case 3:
		sum *= n;
		s='*';
		break;
	case 4:	
		{
			if (sum%n) sum = 9999;//指向一个得不到24的值
			sum /= n;//else
		}
		break;
	default:
		break;
	}
}

int 
Solution::Is24(Ptype a, Ptype b, Ptype c, Ptype d)
{ //a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
	Ptype sum;
	char s1,s2,s3;// 存运算符
	for (int j = 1; j <= 4; j++)
	{//第1个位置的符号
		for (int k = 1; k <= 4; k++)
		{//第2个位置
			for (int l = 1; l <= 4; l++)
			{//第3个位置
				sum = 0;
				sum += a;
				Calculate(j,b,sum,s1);
				Calculate(k,c,sum,s2);
				Calculate(l,d,sum,s3);
				if (sum == 24)
				{//格式化输出
					printf("组合：((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					return 1;
				}
			}
		}
	}
	return 0;
}

int 
Solution::Count(Ptype a, Ptype b, Ptype c, Ptype d)
{//A3 3
	return Is24(a, b, c, d) + Is24(a, b, d, c) + Is24(a, c, b, d) + Is24(a, c, d, b) + Is24(a, d, b, c) + Is24(a, d, c, b);
}

int 
Solution::TotalCount(Ptype a, Ptype b, Ptype c, Ptype d)
{//C4 1
	return Count(a, b, c, d) + Count(b, a, c, d) + Count(c, a, b, d) + Count(d, a, b, c);
}

int 
Solution::dfs( int n, data a[], int r ) 
{// n,数字个数； a[] 存输入的n个数，r 要得到的结果
	int i, j;
	if ( n == 1 )
		if ( a[0].n-r > 1e-8 || a[0].n-r < -1e-8 )
			return 0;
		else return 1;
	for ( i = 0; i < n; ++i ) {
		SWAP( data, a[i], a[0] );
		for ( j = 1; j < n; ++j ) {
			SWAP( data, a[j], a[1] );//指定为data类型
			data temp = a[1];
			OP( + );
			OP( - );
			OP( * );
			if ( a[1].n > 1e-8 || a[1].n < -1e-8 )
				OP( / );
			SWAP( data, a[j], a[1] );
		}
		SWAP( data, a[i], a[0] );
	}
	return 0;
}


int main()
{
	/*
	 *    int a, b, c, d;
	 *    cout<<"请输入4个数，以空格隔开:"<<endl;
	 *    cin >> a >> b >> c >> d;
	 *
	 *    Solution* ans=new Solution;
	 *    int ct = ans->TotalCount(a, b, c, d);//A4 4
	 *    delete ans;
	 *
	 *    if (ct == 0) cout << "不存在相应的24点的组合" << endl;
	 *    cout<<"总数："<<ct<<endl;
	 *    return 0;
	 */

	int r = 24, i;
	printf("输入4个数字，以空格隔开：\n");
	for ( i = 0; i < 4; ++i ) {
		scanf( "%s", num[i].s );
		sscanf( num[i].s, "%lf", &num[i].n );
	}

	Solution* ans=new Solution;
	if (ans->dfs( 4, num, r ) )
		printf( "%s = %d\n", num[3].s, r );
	else
		printf( "不存在相应的24点的组合\n" );
	return 0;
}

 

 

 

被大佬嫌弃，，，， 可哥，不想改了

 

#include <iostream>
#include <stdio.h>

typedef int Ptype;//para type

using namespace std;

class Solution{
public:
	Solution();
	~Solution();
	int TotalCount(Ptype a, Ptype b, Ptype c, Ptype d);//C4 1 
private:
	void Calculate(int i,Ptype n,Ptype &sum, char &s);//A3 3
	int Is24(Ptype a, Ptype b, Ptype c, Ptype d);
	int Count(Ptype a, Ptype b, Ptype c, Ptype d);
	//int Is24_DFS();//TODO
};


Solution::Solution(){
	//sth
}

Solution::~Solution(){
	//sth
}

void
Solution::Calculate(int i,Ptype n,Ptype &sum, char &s)
{ //+-*/   1234
	switch (i)
	{
	case 1:
		sum += n;
		s='+';
		break;
	case 2:
		sum -= n;
		s='-';
		break;
	case 3:
		sum *= n;
		s='*';
		break;
	case 4:	
		{
			if (sum%n) sum = 9999;//指向一个得不到24的值
			sum /= n;//else
		}
		break;
	default:
		break;
	}
}

int 
Solution::Is24(Ptype a, Ptype b, Ptype c, Ptype d)
{ //a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
	Ptype sum;
	char s1,s2,s3;// 存运算符
	for (int j = 1; j <= 4; j++)
	{//第1个位置的符号
		for (int k = 1; k <= 4; k++)
		{//第2个位置
			for (int l = 1; l <= 4; l++)
			{//第3个位置
				sum = 0;
				sum += a;
				Calculate(j,b,sum,s1);
				Calculate(k,c,sum,s2);
				Calculate(l,d,sum,s3);
				if (sum == 24)
				{//格式化输出
					printf("组合：((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					return 1;
				}
			}
		}
	}
	return 0;
}

int 
Solution::Count(Ptype a, Ptype b, Ptype c, Ptype d)
{//A3 3
	return Is24(a, b, c, d) + Is24(a, b, d, c) + Is24(a, c, b, d) + Is24(a, c, d, b) + Is24(a, d, b, c) + Is24(a, d, c, b);
}

int 
Solution::TotalCount(Ptype a, Ptype b, Ptype c, Ptype d)
{//C4 1
	return Count(a, b, c, d) + Count(b, a, c, d) + Count(c, a, b, d) + Count(d, a, b, c);
}


int main()
{
	int a, b, c, d;
	cout<<"请输入4个数，以空格隔开:"<<endl;
	cin >> a >> b >> c >> d;

	Solution* ans=new Solution;
	int ct = ans->TotalCount(a, b, c, d);//A4 4
	delete ans;

	if (ct == 0) cout << "不存在相应的24点的组合" << endl;
	cout<<"总数："<<ct<<endl;
	return 0;
}

 

#include <iostream>
#include <stdio.h>
#include <math.h>

using namespace std;

class Solution{
public:
	Solution();
	~Solution();
	int TotalCount(int a, int b, int c, int d);//get the total num
private:
	void AddUp(int i,int n,int &sum, char &s);//add nums up
	int Is24(int a, int b, int c, int d);
	int Count(int a, int b, int c, int d);
	//typedef XXX if needed 

};//抽到头文件,大的时候

Solution::Solution(){
	//sth
}

Solution::~Solution(){
	//sth
}
	void
Solution::AddUp(int i,int n,int &sum, char &s)
{//计算
	//+-*/   1234
	switch (i)
	{
	case 1:
		sum += n;
		s='+';
		break;
	case 2:
		sum -= n;
		s='-';
		break;
	case 3:
		sum *= n;
		s='*';
		break;
	case 4:					
		{
			if (sum%n)
			{
				sum = 9999;//指向一个得不到24的值
			} else {
				sum /= n;
			}
		}break;

	default:
		break;
	}
}

	int 
Solution::Is24(int a, int b, int c, int d)
{
	int sum;
	char s1,s2,s3;// 存运算符
	//a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
	for (int j = 1; j <= 4; j++)
	{//第1个位置的符号
		for (int k = 1; k <= 4; k++)
		{//第2个位置的符号
			for (int l = 1; l <= 4; l++)
			{//第3个位置的符号
				sum = 0;
				sum += a;

				AddUp(j,b,sum,s1);
				AddUp(k,c,sum,s2);
				AddUp(l,d,sum,s3);

				if (sum == 24)
				{//判断并格式化输出
					printf("组合：((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					return 1;
				}
			}
		}
	}
	return 0;
}

	int 
Solution::Count(int a, int b, int c, int d)
{
	return Is24(a, b, c, d) + Is24(a, b, d, c) + Is24(a, c, b, d) + Is24(a, c, d, b) + Is24(a, d, b, c) + Is24(a, d, c, b);//各种排列
}

	int 
Solution::TotalCount(int a, int b, int c, int d)
{
	return Count(a, b, c, d) + Count(b, a, c, d) + Count(c, a, b, d) + Count(d, a, b, c);//排列
}




int main()
{
	int a, b, c, d;
	int count = 0;
	cout<<"请输入4个数，以空格隔开:"<<endl;
	cin >> a >> b >> c >> d;

	Solution* ans=new Solution;
	count = ans->TotalCount(a, b, c, d);

	if (count == 0) cout << "不存在相应的24点的组合" << endl;
	cout<<"总数："<<count<<endl;
	return 0;
}

 

 

修改历史：

我是垃圾，，，写不出来啊，，，抄：

https://blog.csdn.net/huplion/article/details/42522239

#include <iostream>
//#include <cstdio>
//#include <cmath>
#include <stdio.h>
#include <math.h>
using namespace std;
//+-*/   1234
unsigned long long int xx[1001];
int x=1;
int pd;
int f1(int a, int b, int c, int d)
{
	int sum;
	pd=0;
	char s1,s2,s3;
	for (int j = 1; j <= 4; j++)
	{
		for (int k = 1; k <= 4; k++)
		{
			for (int l = 1; l <= 4; l++)
			{
				sum = 0;
				sum += a;
				switch (j)
				{
				case 1:sum += b; break;
				case 2:sum -= b; break;
				case 3:sum *= b; break;
				case 4:
					   {
						   if (sum%b)
						   {
							   sum = 9999;
						   }
						   else
						   {
							   sum /= b;
						   }
					   }break;
				default:
					   break;
				}
				switch (k)
				{
				case 1:sum += c; break;
				case 2:sum -= c; break;
				case 3:sum *= c; break;
				case 4:
					   {
						   if (sum%c)
						   {
							   sum = 9999;
						   }
						   else
						   {
							   sum /= c;
						   }
					   }break;
				default:
					   break;
				}
				switch (l)
				{
				case 1:sum += d; break;
				case 2:sum -= d; break;
				case 3:sum *= d; break;
				case 4:
					   {
						   if (sum%d)
						   {
							   sum = 9999;
						   }
						   else
						   {
							   sum /= d;
						   }
					   }break;
				default:
					   break;
				}
				switch (j)
				{
				case 1:s1='+';break;
				case 2:s1='-';break;
				case 3:s1='*';break;
				case 4:s1='/';break;
				}
				switch (k)
				{
				case 1:s2='+';break;
				case 2:s2='-';break;
				case 3:s2='*';break;
				case 4:s2='/';break;
				}
				switch (l)
				{
				case 1:s3='+';break;
				case 2:s3='-';break;
				case 3:s3='*';break;
				case 4:s3='/';break;
				}
				if (sum == 24)
				{
					if (x==0)
					{
						xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
						x++;
						printf("((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					}
					else
					{
						for (int i=1;i<=x;i++)
						{
							if ((a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l)==xx[i])
							{
								pd=1;
								break;
							}
						}
						if (pd==0)
						{
							xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
							x++;
							printf("((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
						}
					}
					return 1;
				}
			}
		}
	}
	return 0;
}


int f2(int a, int b, int c, int d)
{
	int sum = 0;
	sum = f1(a, b, c, d) + f1(a, b, d, c) + f1(a, c, b, d) + f1(a, c, d, b) + f1(a, d, b, c) + f1(a, d, c, b);
	
	
	if (sum != 0)
	{
		cout << "存在" << endl;
		return 1;
	}
	else
	{
		cout << "不存在" << endl;
		return 0;
	}
}


int main()
{
	int a, b, c, d;
	int sum;
	cout<<"请输入4个数，以空格隔开如：3 3 8 9"<<endl;
	cin >> a >> b >> c >> d;
	sum = f2(a, b, c, d) + f2(b, a, c, d) + f2(c, a, b, d) + f2(d, a, b, c);
	if (sum == 0)
	{
		cout << "不存在相应的24点的组合" << endl;
	}
	return 0;
}

自己注释：

#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
//+-*/   1234
unsigned long long int xx[1001];// 保存值的数组
int x=1;//
int pd;//判断

int f1(int a, int b, int c, int d)
{
	int sum;
	pd=0;
	char s1,s2,s3;// 存运算符
	//a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
	for (int j = 1; j <= 4; j++)
	{//第1个位置的符号
		for (int k = 1; k <= 4; k++)
		{//第2个位置的符号
			for (int l = 1; l <= 4; l++)
			{//第3个位置的符号
				sum = 0;
				sum += a;
				switch (j)
				{
				case 1:sum += b; break;
				case 2:sum -= b; break;
				case 3:sum *= b; break;
				case 4:
					   {
						   if (sum%b)
						   {
							   sum = 9999;
						   }
						   else
						   {
							   sum /= b;
						   }
					   }break;
				default:
					   break;
				}
				switch (k)
				{
				case 1:sum += c; break;
				case 2:sum -= c; break;
				case 3:sum *= c; break;
				case 4:
					   {
						   if (sum%c)
						   {
							   sum = 9999;
						   }
						   else
						   {
							   sum /= c;
						   }
					   }break;
				default:
					   break;
				}
				switch (l)
				{
				case 1:sum += d; break;
				case 2:sum -= d; break;
				case 3:sum *= d; break;
				case 4:
					   {
						   if (sum%d)
						   {//不能被整除
							   sum = 9999;//不能被整除，意味着得不到24
						   }
						   else
						   {//能被整除
							   sum /= d;
						   }
					   }break;
				default:
					   break;
				}

				//存符号
				switch (j)
				{
				case 1:s1='+';break;
				case 2:s1='-';break;
				case 3:s1='*';break;
				case 4:s1='/';break;
				}
				switch (k)
				{
				case 1:s2='+';break;
				case 2:s2='-';break;
				case 3:s2='*';break;
				case 4:s2='/';break;
				}
				switch (l)
				{
				case 1:s3='+';break;
				case 2:s3='-';break;
				case 3:s3='*';break;
				case 4:s3='/';break;
				}

				if (sum == 24)
				{//判断并格式化输出
					if (x==0)
					{//第1个等于24的时候进去？永远不会执行？
						xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;//存组合及符号
						x++;
						printf("x==0,,,,((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					}
					else
					{
						for (int i=1;i<=x;i++)
						{
							if ((a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l)==xx[i])
							{
								pd=1;
								break;
							}
						}
						if (pd==0)
						{
							xx[x]=a*1000000+b*100000+c*10000+d*1000+j*100+k*10+l;
							x++;
							printf("pd==0,,,((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
						}
					}
					return 1;
				}
			}
		}
	}
	return 0;
}


int f2(int a, int b, int c, int d)
{
	int sum = 0;
	sum = f1(a, b, c, d) + f1(a, b, d, c) + f1(a, c, b, d) + f1(a, c, d, b) + f1(a, d, b, c) + f1(a, d, c, b);//各种排列
	
	
	if (sum != 0)
	{
		//cout << "存在" << endl;
		return 1;
	}
	else
	{
		//cout << "不存在" << endl;
		return 0;
	}
}


int main()
{
	int a, b, c, d;
	int sum;
	cout<<"请输入4个数，以空格隔开:"<<endl;
	cin >> a >> b >> c >> d;
	sum = f2(a, b, c, d) + f2(b, a, c, d) + f2(c, a, b, d) + f2(d, a, b, c);
	if (sum == 0)
	{
		cout << "不存在相应的24点的组合" << endl;
	}
	return 0;
}

 

修改：

看不懂里面写的一些东西是干什么的，，，

不是很懂大佬之前的意思，，

删，

#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
//+-*/   1234

void SwitchFunc(int i,int c,int &sum, char &s2)
{

	switch (i)
	{
	case 1:
		sum += c;
		s2='+';
		break;
	case 2:
		sum -= c;
		s2='-';
		break;
	case 3:
		sum *= c;
		s2='*';
		break;
	case 4:
		sum /= c;
		s2='/';
		break;
	default:
		break;
	}
}

int f1(int a, int b, int c, int d)
{
	int sum;
	char s1,s2,s3;// 存运算符
	//a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
	for (int j = 1; j <= 4; j++)
	{//第1个位置的符号
		for (int k = 1; k <= 4; k++)
		{//第2个位置的符号
			for (int l = 1; l <= 4; l++)
			{//第3个位置的符号
				sum = 0;
				sum += a;

				SwitchFunc(j,b,sum,s1);
				SwitchFunc(k,c,sum,s2);
				SwitchFunc(l,d,sum,s3);

				if (sum == 24)
				{//判断并格式化输出
					printf("pd==waimian,,,((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					return 1;
				}
			}
		}
	}
	return 0;
}


int f2(int a, int b, int c, int d)
{
	int sum = 0;
	sum = f1(a, b, c, d) + f1(a, b, d, c) + f1(a, c, b, d) + f1(a, c, d, b) + f1(a, d, b, c) + f1(a, d, c, b);//各种排列

	return sum;
}


int main()
{
	int a, b, c, d;
	int sum;
	cout<<"请输入4个数，以空格隔开:"<<endl;
	cin >> a >> b >> c >> d;
	sum = f2(a, b, c, d) + f2(b, a, c, d) + f2(c, a, b, d) + f2(d, a, b, c);//为啥要这样写？？？不懂
	if (sum == 0)
	{
		cout << "不存在相应的24点的组合" << endl;
	}
	return 0;
}

 

改，

#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
//+-*/   1234

void SwitchFunc(int i,int n,int &sum, char &s)
{

	switch (i)
	{
	case 1:
		sum += n;
		s='+';
		break;
	case 2:
		sum -= n;
		s='-';
		break;
	case 3:
		sum *= n;
		s='*';
		break;
	case 4:
		sum /= n;
		s='/';
		break;
	default:
		break;
	}
}

int Is24(int a, int b, int c, int d)
{
	int sum;
	char s1,s2,s3;// 存运算符
	//a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
	for (int j = 1; j <= 4; j++)
	{//第1个位置的符号
		for (int k = 1; k <= 4; k++)
		{//第2个位置的符号
			for (int l = 1; l <= 4; l++)
			{//第3个位置的符号
				sum = 0;
				sum += a;

				SwitchFunc(j,b,sum,s1);
				SwitchFunc(k,c,sum,s2);
				SwitchFunc(l,d,sum,s3);

				if (sum == 24)
				{//判断并格式化输出
					printf("组合：((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
					return 1;
				}
			}
		}
	}
	return 0;
}


int Count(int a, int b, int c, int d)
{
	return Is24(a, b, c, d) + Is24(a, b, d, c) + Is24(a, c, b, d) + Is24(a, c, d, b) + Is24(a, d, b, c) + Is24(a, d, c, b);//各种排列
}


int main()
{
	int a, b, c, d;
	int count = 0;
	cout<<"请输入4个数，以空格隔开:"<<endl;
	cin >> a >> b >> c >> d;
	count = Count(a, b, c, d) + Count(b, a, c, d) + Count(c, a, b, d) + Count(d, a, b, c);
	if (count == 0) cout << "不存在相应的24点的组合" << endl;
	cout<<"总数："<<count<<endl;
	return 0;
}

 

对象，

#include <iostream>
#include <stdio.h>
#include <math.h>

using namespace std;

class Solution{
public:
	void AddUp(int i,int n,int &sum, char &s)
	{//计算
		//+-*/   1234
		switch (i)
		{
		case 1:
			sum += n;
			s='+';
			break;
		case 2:
			sum -= n;
			s='-';
			break;
		case 3:
			sum *= n;
			s='*';
			break;
		case 4:
			sum /= n;
			s='/';
			break;
		default:
			break;
		}
	}

	int Is24(int a, int b, int c, int d)
	{
		int sum;
		char s1,s2,s3;// 存运算符
		//a b c d 4个数中间分别都有+ - * / 四种运算符的可能性 暴力枚举
		for (int j = 1; j <= 4; j++)
		{//第1个位置的符号
			for (int k = 1; k <= 4; k++)
			{//第2个位置的符号
				for (int l = 1; l <= 4; l++)
				{//第3个位置的符号
					sum = 0;
					sum += a;

					AddUp(j,b,sum,s1);
					AddUp(k,c,sum,s2);
					AddUp(l,d,sum,s3);

					if (sum == 24)
					{//判断并格式化输出
						printf("组合：((%d%c%d)%c%d)%c%d==24\n",a,s1,b,s2,c,s3,d);
						return 1;
					}
				}
			}
		}
		return 0;
	}


	int Count(int a, int b, int c, int d)
	{
		return Is24(a, b, c, d) + Is24(a, b, d, c) + Is24(a, c, b, d) + Is24(a, c, d, b) + Is24(a, d, b, c) + Is24(a, d, c, b);//各种排列
	}

};//class Solution 



int main()
{
	int a, b, c, d;
	int count = 0;
	cout<<"请输入4个数，以空格隔开:"<<endl;
	cin >> a >> b >> c >> d;
	Solution* ans=new Solution;

	count = ans->Count(a, b, c, d) +ans-> Count(b, a, c, d) + ans->Count(c, a, b, d) +ans-> Count(d, a, b, c);//排列
	if (count == 0) cout << "不存在相应的24点的组合" << endl;
	cout<<"总数："<<count<<endl;
	return 0;
}

 

nedwons
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编程之美上24点游戏的实现
03-19 597
#include #include using namespace std; set f(int i); void game24(int Array[]); bool Check(set s); bool print(set s) { set::iterator it=s.begin(); while(it!=s.end()){ //while(it++!=s.end())少用
二、递归还是循环？这是个问题
autumn20080101的专栏
05-27 1429
二、递归还是循环？这是个问题 1、 一个简单的24点程序          下面本文将通过两个题目实例，分别给出用递归方法和循环方法的解决方案以及解题思路，便于读者更好地掌握两种方法。首先是一个简单的计算24点的问题（为了简化问题，我们假设只使用求和计算方法）：   从1－9中任选四个数字（数字可以有重复），使四个数字的和刚好是24。   题目很简单，数字都是个
24点游戏
weixin_42959372的博客
04-14 752
一．实验内容 24点游戏是经典的纸牌益智游戏。 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。 1.程序风格良好(使用自定义注释模...
24点
MPF1230的博客
04-14 286
24点 算法借鉴 网址链接https://blog.csdn.net/huplion/article/details/42522239 因为4个数的四则运算有3个运算符，所以用3给for循环每次循环4次来一次一次循环尝试总共可能出现的4的3次方种可能，用户switch来给四则运算编号，可以最终确定选出的运算符， ​ switch (j...
编程之美-24点游戏方法整理
GarfieldEr007的专栏
11-09 1812
【试题描述】 方法一： 方法二：部分伪代码 part 1：伪代码 part 2：伪代码
C++实现简单24点游戏
08-24
本文详细介绍了使用C++语言实现简单的24点游戏，游戏的主要思路是随机生成四个代表扑克牌牌面的数字字母，然后程序自动列出所有可能算出24的表达式。该游戏的实现思路主要包括生成牌面数字、计算表达式和穷举计算三...
java实现24点游戏
08-26
Java实现24点游戏知识点 本文主要介绍了Java实现24点游戏的思路和实现方法。该游戏的规则是从扑克中每次取出4张牌，使用加减乘除，第一个能得出24者为赢。下面是Java实现24点游戏的知识点： 1. 随机生成4个代表...
Java实现24点小游戏
08-26
【Java实现24点小游戏】是一个利用编程技术模拟经典纸牌游戏的项目。在这个游戏中，玩家需要通过加、减、乘、除运算使得四张扑克牌的数值组合运算得到24。下面我们将详细讨论实现这个游戏的Java代码及其背后的算法...
python经典趣味24点游戏程序设计
09-18
在Python编程中，设计一款24点游戏程序是一项有趣且富有挑战性的任务。这个游戏的目标是从四张扑克牌中，利用加、减、乘、除运算得出24。在这个程序设计中，作者采取了表达式树作为核心算法，使得程序能够处理各种...
C语言-24点游戏
05-08
棋牌类益智游戏，要求四个数字运算结果等于二十四，一起来玩玩吧!这个游戏用扑克牌更容易来开展。拿一副牌，抽去大小王后(初练也可以把J/Q/K也拿去)，剩下1～10这40张牌(以下用1代替A)。任意抽取4张牌(称为牌组)，用...
24点算法之我见
weixin_34195546的博客
03-17 222
之前发了一篇博文“24点的所有组合的解法”，有人颇不以为然。我想说的是，发这篇文章是说明我可以用计算机求出24点的所有组合的解法。而在实际的运用中，如果要使用24点的算法有时还不见得利用查表法来得简单和快速。毕竟，要短时间内写出正确的算法并验证，也不是一件很容易的事。   24点游戏的规则：给定4个正整数（1到10），利用加减乘除运算，得出运算结果为24的运算式 例如： 1，2，3，4——...
使用面向对象的编程思想实现加减乘除运算
梦回唐朝
09-13 3636
脚本1Main 函数的代码: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Computer { class Program { static void Ma...
3 3 8 8四则运算得24
刘旭丹的博客
09-18 7917
这在面试资料上看到这个题的，其实这里都没提是直接数学运算还是程序中的四则运算，两者是有区别的 比如数学中3除以8得到的是一个分数，而程序中的3/8就为0了，这里暂且我们就用程序的方式来。 public class TestA { public static void main(String[] args) { int a = 8*8/3+3; /**
Java实现24点游戏
lx010802的博客
05-10 862
算法分析 一 首先利用Java中的Random来随机生成四个范围在1~13中的数字并输出。 二 创建calculate函数，将数字存入哈希表，利用Hashmap的方法来判断是否含有重复的数字，并且根据重复的情况列出不同的排序组合，并且调用calculation（）函数。 三 将得到的组合在calculation中进行计算，根据可能出现的计算顺序来输出不同的运算表达式，如果计算后的结果可以到24，则输出所有得到24的结果，若不能，则输出不能经过运算得到24。 四 在主函数中调用calculate（）函数。 流
C语言给出任意4个数算24点,讨论24点算法。
weixin_35586996的博客
05-21 1943
讨论24点算法。24点是扑克牌游戏 玩法是：从一副扑克的A到10里随意抽出4张牌用‘加’’减‘‘乘’‘除’四个符号算出4个数是否等于24，是的话成功，否的话失败；我用的是穷举法！(源码有点长)就是穷举出所有可能的算术式；我们想设4张牌为W，X，Y，Z；先把4张牌做排列组合：如W；X；Y；Z； W；X；Z；Y； W；Y；X；Z；W；Y；Z；X； W；z；x；y； w；z；y；x...
24点游戏算法 （无脑递归暴力破解）
麦芽雪冷萃
12-28 5435
题目描述 问题描述：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利 输入： 4个1-10的数字。[数字允许重复，但每个数字仅允许使用一次，测试用例保证无异常数字] 输出： true or false 输入描述: 输入4个int整数 输出描述: 返回能否得到24点，能输出true，不能输出false 输入样例： 7 2 1 10 输出样例： true 解题思路：...
24点经典算法
weixin_34415923的博客
06-11 507
1、概要 　　特定4整数，每个号码只能使用一次；随意使用 + - * / ( ) 。构建表达，从而使最终结果24，这是一种常见的操作者24游戏点。该方案的这一方面是非常，它们一般详尽的解决。本文介绍一种典型的算24点的程序算法，并给出两个详细的算24点的程序：一个是面向过程的C实现，一个是面向对象的java实现。 　　2、基本原理 　　基本原理是穷举4个整数全部可能的表达式。然后对表达式...
pcl icp 点到面
最新发布
08-17
PCL中的ICP（Iterative Closest Point）是一种用于点云配准的算法。点到面(ICP点到面)是ICP的一种改进方法。 ICP点到面算法在点云配准中更加准确和稳健。它利用了点云表面的法线信息，将目标点云中的点与参考点云中的表面进行匹配，从而提高了配准的精度和鲁棒性。 ICP点到面算法的步骤如下： 1. 计算参考点云的法线信息：根据输入的点云数据，通过计算k邻近点的法线向量，估计表面平面的法线方向。 2. 初始对齐：选择一个初始变换矩阵（平移和旋转），将目标点云变换到与参考点云初始对齐。 3. 最近邻搜索：对于目标点云中的每一个点，在参考点云中搜索最近的点。 4. 计算误差度量：根据目标点云中的点和其对应最近邻点的距离以及法线之间的角度误差，计算误差度量。 5. 利用误差度量更新变换：通过最小化误差度量，更新之前的变换矩阵。 6. 迭代：重复步骤3-5，直到满足收敛条件（例如，变换矩阵的变化小于设定的阈值）。 经过多次迭代后，ICP点到面算法能够找到最佳的变换矩阵，从而达到点云的配准目标。 ICP点到面算法比传统的ICP点到点算法更加精确，特别适用于曲面配准和高度复杂的点云数据。在计算机视觉、机器人技术和三维重建等领域中，ICP点到面算法都有广泛的应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值