11年蓝桥杯选拔赛Java组第10题

原题目如下：

1 2 3 4 5 6 7 8 9=110，有这9个数字，数字的位置固定，现在在每个数字之间填入+号或-号或空格，填入空格时为数字相连起来。

例如有12+34+56+7-8+9=110，无论怎么填+ - 空格，最后运算的结果=110。

求出所有能运算=110的方案。

 

这个题，想来不难，但是处理起来也不好处理，题目要求是输出等式。

我说说我的方法：

把所有能出现的方案全部都列出来，然后做字符串处理，一个个地计算。

一下是我的代码：

 

public class Test10 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        String num = "1 2 3 4 5 6 7 8 9" ; // 要处理的数字，字符串
        String numDemo = num ; // 临时存放num，用于处理
        int[] ko = {0,0,0,0,0,0,0,0} ; // ko数组用于控制8个空格的“+- ”变化
        int com = 0 ; // 一种状态下得出的结果，用于判断是不是110

        for(ko[0] = 0; ko[0] < 3; ko[0]++)
            for(ko[1] = 0; ko[1] < 3; ko[1]++)
                for(ko[2] = 0; ko[2] < 3; ko[2]++)
                    for(ko[3] = 0; ko[3] < 3; ko[3]++)
                        for(ko[4] = 0; ko[4] < 3; ko[4]++)
                            for(ko[5] = 0; ko[5] < 3; ko[5]++)
                                for(ko[6] = 0; ko[6] < 3; ko[6]++)
                                    for(ko[7] = 0; ko[7] < 3; ko[7]++) {

                                        // 这个用于将numDemo字符串的空格改为+或-或空格，函数用replaceFirst
                                        for(int i = 0; i < 8; i++) {
                                            numDemo = numDemo.replaceFirst(" ", f(ko[i])) ;
                                        }

                                        // numArr是存放用+ -分隔开的数字数组，用正则分隔，遇到+或-号是分割，存放到numArr字符串数组中
                                        String[] numArr = numDemo.split("(\\+|-)") ;
                                        // 第一个com用于存放第一个numArr的数字，用于下面的计算
                                        com = Integer.valueOf(numArr[0]) ;
                                        // up用于控制numArr数组下标移动
                                        int up = 1 ;

                                        // 历遍numDemo字符串，当遇到+或-进入计算
                                        // 继续判断是+号还是-号
                                        // 是+号就用com+numArr[up]，这里的numArr[up]为下一个已经在numArr的数
                                        // 是-号同理
                                        for(int s = 0; s < numDemo.length()-1; s++) {
                                            if(numDemo.substring(s, s+1).equals("+") || numDemo.substring(s, s+1).equals("-")) {
                                                if(numDemo.substring(s, s+1).equals("+")) {
                                                    com += Integer.valueOf(numArr[up]) ;
                                                    up++ ;
                                                }else {
                                                    com -= Integer.valueOf(numArr[up]) ;
                                                    up++ ;
                                                }
                                            }
                                        }

                                        // 判断com==110，输出numDemo
                                        if(com == 110) {
                                            System.out.println(numDemo + "=110") ;
                                        }

                                        // 处理完的numDemo继续还原为num，用于下次处理
                                        numDemo = num ;
                                    }
    }

    /**
     *
     * @param i 传进来的是ko数组中的值
     * @return 返回的是字符串，只有+ - 空格
     */
    public static String f(int i) {
        if(i == 0) {
            return "" ;
        }else if(i == 1) {
            return "+" ;
        }else if(i == 2) {
            return "-" ;
        }
        return null ;
    }

}

输出的方案为：

123+4+5+67-89=110 123+4-5-6-7-8+9=110 123-4+5-6-7+8-9=110 123-4-5+6+7-8-9=110 12+34+56+7-8+9=110 12+3+45+67-8-9=110 12-3+4-5+6+7+89=110 1+234-56-78+9=110 1+2+34+5+67-8+9=110 1-2+3+45-6+78-9=110

这些题，说到底就是组合的题目，难就难在怎么做字符串处理，和各种的转化问题。原理是很简单的，也是对编程基础的一种考查吧！

 

 

转载于:https://blog.51cto.com/dacai/854954