[20-05-03][Self-test 37]Java Vampire Number 2

  1 package test_1_1;
  2 
  3 public class VampireNum {
  4 
  5     public static void main(String[] args) {
  6 
  7         /**
  8          * 吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到
  9          * 这对数字各包含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排序
 10          * 以两个0结尾的数字是不允许的，例如：
 11          * 1260 = 21 * 60
 12          * 1827 = 21 * 87
 13          * 找到4位数所有吸血鬼数
 14          */
 15         
 16         System.out.println("吸血鬼数包括：");
 17         
 18         for (int i = 1000; i < 10000; i++) {
 19             judgeVampireNum(i);
 20         }
 21     }
 22 
 23     private static void judgeVampireNum(int num) {
 24 
 25         char[] chaArr = ("" + num).toCharArray();
 26         
 27         int thou = (int)chaArr[0] - 48;
 28         int hun = (int)chaArr[1] - 48;
 29         int dec = (int)chaArr[2] - 48;
 30         int unit = (int)chaArr[3] - 48;
 31         
 32         int[] numArr = {thou, hun, dec, unit};
 33         boolean[] isChosen = new boolean[numArr.length];
 34         
 35         isVampireNum(numArr, isChosen, num);
 36         
 37     }
 38 
 39     private static void isVampireNum(int[] numArr, boolean[] isChosen, int num) {
 40         
 41         int a = 0;
 42         int b = 0;
 43         int c = 0;
 44         int d = 0;
 45         
 46         for (int i = 0; i < numArr.length; i++) {
 47             
 48             if (isChosen[i] == true) {
 49                 continue;
 50             }
 51                 a = numArr[i];
 52                 isChosen[i] = true;
 53             
 54             for (int j = 0; j < numArr.length; j++) {
 55                 
 56                 if (isChosen[j] == true) {
 57                     continue;
 58                 }
 59                     b = numArr[j];
 60                     isChosen[j] = true;
 61                 
 62                 for (int k = 0; k < numArr.length; k++) {
 63                     
 64                     if (isChosen[k] == true) {
 65                         continue;
 66                     }
 67                         c = numArr[k];
 68                         isChosen[k] = true;
 69                     
 70                     for (int l = 0; l < numArr.length; l++) {
 71                         
 72                         if (isChosen[l] == true) {
 73                             continue;
 74                         }
 75                             d = numArr[l];
 76                             isChosen[l] = true;
 77                             
 78                             if ((a * 10 + b) * (c * 10 + d) == num) {
 79                                 System.out.println(num + " = " + (a * 10 + b) + " * " + (c * 10 + d));
 80                                 return;
 81                             }
 82                             
 83                             isChosen[l] = false;
 84                 
 85                     }
 86                     
 87                     isChosen[k] = false;
 88                     
 89                 }
 90                 
 91                 isChosen[j] = false;
 92                         
 93             }
 94             
 95             isChosen[i] = false;
 96             
 97         }
 98         
 99     }
100     
101 }

结果如下：

吸血鬼数包括：
1260 = 21 * 60
1395 = 15 * 93
1435 = 41 * 35
1530 = 51 * 30
1827 = 87 * 21
2187 = 27 * 81
6880 = 86 * 80