《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);
                }
            }
        }
    }
}

运行结果：