Encuentra "el número de vampiro" (Java, ordenamiento de burbuja)

número vampiro se refiere a los bits digitales un número par, y puede obtenerse mediante la multiplicación por un par de números, cada uno de los cuales contiene la mitad del producto del número de bits de los números digitales, que seleccionan a partir de los números digitales iniciales puede ser la orden arbitrario. Dos digitales 0 no está permitido, por ejemplo, las siguientes figuras son números finales "vampiro":
1260 = 21 * 60
1827 = 21 * 87
2187 * 81 = 27

Por lo tanto, comenzar

Dado que el número de cuatro dígitos se puede determinar si el producto de dos dígitos en dos, el producto resultante de la relación de determinación dígitos de cuatro dígitos, muchos problemas, por lo que la idea de este último.

Importación de java.util.ArrayList;
 Importación java.util.Arrays; 

/ ** 
 * comenzar 1001 a 9999 la determinación de inicio de inicio, si dos dígitos en dos, de ser así, si el número de la tecnología digital de dos dimensiones contiene los cuatro 
 * desglosa en la multiplicación de dos dígitos de cuatro dígitos demasiados problemas, y puede haber una variedad de métodos de descomposición de cuatro dígitos para aumentar la dificultad del diseño 
 * Sin embargo, a su vez, multiplicado por el número de dos dígitos de dígitos es mucho más simple, esta vez se puede ir a determinar 
 * la solución de integración en cuatro dígitos, en una matriz. Dos multiplicadores respectivamente en dos dígitos, en una matriz 
 * la clasificación de las dos matrices, una por una de acuerdo con el siguiente estándar, y si las dos matrices son idénticos, vuelve a verdadero 
 * @author zhaoke 
 * 
 * / 
público  clase vampiro { 

    // toma ordenamiento de burbuja 
    público  void ordenar ( int [] array) {
         para ( int i = 0;. I <Array.length -be 1; I ++ ) {
             para (int . J = I + 1; J <ser Array.length; J ++ ) {
                 IF (Array [I]> Array [J]) {
                     // posiciones intercambió dos números 
                    Array [I] = Array [I] - Array [J ]; 
                    array [J] = array [I] + array [J]; 
                    array [I] = array [J] - array [I]; 
                } 
            } 
        } 
    } 
    
    / ** 
     dígito (el dígito después de determinar la presencia de descomposición * array), contiene exactamente si todos los dígitos de los dos factor de multiplicación 
     * por simplicidad, se clasifican en primer lugar el método y luego comparar las dos matrices son iguales 
     * / 
    pública  de Boole Check ( int [] dígitos, int num1,int num2) {
         el este .Sort (dígitos);
 //         System.out.println (de Arrays.toString (dígitos)); 
        
        int [] = Factores nuevo nuevo  int [4. ];
         // separa los dos primeros dígitos de un multiplicador 
        int [] = numarray el este .divideNumber (num1);
         para ( int i = 0; I <2; I ++ ) { 
            Factores [I] = numarray [I]; 
        } 
        // dos dígitos separados del segundo multiplicador 
        numarray = el este .divideNumber (num2);
         para ( int I = 2;. I <4; I ++ ) {
            factores [i] = arrNumeros [i-2 ]; 
        } 
        Esta .Sort (factores);
//         System.out.println (Arrays.toString (factores)); 
        para ( int i = 0; i <digits.length; i ++ ) {
             si (dígitos [i] =! factores [i]) {
                 retorno  falsa ; 
            } 
        } 
        Regresar  verdadera ; 
    } 
    
    Pública  int [] divideNumber ( int número) {
         int [] dígitos = nuevo  int [2 ]; 
        dígitos [0] = número / 10 ; 
        dígitos [ 1] = número - 10 * (número / 10 );
        volver dígitos; 
    } 
    
    / ** 
     *获得每个位的数字
     * / 
    pública  int [] divideArray ( int numero) {
         int [] = dígitos nueva  int [4 ];
        int = factor de 1000 ;
        para ( int i = 0; i <digits.length; i ++ ) { 
            dígitos [i] = número / factor de; 
            número - = dígitos [i] * factor de; 
            factor de / = 10; 
        } 
        Retorno dígitos; 
    } 
    ArrayList <Integer> = Resultado nueva nueva ArrayList <Integer> (); 

    / ** 
     . * 10 * 99 es menor que 1000, y el bucle desde el principio 11 
     * / 
    público  vacío Inicio () {
         int count = 0; // contador sólo 
        para ( int I = 11;. I <100; I ++ ) {
             para ( int J = 11;. J <100; J ++ ) {
                 IF (I * J <1,000 )
                     Continuar ;
                 IF (I * J% 100 == 0) {
                     // El título, si los dos últimos bits son 0, ni 
                    Continuar ; 
                } 
                int [] = divideArray dígitos (I * J);
                 SI ( el este .Comprobar (dígitos, I, J)) {
                     SI ( el este .Result .Contains (I * J))
                         Continuar ;
                     el este .result.add (I * J); 
                    System.out.printf ( "número vampiro% d:% d =% dx% d. \ n", ++ recuento, * I J, I, J); 
                } 
            } 
        } 
    } 
    
    pública  estática  vacíoprincipal (String [] args) { 
        vampiro v = nuevo vampiro (); 
        v.start (); 
    } 

}

Los resultados son como sigue:

Primero número vampiro: 1395 = 15 x 93 
segundo número vampiro: 1260 = 21 x 60 
tercera número vampiro: 1827 = 21 x 87 
número vampiro cuarta: 2187 = 27 x 81 
número vampiro quinta: 1530 = 30 x 51 
sexto número vampiro: 1435 = 35 x 41 
séptimo número vampiro: 6880 = 80 x 86

Resumen: pensamiento inverso, el diseño modular