1. 你能用连续4张扑克算出“24点”吗你能想出几种
24可以简单写成3×8、4×6、12×2、1×24等，还可以写成（10—2）×3、（9—1）×3、（2+1）×8、（5+7）×2、（5+1）×4等，这些算式变化多样。利用上面的思考方式可以这样算：
因为：3×8=24
2—1=1
所以：（3×8）×（2—1）=24
1、用4×6的方法凑24。
因为4×6=24，（2—1）=1，所以4×6×（2—1）=24。
2、用3×8的方法凑24。
当四个数凑24，用3×8、4×6、12×2等基本思路行不通时，可以先考虑两个数的和或差凑24。
因为：4—1=3，2+6=8，所以：（4—1）×（2+6）=24
组合就太多了包括号变化，但思路是以上方法为主导解法不变。
2. 4张扑克牌怎样才能得到24呢
从扑克中任意抽出四张（数字表示为1－13），用加、减、乘、除的方法使结果成为24，每张牌只能用一次。一副牌（52张）中，任意抽取4张可有1820种不同组合，其中有458个牌组算不出24点所以有很多 在下举一例：6乘以8在除以（9加-7）=48除2=24
3. 4张牌算24点,4.4.8.8.
4+4+8+8
=24;
4x(8-4)+8
=4x4+8
=16+8
=24;
(4+8)÷4x8
=12÷4x8
=3x8
=24;
……
供参考。
4. 1个关于取4张牌计算24点的问题
#include <stdio.h>
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 >= 0.0 ? 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("栈下溢"); } // 弹出栈顶数据
// 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];
opnstk.reset( );
for(jn = jo = 0, p = stkmode[i]; *p != ' '; ++p) switch(*p) {
case 'n':
opnstk.push(b[jn++]); break;
case '#':
a2 = opnstk.pop( ); a1 = opnstk.pop( ); op = enumopr[jo++];
if(calc(a1, op, a2, c)) opnstk.push(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;
}
5. 用4张牌凑成24规律_
你好！“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧。计算时，我们不可能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑。刚开始的时候，可能需要花很长的时间去想一种解法，我们可以慢一点，引导利用一些规律：比如利用3×8＝24、4×6＝24求解，
把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。
6. 利用下面每组中的四张扑克牌算出“24点”)
5*4+7-3=24
3*（5+7-4）=24
4*3*（7-5）=24
3*4+7+5=24
7. 根据下面4张扑克牌上面的数，算出24点
同乐，可口可乐了
8. 四张扑克牌算24点规则是什么
游戏规则：这是一个扑克牌小游戏，用来测试人的计算水平的，它的运算规则其实就是四则混合运算，用加减乘除计算四张扑克牌上的数字，能得到结果是24就为赢了。
1、利用3×8＝24、4×6＝24求解。
把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。如3、3、6、10可组成（10-6÷3）×3＝24等。又如2、3、3、7可组成（7＋3-2）×3＝24等。
2、利用0、1的运算特性求解。
如3、4、4、8可组成3×8＋4-4＝24等。又如4、5、J、K可组成11×（5-4）＋13＝24等。
在有解的牌组中，用得广泛的是以下六种解法（我们用a、b、c、d表示牌面上的四个数）：
1、（a-b）×（c＋d）；如（10-4）×（2＋2）＝24等。
2、（a＋b）÷c×d；如（10＋2）÷2×4＝24等。
3、（a－b÷c）×d；如（3-2÷2）×12＝24等。
4、（a＋b－c）×d；如（9＋5-2）×2＝24等。
5、a×b＋c-d；如11×3＋l-0＝24等。
6、（a－b）×c＋d；如（4—l）×6＋6＝24等。
9. 用4张牌凑成24规律_
一、拿出一副扑克牌，取出大小王，剩下1到10，这40张牌(1用A代替)。任意从中取出4张牌，用加减乘除及括号进行计算，使结果等于24。每张牌只能用一次。二、利用0和1特殊性进行运算，比如4、6、8、8可以计算为4×6+8-8=24。三、运用2×12=24 ，3×8=24，4×6=24计算。如2、3、3、7，想办法将四个数，组合成以上三组中任意的一组。(7+3-2)×3=24。四、利用3×8=24、4×6=24求解，把牌面上的4个数想办法凑成3和8。五、4和6，再相乘求解。同学们平时一定要多加练习，只有掌握熟练才能快速正确的算出。