华为2015机考题最后一题解法

第三题：等式变换
输入一个正整数X，在下面的等式左边的数字之间添加+号或者-号，使得等式成立。
1 2 3 4 5 6 7 8 9 = X
比如：
12-34+5-67+89 = 5
1+23+4-5+6-7-8-9 = 5
请编写程序，统计满足输入整数的所有整数个数。
输入： 正整数，等式右边的数字
输出： 使该等式成立的个数
样例输入：5
样例输出：21
解法一：用最笨的方法（暴力解法），直接全部纯循环获取表达式的所有可能，然后计算每一个表达式的值。

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

/**  
 * Package: Test  
 *  
 * File: Test.java   
 *  
 *   
 */
public class Test {

    /**
     * 计算表达式的值
     * @param input
     * @return
     */
    public static int getExpressionSum(String input){
        int sum = 0;
        String str = input.replace(" ", "");
        String[] array = str.split("\\+");
        for (int i = 0; i < array.length; i++) {
            String newStr = array[i];
            if (newStr.contains("-")) {
                String[] array_newStr = newStr.split("-");
                int sum_newStr = Integer.valueOf(array_newStr[0]);
                for (int j = 1; j < array_newStr.length; j++) {
                    sum_newStr -= Integer.valueOf(array_newStr[j]);
                }
                array[i] = String.valueOf(sum_newStr);
            }
        }
        for(String s : array){
            sum += Integer.valueOf(s);
        }
        return sum;
    }
    /**
     * 获取计算的表达式，将数字和计算符组成计算表达式
     * @param operators：计算符
     * @return
     */
    public static String getExpression(String operators){
        StringBuffer res = new StringBuffer();
        for (int i = 1; i < 10; i++) {
            res.append(i); //添加计算数
            if (i <= 8) {
                res.append(operators.charAt(i - 1)); //添加计算符
            }
        }
        return res.toString();
    }

    /**
     * 通过纯循环的方式得到表达式的所有可能情况，并计算值，得到结果
     * @param input
     * @return
     */
    public static int getAnswerNum(String input){
        int sum = 0;
        int answerSum = 0;
        StringBuffer expression = null;
        StringBuffer operators = null;
        String[] operator = {"+","-"," "};
        for (int i = 0; i < operator.length; i++) {
            for (int j = 0; j < operator.length; j++) {
                for (int j2 = 0; j2 < operator.length; j2++) {
                    for (int k = 0; k < operator.length; k++) {
                        for (int k2 = 0; k2 < operator.length; k2++) {
                            for (int l = 0; l < operator.length; l++) {
                                for (int l2 = 0; l2 < operator.length; l2++) {
                                    for (int m = 0; m < operator.length; m++) {
                                        operators = new StringBuffer();
                                        expression = new StringBuffer();
                                        //获得计算符
                                        operators.append(operator[i]).append(operator[j]).append(operator[j2])
                                        .append(operator[k]).append(operator[k2]).append(operator[l]).append(operator[l2])
                                        .append(operator[m]);
                                        //获得表达式
                                        expression.append(getExpression(operators.toString()));
                                        sum = getExpressionSum(expression.toString()); //计算表达式
                                        if (sum == Integer.valueOf(input)) {
                                            answerSum++;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return answerSum;
    }
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int input = scanner.nextInt();
        System.out.println(getAnswerNum(String.valueOf(input)));
        scanner.close();
    }
}

解法二：用递归的思想得到所有表达式的全部可能，然后计算值。

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

/**  
 * Package: Test  
 *  
 * File: Test.java   
 *   
 */
public class Test {

    private static List<Integer> sumList = new ArrayList<Integer>();

    /**
     * 计算表达式的值
     * @param input
     * @return
     */
    public static int getExpressionSum(String input){
        int sum = 0;
        String str = input.replace(" ", "");
        String[] array = str.split("\\+");
        for (int i = 0; i < array.length; i++) {
            String newStr = array[i];
            if (newStr.contains("-")) {
                String[] array_newStr = newStr.split("-");
                int sum_newStr = Integer.valueOf(array_newStr[0]);
                for (int j = 1; j < array_newStr.length; j++) {
                    sum_newStr -= Integer.valueOf(array_newStr[j]);
                }
                array[i] = String.valueOf(sum_newStr);
            }
        }
        for(String s : array){
            sum += Integer.valueOf(s);
        }
        return sum;
    }
    /**
     * 获取计算的表达式，将数字和计算符组成计算表达式
     * @param operators：计算符
     * @return
     */
    public static String getExpression(String operators){
        StringBuffer res = new StringBuffer();
        for (int i = 1; i < 10; i++) {
            res.append(i); //添加计算数
            if (i <= 8) {
                res.append(operators.charAt(i - 1)); //添加计算符
            }
        }
        return res.toString();
    }
    /**
     * 以递归的方式得到8个位置3种计算符{加（+）、减（-）、连接（ ）}（注：这里的用空格表示连接符，
     * 代表直接把左右两边的数字连接起来作为一个数字）
     * @param inStr：3种计算符组成的一个字符串
     * @param pos：当前需要添加的计算符在inStr中的位置
     * @param parentData 上一次递归后的计算符字符串
     */
    public static void getOperator(String inStr,int pos,StringBuffer parentData){

        StringBuffer operator = new StringBuffer();
        operator.append(parentData.toString()).append(inStr.charAt(pos));
        if (operator.length() == 8) {
            String expression = getExpression(operator.toString());//获得表达式
            sumList.add(getExpressionSum(expression));//计算表达式并把值存入到sumList中
            return;
        }
        for (int i = 0; i < inStr.length(); i++) {
            getOperator(inStr, i, operator);//递归
        }

    }

    public static void main(String[] args) {

        String inStr = "+- ";
        StringBuffer parentData = new StringBuffer();
        for (int i = 0; i < inStr.length(); i++) {
            getOperator(inStr, i, parentData);
        }
        Scanner scanner = new Scanner(System.in);
        int input = scanner.nextInt();
        int answerSum = 0;
        for(int i : sumList){
            if (i == input) {
                answerSum++;
            }
        }
        System.out.println(answerSum);
        scanner.close();
    }
}