我一直想这一点，但每次我开始思考这个问题它吹我的脑海里这样做，因为它的指数特性。

I have always wanted to do this but every time I start thinking about the problem it blows my mind because of its exponential nature.

问题解决者我希望能够理解和code是倒计时数学题：

The problem solver I want to be able to understand and code is for the countdown maths problem:

由于定数X1到X5的计算它们如何使用数学运算，使Y.组合 您可以将乘法，除法，加法和减法。

Given set of number X1 to X5 calculate how they can be combined using mathematical operations to make Y. You can apply multiplication, division, addition and subtraction.

那么，如何 1,3,7,6,8,3 让 348 ？

答：（（（8 * 7）+ 3）-1）* 6 = 348

如何写一个算法，可以解决这个问题？哪里试图解决这样一个问题，当你开始？有什么重要的考虑因素你必须考虑设计这样的算法是什么时候？

How to write an algorithm that can solve this problem? Where do you begin when trying to solve a problem like this? What important considerations do you have to think about when designing such an algorithm?

推荐答案

在Java中非常快速和肮脏的解决方案：

Very quick and dirty solution in Java:

public class JavaApplication1
{

    public static void main(String[] args)
    {
        List<Integer> list = Arrays.asList(1, 3, 7, 6, 8, 3);
        for (Integer integer : list) {
            List<Integer> runList = new ArrayList<>(list);
            runList.remove(integer);
            Result result = getOperations(runList, integer, 348);
            if (result.success) {
                System.out.println(integer + result.output);
                return;
            }
        }
    }

    public static class Result
    {

        public String output;
        public boolean success;
    }

    public static Result getOperations(List<Integer> numbers, int midNumber, int target)
    {
        Result midResult = new Result();
        if (midNumber == target) {
            midResult.success = true;
            midResult.output = "";
            return midResult;
        }
        for (Integer number : numbers) {
            List<Integer> newList = new ArrayList<Integer>(numbers);
            newList.remove(number);
            if (newList.isEmpty()) {
                if (midNumber - number == target) {
                    midResult.success = true;
                    midResult.output = "-" + number;
                    return midResult;
                }
                if (midNumber + number == target) {
                    midResult.success = true;
                    midResult.output = "+" + number;
                    return midResult;
                }
                if (midNumber * number == target) {
                    midResult.success = true;
                    midResult.output = "*" + number;
                    return midResult;
                }
                if (midNumber / number == target) {
                    midResult.success = true;
                    midResult.output = "/" + number;
                    return midResult;
                }
                midResult.success = false;
                midResult.output = "f" + number;
                return midResult;
            } else {
                midResult = getOperations(newList, midNumber - number, target);
                if (midResult.success) {
                    midResult.output = "-" + number + midResult.output;
                    return midResult;
                }
                midResult = getOperations(newList, midNumber + number, target);
                if (midResult.success) {
                    midResult.output = "+" + number + midResult.output;
                    return midResult;
                }
                midResult = getOperations(newList, midNumber * number, target);
                if (midResult.success) {
                    midResult.output = "*" + number + midResult.output;
                    return midResult;
                }
                midResult = getOperations(newList, midNumber / number, target);
                if (midResult.success) {
                    midResult.output = "/" + number + midResult.output;
                    return midResult
                }
            }

        }
        return midResult;
    }
}

更新

这基本上只是简单的蛮力算法指数复杂。 但是，您可以通过利用一些启发式的功能，这将有助于您订购的序列号或（和）操作时，将会在 getOperatiosn（）函数的递归的每一层处理获得一些improvemens

It's basically just simple brute force algorithm with exponential complexity. However you can gain some improvemens by leveraging some heuristic function which will help you to order sequence of numbers or(and) operations you will process in each level of getOperatiosn() function recursion.

这样的启发函数实例是中间结果和总目标结果的例子差异。

Example of such heuristic function is for example difference between mid result and total target result.

此方法仅但是最好情况和平均情况的复杂性得到改善。最坏情况的复杂性保持不变。

This way however only best-case and average-case complexities get improved. Worst case complexity remains untouched.

最坏情况的复杂性可以通过某种形式的分支切割得到改善。我不知道是否有可能在这种情况下。

Worst case complexity can be improved by some kind of branch cutting. I'm not sure if it's possible in this case.