elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  Recorrido del caballo y lentitud al ejecutarlo en java
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Recorrido del caballo y lentitud al ejecutarlo en java  (Leído 3,751 veces)
nenea4

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Recorrido del caballo y lentitud al ejecutarlo en java
« en: 25 Enero 2015, 04:11 am »

Buenas tengo una pequeña duda.

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

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

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: 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  :)


En línea

engel lex
Moderador Global
***
Desconectado Desconectado

Mensajes: 15.514



Ver Perfil
Re: Recorrido del caballo y lentitud al ejecutarlo en java
« Respuesta #1 en: 25 Enero 2015, 04:20 am »

el uso del break no es malo... es eso o peor aún, llevar la variable de control a su ultima consecuencia...

java no es interpretado realmente porque el si compila y crea un binario ejecutable... solo que lo ejecuta solo dentro de su maquina virtual (es algo similar para .net)... realmente no se java como para juzgar los codigos, pero java si es ampliamente más lento que C estoy probando y no es tan lento jejeje


« Última modificación: 25 Enero 2015, 05:40 am por engel lex » En línea

El problema con la sociedad actualmente radica en que todos creen que tienen el derecho de tener una opinión, y que esa opinión sea validada por todos, cuando lo correcto es que todos tengan derecho a una opinión, siempre y cuando esa opinión pueda ser ignorada, cuestionada, e incluso ser sujeta a burla, particularmente cuando no tiene sentido alguno.
Usuario Invitado


Desconectado Desconectado

Mensajes: 625



Ver Perfil
Re: Recorrido del caballo y lentitud al ejecutarlo en java
« Respuesta #2 en: 25 Enero 2015, 14:33 pm »

Hmm, quizás ejecutándolo dentro de un Thread para que no interfiera con el thread principal puede mejorar la velocidad de procesamiento.

Alternativamente, te recomiendo colocar ésta duda que me parece muy interesante, en StackOverFlow, que estoy seguro te darán muy buenas respuestas los expertos. Para ésto, te recomiendo que re-escribas tu código en ingés.

Mi estimado @engel lex, sí es muy cierto que Java antes era un dinosaurio (me refiero a lo pesado xD). Pero en los últimos años, tanto el lenguaje como la JVM han sido optimizados mucho (como por ejemplo la implementación de la tecnología JIT en la JVM), dando como resultado un lenguaje y una JVM muchos más rápidos. Es más, en los últimos benchmarks que he podido observar, Java ejecuta la mayoría de algoritmos a la misma velocidad e incluso en algunos más que C++. Y con el esperado Jigsaw en Java 9, Java será una delicia xD
« Última modificación: 25 Enero 2015, 15:34 pm por Gus Garsaky » En línea

"La vida es muy peligrosa. No por las personas que hacen el mal, si no por las que se sientan a ver lo que pasa." Albert Einstein
3n31ch


Desconectado Desconectado

Mensajes: 445


Grandes conocimientos engendran grandes dudas


Ver Perfil
Re: Recorrido del caballo y lentitud al ejecutarlo en java
« Respuesta #3 en: 25 Enero 2015, 15:04 pm »

Comparto lo que dijo Gus Garsaky, hace un tiempo atrás por una evaluación tuve que defender a java como el mejor lenguaje de programación, claramente lo primero que pensé "El primer contra argumento que me den, sera respecto a su velocidad", Quede sorprendido al buscar información sobre el lenguaje... ya que realmente no es como lo pintan. Antiguamente si, claro que lo era, y quizás su popularidad de caracol se deba en gran parte por las applets que bueno... No se como estarán ahora las applets de java pero al menos si en algún momento me encontré últimamente con alguna en la web, ni cuenta me di porque cargo rapido xD!.

PD: La evaluación solo fue una evaluación, no comparto la forma de pensar de algunos que creen que un lenguaje es superior en todo aspecto a otro y por ello solo se debe usar un lenguaje.

PD: Un dato que me gustaría agregar, un estracto que encontré en mis apuntes:

La máquina virtual de Java cuenta hoy en día con compiladores JIT (Just In Time) que traducen el bytecode a código nativo de la máquina. Además, la JVM también puede monitorizar qué partes del programa se ejecutan más a menudo y optimizar la compilación para el uso real que se le da a la aplicación. Es lo que se conoce como Optimización Adaptativa, y es una ventaja muy importante con la que no cuentan los compiladores tradicionales.

El resultado de todos estos cambios, es que Java, a día de hoy es tan rápido o más que C++. Dependiendo de quién haga el benchmark, Java resulta ser un poco más rápido o un poco más lento.

Por ejemplo, el The Computer Language Benchmarks Game es un juego de benchmarks basados en pruebas de cálculo aritmético sencillas donde se comparan distintos lenguajes. En esas pruebas Java, cuando descontamos el tiempo de arranque de la máquina virtual, aparece en los primeros puestos, sólo por detrás de C, C++ y ATS, sacando bastante ventaja a otros lenguajes como C# y barriendo literalmente a los lenguajes dinámicos como Ruby, Python o PHP. Java resulta ser unas 80 veces más rápido que PHP.

Aca la url con la info: http://codigocomestible.com/2010/03/29/java-es-lento

Leanlo es interesante.
« Última modificación: 25 Enero 2015, 15:16 pm por Nac-ho » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
recorrido de una matriz de forma recursiva
Programación General
dark_headhunter 4 16,979 Último mensaje 10 Junio 2011, 23:39 pm
por Khronos14
Recorrido de una Matriz
Java
Fabi0lo 3 3,889 Último mensaje 26 Octubre 2011, 00:46 am
por s00rk
Caballo Ajedrez JAVA
Ejercicios
Kacoae 1 5,361 Último mensaje 17 Mayo 2013, 06:41 am
por Kacoae
Caballo del Ajedrez en JAVA
Ejercicios
Kacoae 2 17,433 Último mensaje 24 Febrero 2014, 14:47 pm
por gordo23
problema recorrido de arreglo
Programación C/C++
marchiali 0 1,257 Último mensaje 24 Julio 2014, 21:34 pm
por marchiali
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines