24點運算

題目描述

計算24點是一種撲克牌益智遊戲，隨機抽出4張撲克牌，經過加(+)，減(-)，乘(*), 除(/)四種運算法則計算獲得整數24，
本問題中，撲克牌經過以下字符或者字符串表示，其中，小寫joker表示小王，大寫JOKER表示大王：
               3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
本程序要求實現：輸入4張牌，輸出一個算式，算式的結果爲24點。
詳細說明：
1.運算只考慮加減乘除運算，沒有階乘等特殊運算符號，友情提醒，整數除法要小心；
2.牌面2~10對應的權值爲2~10, J、Q、K、A權值分別爲爲十一、十二、1三、1；
3.輸入4張牌爲字符串形式，以一個空格隔開，首尾無空格；若是輸入的4張牌中包含大小王，則輸出字符串「ERROR」，表示沒法運算；
4.輸出的算式格式爲4張牌經過+-*/四個運算符相連，中間無空格，4張牌出現順序任意，只要結果正確；
5.輸出算式的運算順序從左至右，不包含括號，如1+2+3*4的結果爲24
6.若是存在多種算式都能計算得出24，只需輸出一種便可，若是沒法得出24，則輸出「NONE」表示無解。

輸入描述

輸入4張牌爲字符串形式，以一個空格隔開，首尾無空格；

輸出描述

若是輸入的4張牌中包含大小王，則輸出字符串「ERROR」，表示沒法運算；

輸入例子

A A A A

輸出例子

NONE

算法實現

import java.util.Scanner;

/**
 * Declaration: All Rights Reserved !!!
 */
public class Main {
    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data2.txt"));
        while (scanner.hasNextLine()) {
            String input = scanner.nextLine();
            System.out.println(solve(input));
        }

        scanner.close();
    }

    /**
     * 進行24點運算，假設輸入的牌都是合法的
     *
     * @param input 輸入的牌
     * @return 結果
     */
    private static String solve(String input) {

        // 有王
        if (input.contains("joker") || input.contains("JOKER")) {
            return "ERROR";
        }

        String[] parts = input.split("(\\s)+");

        // 不是四個牌
        if (parts.length != 4) {
            return "ERROR";
        }

        // 將牌轉換成數字
        int[] ints = new int[parts.length];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = convert(parts[i]);
        }

        String[] r = {""};
        boolean result = point24(ints, r);

        // 有結果
        if (result) {
            return r[0];

        }

        return "ERROR";
    }

    /**
     * 4個[1, 13]的可否經過加減乘除，獲得數字爲24
     *
     * @param opd 四個元素的數組
     * @param r   用於保存結果
     * @return true，能夠組成24，false不能夠組成24
     */
    private static boolean point24(int[] opd, String[] r) {

        char[] opt = new char[opd.length - 1];
        char[] all = {'+', '-', '*', '/'};
        return point24(opd, opt, all, 0, r);
    }

    /**
     * @param opd 操做數
     * @param opt 用於計算的操做符
     * @param all 能夠使用的所有操做符
     * @param n   當前處理的數
     * @param r   用於保存表達式結果
     * @return true，計算的值爲24，false，計算的值不是24
     */
    private static boolean point24(int[] opd, char[] opt, char[] all, int n, String[] r) {

        // 處理最後一個數字
        if (n == opd.length - 1) {
            if (calculate(opd, opt, r)) {
                return true;
            }
        } else {
            for (int i = n; i < opd.length; i++) {
                int temp = opd[n];
                opd[n] = opd[i];
                opd[i] = temp;
                for (char a : all) {
                    opt[n] = a;
                    boolean find = point24(opd, opt, all, n + 1, r);
                    if (find) {
                        return true;
                    }
                }

                //  現場還原
                temp = opd[n];
                opd[n] = opd[i];
                opd[i] = temp;
            }
        }


        return false;
    }

    /**
     * 計算值
     *
     * @param opd 操做數
     * @param opt 操做符
     * @param r   保存結果表達式
     * @return true，結果爲24，false結果不是24
     */
    private static boolean calculate(int[] opd, char[] opt, String[] r) {

        double v = opd[0];
        for (int i = 0; i < opt.length; i++) {
            v = calculate(v, opd[i + 1], opt[i]);
        }

        boolean eq = Math.abs(v - 24) < 0.0000001;

        if (eq) {
            r[0] = convert(opd[0]);
            for (int i = 0; i < opt.length; i++) {
                r[0] = r[0] + opt[i] + convert(opd[i + 1]);
            }
        }

        return eq;
    }

    /**
     * 將牌轉換成對應的數值
     *
     * @param s 牌
     * @return 數值
     */
    private static int convert(String s) {

        if (s.length() == 1) {
            char c = s.charAt(0);
            if (c >= '2' && c <= '9') {
                return c - '0';
            }

            switch (c) {
                case 'J':
                    return 11;
                case 'Q':
                    return 12;
                case 'K':
                    return 13;
                case 'A':
                    return 1;
                default:
                    // do nothing
            }

        } else {
            switch (s) {
                case "10":
                    return 10;
                default:
                    // do nothing
            }
        }

        throw new RuntimeException("參數錯誤：" + s + "，只能輸入[2, 10]、J、Q、K、A");
    }

    /**
     * 將數值轉換成牌
     *
     * @param i 數值
     * @return 牌
     */
    private static String convert(int i) {
        if (i >= 2 && i <= 10) {
            return "" + i;
        }

        switch (i) {
            case 1:
                return "A";
            case 11:
                return "J";
            case 12:
                return "Q";
            case 13:
                return "K";
            default:
                // do nothing
        }

        throw new RuntimeException("參數錯誤:" + i + "，牌值[1, 13]的整數");
    }

    /**
     * 表達式求值
     *
     * @param a   操做數一
     * @param b   操做數二
     * @param opt 操做符
     * @return 運算結果
     */
    private static double calculate(double a, double b, int opt) {
        switch (opt) {
            case '+':
                return a + b;
            case '-':
                return a - b;
            case '*':
                return a * b;
            case '/':
                return a / b;
            default:
                // do nothing
        }

        throw new RuntimeException("參數錯誤：" + ((char) opt) + "計算操做只支持加(+)、減(-)、*(乘)、除(、)");
    }

}