24点游戏

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量136 收藏
点赞数
分类专栏： 作业 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45876491/article/details/116649069
版权

文章目录

一、游戏内容

程序设计要求：
24点游戏是经典的纸牌益智游戏。
常见游戏规则：
从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。
基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。
1.程序风格良好(使用自定义注释模板)
2.列出表达式无重复。

二、源代码

import java.util.*;
public class game {
    static int number[] = new int[4];
    static int m[]=new int [4];
    static String n[] = new String[4];
    static boolean flag = false;
    static char[] operator = { '+', '-', '*', '/' };
    private static Object key;
    public static void main(String[] args){
        Random rand = new Random();
        System.out.println("下列给出四个数字，使用+，-，*，/进行计算使最后计算结果为24");
        for(int i=0;i<4;i++){
            number[i]=rand.nextInt(13)+1;
            if(number[i]==1){
                System.out.println("A");
            }
            else if(number[i]==11){
                System.out.println("J");
            }
            else if(number[i]==12){
                System.out.println("Q");
            }
            else if(number[i]==13){
                System.out.println("K");
            }
            else
                System.out.println(number[i]);
        }
        System.out.println("可能的结果有：");
        calculate();

    }
    public static int calcute(int count1, int count2, char operator) {
        if (operator == '+') {
            return count1 + count2;
        }
        else if (operator == '-') {
            return count1 - count2;
        }
        else if (operator == '*') {
            return count1 * count2;
        }
        else if ((operator == '/' )&& (count2 != 0) && (count1%count2==0)) {
            return count1 / count2;
        }
        else {
            return -1;
        }
    }
    public static void calculate(){
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < number.length; i++) {
            if(map.get(number[i]) == null){
                map.put(number[i], 1);
            }
            else {
                map.put(number[i], map.get(number[i]) + 1);
            }
        }
        if(map.size() == 1){
            calculation(number[0], number[1],number[2],number[3]);
        }
        else if(map.size()==2){
            int index = 0;
            int state = 0;
            for (Integer key : map.keySet()) {
                if(map.get(key) == 1){
                    number[3] = key;
                    state = 1;
                }
                else if(map.get(key)==2){
                    number[index++]=key;
                    number[index++]=key;
                }
                else{
                    number[index++]=key;
                }
            }
            if(state == 1){
                calculation(number[3],number[1],number[1],number[1]);
                calculation(number[1],number[3],number[1],number[1]);
                calculation(number[1],number[1],number[3],number[1]);
                calculation(number[1],number[1],number[1],number[3]);
            }
            if(state==0){
                calculation(number[1],number[1],number[3],number[3]);
                calculation(number[1],number[3],number[1],number[3]);
                calculation(number[1],number[3],number[3],number[1]);
                calculation(number[3],number[3],number[1],number[1]);
                calculation(number[3],number[1],number[3],number[1]);
                calculation(number[3],number[1],number[1],number[3]);
            }
        }
        else if(map.size()==3){
            int index = 0;
            for (Integer key : map.keySet()) {
                if(map.get(key) == 2){
                    number[2] = key;
                    number[3] = key;
                }
                else {
                    number[index++] = key;
                }
            }
            calculation(number[0],number[1],number[3],number[3]);
            calculation(number[0],number[3],number[1],number[3]);
            calculation(number[0],number[3],number[3],number[1]);
            calculation(number[1],number[0],number[3],number[3]);
            calculation(number[1],number[3],number[0],number[3]);
            calculation(number[1],number[3],number[3],number[0]);
            calculation(number[3],number[3],number[0],number[1]);
            calculation(number[3],number[3],number[1],number[0]);
            calculation(number[3],number[1],number[3],number[0]);
            calculation(number[3],number[0],number[3],number[1]);
            calculation(number[3],number[0],number[1],number[3]);
            calculation(number[3],number[1],number[0],number[3]);
        }
        else if(map.size() == 4){
            calculation(number[0],number[1],number[2],number[3]);
            calculation(number[0],number[1],number[3],number[2]);
            calculation(number[0],number[2],number[1],number[3]);
            calculation(number[0],number[2],number[3],number[1]);
            calculation(number[0],number[3],number[1],number[2]);
            calculation(number[0],number[3],number[2],number[1]);
            calculation(number[1],number[0],number[2],number[3]);
            calculation(number[1],number[0],number[3],number[2]);
            calculation(number[1],number[2],number[3],number[0]);
            calculation(number[1],number[2],number[0],number[3]);
            calculation(number[1],number[3],number[0],number[2]);
            calculation(number[1],number[3],number[2],number[0]);
            calculation(number[2],number[0],number[1],number[3]);
            calculation(number[2],number[0],number[3],number[1]);
            calculation(number[2],number[1],number[0],number[3]);
            calculation(number[2],number[1],number[3],number[0]);
            calculation(number[2],number[3],number[0],number[1]);
            calculation(number[2],number[3],number[1],number[0]);
            calculation(number[3],number[0],number[1],number[2]);
            calculation(number[3],number[0],number[2],number[1]);
            calculation(number[3],number[1],number[0],number[2]);
            calculation(number[3],number[1],number[2],number[0]);
            calculation(number[3],number[2],number[0],number[1]);
            calculation(number[3],number[2],number[1],number[0]);
        }
        if(flag==false)
            System.out.println("这四张牌面数字无法经过运算得到24！");
    }
    public static void calculation(int num1, int num2, int num3, int num4){
        for (int i = 0; i < 4; i++){
            char operator1 = operator[i];
            int firstResult = calcute(num1, num2, operator1);
            int midResult = calcute(num2, num3, operator1);
            int tailResult = calcute(num3,num4, operator1);
            for (int j = 0; j < 4; j++){
                char operator2 = operator[j];
                int firstMidResult = calcute(firstResult, num3, operator2);
                int firstTailResult = calcute(num3,num4,operator2);
                int midFirstResult = calcute(num1, midResult, operator2);
                int midTailResult= calcute(midResult,num4,operator2);
                int tailMidResult = calcute(num2, tailResult, operator2);
                for (int k = 0; k < 4; k++){
                    char operator3 = operator[k];
                    if(calcute(firstMidResult, num4, operator3) == 24){
                        m[0]=num1;
                        m[1]=num2;
                        m[2]=num3;
                        m[3]=num4;
                        for(int p=0;p<4;p++){
                            if(m[p]==1){
                                n[p]="A";}
                            if(m[p]==2){
                                n[p]="2";}
                            if(m[p]==3){
                                n[p]="3";}
                            if(m[p]==4){
                                n[p]="4";}
                            if(m[p]==5){
                                n[p]="5";}
                            if(m[p]==6){
                            n[p]="6";}
                            if(m[p]==7){
                                n[p]="7";}
                            if(m[p]==8){
                                n[p]="8";}
                            if(m[p]==9){
                                n[p]="9";}
                            if(m[p]==10){
                                n[p]="10";}
                            if(m[p]==11){
                                n[p]="J";}
                            if(m[p]==12){
                                n[p]="Q";}
                            if(m[p]==13){
                                n[p]="k";}
                        }
                        System.out.println("((" + n[0] + operator1 + n[1] + ")" + operator2 + n[2] + ")" + operator3 + n[3]);
                        flag = true;
                    }
                    if(calcute(firstResult, firstTailResult, operator3) == 24){
                        System.out.println("(" + n[0] + operator1 + n[1] + ")" + operator3 + "(" + n[2] + operator2 + n[3] + ")");
                        flag = true;
                    }
                    if(calcute(midFirstResult, num4, operator3) == 24){
                        m[0]=num1;
                        m[1]=num2;
                        m[2]=num3;
                        m[3]=num4;
                        for(int p=0;p<4;p++){
                            if(m[p]==1){
                                n[p]="A";}
                            if(m[p]==2){
                                n[p]="2";}
                            if(m[p]==3){
                                n[p]="3";}
                            if(m[p]==4){
                                n[p]="4";}
                            if(m[p]==5){
                                n[p]="5";}
                            if(m[p]==6){
                                n[p]="6";}
                            if(m[p]==7){
                                n[p]="7";}
                            if(m[p]==8){
                                n[p]="8";}
                            if(m[p]==9){
                                n[p]="9";}
                            if(m[p]==10){
                                n[p]="10";}
                            if(m[p]==11){
                                n[p]="J";}
                            if(m[p]==12){
                                n[p]="Q";}
                            if(m[p]==13){
                                n[p]="k";}
                        }
                        System.out.println("(" + n[0] + operator2 + "(" + n[1] + operator1 + n[2] + "))" + operator3 + n[3]);
                        flag = true;
                    }
                    if(calcute(num1,midTailResult, operator3) == 24){
                        m[0]=num1;
                        m[1]=num2;
                        m[2]=num3;
                        m[3]=num4;
                        for(int p=0;p<4;p++){
                            if(m[p]==1){
                                n[p]="A";}
                            if(m[p]==2){
                                n[p]="2";}
                            if(m[p]==3){
                                n[p]="3";}
                            if(m[p]==4){
                                n[p]="4";}
                            if(m[p]==5){
                                n[p]="5";}
                            if(m[p]==6){
                                n[p]="6";}
                            if(m[p]==7){
                                n[p]="7";}
                            if(m[p]==8){
                                n[p]="8";}
                            if(m[p]==9){
                                n[p]="9";}
                            if(m[p]==10){
                                n[p]="10";}
                            if(m[p]==11){
                                n[p]="J";}
                            if(m[p]==12){
                                n[p]="Q";}
                            if(m[p]==13){
                                n[p]="k";}
                        }
                        System.out.println(" " + n[0] + operator3 + "((" + n[1] + operator1 + n[2] + ")" + operator2 + n[3] + ")");
                        flag = true;
                    }
                    if(calcute(num1,tailMidResult,operator3) == 24){
                        m[0]=num1;
                        m[1]=num2;
                        m[2]=num3;
                        m[3]=num4;
                        for(int p=0;p<4;p++){
                            if(m[p]==1){
                                n[p]="A";}
                            if(m[p]==2){
                                n[p]="2";}
                            if(m[p]==3){
                                n[p]="3";}
                            if(m[p]==4){
                                n[p]="4";}
                            if(m[p]==5){
                                n[p]="5";}
                            if(m[p]==6){
                                n[p]="6";}
                            if(m[p]==7){
                                n[p]="7";}
                            if(m[p]==8){
                                n[p]="8";}
                            if(m[p]==9){
                                n[p]="9";}
                            if(m[p]==10){
                                n[p]="10";}
                            if(m[p]==11){
                                n[p]="J";}
                            if(m[p]==12){
                                n[p]="Q";}
                            if(m[p]==13){
                                n[p]="k";}
                        }
                        System.out.println(" " + n[0] + operator3 + "(" + n[1] + operator2 + "(" + n[2] + operator1 + n[3] + "))");
                        flag = true;
                    }
                }
            }
        }
    }
}

三、流程图

在这里插入图片描述

总结

在此次代码编写的过程中，遇到了一些问题，通过查阅网络解决了问题，而且在今后的Java代码编写过程中应该多创建类。

一个bug工程师
关注
专栏目录
【python】24点游戏算法
ShikieikiScarlet的博客
11-20 1846
python学生成绩转换程序
计算机上的24点游戏怎么玩,掌握基本规律，轻松玩转24点游戏
weixin_29165725的博客
06-15 7490
关键词：24点如果说起扑克牌，你会想起什么？斗地主、魔术还是赌神？其实，扑克牌也是锻炼思维和培养数学计算能力的很好的工具，比如利用扑克牌计算24点的游戏，就在上个世纪八十年代流行全美。往前追溯，1979年我国出版的《有趣的数学》也对24点数学游戏进行了讨论。24点游戏，就是利用一副扑克牌(去掉大小王，共52张)，然后随机抽取4张牌，通过对4个数字进行不重复使用，计算得到24的游戏。因为是游戏，就考...
【华为机试】HJ67 24点游戏算法
weixin_45932570的博客
04-03 828
1. 题目 2. 代码 首先，题目说明不够清晰。应该是4个数字可以任意排序（全排列，偷个小懒用STL函数next_permutation，排序也用了sort），而且可以加括号。 有除法，所以用了double。但是！double一定要从一而终啊！中间好几个地方写成了int，结果找了好久好久的bug。（果然我是个bug产生器。。。） #include <iostream> #include <algorithm> using namespace std; double x[4];
计算机二十四点游戏,比比速算24点游戏
weixin_35723036的博客
06-22 485
电脑扑克牌游戏试运行在PC端的智力小游戏，这次带来的是比比速算24点游戏，学习纸牌的同时还能不断提高你的头脑思维能力，让你的智商一天比一天更高。比比速算24点游戏设置了一级高手、二级能手、三级好手、四级新手共4个级别！ 比比速算24点游戏介绍：一、游戏规则玩家与电脑每人26张扑克牌，每次各出2张，先计算出24点者为赢家，翻开的4张牌归赢家所有。如果翻开的4张牌无法计算24点，则各自将2张牌收回，并...
计算机上的24点游戏怎么玩,趣味算数二十四点游戏规则怎么玩技巧
热门推荐
weixin_33462540的博客
06-15 1万+
概述：这是一个算数游戏，用四张牌计算得出24。时间：20分钟人数：集体参与目的：锻炼学员的快速计算能力。道具：扑克牌步骤：1.去点大小王，“K”计13点，“Q”计12点，“J”计11点，“A”计1点，其余牌按牌点算。2.把洗好的52张牌牌面朝下放在桌子上，一次翻出四张牌，各人立即运用“+”、“—”、“×”、“÷”四种运算方式，使四张牌变成二十四点，但每张牌只能用一次，不得重复。3.最先计算出来的人...
二十四点游戏Python实现
很酷的站长的博客
09-08 2001
二十四点游戏是一种数学益智游戏，通过组合四个数字和四种基本运算符（加、减、乘、除），使得计算结果等于24。在本文中，我们将使用Python语言实现这个游戏。
计算机二十四点游戏怎么玩,扑克牌二十四点怎么玩？扑克牌二十四点游戏规则介绍...
weixin_31136061的博客
06-15 1万+
扑克牌二十四点是在国际上很流行的一种扑克游戏玩法，因为游戏计算性较强，较为考验的玩家的心算能力，所以很受扑克玩家的喜爱，那么扑克牌二十四点到底是怎么玩的呢？扑克牌二十四点的游戏规则又是什么呢？下面就让最火软件站的小编来为大家详细介绍一下吧！扑克牌二十四点怎么玩？扑克牌二十四点游戏规则介绍二十四点是一种和数学挂钩的扑克游戏，应为该游戏玩法简单，但是又具有极强健脑益智效果，所以很受当下扑克玩家甚至是学...
Python实现24点游戏
weixin_46277779的博客
03-17 1577
24点，数字计算小游戏。
C语言实现24点游戏
qq_45942342的博客
07-03 1724
使用暴力枚举，主函数将四个数进行排列组合，调用calculate函数将运算符进行排列组合，一共有24*64=1536种计算方式。 #include <stdio.h> #include <string.h> char four_fun[4]={'+','-','*','/'}; float a[4]; int i,j,k,l; float calculate(float a,float b,float c,float d); float one_calculate(float a,f
24点游戏（c++）
leoRui_的博客
08-25 1936
24点游戏（自己写了一个没有涉及到算法的较笨的方法）。
24点游戏swing _24点_
10-02
标题中的“24点游戏Swing”指的是使用Java Swing库开发的一款基于24点规则的桌面游戏。Swing是Java的一个图形用户界面(GUI)工具包，它提供了丰富的组件和功能来创建桌面应用，包括游戏。在这个游戏中，玩家需要通过...
C语言二十四点游戏源码+注释.zip
09-22
二十四点游戏通常需要玩家从四张1到13的扑克牌中找到运算方式，使得结果等于24。这个游戏在编程领域常被用来练习基础的编程技巧、逻辑思维以及算法设计。 【描述】: "此文件为C语言二十四点游戏源码+注释。诚实有效...
C++实现简单24点游戏
08-24
本文详细介绍了使用C++语言实现简单的24点游戏，游戏的主要思路是随机生成四个代表扑克牌牌面的数字字母，然后程序自动列出所有可能算出24的表达式。该游戏的实现思路主要包括生成牌面数字、计算表达式和穷举计算三...
基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip
08-09
基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 基于Java的Android应用程序开发-24点游戏源码+详细项目说明.zip 【项目介绍】 该资源...
scratch图形化少儿编程24点小游戏
05-25
scratch图形化少儿编程24点小游戏
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 114
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 280
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 273
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 468
在方法、构造函数或块内部定义的变量。
C语言实现二十四点游戏算法解析
二十四点游戏的基本规则是：给定四张1-13的扑克牌，目标是通过加减乘除和括号操作，使得结果等于24。在这个游戏中，我们可以假设数字为1到9的整数，因为10、J、Q、K分别对应10、10、10、11。 1. **运算符组合策略**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值