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

2024年5月11日 179次阅读

原题目如下：

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

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

 

点赞