中等难度也有一道24点的题 差不多一样的思路 甚至比那个还简单 \doge
先对某一种牌序进行+-*/的深搜 如果有结果就更新结果(默认结果是"NONE")并返回 没结果就换一种牌序列继续深搜 直到搜完了所有牌序 
import java.util.*;

public class Main {
    static Map<String, Integer> CARD_TO_VALUE_MAP = new HashMap<String, Integer>() {{
        put("A", 1);
        put("2", 2);
        put("3", 3);
        put("4", 4);
        put("5", 5);
        put("6", 6);
        put("7", 7);
        put("8", 8);
        put("9", 9);
        put("10", 10);
        put("J", 11);
        put("Q", 12);
        put("K", 13);
    }};
    static Map<Integer, String> VALUE_TO_CARD_MAP = new HashMap<Integer, String>() {{
        put(1, "A");
        put(2, "2");
        put(3, "3");
        put(4, "4");
        put(5, "5");
        put(6, "6");
        put(7, "7");
        put(8, "8");
        put(9, "9");
        put(10, "10");
        put(11, "J");
        put(12, "Q");
        put(13, "K");
    }};
    static LinkedList<Integer> stack = new LinkedList<Integer>();
    static final int[] indexes = new int[]{0, 1, 2, 3};
    static int[] cards;
    static String result = "NONE";

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        if (s.contains("joker") || s.contains("JOKER")) {
            System.out.println("ERROR");
        } else {
            String[] sc = s.split(" ");
            cards = card2int(sc);
            permute(0);
            System.out.println(result);
        }
    }

    static int[] card2int(String[] sc) {
        int[] ic = new int[sc.length];
        for (int i = 0; i < ic.length; i++) {
            ic[i] = CARD_TO_VALUE_MAP.get(sc[i]);
        }
        return ic;
    }

    static String combine(String s, String op, int[] a, int cur) {
        if (cur == 0) {
            return s + VALUE_TO_CARD_MAP.get(a[cur]) + op + VALUE_TO_CARD_MAP.get(a[cur + 1]);
        } else {
            return s + op + VALUE_TO_CARD_MAP.get(a[cur + 1]);
        }
    }

    static boolean dfs(int[] a, int cur, String s) {
        if (a.length - 1 == cur) {
            if (a[0] == 24) {
                result = s;
                return true;
            } else {
                return false;
            }
        } else {
            int[] a1 = Arrays.copyOf(a, a.length);
            int[] a2 = Arrays.copyOf(a, a.length);
            int[] a3 = Arrays.copyOf(a, a.length);
            int[] a4 = Arrays.copyOf(a, a.length);
            a1[0] = a[0] + a[cur + 1];
            a2[0] = a[0] - a[cur + 1];
            a3[0] = a[0] * a[cur + 1];
            a4[0] = a[0] / a[cur + 1];
            return dfs(a1, cur + 1, combine(s, "+", a, cur))
                    || dfs(a2, cur + 1, combine(s, "-", a, cur))
                    || dfs(a3, cur + 1, combine(s, "*", a, cur))
                    || dfs(a4, cur + 1, combine(s, "/", a, cur));
        }
    }

    static void permute(int cur) {
        if (cur == indexes.length) {
            int[] c = getCardsByStack();
            if (dfs(c, 0,"")) {
                return;
            }
        }
        for (int index : indexes) {
            if (!stack.contains(index)) {
                stack.push(index);
                permute(cur + 1);
                stack.pop();
            }
        }
    }

    static int[] getCardsByStack() {
        int[] temp = new int[cards.length];
        for (int i = 0; i < temp.length; i++) {
            temp[i] = cards[stack.get(i)];
        }
        return temp;
    }
}