c语言编程题，计算二十四点 随机生成四个1~10的数字，使用加减乘除运算，计算24.输出这四个数字是否能计算

最随机数1-10 赋值A，最随机数1-赋值B，共赋值ABCD，叛断，赋值A等于BCD，则重取随机数，然后叛断用ABCD相加或减等于24，等则输出，不等于则重取。

#include "stdlibh"

#include "stdioh"

} NODE24;

NODE24 head;int res=24;int maketree(int src,int i, NODE24 p)

{

int d=src[i];

(i)++;

case '/':

p->left=new NODE24;

p->right=new NODE24;

p->left=NULL;

p->right=NULL;

扩展资料：

随机数是专门的随机试验的结果。

在统计学的不同技术中需要使用随机数，比如在从统计总体中抽取有代表性的样本的时候，或者在将实验动物分配到不同的试验组的过程中，或者在进行蒙特卡罗模拟法计算的时候等等。

产生随机数有多种不同的方法。这些方法被称为随机数生成器。随机数最重要的特性是它在产生时后面的那个数与前面的那个数毫无关系。

参考资料来源：百度百科-随机数

算24点”是一种数学游戏，正如象棋、围棋一样是一种人们喜闻乐见的娱乐活动。 它始于何年何月已无从考究，但它以自己独具的数学魅力和丰富的内涵正逐渐被越来越多的人们所接受。这种游戏方式简单易学，能健脑益智。

2、游戏规则：一副牌中抽去大小王剩下52张，J、Q、K可以当成是11、12、13，也可以都当成1。（所以我们把J、Q、K都当成1来算，也可只用1～10这40张牌）任意抽取4张牌（可以两个人玩，也可以四个人玩），用加、减、乘、除（可加括号）把牌面上的数算成24。每张牌必须用一次且只能用一次。谁先算出来，四张牌就归谁，如果无解就各自收回自己的牌，哪一方把所有的牌都赢到手中，就获胜了。

3、计算技巧：“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧。计算时，我们不可能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑。刚开始的时候，可能需要花很长的时间去想一种解法，我们可以慢一点，引导利用一些规律：比如利用3×8＝24、4×6＝24求解， 把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。实践证明，这种方法是利用率最大、命中率最高的一种方法。 当一组牌有多种不同解法时，可以给时间多想想，

1使用二叉树来计算,怎么算,数据结构上写的很清楚,这里就不说了

2关键问题是怎么构造二叉树,

按照人计算24点的方法，构造的二叉树有3种

1）4个数字、3个运算符、没有（括弧）总共7个节点

2）4个数字、3个运算符、2个（1对括弧） 总共9个节点

2）4个数字、3个运算符、4个（2对括弧） 总共11个节点

之后，我觉得只能穷举了，所有对于1）类二叉树可以构造出7！（阶乘个），2）类是9！3）是11！。这里的构造程序可以只用1个函数，就是构造是使用得样本空间不同而已。让计算机算，这点运算也就不到1秒。

3。对每个构造出的二叉树，进行先序遍历，遍历程序《数据结构》上有，遍历的结果就是算术表达式的字符表示，然后，使用aksII编码把字符变成int数和+_()运算符计算。

4。计算的时候，有不少不是算术表达式的，如:

)ab-(cd

做个判断直接跳过。很容易判断的，比如说任何二叉树根节点返回为()+-/的话，这个二叉树跳过

5，把能够计算出int结果的判断是否==24

6 yes，再次遍历次二叉树，每访问1个节点就printf 1个节点。

7 no的话，回步骤3

收工。

小弟才疏学浅，只好穷举了，哈哈 。啊呀呀，有人比我快啊，先回答了，失败。

#include <stdioh>

void Hello( )

{

puts("\n");

puts(" ##################################################");

puts(" ## ##");

puts(" ## 24点程序 ##");

puts(" ## ##");

puts(" ##################################################");

puts(" ## ##");

puts(" ## 输入4个整数，用它们构造一个算术四则运算， ##");

puts(" ## 使结果等于24。每个数恰好利用一次。 ##");

puts(" ## ##");

puts(" ## 例如，输入为 2 7 10 6 ##");

puts(" ## 输出为（2＋6）x（10－7） ##");

puts(" ## …… ##");

puts(" ## …… ##");

puts(" ## （可输出有重复的全部解） ##");

puts(" ## ##");

puts(" ##################################################");

puts(" ## ##");

puts(" ## 设计者：NotorFast ##");

puts(" ## 时 间：2004-10-16 ##");

puts(" ## ##");

puts(" ##################################################");

puts("\n");

}

const int N = 4; // *** 作数的个数/栈的极限高度

#define eps 1E-6 // 浮点精度

inline float abs(float x) { return x >= 00 x : -x; }

// 栈模板

template <class T, int N> class STACK {

protected:

T a[N]; // 栈的存储体

int n; // 栈的高度/未来栈顶位置

public:

STACK( ) { reset( ); } // 栈初始化

void reset( ) { n = 0; } // 清空栈

void push(T x) { if(n < N) a[n++] = x; else puts("栈上溢"); } // 压入数据到栈顶

T pop( ) { if(n > 0) return a[--n]; else puts("栈下溢"); } // d出栈顶数据

// T top( ) { if(n > 0) return a[n-1]; else puts("栈空"); } // 查询栈顶元素

// bool isempty( ) { return n == 0; } // 查询栈是否为空

// int heigth( ) { return n; } // 查询栈的高度

};

const char opr[ ] = "+-/";

int a[N]; // 输入的4个数

STACK<float, N> opnstk; // *** 作数栈

int b[N], K = 0; // a[]的备份/用于生产排列的工作区

void gen(int n, int m) // 生成n个数中取m个数的全排列。m = n时即为n个数的全排列。---

{ // --- 每产生一个排列，放入b[]中。

void gen24( ); // 函数声明

int i;

if(m == 0) {

// for(i = 0; i < K; ++i) printf("%d ", b[i]); putchar('\n'); // 如果只是为了输出排列

gen24( ); // 函数调用

}

else

for(i = 0; i < n; ++i) if(a[i] != '') {

b[K++] = a[i];

a[i] = '';

gen(n, m - 1);

a[i] = b[--K];

}

}

// 用后缀表达式计算，用中缀表达式输出。

// --- n表示将一个 *** 作数压栈，#表示进行一步运算。

// --- abcd指 *** 作数的输出顺序，123指运算符的输出顺序。

const char stkmode[5][22] = {

"nnnn### = a3(b2(c1d))",

"nnn#n## = a3((b1c)2d)",

"nnn##n# = (a2(b1c))3d",

"nn#nn## = (a1b)3(c2d)",

"nn#n#n# = ((a1b)2c)3d",

};

void gen24( ) // 用b[]中的4个数产生等于24的算式

{

bool calc(float, char, float, float&); // 函数声明

int i, jn, jo, p0, p1, p2;

char enumopr[3], op;

float a1, a2, c;

const char p;

// for(i = 0; i < K; ++i) printf("%d ", b[i]); putchar('\n'); // 如果只是为了输出排列

for(i = 0; i < 5; ++i) // 尝试每种栈模式

for(p0 = 0; p0 < 4; ++p0) { enumopr[0] = opr[p0];

for(p1 = 0; p1 < 4; ++p1) { enumopr[1] = opr[p1];

for(p2 = 0; p2 < 4; ++p2) { enumopr[2] = opr[p2];

opnstkreset( );

for(jn = jo = 0, p = stkmode[i]; p != ' '; ++p) switch(p) {

case 'n':

opnstkpush(b[jn++]); break;

case '#':

a2 = opnstkpop( ); a1 = opnstkpop( ); op = enumopr[jo++];

if(calc(a1, op, a2, c)) opnstkpush(c); else goto loc_1;

}

if(abs(c - 24) < eps) {

while(++p != 0) switch(p) {

case '(':

case ')':

putchar(p);

break;

case 'a':

case 'b':

case 'c':

case 'd':

printf("%d", b[p - 'a']);

break;

case '1':

case '2':

case '3':

printf("%c", enumopr[p - '1']);

break;

}

putchar('\n');

goto loc_2;

}

loc_1: continue;

}}}

loc_2: return;

}

bool calc(float a, char op, float b, float& c)

{

static bool bRet;

switch(bRet = true, op) {

case '+': c = a + b; break;

case '-': c = a - b; break;

case '': c = a b; break;

case '/':

if(abs(b) > eps) c = a / b; else bRet = false;

}

return bRet;

}

int main( )

{

Hello( );

while(true) {

printf("请输入%d个整数（用空白分隔。结束程序请输入0）: ", N);

for(int i = 0; i < N; ++i) { scanf("%d", &a[i]); if(a[i] == 0) goto loc_0; }

K = 0; gen(N, N);

}

loc_0: return 0;

}

import javautilRandom;

public class test2

{

public static void main(String[] args)

{

Random random = new Random();

int a[] = new int[4];

for(int i=0; i<4; i++)

{

a[i] = randomnextInt(13)+1;

}

for(int j=0; j<4; j++)

{

Systemoutprintln("第" + j +"个数：" + a[j]);

}

Calcula(a);

}

public static void Calcula(int[] a)

{

int add, sub, multi, div;

add = 0;

sub = 0;

multi = 0;

div = 0;

for(int i=0; i<4; i++)

{

add = add + a[i];

sub = sub - a[i];

multi = multi a[i];

div = div/a[i];

}

if(add==24)

{

Systemoutprintln(a[0] + "+" + a[1] + "+" + a[2] + "+" + a[3]

+ "=" + add);

}

else if(sub==24)

{

Systemoutprintln(a[0] + "-" + a[1] + "-" + a[2] + "-" + a[3]

+ "=" + sub);

}

else if(multi==24)

{

Systemoutprintln(a[0] + "" + a[1] + "" + a[2] + "" + a[3]

+ "=" + multi);

}

else if(div==24)

{

Systemoutprintln(a[0] + "÷" + a[1] + "÷" + a[2] + "÷" + a[3]

+ "=" + div);

}

else

{

Systemoutprintln("对不起，没有实现24点的数");

}

}

}

已编译通过~

解法用到的基本思想就是回溯，树的深度为最深为4，树的判断分支为 加减乘除，对不满足条件的解进行剪枝（即当前结果>=24）,当到达递归边界（即树的深度为四时）时，即判断当前的结果是否符合条件（=24），符合即找到解，否则继续进行。

参考代码如下：

#include<iostream>

#include<mathh>

using namespace std;

const double MIN=1E-6;

void Print(int Rank,double FourNum)

{

for(int i=0;i<4;i++)

cout<<FourNum[Rank[i]]<<" ";

cout<<endl;

}

void Calculate_24(int Rank,int FourNum,char Oper,int i,int j,int k,bool &def)

{

double res=0;

switch(i)

{

case 0:

res=FourNum[Rank[0]]+FourNum[Rank[1]];

break;

case 1:

res=FourNum[Rank[0]]-FourNum[Rank[1]];

break;

case 2:

res=FourNum[Rank[0]]FourNum[Rank[1]];

break;

case 3:

res=FourNum[Rank[0]]/FourNum[Rank[1]];

break;

}

switch(j)

{

case 0:

res=res+FourNum[Rank[2]];

break;

case 1:

res=res-FourNum[Rank[2]];

break;

case 2:

res=resFourNum[Rank[2]];

break;

case 3:

res=res/FourNum[Rank[2]];

break;

}

switch(k)

{

case 0:

res=res+FourNum[Rank[3]];

break;

case 1:

res=res-FourNum[Rank[3]];

break;

case 2:

res=resFourNum[Rank[3]];

break;

case 3:

res=res/FourNum[Rank[3]];

break;

}

if(fabs(res-24)>MIN)

return;

else

{

def=true;

for(int num=1;num<=7;num++)

{

switch(num)

{

case 1:

cout<<FourNum[Rank[0]];

break;

case 3:

cout<<FourNum[Rank[1]];

break;

case 5:

cout<<FourNum[Rank[2]];

break;

case 7:

cout<<FourNum[Rank[3]];

break;

case 2:

cout<<Oper[i];

break;

case 4:

cout<<Oper[j];

break;

case 6:

cout<<Oper[k];

break;

}

}

cout<<endl;

}

}

void SearchTree(int Depth,int Rank,int FourNum,char Oper,bool &def)

{

int i,j,k;

if(Depth==4)

{

for(i=0;i<4;i++)

for(j=0;j<4;j++)

for(k=0;k<4;k++)

Calculate_24(Rank,FourNum,Oper,i,j,k,def);

}

else

{

for(i=0;i<4;i++)

{

int Remember=0;

for(j=0;j<Depth;j++)

{

if(Rank[j]==i)

Remember=1;

}

if(Remember)

continue;

Rank[Depth]=i;

SearchTree(Depth+1,Rank,FourNum,Oper,def);

}

}

}

int main()

{

int a[4],b[4],time;

char c[4]={'+','-','','/'};

bool def=false;

cin>>time;

while(time--)

{

for(int i=0;i<4;i++)//输入测试数据

cin>>a[i];

cout<<"所有可能的结果："<<endl;

SearchTree(0,b,a,c,def);

if(def==false)

cout<<"No"<<endl;

}

return 0;

}

你要是看不懂的话，还是退学吧

下面的东西要编译的话，你一定要看得懂的

问题描述:

有四个整数(0到10),运算符只有加减乘除,还有括号,每个数能且只能用一次,要求判断这些表达的结果中是否有24,如果有,输出过程,格式如下:

4611 (允许有括号)

注意:

1,中间结果允许出现分数,如: (5 – 1/5)5;

2,不能有多余的括号

3,不能出现两个负数相乘,如(1-4)(1-9),看作(4-1)(9-1)的重复,也不能出现8-8(2-4)

4,避免交换律引起的重复

5,避免结合律引起的重复

6,由于数字相同的重复也不允许,如有两个2

分析:

#1,#2,#3代表运算符,a,b,c,d代表运算数,对于表达式a #1 b #2 c #3 d根据运算顺序有如下六种可能

1,运算顺序:#1,#2,#3 (( a #1 b) #2 c) #3 d

2,运算顺序:#1,#3,#2 ( a #1 b ) #2 ( c #3 d)

3,运算顺序:#2,#3,#1 a #1 (( b #2 c ) #3 d )

4,运算顺序:#2,#1,#3 (a #1 ( b #2 c ) ) #3 d

5运算顺序:#3,#1,#2 ( a #1 b ) #2 ( c #3 d )

6运算顺序:#3,#2,#1 a #1 ( b #2 ( c #3 d))

其中运算符对应关系有64种

运算数对应关系24种．

考虑6／（5／4 －1）＝ 24自定义数据类型cdata,包含整形的分子，分母．

最后排除重复(输出成字符串再比较)

1，由于运算数相同的问题，直接比较就行了．

2，交换律的问题：

(( a #1 b) #2 c) #3 d成立

如果＃都是＋或＊

那么，

(( b #1 a) #2 c) #3 d

(c #2 ( a #1 b)) #3 d

d #3 (c #2 ( a #1 b))

调整使不会出现小数加(乘)大数,再比较就行了,注意如果结果相同,还要比较过程,运算符在运算数之前,如:(2+4)6而不是6(2+4)都是运算符也保证顺序的唯一性

3，分配律不认为重复．

4,结合律,如: a + b –c = a – c + b;由于只有三个运算符,故只会出现两个运算符的结合律和三个运算符的结合律我们先将-/变成加乘,全部是加(乘)的结合律好处理a-(bc),a-(b/c),a/(b+c),a/(b-c)不好处理,加个标记就行了总共三个运算符,而结合律至少要两个运算符,故b,c不会再包含运算符

cdata的结构:

#include <iostream>

#include <vector>

#include <cmath>

#include <algorithm>

using namespace std;

const double epsilon = 1E-14;

const double destination = 24;

const double CARD_VALUE_MIN = 1;

const double CARD_VALUE_MAX = 13;

const char symbol_array[] = {'+','-','','/'};

double max(const double a,const double b);

bool approx_equal(const double a,const double b);

double calc_each(const double a,const double b,const int method);

void insert_element(vector<double> &v,const int pos,const double value);

bool print_formule(const vector<double> &v,const int formule_id,const int symb_a,

const int symb_b,const int symb_c);

void calc_elements(const vector<double> &v);

void calc_permutation(vector<double> queue,vector<double> to_permute); //只有对于没有重复的数组才能产生正确的全排列

void calc_permutation_standard(vector<double> queue);

int rcount = 0;

int main(int argc,char argv[])

{ if(argc < 5)

{

cout << "Calc point 24 verstion 01" << endl;

cout << "Usage: " << argv[0] << " <card1> <card2> <card3> <card4> " << endl;

return 1;

}

else

{

vector<double> card(4);

vector<double> helper(1);

for(int i = 0; i < 4; i++)

{

card[i] = atof(argv[i+1]);

if(card[i] < CARD_VALUE_MIN || card[i] > CARD_VALUE_MAX)

{

cout << "Invailed value of card!" << endl;

return 1;

}

}

/if(card[0] == card[1] && card[0] == card[2] && card[0] == card[3])

calc_elements(card);

else

{

calc_elements(card);

calc_permutation(card,helper);

}/

calc_permutation_standard(card);

cout << "The total result is " << rcount << endl;

}

return 0;

}

double max(const double a,const double b)

{ return a > b a : b;

}

bool approx_equal(const double a,const double b)

{ if(a == 0) return fabs(b) <= epsilon;

if(b == 0) return fabs(a) <= epsilon;

return fabs(a - b) / max(fabs(a),fabs(b)) <= epsilon;

}

double calc_each(const double a,const double b,const int method)

{ if(method == 0) return a + b;

if(method == 1) return a - b;

if(method == 2) return a b;

if(method == 3 && b != 0) return a / b;

return -999;

}

void insert_element(vector<double> &v,const int pos,const double value)

{ vpush_back(0);

for(int i = vsize() - 2; i >= pos; i--)

v[i+1] = v[i];

v[pos] = value;

}

bool print_formule(const vector<double> &v,const int formule_id,const int symb_a,

const int symb_b,const int symb_c)

{ double r1,r2,result = 0;

if(formule_id == 0)

{

r1 = calc_each(v[0],v[1],symb_a);

if(approx_equal(r1,-999)) return false;

r2 = calc_each(r1,v[2],symb_b);

if(approx_equal(r2,-999)) return false;

result = calc_each(r2,v[3],symb_c);

}

else if(formule_id == 1)

{

r1 = calc_each(v[0],v[1],symb_a);

if(approx_equal(r1,-999)) return false;

r2 = calc_each(v[2],v[3],symb_b);//symb_c);

if(approx_equal(r2,-999)) return false;

result = calc_each(r1,r2,symb_c);//symb_b);

}

else if(formule_id == 2)

{

r1 = calc_each(v[1],v[2],symb_a);//symb_b);

if(approx_equal(r1,-999)) return false;

r2 = calc_each(v[0],r1,symb_b);//symb_a);

if(approx_equal(r2,-999)) return false;

result = calc_each(r2,v[3],symb_c);

}

else if(formule_id == 3)

{

r1 = calc_each(v[1],v[2],symb_a);//symb_b);

if(approx_equal(r1,-999)) return false;

r2 = calc_each(r1,v[3],symb_b);//symb_c);

if(approx_equal(r2,-999)) return false;

result = calc_each(v[0],r2,symb_c);//symb_a);

}

else if(formule_id == 4)

{

r1 = calc_each(v[2],v[3],symb_a);//symb_c);

if(approx_equal(r1,-999)) return false;

r2 = calc_each(v[1],r1,symb_b);//symb_b);

if(approx_equal(r2,-999)) return false;

result = calc_each(v[0],r2,symb_c);//symb_a);

}

if(approx_equal(result,-999)) return false;

if(approx_equal(result,destination))

{

if(formule_id == 0)

{

cout << "((" << v[0] << symbol_array[symb_a] << v[1] << ")" << symbol_array[symb_b]

<< v[2] << ")" << symbol_array[symb_c] << v[3] << "=" << destination << endl;

return true;

}

else if(formule_id == 1)

{

cout << "(" << v[0] << symbol_array[symb_a] << v[1] << ")" << symbol_array[symb_b]

<< "(" << v[2] << symbol_array[symb_c] << v[3] << ")=" << destination << endl;

return true;

}

else if(formule_id == 2)

{

cout << "(" << v[0] << symbol_array[symb_a] << "(" << v[1] << symbol_array[symb_b]

<< v[2] << "))" << symbol_array[symb_c] << v[3] << "=" << destination << endl;

return true;

}

else if(formule_id == 3)

{

cout << v[0] << symbol_array[symb_a] << "((" << v[1] << symbol_array[symb_b] << v[2]

<< ")" << symbol_array[symb_c] << v[3] << ")=" << destination << endl;

return true;

}

else if(formule_id == 4)

{

cout << v[0] << symbol_array[symb_a] << "(" << v[1] << symbol_array[symb_b] << "("

<< v[2] << symbol_array[symb_c] << v[3] << "))=" << destination << endl;

return true;

}

}

return false;

}

void calc_elements(const vector<double> &v)

{ int i,j,k,l;

for(l = 0; l < 5; l++)

{

for(i = 0; i < 4; i++)

{

for(j = 0; j < 4; j++)

{

for(k = 0; k < 4; k++)

{

if(print_formule(v,l,i,j,k))

{

rcount++;

}

}

}

}

}

}

void calc_permutation(vector<double> queue,vector<double> to_permute)

{ if(queuesize() == 0)

{

to_permutepop_back();

calc_elements(to_permute);

}

else

{

vector<double> mir_queue = queue;

vector<double> mir_to_permute = to_permute;

vector<double> bak_vector;

double back_value = mir_queue[mir_queuesize() - 1];

mir_queuepop_back();

for(int i = 0; i < mir_to_permutesize(); i++)

{

bak_vector = mir_to_permute;

insert_element(mir_to_permute,i,back_value);

calc_permutation(mir_queue,mir_to_permute);

mir_to_permute = bak_vector;

}

}

}

void calc_permutation_standard(vector<double> queue)

{ sort(queuebegin(),queueend());

calc_elements(queue);

while(next_permutation(queuebegin(),queueend()))

{

calc_elements(queue);

}

}

以上就是关于c语言编程题，计算二十四点 随机生成四个1~10的数字，使用加减乘除运算，计算24.输出这四个数字是否能计算全部的内容，包括:c语言编程题，计算二十四点 随机生成四个1~10的数字，使用加减乘除运算，计算24.输出这四个数字是否能计算、编程有一个24点的游戏,规则是给任意四个整数。使用加减乘除运算,、C语言 计算24是流行的扑克游戏。 方法，思路也行。等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！