Java语言怎么实现扑克牌4张用加减乘除，程序自动产生算式计算的实现的过程是什么

Java语言怎么实现扑克牌4张用加减乘除，使得得到的算式的结果是24，程序自动产生算式计算的实现的过程是什么

使用递归方式生成所有可能的表达式，并计算其结果
代码如下

import java.util.ArrayList;
import java.util.List;

public class Poker24Game {

    private static final double TARGET = 24.0;
    private static final double EPSILON = 1e-6;

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4}; // 扑克牌的数字值

        List<String> expressions = findExpressions(nums);
        for (String expression : expressions) {
            System.out.println(expression + " = " + TARGET);
        }
    }

    public static List<String> findExpressions(int[] nums) {
        List<String> expressions = new ArrayList<>();
        helper(nums, new double[nums.length], 0, expressions);
        return expressions;
    }

    private static void helper(int[] nums, double[] results, int count, List<String> expressions) {
        if (count == nums.length) {
            if (Math.abs(results[0] - TARGET) < EPSILON) {
                String expression = buildExpression(results, nums);
                expressions.add(expression);
            }
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == Integer.MAX_VALUE) {
                continue;
            }
            int num = nums[i];
            nums[i] = Integer.MAX_VALUE;

            results[count] = num;
            helper(nums, results, count + 1, expressions);

            results[count] = -num;
            helper(nums, results, count + 1, expressions);

            results[count] = num;
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] == Integer.MAX_VALUE) {
                    continue;
                }
                int nextNum = nums[j];
                nums[j] = Integer.MAX_VALUE;

                results[count] = num + nextNum;
                helper(nums, results, count + 1, expressions);

                results[count] = num - nextNum;
                helper(nums, results, count + 1, expressions);

                results[count] = num * nextNum;
                helper(nums, results, count + 1, expressions);

                if (nextNum != 0) {
                    results[count] = num / nextNum;
                    helper(nums, results, count + 1, expressions);
                }

                if (num != 0) {
                    results[count] = nextNum / num;
                    helper(nums, results, count + 1, expressions);
                }

                nums[j] = nextNum;
            }

            nums[i] = num;
        }
    }

    private static String buildExpression(double[] results, int[] nums) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < results.length; i++) {
            if (i > 0) {
                if (results[i] >= 0) {
                    sb.append(" + ");
                } else {
                    sb.append(" - ");
                }
            }
            sb.append(Math.abs(results[i]));
        }
        for (int num : nums) {
            sb.append(" = ").append(num);
        }
        return sb.toString();
    }
}

你可以看看这篇博客：

java速算24,Java扑克牌速算24的方法_cedar song的博客-CSDN博客已知一副扑克牌有54张，去除大王和小王，剩余52张。在其中随机抽取4张牌，利用加减乘除进行计算得到24. 从A到10，他们的值分别为1到10. 从J到K，他们对应的值是减去10以后的值。编写程序生成一副扑克牌，随机抽取4张，进行计算是否能得到24. 如果可以，列出可能的计算表达式，可能有多种计算形式。主要思想就是先生成除去大小王的52张扑克牌，然后从中随机抽取四张。接着用排列组合的方式找到能计算得..._速算24代码

https://blog.csdn.net/weixin_28788777/article/details/115150784

不知道你这个问题是否已经解决, 如果还没有解决的话:

你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7738294
这篇博客也不错, 你可以看下使用java对大量存在重复且不规律的数据进行统计分析【数据清洗模块】（如需借鉴，请务必标明作者）
同时，你还可以查看手册：java-国际化 - 介绍如何设计软件，使其能够轻松适应（本地化）各种语言和地区。-设置区域设置解释了如何创建和如何使用区域设置对象。-语言标签过滤和查询中的内容
您还可以看一下汪翠老师的java项目实战之欢乐斗地主游戏开发教程毕业项目课程设计带源码课程中的给扑克牌绑定鼠标事件实现单击可以选择出牌列表小节, 巩固相关知识点
除此之外, 这篇博客: JAVA异常体系详解中的如果运行过程中发生非检查性异常，处理的办法是找到发生异常的错误代码或者服务器硬件资源问题处理掉，而不是捕获，这实际上是java多异常做的扩展、容错部分也许能够解决你的问题。

以下回答由chatgpt基于相关博客总结生成:

解决方案

要实现这个问题，我们可以通过回溯算法来生成所有可能的算式，并判断结果是否等于24。这里给出一个Java语言的实现过程。

import java.util.ArrayList;
import java.util.List;

public class GenerateExpression {

    public static void main(String[] args) {
        List<Integer> cards = new ArrayList<>();
        cards.add(4);
        cards.add(7);
        cards.add(8);
        cards.add(2);

        List<String> expressions = generateExpressions(cards);
        for (String expression : expressions) {
            if (eval(expression) == 24) {
                System.out.println(expression);
            }
        }
    }

    private static List<String> generateExpressions(List<Integer> cards) {
        List<String> expressions = new ArrayList<>();
        backtrack(cards, "", expressions);
        return expressions;
    }

    private static void backtrack(List<Integer> cards, String expression, List<String> expressions) {
        if (cards.size() == 1) {
            expressions.add(expression + cards.get(0));
        } else {
            for (int i = 0; i < cards.size(); i++) {
                int card = cards.get(i);

                List<Integer> remainingCards = new ArrayList<>(cards);
                remainingCards.remove(i);

                // 递归生成所有可能的算式
                backtrack(remainingCards, expression + card + "+", expressions);
                backtrack(remainingCards, expression + card + "-", expressions);
                backtrack(remainingCards, expression + card + "*", expressions);
                backtrack(remainingCards, expression + card + "/", expressions);
            }
        }
    }

    private static double eval(String expression) {
        try {
            return (double) new javax.script.ScriptEngineManager()
                    .getEngineByName("JavaScript")
                    .eval(expression);
        } catch (Exception e) {
            return -1;
        }
    }
}

以上代码首先定义了generateExpressions方法，该方法通过回溯算法生成所有可能的算式，然后定义了backtrack方法来递归生成算式。

在main方法中，我们定义了4张扑克牌的数字，并将其添加到一个列表中。然后调用generateExpressions方法来生成所有可能的算式，再用eval方法来计算每个算式的结果。最后，遍历算式结果，打印出结果等于24的算式。

以上是用Java语言实现一个程序，生成由扑克牌中的4张牌通过加减乘除操作得到结果为24的算式的解决方案。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^