先看看运行结果吧，
思路是这样，先把四位数都放入一个集合中然后进行第一步结合1运算，及每位数与其他三位数进行加减乘除运算得到4种运算结果，如刚开始的集合有4个元素，每位数运算后有4种结果，所以四个元素第一次结合1运算后有共16种结果，然后再同上进行结合1操作2次得到(（a?b)?c)?d这样格式的运算结果，可以细分为（a?(b?c))?d、d?(（a?b)?c)、d?（a?(b?c))。？表示运算符。
结合二运算得到的格式为（a？b）？（a？b）。所以最后得到总集合是4位数进行任意组合运算后的所有结果，具体功能有自己定义的函数实现，先看代码吧
#include <iostream>
#include "susuan.h"
using namespace std;
int main()
{
vector<jieguo> p1,p2;
cout << "请输入4个数字，生成随机组合运算后结果为24的所有运算方法" << endl;
scanf_s("%d %d %d %d",&kapai[0], &kapai[1], &kapai[2], &kapai[3]);
/*kapai[0] = 1;
kapai[1] = 2;
kapai[2] = 3;
kapai[3] = 4;*/
jieguo A(kapai[0], 1, 0);
p1.push_back(A);
p2.push_back(A);
jieguo B(kapai[1], 1, 1);
p1.push_back(B);
p2.push_back(B);
jieguo C(kapai[2], 1, 2);
p1.push_back(C);
p2.push_back(C);
jieguo D(kapai[3], 1, 3);
p1.push_back(D);
p2.push_back(D);
//for (int i = 0; i <(int) p1.size(); i++)
//{
// cout << p1.at(i).sum << " ";
//}
//cout << endl;
//for (int i = 0; i < (int)p1.size(); i++)
//{
// for (int j = 0; j < 4; j++)
// {
// cout << p1.at(i).suoyin[j] << " ";
// }
// cout << endl;
//}
jieheyi(&p1);
jieheyi(&p1);
jieheyi(&p1);
jieheyi(&p2);
jieheer(&p2);
//for (int i = 0; i <(int)p1.size(); i++)
//{
// cout << p1.at(i).sum << " ";
//}
//cout << " ************************************************************" << endl;
//for (int i = 0; i <(int)p2.size(); i++)
//{
// cout << p2.at(i).sum << " ";
//}
//cout << endl;
if (checkjieguo(&p1) || checkjieguo(&p2))
cout << "Yes" << endl;
else
cout << "No"<<endl;
//cout << p1.at(0).dj << " " << p1.at(0).sum << endl;
vector<jieguo> p3;
getvector(&p1,&p3);
getvector(&p2,&p3);
//getprocess(&p1,1 );
for (int i = 0; i < (int)p3.size(); i++)
{
getprocess(&p3, i);
}
system("pause");
return 0;
}#ifndef SUSUAN_H
#define SUSUAN_H
#include "jieguo.h"
#include <vector>
#include <iostream>
using namespace std;
static int kapai[4] = { 0,0,0,0 }; //运算数组，存放4个数字
vector<jieguo>* jieheyi(vector<jieguo>* p); //第一种运算方式：每次结合一位数字任意运算结果并赋值到集合p中
vector<jieguo>* jieheer(vector<jieguo>* p); //第二种运算方式：每次结合二位数字的任意运算并赋值到集合p中
vector<int>* getsuoyin(jieguo T, vector<int>*p); //获得结果类T的以后每次运算可取的所有索引
vector<jieguo>* getjieguo(jieguo a,int b, vector<jieguo>*p); //第一种运算：获得结果类a与对应索引b的所有运算结果并赋值到p中
vector<jieguo>* getjieguo2(jieguo a, jieguo b, vector<jieguo>*p);//第二种运算：获得结果类a与对应索引b的所有运算结果并赋值到p中
void cpvetor(vector<jieguo>*p1, vector<jieguo>*p2); //将p2集合所有元素转移到p1集合内
bool checkjieguo(const vector<jieguo>*p); //检查结果集合中是否有符合值为24的结果类对象
void getprocess(const vector<jieguo>*p, int i); //获得p集合中第i-1个元素的运算方式与索引结合顺序
void getvector(const vector<jieguo>*p, vector<jieguo>*p1 ); //将p集合中满足24的结果对象放入P1
vector<jieguo>* jieheyi(vector<jieguo>* p)
{
vector<jieguo> ret; //定义一个存放结果对象的临时集合
for (int i = 0; i <(int) p->size(); i++)
{
vector<int> suoyin; //定义一个存放索引的集合
getsuoyin(p->at(i), &suoyin);
for (int j=0; j < (int)suoyin.size(); j++)
{
getjieguo(p->at(i),suoyin.at(j),&ret);
}
}
p->clear();
cpvetor(p, &ret);
return p;
}
vector<jieguo>* jieheer(vector<jieguo>* p)
{
vector<jieguo> ret; //定义一个存放结果对象的临时集合
for (int i = 0; i <(int)p->size(); i++)
{
vector<int> suoyin; //定义一个存放索引的集合
getsuoyin(p->at(i), &suoyin);
jieguo T;
for (int j = 0; j < (int)suoyin.size(); j++)//将p中第i个对象下一次运算可能取值的所有索引放入结果对象T中
{
T.suoyin[j] = suoyin.at(j);
}
getjieguo2(p->at(i), T, &ret);
}
p->clear();
cpvetor(p, &ret);
return p;
}
vector<int>* getsuoyin(jieguo T, vector<int>*p)
{
for (int i = 0; i < 4; i++)
{
bool isIN = true;
for (int j = 0; j < 4; j++)
{
if (i == T.suoyin[j])isIN = false;
}
if (isIN)p->push_back(i);
}
return p;
}
vector<jieguo>* getjieguo(jieguo a, int b, vector<jieguo>*p)
{
a.dj++; //(（a?b）?c)?d
a.suoyin[a.dj-1 ] = b;
float temp = a.sum;
a.sum += kapai[b];
a.yunsuanfu[a.dj - 2] = '+';
p->push_back(a);
a.sum = temp;
a.sum -= kapai[b];
a.yunsuanfu[a.dj - 2] = '-';
p->push_back(a);
a.sum = temp;
a.sum *= kapai[b];
a.yunsuanfu[a.dj - 2] = '*';
p->push_back(a);
a.sum = temp;
a.sum /= kapai[b];
a.yunsuanfu[a.dj - 2] = '/';
p->push_back(a);
if (a.dj > 2&&a.dj<5) //d?(（a?b）?c) (d?(a?b))?c
{
if(a.dj==3)a.chubiaozhi = 1; //(a/(b?c))?d
if (a.dj == 4)a.chubiaozhi1 = 1; // d/((a?b)?c)
if (a.chubiaozhi1 == 1&&a.chubiaozhi==1)a.chubiaozhi2 = 1; // d/(a/(b?c))
int temp1,temp2;
temp2 = temp1 = a.suoyin[0];
for (int i = 0; i < 3; i++)
{
temp2 = a.suoyin[i + 1];
a.suoyin[i + 1] = temp1;
temp1 = temp2;
}
char temp3, temp4;
temp3 = temp4 = a.yunsuanfu[0];
for (int i = 0; i < 2; i++)
{
temp4 = a.yunsuanfu[i + 1];
a.yunsuanfu[i + 1] = temp3;
temp3 = temp4;
}
a.yunsuanfu[0] = '/';
a.suoyin[0] = b;
a.sum = temp;
a.sum = (float)kapai[b] / a.sum;
p->push_back(a);
}
//d-(（a?b）?c) (d-(a?b))?c d-(a-(b?c))
if (a.yunsuanfu[1] == '*' || a.yunsuanfu[1] == '/' || a.yunsuanfu[2] == '*' || a.yunsuanfu[2] == '/')
{
a.yunsuanfu[0] = '-';
a.suoyin[0] = b;
a.sum = temp;
a.sum = (float)kapai[b] - a.sum;
p->push_back(a);
}
return p;
}
void cpvetor(vector<jieguo>*p1, vector<jieguo>*p2)
{
for (int i = 0; i < (int)p2->size(); i++)
{
p1->push_back(p2->at(i));
}
}
vector<jieguo>* getjieguo2(jieguo a, jieguo b, vector<jieguo>*p) //(a?b)?(c?d)
{
a.dj = 4;
a.chubiaozhi = 3;
a.suoyin[2] = b.suoyin[0];
a.suoyin[3] = b.suoyin[1];
float temp = a.sum;
b.sum = kapai[b.suoyin[0]] + kapai[b.suoyin[1]];
{
a.yunsuanfu[2] = '+';
//a.sum += b.sum;
//p->push_back(a);
//a.sum -= b.sum;
//p->push_back(a);
a.yunsuanfu[1] = '*';
a.sum *= b.sum;
p->push_back(a);
a.yunsuanfu[1] = '/';
a.sum = temp;
a.sum /= b.sum;
p->push_back(a);
}
b.sum = kapai[b.suoyin[0]] - kapai[b.suoyin[1]];
{
a.yunsuanfu[2] = '-';
/* a.sum += b.sum;
p->push_back(a);
a.sum -= b.sum;
p->push_back(a);*/
a.yunsuanfu[1] = '*';
a.sum = temp;
a.sum *= b.sum;
p->push_back(a);
a.yunsuanfu[1] = '/';
a.sum = temp;
a.sum /= b.sum;
p->push_back(a);
}
b.sum = kapai[b.suoyin[0]] * kapai[b.suoyin[1]];
{
a.yunsuanfu[2] = '*';
a.yunsuanfu[1] = '+';
a.sum = temp;
a.sum += b.sum;
p->push_back(a);
a.yunsuanfu[1] = '-';
a.sum = temp;
a.sum -= b.sum;
p->push_back(a);
/* a.sum *= b.sum;
p->push_back(a);
a.sum /= b.sum;
p->push_back(a);*/
}
b.sum = (float)(kapai[b.suoyin[0]] /(float) kapai[b.suoyin[1]]);
{
a.yunsuanfu[2] = '/';
a.yunsuanfu[1] = '+';
a.sum = temp;
a.sum += b.sum;
p->push_back(a);
a.yunsuanfu[1] = '-';
a.sum = temp;
a.sum -= b.sum;
p->push_back(a);
/*a.sum *= b.sum;
p->push_back(a);
a.sum /= b.sum;
p->push_back(a);*/
}
a.suoyin[2] = b.suoyin[1];
a.suoyin[3] = b.suoyin[0];
/*b.sum = kapai[b.suoyin[1]] + kapai[b.suoyin[0]];
{
a.sum += b.sum;
p->push_back(a);
a.sum -= b.sum;
p->push_back(a);
a.sum *= b.sum;
p->push_back(a);
a.sum /= b.sum;
p->push_back(a);
}*/
b.sum = (float)(kapai[b.suoyin[1]] - (float)kapai[b.suoyin[0]]);
{
a.yunsuanfu[2] = '-';
/*a.sum += b.sum;
p->push_back(a);
a.sum -= b.sum;
p->push_back(a);*/
a.yunsuanfu[1] = '*';
a.sum = temp;
a.sum *= b.sum;
p->push_back(a);
a.yunsuanfu[1] = '/';
a.sum = temp;
a.sum /= b.sum;
p->push_back(a);
}
/*b.sum = kapai[b.suoyin[1]] * kapai[b.suoyin[0]];
{
a.sum += b.sum;
p->push_back(a);
a.sum -= b.sum;
p->push_back(a);
a.sum *= b.sum;
p->push_back(a);
a.sum /= b.sum;
p->push_back(a);
}*/
b.sum =(float)( kapai[b.suoyin[1]] /(float) kapai[b.suoyin[0]]);
{
a.yunsuanfu[2] = '/';
a.yunsuanfu[1] = '+';
a.sum = temp;
a.sum += b.sum;
p->push_back(a);
a.yunsuanfu[1] = '-';
a.sum = temp;
a.sum -= b.sum;
p->push_back(a);
/* a.sum *= b.sum;
p->push_back(a);
a.sum /= b.sum;
p->push_back(a);*/
}
return p;
}
bool checkjieguo(const vector<jieguo>*p)
{
for (int i = 0; i < p->size(); i++)
{
if (p->at(i).sum == 24)return true;
}
return false;
}
void getprocess(const vector<jieguo>*p, int i)
{
for (int j = 0; j < sizeof(p->at(0).suoyin) / 4; j++)
{
cout << p->at(i).suoyin[j];
}
cout << endl;
if (p->at(i).chubiaozhi == 0&& p->at(i).chubiaozhi1 == 0)
printf("( ( %d %c %d ) %c %d ) %c %d", //输出格式为运算方式与结合方式，为结合1运算 0:((a?b)? c)?d
kapai[p->at(i).suoyin[0]],p->at(i).yunsuanfu[0],
kapai[p->at(i).suoyin[1]],p->at(i).yunsuanfu[1],
kapai[p->at(i).suoyin[2]],p->at(i).yunsuanfu[2],
kapai[p->at(i).suoyin[3]]);
if(p->at(i).chubiaozhi==1&& p->at(i).chubiaozhi1!=1)
printf("( %d %c ( %d %c %d ) ) %c %d", //结合1 (a/(b?c))?d
kapai[p->at(i).suoyin[0]], p->at(i).yunsuanfu[0],
kapai[p->at(i).suoyin[1]], p->at(i).yunsuanfu[1],
kapai[p->at(i).suoyin[2]], p->at(i).yunsuanfu[2],
kapai[p->at(i).suoyin[3]]);
if (p->at(i).chubiaozhi1 == 1 && p->at(i).chubiaozhi != 1)
printf("%d %c ( ( %d %c %d ) %c %d )", //结合1 d/((a?b)?c)
kapai[p->at(i).suoyin[0]], p->at(i).yunsuanfu[0],
kapai[p->at(i).suoyin[1]], p->at(i).yunsuanfu[1],
kapai[p->at(i).suoyin[2]], p->at(i).yunsuanfu[2],
kapai[p->at(i).suoyin[3]]);
if (p->at(i).chubiaozhi2 == 1 )
printf("%d %c ( %d %c (%d %c %d) )", //结合1 d/(a/(b?c))
kapai[p->at(i).suoyin[0]], p->at(i).yunsuanfu[0],
kapai[p->at(i).suoyin[1]], p->at(i).yunsuanfu[1],
kapai[p->at(i).suoyin[2]], p->at(i).yunsuanfu[2],
kapai[p->at(i).suoyin[3]]);
if (p->at(i).chubiaozhi == 3)
printf("( %d %c %d ) %c ( %d %c %d )", //结合2 (a?b)?(c?d)
kapai[p->at(i).suoyin[0]], p->at(i).yunsuanfu[0],
kapai[p->at(i).suoyin[1]], p->at(i).yunsuanfu[1],
kapai[p->at(i).suoyin[2]], p->at(i).yunsuanfu[2],
kapai[p->at(i).suoyin[3]]);
cout << endl;
}
void getvector(const vector<jieguo>*p, vector<jieguo>*p1 )
{
for (int i = 0; i < p->size(); i++)
{
if (p->at(i).sum == 24)p1->push_back(p->at(i));
}
}
#endif#ifndef JIEGUO_H
#define JIEGUO_H
class jieguo
{
public:
float sum;
int dj;
int suoyin[4];
int chubiaozhi = 0; //1:(a/(b?c))?d 0:((a?b)? c)?d 3:(a?b)?(c?d)
int chubiaozhi1 = 0; // 1: d/((a?b)?c)
int chubiaozhi2 = 0; //d/(a/(b?c))
char yunsuanfu[3];
jieguo(float a,int b,int c);
jieguo()
{}
};
jieguo::jieguo(float a,int b,int c)
{
sum = a;
dj = b;
for (int i = 0; i < 4; i++)
suoyin[i] = -1;
suoyin[0] = c;
}
#endif
不想多做解释了，里面有注释，我发现网上大多数算法有缺陷，比如无法计算（a?b）?(c?d）这种格式，我补上这种缺陷。当然还有没有其他的bug我也不知道。我qq1023499413 有兴趣可以一起交流
扫一扫
2175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
