《Thinking in Java》習題——吸血鬼數字

 

     最近在看《Java編程思想》，這本書非常棒，不愧是Java程序員的聖經。看到第四章，后面有道題目很有意思，於是就自己做了做。

 

      1. 我的思路很簡單，但是算法效率非常之低。就是把4位數拆成4個數字，比如1260--->1,2,6,0。然后4位數字組合成兩個2位數，計算它們

       的乘積，相等則就是吸血鬼數字。

     

public class Test2 {
    /*
     * 將4位數拆分成4個數
     * */
  public int [] array(int num){
      int [] a = new int [4];
      int i=0;
      while(num!=0){
        a[i++]=num%10;
        num=num/10;
     }
    return a;
  } 
  /*
   * 將4給數組合成兩個數，相乘與4位數比較。相等就是吸血鬼數字
   * 
   * */
    public boolean equal(int num,int [] a){
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if(i==j){
                    continue;
                }else{
                    if(6-i-j==5){//i,j=0或1
                        if((a[i]*10+a[j])*(a[3]*10+a[2])==num||(a[i]+a[j]*10)*(a[3]*10+a[2])==num){
                            return true;
                        }
                    }
                    else if(6-i-j==4){//i,j=0或2  
                        if((a[i]*10+a[j])*(a[3]*10+a[1])==num||(a[i]+a[j]*10)*(a[3]*10+a[1])==num){
                            return true;
                    }
                     }
                    else if(6-i-j==3&&(i==3||j==3)){ //i,j或0,3 
                        if((a[i]*10+a[j])*(a[2]*10+a[1])==num||(a[i]+a[j]*10)*(a[2]*10+a[1])==num){
                            return true;
                     }
                        }
                        else if(6-i-j==3&&(i==1||j==1)){//i,j=1或2
                         if((a[i]*10+a[j])*(a[3]*10+a[0])==num||(a[i]+a[j]*10)*(a[3]*10+a[0])==num){
                                return true;
                     }
                        } 
                        else if(6-i-j==2){//i,j=1或3 
                         if((a[i]*10+a[j])*(a[2]*10+a[0])==num||(a[i]+a[j]*10)*(a[2]*10+a[0])==num){
                                return true;
                     }
                        }
                        else if(6-i-j==1){//i,j=2或3 
                         if((a[i]*10+a[j])*(a[1]*10+a[0])==num||(a[i]+a[j]*10)*(a[1]*10+a[0])==num){
                                return true;
                       }
                      }
                     }
                   }
                }
             return false;
            }
      public static void main(String[] args) {
          Test2 t2 = new Test2();
         for(int i =1001;(i<=9999);i++){
             if(t2.equal(i, t2.array(i))){
                 System.out.println(i);
             }
         }
    }
        
   }

    運行結果：

    

     結果是對的，但是算法效率太低。將近要循環9000*4*4=14400次。

    在網上找了找，有很多高效的算法。貼出來研究一下別人的思路。

    2.

   

public class XiXueGui {   
    /**  
     * 吸血鬼數字算法  
     * 如：12*60=1260  
     * YangL.  
     */   
    public static void main(String[] args) {   
        String[] ar_str1 = null, ar_str2;   
        int sum = 0;   
        int count=0;
        for (int i = 10; i < 100; i++) {   
            for (int j = i + 1; j < 100; j++) {   
                int i_val = i * j;   
                if (i_val < 1000 || i_val > 9999)   
                    continue; // 積小於1000或大於9999排除,繼續下一輪環   
                count++;
                ar_str1 = String.valueOf(i_val).split("");   
                ar_str2 = (String.valueOf(i) + String.valueOf(j)).split("");   
                java.util.Arrays.sort(ar_str1);   
                java.util.Arrays.sort(ar_str2);   
                if (java.util.Arrays.equals(ar_str1, ar_str2)) {   
                    // 排序后比較,為真則找到一組   
                    sum++;   
                    System.out.println("第" + sum + "組: " + i + "*" + j + "="   
                            + i_val);   
                }   
            }   
        }   
        System.out.println("共找到" + sum + "組吸血鬼數"+"\ncount"+count);
       
    }   
} 

 

    這個算法非常棒，基本思路是：4位數字的吸血鬼數字只能拆分成兩個2位數。於是就計算兩個2位數相乘（11，12行）。用String.valueOf(j)).split("");的方法來把數字轉換為字符串，排序，比較4位數的字符串和兩個2位數的字符串，若相等，就是吸血鬼數字。把數字的比較，轉換為對字符串的比較，非常棒。

     這個算法循環了3721次。

   運行結果：

  

   3.《Thinking in Java》官方答案

 

//: control/E10_Vampire.java
/****************** Exercise 10 *********************
* A vampire number has an even number of digits and
* is formed by multiplying a pair of numbers containing
* half the number of digits of the result. The digits
* are taken from the original number in any order.
* Pairs of trailing zeroes are not allowed. Examples
* include:
* 1260 = 21 * 60
* 1827 = 21 * 87
* 2187 = 27 * 81
* Write a program that finds all the 4-digit vampire
* numbers. (Suggested by Dan Forhan.)
****************************************************/
public class E10_Vampire {
public static void main(String[] args) {
    int[] startDigit = new int[4];
    int[] productDigit = new int[4];
    for(int num1 = 10; num1 <= 99; num1++)
        for(int num2 = num1; num2 <= 99; num2++) {
            // Pete Hartley's theoretical result:
            // If x·y is a vampire number then
            // x·y == x+y (mod 9)
            if((num1 * num2) % 9 != (num1 + num2) % 9)
                continue;
    int product = num1 * num2;
    startDigit[0] = num1 / 10;
    startDigit[1] = num1 % 10;
    startDigit[2] = num2 / 10;
    startDigit[3] = num2 % 10;
    productDigit[0] = product / 1000;
    productDigit[1] = (product % 1000) / 100;
    productDigit[2] = product % 1000 % 100 / 10;
    productDigit[3] = product % 1000 % 100 % 10;
    int count = 0;
    for(int x = 0; x < 4; x++)
      for(int y = 0; y < 4; y++) {
          if(productDigit[x] == startDigit[y]) {
              count++;
              productDigit[x] = -1;
              startDigit[y] = -2;
              if(count == 4)
                  System.out.println(num1 + " * " + num2
                          + " : " + product);
                }
            }
        }
    }
}

運行結果：