Java 语言 计算 24 点

最新推荐文章于 2024-07-10 03:13:59 发布
最新推荐文章于 2024-07-10 03:13:59 发布
阅读量617 收藏 1
点赞数 1
分类专栏： # JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37788383/article/details/100512741
版权

计算 24 点 游戏：
任意 输入 4 个数字，进行计算，判断结果能否等于 24.
若 有，则 具体的 输出表达式

这里的计算 24 点，有两种形式
下面式子中 * 可能是 + - * /
第一种： （a * ( b * ( c * d ))）
第二种： （a * b）+ ( c * d ) 或 （a * b）- ( c * d )
在这里插入图片描述

import java.util.Arrays;
import java.util.HashSet;       //实现 Set接口，由 哈希表支持。使用HashSet类创建Set集合对象，然后调用add方法为Set集合添加内容。
import java.util.Iterator;      //迭代器，通过 遍历，能得到集合类 中的内容。
import java.util.Scanner;

public class calculate_twfour_points {
    /*
这是java对态的一种表现,有时候可能不知道子类需要何种类型而声明一个接口.以后类似
Set<String> setStr=new HashSet<String>();这种声明 其实SetStr是HashSet类型(虽然声明时为Set,但JVM
运行时回自动把他转化为HashSet类型的),这种做法就更能体现接口的意义了.
*/
    private static HashSet<String> set = new HashSet<String>();

    public static void main(String[] args) {
        int nums[] = new int[4];
        Scanner sc = new Scanner(System.in);
        System.out.println(" 请输入 4 个数字:");
        for (int i = 0; i < 4; i++) {
            nums[i] = sc.nextInt();
        }
        System.out.println(" 计算 24 点的结果如下:");
        total(nums);
        print(set);
       
        /*
        这是一组 用于测试 用的 数据
//      int[] nums = {5, 5, 5, 1};
//		int[]nums = {3,3,8,8}; *** 、、、
//		int[]nums ={3,4,4,9};  ***
//      int[] nums = {4, 6, 9, 11};***
//		int[]nums ={2,2,7,9};***
//      int[]nums = {4, 5, 7, 8};

//		int[]nums={3,4,6,9};
//		int[]nums={3,4,5,10};
        */
      
    }


    
    
    public static void total(int[] nums) {
        Arrays.sort(nums);                     //对数组进行从小到大排序，默认字典序排序（ASCII）
        int count = equalsCount(nums);         //统计 4 个数，有几个相同的
        int a = nums[0];
        int b = nums[1];
        int c = nums[2];
        int d = nums[3];
        if (count == 0) {                     //a b c d  ，4个数各不相同
            main(new int[]{a, b, c, d});      //计算 这 4 个数，能否实现24点
            main(new int[]{a, b, d, c});
            main(new int[]{a, c, b, d});
            main(new int[]{a, c, d, b});
            main(new int[]{a, d, b, c});
            main(new int[]{a, d, c, b});

            main(new int[]{b, c, d, a});
            main(new int[]{b, c, a, d});
            main(new int[]{b, d, a, c});
            main(new int[]{b, d, c, a});
            main(new int[]{b, a, c, d});
            main(new int[]{b, a, d, c});

            main(new int[]{c, d, a, b});
            main(new int[]{c, d, b, a});
            main(new int[]{c, a, b, d});
            main(new int[]{c, a, d, b});
            main(new int[]{c, b, a, d});
            main(new int[]{c, b, d, a});
        } else if (count == 1) {               //a a b c
            int m = 0;//相同
            int p = 0;
            int q = 0;
            if (a == b) {
                m = a;
                p = c;
                q = d;
                main(new int[]{m, m, p, q});
                main(new int[]{m, m, q, p});
            } else if (b == c) {
                m = b;
                p = a;
                q = d;
                main(new int[]{p, m, m, q});
                main(new int[]{q, m, m, p});
            } else if (c == d) {
                m = c;
                p = a;
                q = b;
                main(new int[]{p, q, m, m});
                main(new int[]{q, p, m, m});
            }
        } else if (count == 4) {              //a a b b  这4个数 与 a a a b 在计算count时 是同一个值 2
            int m = a;
            int n = c;
            main(new int[]{m, m, n, n});
            main(new int[]{n, n, m, m});
            main(new int[]{m, n, m, n});
            main(new int[]{n, m, n, m});
        } else if (count == 2) {              // a a a b  有3 个数相同
            int m = 0;//相同的
            int n = 0;//单独的
            if (a == b) {
                m = a;
                n = d;
            } else if (c == d) {
                m = d;
                n = a;
            }
            main(new int[]{m, m, m, n});
            main(new int[]{m, m, n, m});
            main(new int[]{m, n, m, m});
            main(new int[]{n, m, m, m});
        } else if (count == 3) {               //a a a a 四个数相同
            main(new int[]{a, b, c, d});
        }
    }
    ///
    ///

    public static int equalsCount(int nums[]) {           //统计 4 个数，有几个相同的
        int count = 0;
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                count++;
            }
        }
        if (count == 2) {                      // 要对 4个数是 a a a b 型 和 a a b b 型 进行区分
            if (nums[1] == nums[2]) {           //a a b b 型
                return 2;
            } else                               //a a a c 型  ，因为前面进行 排过序了
                return 4;

        }
        return count;
    }

    public static void main(int nums[]) {     //实现 计算 24 点 的 函数
        double a = nums[0];
        double b = nums[1];
        double c = nums[2];
        double d = nums[3];
        double sum = 0;
        double sumad1 = 0;
        double sumad2 = 0;
        double sumad3 = 0;
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                for (int k = 0; k < 6; k++) {
                    sum = calculate(calculate(calculate(a, b, i), c, j), d, k);   //递归 遍历计算
                    sumad1 = calculate(calculate(a, b, i), calculate(c, d, j), k);
                    sumad2 = calculate(calculate(a, c, i), calculate(b, d, j), k);
                    sumad3 = calculate(calculate(a, d, i), calculate(b, c, j), k);
                    if (sum > 23.999999999 && sum < 24.00000001) {                // sum 是浮点型，不能用 sum ==24.0 ，比如 3 3 8 8 就计算不出来
                        set.add(format(i, j, k, a, b, c, d));                     //使用HashSet类创建Set集合对象，然后调用add方法为Set集合添加内容。
                    }
                    if (sumad1 > 23.999999999 && sumad1 < 24.00000001) {
                        System.out.println(sumad1);
                        System.out.println(format( a, b, c, d, i, j, k));
                    }
                    if (sumad2 > 23.999999999 && sumad2 < 24.00000001) {
                        System.out.println(sumad2);
                        System.out.println(format( a, b, c, d, i, j, k));
                    }
                    if (sumad3 > 23.999999999 && sumad3 < 24.00000001) {
                        System.out.println(sumad3);
                        System.out.println(format( a, b, c, d, i, j, k));
                    }
                }
            }
        }

    }

    /************************************************************************************************************
     ***********************************************************************************************************/
    /**
这个 format 函数  和 下面 还有一个 format 函数 是不同的。
此处的 用于 显示 第二种 形式的 表达式。
*/
    private static StringBuilder format(double a, double b, double c, double d, int i, int j, int k) {
        StringBuilder sb = new StringBuilder();                                        // new 的StringBuilder 去构造的字符串
        if ((i == 2 || i == 5) && (j == 2 || j == 5) && (k == 2 || k == 5)) {
            sb.append('(');
            sb.append(d);
            sb.append(symbol(j));
            sb.append(c);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(b);
            sb.append(symbol(i));
            sb.append(a);
            sb.append(')');
        }
        if ((i == 2 || i == 5) && (j == 2 || j == 5) && (k != 2 && k != 5)) {
            //System.out.println(  '(' + b + symbol(i) + a + ')'+ symbol(k) +'(' + d + symbol(j) + c + ')');
            sb.append('(');
            sb.append(b);
            sb.append(symbol(i));
            sb.append(a);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(d);
            sb.append(symbol(j));
            sb.append(c);
            sb.append(')');
        }
        if ((i == 2 || i == 5) && (k == 2 || k == 5) && (j != 2 && j != 5)) {
            //System.out.println(  '(' + c + symbol(j) + d + ')'+ symbol(k) +'(' + b + symbol(i) + a + ')');
            sb.append('(');
            sb.append(c);
            sb.append(symbol(j));
            sb.append(d);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(b);
            sb.append(symbol(i));
            sb.append(a);
            sb.append(')');
        }
        if ((j == 2 || j == 5) && (k == 2 || k == 5) && (i != 2 && i != 5)) {
            //System.out.println(  '(' + d + symbol(j) + c + ')'+ symbol(k) +'(' + a + symbol(i) + b + ')');
            sb.append('(');
            sb.append(d);
            sb.append(symbol(j));
            sb.append(c);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(a);
            sb.append(symbol(i));
            sb.append(b);
            sb.append(')');
        }
        if ((i == 2 || i == 5) && (j != 2 && j != 5) && (k != 2 && k != 5)) {
            //System.out.println(  '(' + b + symbol(i) + a + ')'+ symbol(k) +'(' + c + symbol(j) + d + ')');
            sb.append('(');
            sb.append(b);
            sb.append(symbol(i));
            sb.append(a);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(c);
            sb.append(symbol(j));
            sb.append(d);
            sb.append(')');
        }
        if ((j == 2 || j == 5) && (i != 2 && i != 5) && (k != 2 && k != 5)) {
            //System.out.println(  '(' + a + symbol(i) + b + ')'+ symbol(k) +'(' + d + symbol(j) + c + ')');
            sb.append('(');
            sb.append(a);
            sb.append(symbol(i));
            sb.append(b);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(d);
            sb.append(symbol(j));
            sb.append(c);
            sb.append(')');
        }
        if ((k == 2 || k == 5) && (i != 2 && i != 5) && (j != 2 && j != 5)) {
            //System.out.println(  '(' + c + symbol(j) + d + ')'+ symbol(k) +'(' + a + symbol(i) + b + ')');
            sb.append('(');
            sb.append(c);
            sb.append(symbol(j));
            sb.append(d);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(a);
            sb.append(symbol(i));
            sb.append(b);
            sb.append(')');
        }
        if ((i != 2 && i != 5) && (j != 2 && j != 5) && (k != 2 && k != 5)) {
            sb.append('(');
            sb.append(a);
            sb.append(symbol(i));
            sb.append(b);
            sb.append(')');
            sb.append(symbol(k));
            sb.append('(');
            sb.append(c);
            sb.append(symbol(j));
            sb.append(d);
            sb.append(')');
        }
        return sb;
    }

/**
symbol 是符号的意思
*/
    public static char symbol(int n) {
        switch (n) {
            case 0:
                return '+';
            case 1:
                return '-';
            case 2:
                return '-';
            case 3:
                return '*';
            case 4:
                return '/';
            case 5:
                return '/';
            default:
                throw new RuntimeException("--Wrong！！！！！--");
        }
    }


    /***************************************************************************************************************/
    /************************************************************************************************************
     ***********************************************************************************************************/

    public static double calculate(double a, double b, int n) {                  //每次 每2个数 进行计算
        switch (n) {
            case 0:
                return a + b;
            case 1:
                return a - b;
            case 2:
                return b - a;
            case 3:
                return a * b;
            case 4:
                return a / b;
            case 5:
                return b / a;
            default:
                throw new RuntimeException("--Wrong！！！！！--");
                /*
                 提示调用者该功能尚未实现，Wrong只是留了个接口，并未真正实现功能。 RuntimeException属于运行异常，
                 抛出来所以调用它的函数就不需要处理异常了。抛异常后下面就不执行了，所以不用写返回值
                */
        }
    }

    ///
    ///

    /**
     * 下面 函数 用于输出 显示  第 一 种 形式的 公式
     */
    public static String format(int i, int j, int k, double a, double b, double c, double d) {   //使用 String.format() 这个方法连接字符串
        StringBuilder sb = new StringBuilder();
        sb.append(format(format(format(new StringBuilder(valueOf(a)), new StringBuilder(valueOf(b)), i), new StringBuilder(valueOf(c)), j), new StringBuilder(valueOf(d)), k));
        return sb.toString();
    }


    private static String valueOf(double b) {     // 返回 double 参数的 字符串 表示形式。
        String result = String.valueOf(b);
        if (result.endsWith(".0")) {
            return result.substring(0, result.length() - 2);
        }
        return result;
    }

    private static StringBuilder format(StringBuilder a, StringBuilder b, int n) {
        StringBuilder sb = new StringBuilder();                                        // new 的StringBuilder 去构造的字符串
        switch (n) {
            case 0:                // ( a + b )
                sb.append('(');    //意思是在字符串  sb  末尾添加上 '(' ，在对字符串有多个拼接字符串操作的时候效率比string高。
                sb.append(a);
                sb.append('+');
                sb.append(b);
                sb.append(')');
                return sb;
            case 1:
                sb.append('(');   // ( a - b )
                sb.append(a);
                sb.append('-');
                sb.append(b);
                sb.append(')');
                return sb;
            case 2:               // ( b - a )
                sb.append('(');
                sb.append(b);
                sb.append('-');
                sb.append(a);
                sb.append(')');
                return sb;
            case 3:              // a * b
                sb.append(a);
                sb.append('*');
                sb.append(b);
                return sb;
            case 4:              // ( a / b )
                sb.append('(');
                sb.append(a);
                sb.append('/');
                sb.append(b);
                sb.append(')');
                return sb;
            case 5:              // ( b / a )
                sb.append('(');
                sb.append(b);
                sb.append('/');
                sb.append(a);
                sb.append(')');
                return sb;
            default:
                throw new RuntimeException("--Wrong！！！！！--");
        }
    }

    private static void print(HashSet<String> set) {
        if (set.size() == 0) {
            System.out.println("形式 2 无解");
            return;
        }
        Iterator<String> ite = set.iterator();
        while (ite.hasNext()) {
            String str = ite.next();
            System.out.println(str);
        }
    }

}
Bruce_lp
关注
专栏目录
24点游戏java_使用java编写计算24点游戏程序
weixin_34186408的博客
02-15 319
初学java,编写了一个计算24点的程序，时间有限，有些粗糙，不过可以使用。//-------------Cal24.java---------------//计算24点程序//作者：徒步天下(hiker2008.blog.51cto.com)////运行格式： java Cal24 abcd//abcd为四个1-9数字////输出为结果等于24的算式，及个数import java.util.*;...
计算24点java
今天也要AC呀！！！
10-10 408
计算24点java #题目要求： 本次作业是写一个程序，完成抽取4张扑克牌计算24点。如果能计算出24点，则输出所有的计算方式。如果不能计算出24点，则输出不能。如果有多种计算方式，输出时进行排序。 输出格式： 第1种：ab+c/d=24 第2种：ac-b/d=24 … 编程要求： 注意规范性，类名称，函数名称，标识符名称，注释等。 编写一个类表示一个扑克牌，至少包含两个成员变量，一个表示花色，一个表示对应的数字。 编写一个计算24点的类。 （1）包含main函数，负责总体执行流程。创建扑克牌，抽取扑克牌
Java：做一个自动生成24点游戏，并能自主解决的程序
fxalll的博客
03-25 3264
我们首先利用random函数，随机从1～13中挑选数字，挑选四次。 public static void main(String[] args) { Random r = new Random(); int r1 = r.nextInt(13) + 1; int r2 = r.nextInt(13) + 1; int r3 = r.nextInt(13) + 1; int r4 = r.nextInt(13) + 1;
用JAVA编程24点问题（改进版）
m0_58001141的博客
11-14 150
/数字可能出现11 12 13,出现11 12 13转换J Q K，把变量接收，判断是否是11 12 13。//采用这个内容，不满足表达式一定报错，借助于ScriptEngine中的异常，现在不能抛，去try。System.out.println("接下来是否继续下一个随机数值(y/n)");//可以简单化，直接输出数字到屏幕,输出4遍随机，这里可以用循环，确定循环次数。//nextLine()用户会输入一堆空格，没有用户名，直接回车，这种情况违法。
用java实现算24游戏的功能
最新发布
weixin_42089275的博客
07-10 37
代码示例相关视频讲解：数组-Go代码演示用Java实现算24游戏的功能 算24游戏是一种常见的益智游戏，玩家需要通过组合给定的数字和运算符，使其结果等于24。今天我们将用Java语言来实现这个游戏的功能。 游戏规则 在算24游戏中，玩家会随机得到4个数字，然后可以使用加减乘除四则运算符来计算这4个数字，使得最终结果等于2...
Java计算24点
hlb0103的专栏
12-06 939
<br />/**<br /> * <br /> * @author hlb<br /> * 功能：给定四个整数组成的数字，计算所有24点的算式<br /> * 实现简单，有待完善<br /> */<br />public class jisuan24 {<br /> //插入排序<br /> public static int[] cr(int[] arr){<br />  for(int i = 1; i < arr.length; i ++){<br />   int tmp = arr[i];<br
java 24点算法_java用扑克牌计算24点
weixin_35133464的博客
02-15 730
一副扑克牌的每张牌表示一个数(J、Q、K 分别表示 11、12、13，两个司令都表示 6)。任取4 张牌，即得到 4 个 1~13 的数，请添加运算符(规定为加+ 减- 乘* 除/ 四种)使之成为一个运算式。每个数只能参与一次运算，4 个数顺序可以任意组合，4 个运算符任意取 3 个且可以重复取。运算遵从一定优先级别，可加括号控制，最终使运算结果为 24。请输出一种解决方案的表达式，用括号表示运算...
JAVA 算24点
2302_77234811的博客
11-01 320
对玩家来说，可以自由任意（+-*/)组合这4张扑克牌，使其结果为24即可；取出4张扑克牌，其中可能包含1-10、J、Q、K四种牌面；玩家须进行计算，如果没有。
24点计算java实现
daqinzl的专栏
09-22 547
给4个1至9的整数，计算出通过加减乘除四则运算得到24的所有组合 public class TwentyFour { public TwentyFour src; public TwentyFour dst; public int op; //0,1,2,3 + - * / public int value; public boolean type; // 0,基本型 1组合型 public String...
java实现24点计算
胡家伟的博客
01-19 3426
题目描述 计算24点是一种扑克牌益智游戏，随机抽出4张扑克牌，通过加(+)，减(-)，乘(*), 除(/)四种运算法则计算得到整数24，本问题中，扑克牌通过如下字符或者字符串表示，其中，小写joker表示小王，大写JOKER表示大王： 3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER 本程序要求实现：输入4张牌，输出一个算式，算式的结果为...
java用扑克牌计算24点
08-24
本资源主要介绍了Java实现24点扑克牌游戏的相关知识点，通过详细的示例代码，介绍了如何使用Java语言实现扑克牌计算24点游戏。以下是相关知识点的详细介绍： 1. 扑克牌的数值表示：在扑克牌游戏中，每张牌都有一个...
JAVA算24点
04-09
算24的JAVA程序 挺有意思的 输入4张牌 和 需要几种解法 计算
java 算24点（可算5555、3388）
06-30
一个算24点小程序，java写的。
java 24点小游戏算法
07-02
【原创】2010年全国软件专业人才设计与开发大赛决赛样题 -- 24点小游戏算法 网上找了些java实现24点小游戏的算法，看了一下，头都晕了！ 自己写了一个类，各位可以看一下思路，如果需要的话，只要实例化PointGame类并在构造方法里传递参与计算的四个数字和需要的结果就好了，然后调用getExpressions方法返回所有的表达式组合，是一个List类
java 扑克牌24点算法
06-24
java 扑克牌24点算法 输入4个数（1-10），可以得到用+-*/运算，结果为24的方法
JAVA 根据身份证计算年龄的实现代码
08-27
标签“java 身份证计算年龄 java 计算年龄”也表明了这篇文章的主要内容，即使用JAVA语言根据身份证和出生日期计算年龄的方法。 在部分内容中，作者提供了两个计算年龄的方法。第一个方法是根据身份证计算年龄的...
java语言计算圆周率_Java语言简单计算圆周率完整示例
weixin_42474220的博客
02-28 2368
本文实例讲述了Java语言简单计算圆周率完整示例。分享给大家供大家参考，具体如下，希望对大家学习Java语言简单计算圆周率有所帮助。这两天在网上看到一个题，已知Pi可以用函数4 * (1 – 1/3 + 1/5 – 1/7 + …) 计算，计算出小数点后五位(计算圆周率)。于是手动写了一个小demo，欢迎大家留言，进行交流与指教。完整示例代码如下：packagemath;publicclass...
java计算24节气
04-15
综上所述，要实现“java计算24节气”的功能，我们需要熟悉Java的日期时间API，理解24节气的天文背景，编写算法或利用现有库，最后通过编程将这些元素整合起来，确保代码的正确性和效率。在实际项目中，还可以考虑...
七参数坐标转换Java语言代码
04-28
这个不是现成的工具，而是具体的Java语言代码功能实现。利用java语言实现了大地坐标系和空间直角坐标系的相互转换，以及求解七参数的值的方法。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值