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

原题目如下:

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

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

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

 

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

我说说我的方法:

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

一下是我的代码:

 

 
 
  1. public class Test10 { 
  2.  
  3.     /** 
  4.      * @param args 
  5.      */ 
  6.     public static void main(String[] args) { 
  7.          
  8.         String num = "1 2 3 4 5 6 7 8 9" ; // 要处理的数字,字符串 
  9.         String numDemo = num ; // 临时存放num,用于处理 
  10.         int[] ko = {0,0,0,0,0,0,0,0} ; // ko数组用于控制8个空格的“+- ”变化 
  11.         int com = 0 ; // 一种状态下得出的结果,用于判断是不是110 
  12.          
  13.         for(ko[0] = 0; ko[0] < 3; ko[0]++) 
  14.             for(ko[1] = 0; ko[1] < 3; ko[1]++) 
  15.                 for(ko[2] = 0; ko[2] < 3; ko[2]++) 
  16.                     for(ko[3] = 0; ko[3] < 3; ko[3]++) 
  17.                         for(ko[4] = 0; ko[4] < 3; ko[4]++) 
  18.                             for(ko[5] = 0; ko[5] < 3; ko[5]++) 
  19.                                 for(ko[6] = 0; ko[6] < 3; ko[6]++) 
  20.                                     for(ko[7] = 0; ko[7] < 3; ko[7]++) { 
  21.                                          
  22.                                         // 这个用于将numDemo字符串的空格改为+或-或空格,函数用replaceFirst 
  23.                                         for(int i = 0; i < 8; i++) { 
  24.                                             numDemo = numDemo.replaceFirst(" ", f(ko[i])) ; 
  25.                                         } 
  26.                                          
  27.                                         // numArr是存放用+ -分隔开的数字数组,用正则分隔,遇到+或-号是分割,存放到numArr字符串数组中 
  28.                                         String[] numArr = numDemo.split("(\\+|-)") ; 
  29.                                         // 第一个com用于存放第一个numArr的数字,用于下面的计算 
  30.                                         com = Integer.valueOf(numArr[0]) ; 
  31.                                         // up用于控制numArr数组下标移动 
  32.                                         int up = 1 ; 
  33.                                          
  34.                                         // 历遍numDemo字符串,当遇到+或-进入计算 
  35.                                         // 继续判断是+号还是-号 
  36.                                         // 是+号就用com+numArr[up],这里的numArr[up]为下一个已经在numArr的数 
  37.                                         // 是-号同理 
  38.                                         for(int s = 0; s < numDemo.length()-1; s++) { 
  39.                                             if(numDemo.substring(s, s+1).equals("+") || numDemo.substring(s, s+1).equals("-")) { 
  40.                                                 if(numDemo.substring(s, s+1).equals("+")) { 
  41.                                                     com += Integer.valueOf(numArr[up]) ; 
  42.                                                     up++ ; 
  43.                                                 }else { 
  44.                                                     com -= Integer.valueOf(numArr[up]) ; 
  45.                                                     up++ ; 
  46.                                                 } 
  47.                                             } 
  48.                                         } 
  49.                                          
  50.                                         // 判断com==110,输出numDemo 
  51.                                         if(com == 110) { 
  52.                                             System.out.println(numDemo + "=110") ; 
  53.                                         } 
  54.                                          
  55.                                         // 处理完的numDemo继续还原为num,用于下次处理 
  56.                                         numDemo = num ; 
  57.                                     } 
  58.     } 
  59.      
  60.     /** 
  61.      *  
  62.      * @param i 传进来的是ko数组中的值 
  63.      * @return 返回的是字符串,只有+ - 空格 
  64.      */ 
  65.     public static String f(int i) { 
  66.         if(i == 0) { 
  67.             return "" ; 
  68.         }else if(i == 1) { 
  69.             return "+" ; 
  70.         }else if(i == 2) { 
  71.             return "-" ; 
  72.         } 
  73.         return null ; 
  74.     } 
  75.  

输出的方案为:

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


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

 

 

点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注