Java - Recorrido del caballo y lentitud en java

   
Vista:
Imágen de perfil de Michel

Recorrido del caballo y lentitud en java

Publicado por Michel Michel_Betancourt@hotmail.com (1 intervención) el 25/01/2015 04:52:11
Buenas tengo una pequeña duda.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package tableroajedrez.caballo;
 
    import java.util.Random;
 
    /**
     *
     * @author aleinshir
     */
    public class Kernel {
 
        private int Tablero[][];                                                        // Tablero de ajedre representado en una matriz
        private static int horizontal[] = new int[] {  2,  1, -1, -2, -2, -1, 1, 2 };                       // Movimientos posibles de manera horizonta
        private static int vertical[] = new int[]      { -1, -2, -2, -1,  1,  2, 2, 1 };                        // Movimientos posibles de manera vertical
        private int movimientos;                                                        // Movimientos realizados
        private boolean aux_mov;                                                        // Auxiliar de prueba
        private int prueba;                                                         // Variable para probar todos los movimientos
        private boolean auxiliar;                                                       // Auxiliar para saber si se soluciono el problema
        private int siguiente_mov;                                                      // Siguiente movimiento que hara el caballo
        private int errores;                                                            // Se asegura que el caballo no este atrapado
        private Random rand;                                                        // Numero aleatorio
        private boolean auxiliar_ex;
        private boolean auxiliar_listo;
        private int numero;
        /**
         * Inicializa el tablero y randomiza la clase "Random".
         */
        public Kernel() {
            this.Tablero = new int[8][8];
            rand = new Random(System.nanoTime());
            construir_array();
        }
 
        /**
         *
         * Clase que inicial el kernel para determina el final del problema.
         *
         * @param posicionH Posicion inicial vertical
         * @param posicionV Posicion inicial vertical
         * @return El tablero ya resuelto
         */
        @SuppressWarnings("empty-statement")
        public int [][] start(int posicionH, int posicionV) {
            do
                auxiliar_listo =  recorrido_completo(posicionH, posicionV);
            while (auxiliar_listo == false);
            return Tablero;
        }
 
        /**
         *
         * @return True si esta completo el recorrido
         */
        private  boolean recorrido_completo(int posicionH, int posicionV) {
 
            auxiliar = true;
            for (movimientos = 1, errores = 0; movimientos <= 64 && auxiliar; movimientos++)    // Ciclo exterior
            {
                aux_mov = true;
                siguiente_mov = rand.nextInt(8);                                        // Determina el proximo movimiento
                for (prueba = 0; prueba < 8 && aux_mov; prueba++, siguiente_mov++, errores++)// Prueba todos los posibles movimientos
                {
 
                    if (siguiente_mov == 8)                                         // Pasa al movimento 0 cuando llega al 8
                        siguiente_mov = 0;
 
                    try
                    {
                        if (Tablero[posicionH + horizontal[siguiente_mov]][posicionV + vertical[siguiente_mov]] == 0)
                        {
                            Tablero[posicionH][posicionV] = movimientos;
 
                            errores = 0;
                            aux_mov = false;
                            posicionV += vertical[siguiente_mov] ;
                            posicionH += horizontal[siguiente_mov] ;
                        }
                    }
                    catch(ArrayIndexOutOfBoundsException e)
                    {
 
                    }
                }
 
                if (errores >= 8)                                                   // Si hay mas de 8 errores corta el recorrido
                    auxiliar =false;
            }
 
            return movimientos >= 64;                                               // True si hizo los 64 movimiento
        }
 
        /**
         *
         * Construye el array dandole 0 (no necesario en java pero es mejor inicializarlo.
         */
        private void construir_array() {
            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    Tablero[j] = 0;
                }
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
    #include <stdlib.h>
    #include <stdio.h>
    #include <time.h>
 
    #define TAMANIOV 12                                     // Altura del tablero
    #define TAMANIOH 12                                     // Anchura del tablero
 
    int despliega_tablero(const int tablero[][TAMANIOV]);
    int llamar(int posicionH, int posicionV, int intento);
 
    int main()
    {
        srand(time(NULL));
        int posicionH, posicionV;
        scanf("%d%d", &posicionH, &posicionV);
        posicionH += 2;
        posicionV += 2;
        int i, intento = 0;
        for (i = 0; i == 0;)
        {
            intento++;
            if (llamar(posicionH, posicionV, intento) == 1)
            {
                intento = 0;
            }
        }
        system("pause");
        return 0;
    }
 
    int llamar(int posicionH, int posicionV, int intento)
    {
        int Tablero[TAMANIOH][TAMANIOV] = { 0 };
        int horizontal[8] = { 02, 01, -1, -2, -2, -1, 1, 2 };
        int vertical[8] =   { -1, -2, -2, -1, 01, 02, 2, 1 };
        int movimientos, errorlevel, almacenaH, almacenaV;
        int siguiente, fun;
        for  (movimientos = 1, errorlevel = 0; movimientos != 65;)
        {
             siguiente = rand() % 7;
             for (fun = 0; fun < 8; siguiente++, fun++)
             {
                 if (siguiente == 8)
                     siguiente = 0;
                 if (Tablero[posicionH + horizontal[siguiente]][posicionV + vertical[siguiente]] == 0)
                 {
                     errorlevel = 0;
                     Tablero[posicionH][posicionV] = movimientos;
                     almacenaH = posicionH;
                     almacenaV = posicionV;
                     posicionH += horizontal[siguiente];
                     posicionV += vertical[siguiente];
                     if (posicionH == 0 || posicionH == 1 || posicionV == 0 || posicionV == 1)
                     {
                         Tablero[posicionH][posicionV] = 1;
                         posicionH = almacenaH;
                         posicionV = almacenaV;
                         continue;
                     }
 
                     if (posicionH == 10 || posicionH == 11 || posicionV == 10 || posicionV == 11)
                     {
                         Tablero[posicionH][posicionV] = 1;
                         posicionH = almacenaH;
                         posicionV = almacenaV;
                         continue;
                     }
                     movimientos++;
                     break;
                 }
             }
            errorlevel++;
            if (errorlevel >= 8)
               break;
 
        }
 
        if (movimientos >= 64)
        {
            system("cls");
            despliega_tablero(Tablero);
            printf("movimientos = %d\nintentos = %d\n", movimientos, intento);
            system("pause");
            return 1;
        }
        else
        {
            return 0;
        }
 
 
    }
 
    int despliega_tablero(const int tablero[][TAMANIOV])
    {
         int columna, fila;
         for (columna = 2; columna < 10; columna++)
         {
             for(fila = 2; fila < 10; fila++)
             {
                      if( tablero[columna][fila] == 0)
                          printf("%3s", "0" );
                      if(tablero[columna][fila] != 0)
                          printf("%3d", tablero[columna][fila]);
             }
             printf("\n");
 
         }
         return 0;
    }

El codigo java (el primero):
Es una clase que hice, la cual crea un arreglo que contiene todo el recorrido del caballo ya resuelto (enumera del 1 al 64 los movimientos a seguir). El problema: [i]Tarda
mucho en resolverlo.

El codigo C (el segundo):
Es uno que cree hace ya tiempito, resolvia el recorrido y luego lo mostraba, la manera que se me ocurrio de resolverlo fue llenar con 2 arreglos mas de cada lado para saber cuando se desbordaba (no me se explicar muy bien, pero se nota en el codigo ya que es 12x12 en vez de 8x8). Este se ejecuta bastante rapido (casi instantaneo) apesar de que usa la fuerza bruta.

Mi pregunta:
¿Hice algo malo en el codigo de java?, ¿porqué este tarda mucho mas? o ¿Es por el hecho de que C es un lenguaje compilado y java interpretado?.

PD: Seguro algunos me dicen que es malo usar break por eso de la programacion estructurada etc, pero cuando hice el code no lo sabia xd y me dio lala corregirlo, en java si use una variable de "escape".

Gracias por su tiempo :)
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
información
Otras secciones de LWP con contenido de Java
- Código fuente de Java
- Cursos de Java
- Temas de Java
- Chat de Java
información
Códigos de Java
- Mostrar Imagenes
- Juego del Tetris
- ArbolesBinarios
Imágen de perfil de Nacho

Recorrido del caballo y lentitud en java

Publicado por Nacho (27 intervenciones) el 25/01/2015 18:45:23
Esto ya te lo respondieron en el otro foro xD!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar