精华内容
下载资源
问答
  • java用扑克计算24点

    2020-08-24 22:06:39
    主要为大家详细介绍了java实现24点扑克游戏,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • /* 从一副扑克中,任取4张。 2-10 按其点数计算(为了表示方便10用T表示),J,Q,K,A 统一按 1 计算 要求通过加减乘除则运算得到数字 24。 本程序可以随机抽取纸牌,并用试探法求解。 */
  • 现在随机抽取四张牌,每张必须得用到并且每张只能用一次,用+ - * / () 看能否实现最后结果可以等于24,例如:输入4 5 6 7 ,输出yes,输入 1 1 2 6 输出yes,输入 1 1 1 1,输出no 现在我的想法是: 1、随机...

    昨天参加了某公司的一个笔试题,其中有一道编程题大概意思是:有一副扑克牌,去掉大小王,还剩52张牌,J Q K代表11,12,13。现在随机抽取四张牌,每张牌必须得用到并且每张牌只能用一次,用+ - * / () 看能否实现最后结果可以等于24,例如:输入4 5 6 7 ,输出yes,输入 1 1 2 6 输出yes,输入 1 1 1 1,输出no
    现在我的想法是:
    1、随机抽取两个数
    2、将这两个数进行+ - * / 运算,然后把这个数放到新的数组,将以前的去掉,现在数组就是3个数
    3、将然后再回到1,进行递归运算,直到n=1
    4、当n=1时,判断结果是否为24,是返回true,否返回false

    另外:这样做用到了穷举法的思想,而且这样的算法省略了()的麻烦,应该还有另一种解决办法,就是用后缀表达式来完成,但是我本事不够,目前还没想到该如何实现,还请会的朋友们在下面留下你们的代码

    我的代码:

    import java.util.Scanner;
    /**
     * 
     * @author 二哈大叔
     *
     */
    public class Poker24 {
        private static int COUNT = 4; //抽取的扑克牌数量
        private static double[] number = new double[COUNT]; //扑克牌的数组
        private static String[] expression = new String[COUNT]; //表达式数组
    
        public static boolean checkCondition(int n){
            //当递归到只有一个数时,判断是否满足条件
            if(n == 1){
                if(number[0] == 24){
                    System.out.println(expression[0].substring(1, expression[0].length()-1));
                    return true;
                }
                else
                    return false;
            }
            for (int i = 0; i < n - 1; i++) {
                for(int j = i + 1; j < n; j++){
                    double tempA = number[i];
                    double tempB = number[j];
                    String expreA = expression[i];
                    String expreB = expression[j];
                    number[j] = number[n-1];
                    expression[j] = expression[n-1];
                    //开始做加法
                    expression[i] = "("+expreA+"+"+expreB+")";
                    number[i] = tempA+tempB;
                    if(checkCondition(n-1))
                        return true;
                    //减法,两种情况,tempA-tempB和tempB-tempA
                    expression[i] = "("+expreA+"-"+expreB+")";
                    number[i] = tempA-tempB;
                    if(checkCondition(n-1))
                        return true;
                    expression[i] = "("+expreB+"-"+expreA+")";
                    number[i] = tempB-tempA;
                    if(checkCondition(n-1))
                        return true;
                    //乘法
                    expression[i] = "("+expreA+"*"+expreB+")";
                    number[i] = tempA*tempB;
                    if(checkCondition(n-1))
                        return true;
                    //除法,两种情况,tempA/tempB和tempB/tempA,并且保证分母不为0
                    if(tempB != 0){
                        expression[i] = "("+expreA+"/"+expreB+")";
                        number[i] = tempA/tempB;
                        if(checkCondition(n-1))
                            return true;
                    }
                    if(tempA != 0){
                        expression[i] = "("+expreB+"/"+expreA+")";
                        number[i] = tempB/tempA;
                        if(checkCondition(n-1))
                            return true;
                    }
                    number[i] = tempA;
                    number[j] = tempB;
                    expression[i] = expreA;
                    expression[j] = expreB;
                }
            }
            return false;
        }
    
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入1-13中"+COUNT+"个正整数");
            for (int i = 0; i < COUNT; i++) {
                number[i] = scanner.nextInt();
                int x;
                x = (int)number[i];
                expression[i] = String.valueOf(x);
            }
            if(checkCondition(COUNT))
                System.out.println("yes");
            else
                System.out.println("no");
        }
    }
    展开全文
  • #include <stdio.h> #include <math.h> int main() { int x,y,n=0; int a,b,c,d; char Hua[4]={'A','B','C','D'}; for (x=1;x<=10;x++) for (y=1;y<=10;y++) ...

     #include <stdio.h>
    #include <math.h>
    int main()
            {
                int x,y,n=0;
                 int a,b,c,d;
                 char Hua[4]={'A','B','C','D'};
                for (x=1;x<=10;x++)
                    for (y=1;y<=10;y++)
                        for (n=1;n<=10;n++)
                             if((x!=y)&&(x!=n)&&(y!=n)&&((x+x+y+n)==24))
                             {
                                 for (a=0;a<4;a++)
                                        for (b=0;b<4;b++)
                                            for (c=0;c<4;c++)    
                                                 for (d=0;d<4;d++)    
                                                     if(a!=b)
                                                                 printf("%c %d,%c%d ,%c%d ,%c%d\n", Hua[a],x, Hua[b],x, Hua[c],y, Hua[d],n);
                             }

                return 0;
            }
     

    展开全文
  • 如何判断4张牌是否可以24点

    千次阅读 2015-01-23 17:58:21
    24点游戏是我们经常玩的一种游戏,这种游戏规则简单,但是有时候却非常考验我们的大脑,今天通过c++代码写了一个计算4张牌是否可以组成24点的程序: #include using namespace std; const char sign[4] = {'+', '-...

    24点游戏是我们经常玩的一种游戏,这种游戏规则简单,但是有时候却非常考验我们的大脑,今天通过c++代码写了一个计算4张牌是否可以组成24点的程序:

    #include<iostream>
    using namespace std;
    
    const char sign[4] = {'+', '-', '*', '/'};
    bool is24 = false; //记录是否可以组成24点 
    
    void isTF(float a[], int len) {
    	if (len == 1) {
    		if (a[0] > 23.9999 && a[0] < 24.0001) {
    			is24 = true;
    		}
    		return; 
    	}
    	
    	for (int i=0; i<len; i++) {
    		for (int j=0; j<len; j++) {
    			if (j == i) {
    				continue;	
    			}
    			
    			//使用不用的组合来实现 
    			for (int k=0; k<4; k++) {
    				float t[len - 1];
    				char b1[20];
    				if (sign[k] == '+') {
    					
    					t[0] = a[i] + a[j];	
    	
    				} else if (sign[k] == '-') {
    					
    					t[0] = a[i] - a[j];	
    					
    				} else if (sign[k] == '*') {
    					
    					t[0] = a[i] * a[j];	
    					
    				} else if (sign[k] == '/') {
    					
    					t[0] = a[i] / a[j];	
    					
    				} else {
    					break;	
    				} 
    				int n = 1;
    				for (int m=0; m<len; m++) {
    					if (m != i && m != j) {
    						t[n++] = a[m];
    					}
    				}
    				//递归调用 
    				isTF(t, len-1);
    			}
    		}	
    	}
    }
    
    int main() {
    	
    	float t[4];
    	while (cin>>t[0]>>t[1]>>t[2]>>t[3]) {
    		bool is_ok = true;
    		for (int i=0; i<4; i++) {
    			if (t[i] <= 0 || t[i] > 13) {
    				is_ok = false;
    				break; 
    			}	
    		} 
    		
    		if (!is_ok) {
    			cout<<"输入的数字不合法,请输入1-13之间的数字"<<endl;
    			continue;	
    		}
    		
    		isTF(t, 4);
    		if (is24) {
    			cout<<"可以组成24点"<<endl;	
    			is24 = false; 
    		} else {
    			cout<<"不能组成24点"<<endl;	
    		}
    	}
    	
    	return 0;	
    }
    

    原则上就是使用递归 + 遍历 来实现的。程序很简单。至于效率在目前这么几个数还是可以接受的。

    展开全文
  • 标准算24只是扑克计算玩法的一个特例。 简单地说,至少有三种扩展: 1、目标数字不仅是24,还可以其他数字 2、牌组不仅用4张牌组,还可以用3、5、6牌组 3、计算方法不限于简单则运算,还可以增加新的运算...

    算24的扩展

    标准算24只是扑克牌计算玩法的一个特例。
    简单地说,至少有三种扩展:
    1、目标数字不仅是24,还可以算其他数字
    2、牌组不仅用4张牌组,还可以用3、5、6张牌组
    3、计算方法不限于简单四则运算,还可以增加新的运算方法

    五张牌组算2

    在前面的这三重扩展下,我发现了一个有趣的事情:
    几乎所有的5张牌组,用标准的四则运算都可以算出2
    唯一一组不能计算的是[8, 13, 13, 13, 13]。
    但是,这一牌组,如果增加一个扩展运算:^(幂次运算例如:3 ^ 2 = 9),就可以算出2。
    有没有想挑战一下的朋友呢?

    六张牌组算2和3

    在六张牌组下,全部18564组合,都可以在标准四则运算中计算出24。
    六张牌组中,唯二的两个组合,不能在常规计算中算出3。
    [1, 1, 1, 1, 11]
    [1, 1, 1, 1, 13]
    但若增加前面提到的幂次运算,也都可以。
    朋友可以自行尝试

    六张牌组算24

    并且,全部18564个组合中,常规四则运算中只有下面10个组合不能算出24。
    [1, 1, 1, 1, 1, 1]
    [1, 1, 1, 1, 1, 2]
    [1, 1, 1, 1, 1, 3]
    [1, 1, 1, 1, 2, 2]
    [9, 9, 9, 9, 9, 9]
    [9, 9, 9, 9, 9, 10]
    [1, 10, 10, 10, 10, 10]
    [9, 9, 10, 10, 10, 10]
    [9, 9, 9, 10, 10, 10]
    [10, 10, 10, 10, 10, 10]
    这10组数字前面4组可以理解,因为数字太小,全乘在一起也达不到24。
    后面的6组就很有趣,好像是9和10多了,就难以计算,不知道内在的原因是什么。

    另外,如果增加幂次运算,其中有两组是可以算出24的。
    哪两组呢?留给想挑战的朋友。

    展开全文
  • 其方法是任意取出4张牌,A J Q K 王牌 1,其它按点数计算,花色不计.目标是通过加、减、乘、除和括号最终24.设计一个程序,输入4个数字(1~10)则列出所有可能计算结果为24的方案.要求:方案不能重复(加法乘法...
  • 任取4张牌,即得到1-13的数,请添加运算符(规定为加、减、乘、除种)使之成为运算式。每个数只能参与一次运算,4个数顺序可以任意组合,4个运算符任意取3个且可以重复取。运算遵从一定有限级别,可加括号控制,...
  • 任意输入四张纸牌,使用加减乘除及括号,计算24的方法。(每张必须使用且都只能使用一次) 例如 4 6 7 8 可以通过4*6*(8-7)=24得到。 使用方法:在matlab环境下,将make24.p拷贝到当前目录,在commond输入命令...
  • 什么是24点我们先来约定下老王和他媳妇玩的24点规则:给定4任意数字(0-9),然后通过+,-,*,/,将这4个数字计算出24。小时候玩的都是这个规则,长大了才有根号,才有各种莫名其妙的高级算法,不好玩了,因为我不会。...
  • 一副中抽去大小王剩下 52 (如果初练也可只用 1~10 这 40 张牌),任意抽取 4 (称牌组),用加、减、乘、除(可加括号)把面上的数算成 24。每张牌必须用一次且只 能用一次,如抽出的是 3、8、8、9,...
  • 用扑克计算24点

    千次阅读 2021-01-10 18:37:15
    任取4张牌,即得到1-13的数,请添加运算符(规定为加、减、乘、除种)使之成为运算式。每个数只能参与一次运算,4个数顺序可以任意组合,4个运算符任意取3个且可以重复取。运算遵从一定有限级别,可加括号控制,...
  • 7-7 用扑克计算24点 (25 分)

    千次阅读 2019-09-25 21:47:40
    任取4 张牌,即得到 4 个 1~13 的数,请添加运算符(规定为加+ 减- 乘* 除/ 种)使之成为一个运算式。每个数只能参与一次运算,4 个数顺序可以任意组合,4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别...
  • 用扑克计算24点(java)

    千次阅读 2019-01-18 00:46:21
    任取4 张牌,即得到 4 个 1~13 的数,请添加运算符(规定为加+ 减- 乘* 除/ 种)使之成为一个运算式。每个数只能参与一次运算,4 个数顺序可以任意组合,4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别...
  • *7.29(游戏:挑选四张牌)编写一个程序,从一副52张中选出4张,然后计算它们的和。Ace King Quee Jack分别表示1、13、12和11,显示得到和为24的选次数题目题目描述破题:不重复抽取代码运行实例 题目 题目描述 ...
  • String[] ranks= {“Ace”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“Jack”,“Queen”,“King”}; for(int i=0;i<deck.length;i++) { deck[i]=i; } for(int i=0;i<deck.length;i++) { int ...
  • 要求设计一个程序,对于任意给出52张中的四张,运用+-×÷四种运算来判断能否每个数只能用一次,但不能不用,24来。注意,给出的4个数是无序的。 测试输入关于“测试输入”的帮助 期待的输出关于“期待的...
  • python 7-25 用扑克计算24点 (25 分)
  • 任取4 张牌,即得到 4 个 1~13 的数,请添加运算符(规定为加+ 减- 乘* 除/ 种)使之成为一个运算式。每个数只能参与一次运算,4 个数顺序可以任意组合,4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别...
  • 有2、3、4、5、6、7、8、9、10、J、Q、K、A共13张牌,运用数据结构编一程序,判断对任意给定的4张牌,能否在进行加、减、乘、除运算后,其运算结果等于24。其中J按11计算,Q按12计算,K按13计算,A按1计算。如果能...
  • 一种有趣的扑克游戏–算24众多的扑克游戏中,算24是一种不错的锻炼反应力和计算能力的智力游戏,游戏规则大致是这样:从去掉大小王的一副扑克中任意抽取四张,读取上面的数字(其中A1,2-10就是2-10,J11,Q...
  • 讨论24点算法。

    2021-05-22 18:50:06
    24点是扑克游戏 玩法是:从一副扑克的A到10里随意抽出4张牌用‘加’’减‘‘乘’‘除’个符号4个数是否等于24,是的话成功,否的话失败;我用的是穷举法!(源码有点长)就是穷举出所有可能的算术式;我们想设...
  • 网上的24点算法基本上都专注于4张牌24点,有的算法甚至枚举了所有括号的组合,让人看得头晕眼花。这些算法若是推广到n个数凑n,基本都歇菜了。 丧心病狂如这位:...
  • 扑克牌24点 一、题目要求 24游戏是经典的纸牌益智游戏。 常见游戏规则:从扑克中每次取出4张牌。使用加减乘除,第一个能得出24者为赢。(其中,J代表11,Q代表12,K代表13,A代表1),按照要求编程解决24游戏。 ...
  • Q1:52扑克,任取5张牌,求出现一对、两对、同花顺的概率。 请帮忙解决一下这道概率题,求详细的列出式...给你三个式子:1*3/51*48/50*44/49*40/48这个是出现一对的概率2对1*3/51*48/50*3/49*40/48同花顺:1/13*...
  • 任取4 张牌,即得到 4 个 1~13 的数,请添加运算符(规定为加+ 减- 乘* 除/ 种)使之成为一个运算式。每个数只能参与一次运算,4 个数顺序可以任意组合,4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别...
  • 24点扑克游戏

    2016-12-11 19:32:48
    一副中抽去大小王剩下52(如果初练也可只用1~10这40张牌),任意抽取4张牌(称牌组),用加、减、乘、除(可加括号)把面上的数算成24。每张牌必须用一次且只能用一次,如抽出的是3、8、8、9,那么算式为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,588
精华内容 11,435
关键字:

任意4张牌算24点