56789+-*/() 2000

56789+-*/() 2000

前些日子在群里讨论，有一个哥们出一道题：5,6,7,8,9,10按顺序插入+-*/和括号，得到结果2000.
大家的先沉默了一会，二分钟后，有人说这题没意思。呵呵。口算还是有点难的。于是我说，可以写个程序试一试。结果，花了三个小时，写完了

import  java.util.HashSet;
import  java.util.Iterator;
import  java.util.Set;

/**
 *  @author  Sam Wang
 *  @since  Mar 22, 2011
  */
public   class  Demo {

     public   static   void  main(String[] args) {

         double [] arr  =  {  5 ,  6 ,  7 ,  8 ,  9 ,  10  };
         double [] arrTemp  =   null ;
         int  random  =   0 ;
         double  last  =   0 ;
        StringBuffer sb  =   null ;
        Set < String >  results  =   new  HashSet < String > ();

         for  ( int  i  =   0 ; i  <   100000 ; i ++ ) {
            arrTemp  =  arr.clone();
            shuffle(arrTemp);
            sb  =   new  StringBuffer();
            sb.append(arrTemp[ 0 ]);
             for  ( int  j  =   1 ; j  <  arrTemp.length; j ++ ) {
                random  =  ( int ) (Math.random()  *   4 );
                 switch  (random) {
                 case   0 :
                    sb.append( " + " ).append(arrTemp[j]);
                    arrTemp[j]  =  arrTemp[j  -   1 ]  +  arrTemp[j];
                     break ;
                 case   1 :
                    sb.append( " - " ).append(arrTemp[j]);
                    arrTemp[j]  =  arrTemp[j  -   1 ]  -  arrTemp[j];
                     break ;
                 case   2 :
                    sb.append( " * " ).append(arrTemp[j]);
                    arrTemp[j]  =  arrTemp[j  -   1 ]  *  arrTemp[j];
                     break ;
                 case   3 :
                    sb.append( " / " ).append(arrTemp[j]);
                    arrTemp[j]  =  arrTemp[j  -   1 ]  /  arrTemp[j];
                     break ;

                 default :
                     break ;
                }
            }

            last  =  arrTemp[arrTemp.length  -   1 ];
            System.out.println(last);
             if  (last  ==   2000 ) {
                sb.append( " =2000 " );
                results.add(sb.toString());
            }
        }

         for  (Iterator < String >  it  =  results.iterator(); it.hasNext();) {
            String item  =  it.next();
            System.out.println(item);

        }
    }

     /**
     *  @param  arrTemp
     *  @return  void 打乱数组元素顺序。
      */
     private   static   void  shuffle( double [] arrTemp) {
         int  index  =   0 ;

         for  ( int  i  =   0 ; i  <  arrTemp.length; i ++ ) {
            index  =  ( int ) (Math.random()  *  arrTemp.length);
            swap(arrTemp, i, index);
        }
    }

     /**
     *  @param  arrTemp
     *  @param  i
     *  @param  index
     *            交换数据元素
      */
     private   static   void  swap( double [] arrTemp,  int  i,  int  index) {
         double  temp  =  arrTemp[i];
        arrTemp[i]  =  arrTemp[index];
        arrTemp[index]  =  temp;
    }

}

有两个技巧：在不确定是+-*/哪种情况下，可以random一下，多for几次，那么这几种情况大致上可以照顾到。
                      ()在算法里面的体现是，使用()我发现，数字的前后顺序可以混乱。打印出结果不行的话再删除不迟。
打印结果:

9.0 * 8.0 - 7.0 * 6.0 + 10.0 * 5.0 = 2000
8.0 * 9.0 - 7.0 * 6.0 + 10.0 * 5.0 = 2000
7.0 * 8.0 + 9.0 * 6.0 + 10.0 * 5.0 = 2000

打印出来的效果不太好，我组织一下:
5*(6*(-7+8*9)+10)=2000;
5*(6*(7*8+9)+10)=2000;
如果，不允许取负数的话，当然就只有一个结果了。

有点疑惑，为什么Collection.shuffle()可以，Array.shuffle()却不提供。

当然，算法肯定有可以改进的地方。