Encontrar "o número de vampiro" (Java, bubble sort)

número vampiro refere-se aos bits digitais um número par, e pode ser obtida por multiplicação por um par de números, cada um dos quais contém metade do produto do número de bits de valores digitais, que seleccionam a partir dos números digitais inicial pode ser ordem arbitrária. Dois terminais digitais 0 não é permitido, por exemplo, as seguintes figuras são "vampire" números:
1260 = 21 * 60
1827 = 21 * 87
2187 * 81 = 27

Então, comece

Uma vez que o número de quatro dígitos pode ser determinado se o produto de dois dígitos em dois, o produto resultante da proporção de determinação dígitos de quatro dígitos, muita dificuldade, de modo que a ideia deste último.

Importação de java.util.ArrayList;
 importação java.util.Arrays; 

/ ** 
 * iniciar 1001-9999 determinação início início, se dois dígitos em dois, em caso afirmativo, se o número do digital bidimensional contém todos os quatro 
 * dividido em quatro dígitos de dois dígitos multiplicação muita dificuldade, e pode haver uma variedade de métodos de decomposição de quatro dígitos para aumentar a dificuldade do desenho 
 * no entanto, por sua vez, multiplicado pelo número de dois dígitos de dígitos é muito mais simples, desta vez você pode ir para determinar 
 * a solução de integração em quatro dígitos, em uma matriz. Dois multiplicadores respectivamente em dois dígitos, em uma matriz 
 * classificando as duas matrizes, um por um de acordo com o seguinte padrão, e se os dois conjuntos são idênticos, retorna ao verdadeiro 
 * @author Zhaoke 
 * 
 * / 
público  classe vampiro { 

    // tomada bubble sort 
    pública  vazio Sort ( int [] array) {
         para ( int i = 0;. I <array.length -ser 1; i ++ ) {
             para (Int . J = i + 1; J <ser array.length; J ++ ) {
                 SE (Matriz [i]> Array [J]) {
                     // posições trocadas dois números 
                    Array [I] = Array [I] - Matriz [J ]; 
                    matriz [J] = array [I] + array [J]; 
                    matriz [I] = array [J] - matriz [I]; 
                } 
            } 
        } 
    } 
    
    / ** 
     dígitos (o dígito depois de determinar a presença de decomposição * array), contém exatamente se todos os dígitos dos dois multiplicação fator 
     * por simplicidade, o método é primeiro classificado e, em seguida, comparar as duas matrizes são iguais 
     * / 
    público  booleana check ( int [] dígitos, int num1,int num2) {
         a esta .Sort (dígitos);
 //         System.out.printlnl (de Arrays.toString (dígitos)); 
        
        int [] = Factores novo novo  int [4. ];
         // separa os dois primeiros dígitos de um multiplicador 
        int [] = numarray a esta .divideNumber (num1);
         para ( int i = 0; I <2; i ++ ) { 
            Factores [I] = numarray [I]; 
        } 
        // dois dígitos separadas do segundo multiplicador 
        numarray = a esta .divideNumber (num2);
         para ( int I = 2;. I <4; i ++ ) {
            factores de [i] = numArray [I-2 ]; 
        } 
        Esta .Sort (factores);
//         System.out.printlnl (Arrays.toString (factores)); 
        para ( int i = 0; i <digits.length; i ++ ) {
             se (dígitos [i] =! fatores [i]) {
                 return  false ; 
            } 
        } 
        Retornar  verdadeiro ; 
    } 
    
    Público  int [] divideNumber ( int número) {
         int [] = dígitos novo  int [2 ]; 
        dígitos [0] = número / 10 ; 
        dígitos [ 1] = número - 10 * (número / 10 );
        voltar dígitos; 
    } 
    
    / ** 
     *获得每个位的数字
     * / 
    público  int [] divideArray ( int número) {
         int [] = dígitos novo  int [4 ];
        int = factor de 1000 ;
        para ( int i = 0; i <digits.length; i ++ ) { 
            dígitos [i] = número / fator; 
            Número - = dígitos [i] * fator; 
            fator / 10 =; 
        } 
        Retorno dígitos; 
    } 
    o ArrayList <Integer> = Resultado new new ArrayList <Integer> (); 

    / ** 
     . * 10 * 99 é inferior a 1000, eo loop desde o início 11 
     * / 
    público  vazio Iniciar () {
         int count = 0; // contador só 
        para ( int I = 11;. I <100; i ++ ) {
             para ( int J = 11;. J <100; J ++ ) {
                 SE (I * J <1,000 )
                     Continuar ;
                 IF (I * J% 100 == 0) {
                     // O título, se os dois últimos bits são 0, nem 
                    Continuar ; 
                } 
                int [] = divideArray dígitos (I * J);
                 IF ( a este .Verificar (dígitos, I, J)) {
                     IF ( a este .Result .Contains (I * J))
                         Continuar ;
                     a esta .result.add (I * J); 
                    System.out.printf ( "número vampiro% d:% d =% dx% d. \ n", ++ contagem, * I J, I, J); 
                } 
            } 
        } 
    } 
    
    público  estático  vazioprincipal (String [] args) { 
        vampiro v = novo vampiro (); 
        v.start (); 
    } 

}

Os resultados são os seguintes:

1 número vampiro: 1395 = 15 x 93 
segundo número vampiro: 1260 = 21 x 60 
3 número vampiro: 1827 = 21 x 87 
4 número vampiro: 2187 = 27 x 81 
5 número vampiro: 1530 = 30 x 51 
6 número vampiro: 1435 = 35 x 41 
sétimo número vampiro: 6880 = 80 x 86

Resumo: o pensamento reverso, design modular