看java编程思想的时候看到这么一个题，与大家分享一下。吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这个数字各包含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排序。以两个0结尾的数字是不允许的，例如，下列数字都是“吸血鬼”数字：
1260=21*60
1827=21*87
2187=27*81
挺有意思的题目，大家一块学习一下

import java.util.Arrays;   
/**  
* 吸血鬼数字
*/  
public class Vampire {   
  public static void main(String[] arg) {   
    String[] ar_str1, ar_str2;   
    int sum = 0;   
    int from;   
    int to;   
    int i_val;   
    int count = 0;   
    // 双重循环穷举   
    for (int i = 10; i < 100; i++) {   
      // j=i+1避免重复   
      from = Math.max(1000 / i, i + 1);   
      to = Math.min(10000 / i, 100);   
      for (int j = from; j < to; j++) {   
        i_val = i * j;   
                if (i_val % 100 == 0 || (i_val - i - j) % 9 != 0) {   
          continue;   
        }   
        count++;   
        ar_str1 = String.valueOf(i_val).split("");   
        ar_str2 = (String.valueOf(i) + String.valueOf(j)).split("");   
        Arrays.sort(ar_str1);   
        Arrays.sort(ar_str2);   
        if (Arrays.equals(ar_str1, ar_str2)) {// 排序后比较,为真则找到一组   
          sum++;   
          System.out.println("第" + sum + "组: " + i + "*" + j + "=" + i_val);   
        }   
      }   
    }   
    System.out.println("共找到" + sum + "组吸血鬼数");   
    System.out.println(count);   
  }   
}  

张洁 发表于 2012-6-12 20:13
import java.util.Arrays;   
/**  
* 吸血鬼数字

百度固然方便，还是自己动手动脑一下，比较好吧，

这个是四位的吸血鬼数字计算，虽然有点罗嗦，不过挺好玩的。
public class Xixueguinumber
{
      
      public int cal(int x, int y, int z, int w)
      {
          int num = (x * 10 + y) * (z * 10 + w);
          return num;
         
      }
     public static void main(String[] args)
     {
         for (int i = 1000; i <= 9999;i++)
         {
             int a = (int)(i/1000);
             int b = (int)((i - a*1000)/100);
             int c = (int)((i-((int)(i/100))*100)/10);
             int d = (int)(i - ((int)(i/10))*10);
             Xixueguinumber Xi = new Xixueguinumber();
             boolean b1 = Xi.cal(a,b,c,d) == i;
             boolean b2 = Xi.cal(b,a,c,d) == i;
             boolean b3 = Xi.cal(a,b,d,c) == i;
             boolean b4 = Xi.cal(b,a,d,c) == i;
             boolean b5 = Xi.cal(a,c,b,d) == i;
             boolean b6 = Xi.cal(a,c,d,b) == i ;
             boolean b7 = Xi.cal(c,a,b,d) == i;
             boolean b8 = Xi.cal(c,a,d,b) == i;
             boolean b9 = Xi.cal(a,d,b,c) == i;
             boolean b10 = Xi.cal(d,a,b,c) == i;
             boolean b11 = Xi.cal(a,d,c,b) == i;
             boolean b12 = Xi.cal(d,a,c,b) == i;
             Boolean array[] ={b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11,b12};
             for(int j = 0; j <12; j++)
             {
                 if(array[j])
                 {
                     System.out.print("吸血鬼数字为:" + i + "=" );
                     switch(j+1)
                     {
                         case 1 : System.out.println(""+ a + b + " * " + c + d);break;
                         case 2 : System.out.println(""+ b + a + " * " + c + d);break;
                         case 3 : System.out.println(""+ a + b + " * " + d + c);break;
                         case 4 : System.out.println(""+ b + a + " * " + d + c);break;
                         case 5 : System.out.println(""+ a + c + " * " + b + d);break;
                         case 6 : System.out.println(""+ a + c + " * " + d + b);break;
                         case 7 : System.out.println(""+ c + a + " * " + b + d);break;
                         case 8 : System.out.println(""+ c + a + " * " + d + b);break;
                         case 9 : System.out.println(""+ a + d + " * " + b + c);break;
                         case 10 : System.out.println(""+ d + a + " * " + b + c);break;
                         case 11 : System.out.println(""+ a + d + " * " + c + b);break;
                         case 12 : System.out.println(""+ d + a + " * " + c + b);break;
                     }
                 }

             }

         }
     }
}

史卜坤 发表于 2012-6-12 21:09
这个是四位的吸血鬼数字计算，虽然有点罗嗦，不过挺好玩的。
public class Xixueguinumber
{

Good！~  好直接的方法

1. 
   
2. public class XiXueGui {
   
3. 
   
4.         public static void main(String[] args){
   
5.                 int bits=1;// 例 A*B  bits 代表 A的位数
   
6.                 int temp_i;
   
7.                 int[] b =new int[10];
   
8.                
   
9.         //        System.out.println(b[5]);
   
10.                 for(int i=0;i<1000;i++){
    
11.                        
    
12.                        
    
13.                         temp_i = i;
    
14.                         while(temp_i/10!=0){
    
15.                                 temp_i/=10;
    
16.                                 bits*=10;
    
17.                         }
    
18.         //                System.out.println(bits);
    
19.                         for(int j=bits; j<bits*10; j++){
    
20.                                 setfalse(b); //标记数组全部置为 false
    
21.                                 setture(b,i*j);// 将答案拆分成一位一位的  在对应的 标记为置 true；
    
22.                                 if(equal(b,i,j))
    
23.                                         System.out.println(i+" * "+j+" = "+i*j);
    
24.                         }
    
25.                         bits=1;
    
26.                 }
    
27.         }
    
28.        
    
29.         //检测是否相等
    
30.         private static boolean equal(int[] b,int i, int j){
    
31.                 int temp = i*j;
    
32.                 do{
    
33.                         if(b[i%10]==0)
    
34.                                 return false;
    
35.                         b[i%10]--;
    
36.                         i = i/10;
    
37.                 }while(i!=0);
    
38.                 do{
    
39.                         if(b[j%10]==0)
    
40.                                 return false;
    
41.                         b[j%10]--;
    
42.                         j = j/10;
    
43.                 }while(j!=0);
    
44.                 if(temp%100==0)//排除末尾为两个零
    
45.                         return false;
    
46.                 return true;
    
47.         }
    
48.        
    
49.         //
    
50.         private static void setture(int[] b,int num){
    
51.                 do{
    
52.                         b[num%10]+= 1;
    
53.                         num = num/10;
    
54.                 }while(num!=0);
    
55.                
    
56.         }
    
57.        
    
58.         //讲数组初 置 false
    
59.         private static void setfalse(int[] b){
    
60.                 for(int i=0; i<b.length; i++){
    
61.                         b[i]=0;
    
62.                 }
    
63.         }
    
64. }
    
65. 
    
66. 
    
67. 不知道能否被看懂~  o(∩_∩)o 哈哈，只追求结果，所以没有考虑可读性，还好我也做了一点注解

复制代码

1. <div class="blockcode"><blockquote>public class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 vampire();
   
6.         }
   
7. 
   
8.         public static void vampire()
   
9.         {
   
10.                 int product = 0;
    
11.                 for (int x = 100; x<1000; x++)
    
12.                 {
    
13.                         for (int y=x; y<1000; y++)
    
14.                         {
    
15.                                 product = x*y;
    
16.                                 if (compare(product,x,y))
    
17.                                 {
    
18.                                         System.out.println(product+"="+x+"*"+y);
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.         }
    
23.        
    
24.         //比较整数a和b，c的各个数字是否相同
    
25.         public static boolean compare(int a, int b, int c)
    
26.         {
    
27.                 int[] product = toArray(a);
    
28.                 int[] bc = addArray(toArray(b),toArray(c));
    
29.                 if (product.length != bc.length)
    
30.                 {
    
31.                         return false;
    
32.                 }
    
33.                 else if (product[product.length-1]==0 && product[product.length-2]==0)
    
34.                 {
    
35.                         return false;
    
36.                 }
    
37.                 sortArray(product);
    
38.                 sortArray(bc);
    
39.                 for (int i=0; i<product.length; i++)
    
40.                 {
    
41.                         if (product[i]!=bc[i])
    
42.                         {
    
43.                                 return false;
    
44.                         }
    
45.                 }
    
46.                 return true;
    
47.         }
    
48. 
    
49.         public static void sortArray(int[] arr)
    
50.         {
    
51.                 for (int i=0; i<arr.length-1; i++)
    
52.                 {
    
53.                         for (int j=1; j<arr.length; j++)
    
54.                         {
    
55.                                 int temp;
    
56.                                 if (arr[i]>arr[j])
    
57.                                 {
    
58.                                         temp = arr[i];
    
59.                                         arr[i] = arr[j];
    
60.                                         arr[j] = temp;
    
61.                                 }
    
62.                         }
    
63.                 }
    
64.         }
    
65. //把整数换成整形数组
    
66.         public static int[] addArray(int[] a, int[] b)
    
67.         {
    
68.                 int al = a.length, bl = b.length;
    
69.                 int[] add = new int[al+bl];
    
70.                 for (int i=0; i<al; i++)
    
71.                 {
    
72.                         add[i] = a[i];
    
73.                 }
    
74.                 for (int i=al; i<al+bl; i++)
    
75.                 {
    
76.                         add[i] = b[i-al];
    
77.                 }
    
78.                 return add;
    
79.         }
    
80. //排序
    
81.         public static int[] toArray(int x)
    
82.         {
    
83.                 int index = bits(x);
    
84.                 int[] num = new int[index];
    
85.                 for (int i = index-1; i>=0; i--)
    
86.                 {
    
87.                         num[i] = x%10;
    
88.                         x = x/10;
    
89.                 }
    
90.                 return num;
    
91.         }
    
92. //x是多少位数
    
93.         public static int bits(int x)
    
94.         {
    
95.                 int bits = 1;
    
96.                 while(x/10!=0)
    
97.                 {
    
98.                         bits++;
    
99.                         x = x/10;
    
100.                 }
     
101.                 return bits;
     
102.         }
     
103. }

复制代码

三位数的吸血鬼数好多啊，四位数就开始刷屏了
118440=141*840
136948=146*938
115672=152*761
146952=156*942
116725=161*725
156915=165*951
162976=176*926
129775=179*725
102510=201*510
126027=201*627。。。。

郭宁 发表于 2012-6-12 22:36

这个方法好，佩服:handshake

何旭栋 发表于 2012-6-13 01:22
这个方法好，佩服

程序应该写成你这样的，有很好的可读性，也方便修改和优化。

额 上午看到这道题弄了下，贴下我的代码，这里没用数组直接用ArrayList集合。

1. public class VampireNumber {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 getVampireNumber(3);
   
9.         }
   
10.         /**
    
11.          * 用来获得打印打印吸血鬼数字的函数
    
12.          * 初始条件：无
    
13.          * 结束条件：无
    
14.          * @param int digit:乘数的数位位数
    
15.          *        double numScope: 乘数的最大数字边界                           
    
16.          */
    
17.         public static void getVampireNumber(int digit){
    
18.                 double numScope = Math.pow(10, digit);               
    
19.                                 
    
20.                 for (int i = (int)Math.pow(10, (digit - 1)); i < numScope; i++){
    
21.                         for (int j = i; j < numScope; j++){                                
    
22.                                 if(calculateNum(i, j) != 0){
    
23.                                         System.out.println("乘数为"+digit+"位的吸血鬼数字为："+calculateNum(i, j)+" = "
    
24.                                                                                         + i + "*" +j);
    
25.                                 }
    
26.                         }
    
27.                 }
    
28.         }
    
29.         /**
    
30.          * 用来计算吸血鬼数字的函数
    
31.          * 初始条件：无
    
32.          * 结束条件：返回数字乘积product  
    
33.          * @param int multiplierFir: 乘数一
    
34.          *        int multiplierSec: 乘数二
    
35.          *        int product: 乘积
    
36.          *               
    
37.          */
    
38.         public static int calculateNum(int multiplierFir, int multiplierSec){
    
39.                 ArrayList<Integer> alMultiplier = new ArrayList<Integer>();
    
40.                 ArrayList<Integer> alProduct = new ArrayList<Integer>();
    
41.                 int product = multiplierFir * multiplierSec;
    
42.                 //将两个乘数的所有数字存入乘数集合alMultiplier中
    
43.                 if ((multiplierFir % 10 != 0) || (multiplierSec % 10 != 0)){
    
44.                         int mFirData = multiplierFir;
    
45.                         int mSecData = multiplierSec;
    
46.                         while ((mFirData != 0)&& (mSecData != 0)){
    
47.                                 alMultiplier.add(mFirData % 10);
    
48.                                 mFirData = mFirData / 10;
    
49.                                 alMultiplier.add(mSecData % 10);
    
50.                                 mSecData = mSecData / 10;                                
    
51.                         }                        
    
52.                 }
    
53.                 //将两个数的成绩存入乘积集合alProduct中
    
54.                 int temp = product;
    
55.                 while(temp != 0){                        
    
56.                         alProduct.add(temp % 10);
    
57.                         temp = temp / 10;
    
58.                 }                        
    
59.                
    
60.                 Collections.sort(alMultiplier);
    
61.                 Collections.sort(alProduct);
    
62.                 if(equals(alMultiplier,alProduct)){
    
63.                         return product;
    
64.                 }
    
65.                 return 0;
    
66.         }
    
67.         /**
    
68.          * 用来判断两个具有自然顺序的ArrayList<Integer>集合的所有元素是否相同
    
69.          * 初始条件：无
    
70.          * 结束条件：返回boolean flag的值
    
71.          * @param ArrayList<Integer> alist1: 集合一
    
72.          *        ArrayList<Integer> alist2: 集合二
    
73.          *        boolean flag: 判断标记                        
    
74.          */
    
75.         
    
76.         public static boolean equals(ArrayList<Integer> alist1, ArrayList<Integer> alist2){
    
77.                 boolean flag = true;
    
78.                 if(alist1.size() == alist2.size()){
    
79.                         for (int i = 0; i < alist1.size(); i++){
    
80.                                 if (alist1.get(i) != alist2.get(i)){
    
81.                                         flag = false;
    
82.                                         break;
    
83.                                 }                                       
    
84.                         }
    
85.                         return flag;
    
86.                 }
    
87.                 return !flag;                                
    
88.         }
    
89. }

复制代码