Mostrando entradas con la etiqueta Eclipse. Mostrar todas las entradas
Mostrando entradas con la etiqueta Eclipse. Mostrar todas las entradas

jueves, 24 de julio de 2014

La tournée de un caballo por esos tableros de Dios -- en Java -- . (Knight's tour in Java language, y II)


Dejé la anterior entrada colgada hace ya un año y medio, faltando algunas cosas que, si bien no eran importantes para la interpretación de la resolución, lo eran para presentar el programa para su uso.

     Quisiera dar una excusa del tipo: “Un nutrido grupo de bellezas eslavas – que jamás tal llegara a imaginar el maestro Bécquer – me ha tenido secuestrado y me han usado para satisfacer sus más oscuros deseos y perversiones”. Ojalá.

Eslava anime
Clotilde , eslava anime que, aún insiste en hacer de Calipso


Al fondo , a la derecha
Al fondo, a la derecha
    Pero, dado que el tiempo es cruel para todos, nos conformaremos con un: “La vida es caprichosa , y hago lo imposible por sobrevivir en este infierno" -harto español- .

        Y , citando este chiste de un amigo mío, por “infierno español” se ha de entender aquella demoníaca tarea de pintar de mierda unas paredes en un sitio tal que: cuando hay mierda, no hay cubo; cuando hay cubo, no hay mierda; y, cuando hay cubo y mierda no hay brochas para pintar. 

 
      A buen entendedor , con pocas palabras bastan y quien no, quédese con que, la razón de ésta es  que no encontraba los aseos.


 
  1.       Voy a presentar en imágenes cómo probar en Eclipse el programa de la anterior entrada, el del salto del caballo. Es decir, cómo invocar con parámetros desde Eclipse.
  2.      Después, os presentaré en imágenes cómo generar el archivo .jar ejecutable desde Eclipse y cómo invocarlo sin Eclipse.
  3.      Luego, os colgaré el programa – versionado mínimamente, para que quede clara la autoría – en mi cuenta de Mediafire, para que lo descarguéis y, os haré un par de observaciones.
  4.      Tras ello, cerraré la entrada hablando del potencial de este programa – No quiero entrar en futuras versiones pero, sí, mencionar todo el potencial--.
  5.       Recordaré el apartado de comentarios y correo para dudas y retroalimentación técnica.


    Ya apagado el PC, intentaré fustigarme para, aunque sea 30 minutos  diarios, ir plasmando y publicando todo lo acontecido estos casi 18 meses relativo a informática --  que ha sido "mucho muchísimo" y variado --.



gitana rastro
Google: Rastro gitana. marketing del bueno





¿Sí? 
Pues;  “Amos nenaaaaaa, que me lo quitan de las manos”.

Empecemos.
 



¿Cómo invocar con parámetros desde Eclipse?




En este apartado las fotos lo dicen todo
 
Salto caballo Eclipse ejecuccion con parametros 1
Salto caballo Invocar con parámetros Eclipse paso 2

INvocación parametros eclipse , salto caballo , paso 3Recordar nuestros parámetros
-n numero para casillas por lado de tablero cuadrado
-x numero -y numero para posición de la salida del caballo en el tablero
-t para indicar que quiero traza
-a para indicar quiero todas las soluciones para el tablero y posición.

Una vez hemos escrito los parámetros en "Program Arguments" y le hemos dado a "Aplicar", le damos a "Run". 



Invocar con parametros, Eclipse, salto caballo, paso 4
Si acercamos, tras ello , el cursor al botón rápido de ejecución, veremos un contextual que nos indica si se está ejecutando o no.

Y, si abrimos el archivo generado, cuando finalice su ejecución veremos que está correcto.





¿Dónde está ese archivo? 

      El programa no crea ruta nueva, así que, los archivos resultado de la invocación
¿Dónde me genera el archivo resultado, Eclipse?
Resultados invocacion Eclipselos genera en la carpeta del proyecto. En mi caso,  creé por defecto en Workspace cuando lo empecé.







Archivo resultado invocacion parametros eclipse

Con esto queda resuelto , cómo invocar con parámetros en Eclipse.


¿Cómo generar el archivo .jar ejecutable con Eclipse del proyecto?


Este proyecto no es muy complejo. Los pasos son los siguientes:
Crear archivo jar ejecutable, Eclipse, step 1



Primero: en Archivo -->  Exportar





Crear jar ejecutable, Eclipse , Knight's tour , step 2


      Ahora, en la nueva ventana , seleccionamos con doble clic "Runnable JAR file" y , tras ello, le damos a "Next".




La siguiente fase no es baladí. 
Elegimos en "Launch configuration" , nuestro proyecto.
"Export destine" servirá para dar nombre y ruta dónde dejará Eclipse el jar una vez creado.
"Library handling" , como véis,  lo tengo en "Extract required libraries..."  Así Eclipse se encarga de crear el archivo .jar  con "todo, todo, todito" lo necesario, a falta de un intérprete en una máquina, para ser ejecutado.

Damos Finish.

Quizás, el tema de nombrar el jar no haya quedado claro. Explico:

Si el directorio dónde le hemos dicho envie el .jar a Eclipse no alberga .jar alguno, nos aparece esta ventana para darle el nombre que queramos al jar que Eclipse creará.
Recordad que, el nombre del jar que se va a crear no tiene porque ser el mismo que el de la clase que lleva el Main.  
Ese miedo y precaución de principiante, como véis, está de más. Mi clase con Main es saltocaballo.class sin embargo como veis el jar lo llamo: saltocaballov1s1.
Ya que, a la publicación de la anterior entrada un correo demandando veladamente "un copia pega"   me ha hecho modificar ligeramente el código con una "morcilla" a modo de nombre y tiempo en cada resultado.

¿Cómo invocar el programa, un vez creado el .jar ejecutable?




Desde Ubuntu , basta con:
1.- Abrir un terminal (Ctrl+Alt+T)
 2.- Posicionarse en el directorio del .jar
3.- Invocarlo como expliqué en la anterior entrada y usad los parámetros que más os activen el gusanillo.

Desde Windows... Pues, no os lo vais a creer pero .... hace ya un año y medio que no toco Java con Windows y , desde entonces, con Windows me las he visto sólo en unas contadas clases particulares que dí y donde no tocamos para nada java.
 Así que,  mi sentido común, propone el siguiente método y espero, si alguien encuentra algún problema, me mande un "emilio".
              1º.- Descargado el archivo , comprueba su icono es una taza de café humeante.
                         Ello indicará que Windows tiene lo necesario para interpretar el jar.
                             Si el archivo se ve con el mismo icono que un comprimido, id a la página oficial de java (java.com) y descargaros java. Actilizarlo todo lo posible.
              2º.-
    a) Para ejecutarlo con los parámetros "por defecto" programados -->  bastará hacer doble clic sobre él.
                      ¡Ojo!  La ejecución le lleva un tiempo considerable, por mucho pepino de ordenador que tengáis, como ya indiqué en la anterior entrada.
    b) Para ejecutarlo por consola y con parámetros:
              Abrid  la consola "CMD" , posicionaros en el directorio donde hayáis puesto  mi .jar
                 Ahora ya lo podéis invocar según el patrón de la foto para Ubuntu.


¿Dónde descargarlo?  Observaciones





Conviene observar siempre que:
En absoluto conviene pedir traza --  máxime cuando pedimos una búsqueda exhaustiva de soluciones. Esto puede generar archivos de texto plano de unos 80 MB , casi como mínimo. Hablamos de unos 12000000 de líneas--. 
 Ahora bien, si queréis presumir de "ordenador potente"  y darme en los morricos de pitiminí: Os recomiendo empecéis con una tupla de parámetros  -n 6 -x 2 -y 2 -t 
Esta invocación generará un archivo reciote de unos 96 MB. A ver si podéis presumir de PC potente,  y abrirlo :)
Lo dicho, haced invocaciones buscando una única solución.
 Si el equipo responde rápido: Allá valientes surquen mar en Lepanto que, el límite lo pondréis vosotros.

La traza resulta un lastre inútil
Tranquilo Brutus,  "everybody" alucinará con tu Pegaso.
         Quisiera hacer una segunda observación. Necesaria ,al haber recibido  ya,   un correo de un internauta diciendo que " cuando invoca su . jar creado en eclipse, le sale en consola muchos errores y que no encuentra el no se qué".

       Estimado internauta: Siento aguarle su libre albedrío. La forma de crear el jar desde Eclipse es como ya le indiqué en esta misma entrada --en el apartado correspondiente--. 
       Me reconozco, como Virgo , algo "muy" pinchauvas. También, cándidamente, le concedo a la gente una capacidad de lectura y comprensión grave. Por ello sazono las entradas con comentarios y fotos jocosas a modo de "distracción".
       Pero, lo que escribo más allá de bromas o estilos, tiene su porqué. 
       El problema --veo por internet es bastante común-- , probablemente se debe a que cuando crea el .jar en Eclipse no selecciona su proyecto  en el apartado  Launch Configration. 
       Esto hace que  el Manifest.MF no se cree correctamente y produzca los errores que me menciona en su correo.
        Mi consejo es que me lea con detenimiento. 

       Como indiqué en el subtitulo "¿Cómo creo el archivo .jar ejecutable?", la ventana al seleccionar "Runneable JAR File" no es baladí.  
       Preste atención a cumplimentarla correctamente. 
      Si no, la  opción "ahora me cabreo y lo hago a mano" es coger los archivos .java y compilarlos con javac sin eclipse; tra ello, con los class generados, hacer el Manifest.MF "a pedal".
      Pero, entonces la pregunta será ¿Para qué ha instalado Eclipse?  
     Gracias, muchas,  por su lectura de mi blog y los elogios. Siga leyéndome y preguntando cuantas dudas le surjan. 
     

¿Qué potencial tiene esto?  

  
Yo sí tengo potencial, nena
      



        El potencial de este programa es increíble. Hablamos  sin salirnos del tablero de ajedrez, resolver posiciones buscando mates. 
Bastaría con crear para cada ficha describiendo sus movimientos. Dotar un mecánica mínima para "comer" y establecer movimientos de "a uno" por bandos. 
La busqueda en profundidad con vuelta atrás  o Backtracking , es lo que tiene.









De salidas


Solución a la crisis española
    Bueno, no era prudente estar más de una hora haciendo esto y al final han sido casi cuatro. Pero, por lo menos, hoy ya, queda liquidado.
    Intentaré mañana empezar a elaborar   sobre otra cosa hecha estos meses y subirla cuanto antes.

    Por desgracia , no voy a sazonar la salida con una tía/tío o similar que quite el hipo.
    Aunque intento, desde mi mala leche, sonreír y hacer chispa, la realidad de este país me supera.
    Así que, hoy, en honor de todos aquellos políticos , representantes sindicales y organizaciones sin ánimo de lucro onanistas a costa de lo ajeno , así como todos aquellos españoles que pisan el mismo suelo que yo pretendiendo sacarme a mi de él les regalo esta  foto.
 Como ven la fémina tiene una delantera que te deja sin respiración. Es toda suya, ¡Disfrútenla, se la han ganado a pulso! Aún la estoy pagando , pero si se van con ella a otro lado y con viento fresco, la inversión habrá valido la pena.


Dudas técnicas y comentarios, ya sabéis , bienvenidos.
Un saludo y
SED BUENOS!
 




   
  

viernes, 26 de abril de 2013

La tournée de un caballo por esos tableros de Dios -- en Java -- . (Tour Knight in Java language)



Cómo sobrevivir sin un duro
Algo cuco para no dejar el árbol en los huesos

Comienzos de Diciembre de 2012, me surgió un apañillo.
Un estudiante de ingenería informática en la UNED se vió sorprendido por una de sus asignaturas – en concreto la asignatura más avanzada de programación como tal – “Programación III”, obligada para Ingenierías técnicas informáticas – sistemas y gestión –, como para la Ingeniería superior informática.
 Me pidió, le echara una mano.



Contexto sobre la asignatura “Programación III”


Lo que a continuación detallo es tan real como venenoso. Sufrido en carnes, incluso.
       Al tratarse de algo muy español y muy propio de nuestro sistema y país, no lo voy a traducir   --Dejo a visitantes foranos la opción de traducción por "DIY"--.
       Es más, para no desvirtualizar el contenido de la entrada en sí, voy a empezar a usar botones de expandir.





En el curso academico 2005/2006 también me pasó a mi. Entonces, valía 6 créditos – era el plan anguo del 2000 – . Cada curso tenía dos cuatrimestres. Esta se cursaba en el 2º curso, 1er cuatrimestre.

La consecución exitosa de la asignatura



Desde el año que me intenté enfrentar a ella (por primera y última vez) hasta este año académico – a la vista de lo que la otra parte del acuerdo me demandó –, no ha variado nada.
Consiste en que – si el curso se puede empezar entre el 1 de Octubre y el 1 de Noviembre de un año académico – , a mediados de Febrero, más tardar, te examinaban de “si posees el dominio suficiente para algoritmizar problemas computacionales de la vida real” en concordancia con la teoría de el libro Fundamentos de Algoritmia [G. Brassad y P.Bratley] Ed. Pearson Prentice Hall.
En concreto el examen consistía en resolver, en menos de 120 mínutos, un problema de programación algorítmica por la rama – Algoritmos “Voraces”, “Divide y vencerás” o “Exploración de grafos” – que mejor se adecuase – con justificación y análisis de costes computacionales – .

La práctica obligatoria aprobada es requisito previo para examinarse.



Hay un problema añadido y no es, en absoluto, baladí.
Para realizar dicho examen en la asignatura, previamente, tienes que tener aprobada una práctica – supuestamente de similares características al examen pero, además, te piden implementar la solución en Java –.
Práctica cuyo enunciado – varía de año en año – , los profesores títulares de la asignatura dan al alumnado a finales de Noviembre.

¿Cuándo dices Java dices un lenguaje de programación que permita seguir un filosofía de POO (Programación orientada a objetos) como C++ o cualquier otro?
No. Cuando digo Java, digo Java.

Por fortuna, en el enunciado de la práctica, el IDE a utilizar para construir el ejecutable es una recomendación pero, el lenguaje en el que ha de materializarse la implementación, es una Conditio sine qua non

Si no sabes Java, ¿Estás vendido?
Lamentablemente, así es.


¿Y el profesor no te enseña eso?



Normalmente, en los centros asociados, se contrata – a partir de Noviembre – a un profesor para impartir un día a la semana 2 horas de los contenidos del libro referencial de dicha asignatura.
El profesor te dice que, enseñarte Java es imposible. No hay tiempo material.
Teacher
O una cosa o la otra. No hay tiempo para las dos. Me han contratado para los contenidos. Lamentablemente “os tenéis que buscar la vida
Vamos que, a no ser que hayas hecho una FPIII por ejemplo A.S.I. –donde el 2º año y durante 5 meses a hora diaria te formaban en Java – , estás vendido.
No te están pidiendo, en el problema práctico, un pseudocódigo. Lo que te piden entre otras cosas es el jar y probablemente con parámetros de entrada que solucione el problema.


¿Entonces?




Luego, en el caso de una persona sin malicia que, ese cuatimestre curse al menos dos asignaturas de las 12 que consta dicho año, tirará, éste , el dinero de la matrícula y el libro (ninguno de los dos son baratos); habrá jodido su expediente y, probablemente, se habrá dejado algo más de dinero apuntándose a un curso de iniciación de Java de un mes... Eso “a lo legal way”.
Lo sufrí.

¿Y la opción Septiembre?



La opción "Septiembre" pasa porque, en el verano, el tutor del centro asociado al que te matriculaste – Ese que fue contratado hasta la última semana de Enero para impartirte en unas 20 horas el contenido de 320 páginas de teoría pura y dura y además dar el visto bueno inicial a tu práctica –, trabaje sin ser remunerado.
Quiero decir que, en vez de piscinear sus chancletas, se dedique a pasar calor en su cuarto de casa para dar el visto bueno inicial a tus códigos fuentes y contacte con Madrid a decirselo -- Suponiendo que en Madrid también les guste trabajar en veranito -- .
Todos --y todo-- de forma altruista, atendiendo tu “no-capacidad para hacerlo en el plazo en que su trabajo es remunerado”...
Así que, la “opción de Septiembre” la reescribo como “la casualidad de que des con un mercenario altruista de la enseñanaza”.
Recuerdo que en la cultura Española a Quijote lo querían recluir por loco y a Jesucristo nos lo cargamos.
Además, esta – !Y remuneradamente! – , es la España del: “Mariquita el último”, el “A ver si voy a ser yo el único tonto de trabajar, cuando los demás están de cervecitas” o el “primero, hazlo tú; luego ya, si eso, yo”.
Así que de forma gratis no es que sea graciable. Es un milagro.

¿Entonces?



Todo queda reducido pués, para alguien que nunca ha programado en un lenguaje POO como Java y que se presupone sabe lo que es un TDA (Tipo de Dato Abstracto) -- e implementarlo en Modula-2-- y también se le presuponen nociones de formulación matemática de recursividades, a opciones no tan legales.
Éstas pasan por: desde tener un "amigo" que te “ayude” con alguna "indicación" y "corrección", hasta contratar un tutor particular que te haga la práctica -- "OR/AND" explique --.
Estando la opción tabién de buscarla por internet y copiarla – Si no te pillan, te la juegas al examen (que es por lo que en teoría has pagado) –.
Evidentemente, el tutor da el visto bueno inicial a la solución. Por tanto, "copy&paste" -- sin leer detenidamente ,entender y corroborar -- , a la hora de defender el trabajo, revelará la ausencia de esté.
Cualquier opción es práctica cuando el tutor de apoyo contratado por el centro te dice que es your business y que él aún no sabe como componerselas para explicar en 20 horas --o menos--, 320 páginas de chicha tan apretada.
Gracias a ello, me ví requerido a este apañillo -- a cambio de unas t-shirts para correr por las mañanas-- que en esta entrada os relataré.



La práctica 2012/2013:

          .jar para KNIGHT's TOUR o el problema del caballo, básicamente.


  Aquí está la práctica a realizar:

   Como se ve en el pdf , de forma resumida, piden un jar (Archivo java ejecutable) que se pueda invocar basándose en 4 propiedades distintas:
  •  Lado del tablero
  •  Posición inicial de salida del caballo
  •  El programa se ejecuta hasta alcanzar una solución o hasta hallar todas las existentes para la posición de partida 
  •  Dame la traza de cada movimiento



     Queremos pués que, un caballo de ajedrez haga caminos hamiltonianos (pase una y sólo una vez por cada casilla) en un tablero cuadrado y siempre que, su lado sea mayor o igual que 5.

A trotar por el tablero
Noria, carrusel y ahora tablero. No podían elegir al cocodrilo, no.
  El programa admitirá que demos longitud al lado del tablero.
  También permitirá que establezcamos una posicion incial (x,y) para el caballo.    Obligada la casilla inferior izquierda como 0,0.
   Permitirá la opción de detenerse cuando encuentre un camino o de mostrar todos los posibles.
 Permitirá la opción de mostrar la traza a cada  “intento de moviento“ o no.

Por defecto, si no añadimos ningún parámetro el programa entiende que:
-El tablero es 8*8
- La posición inicial de caballo es la casilla situada en el vertice inferior izquierdo (en un tablero visual). La llameremos casilla 1 y la podríamos etiquetar como a un par ordenado (x,y) correspondiente (0,0).
- El programa se detendrá al encontrar un camino y lo mostrará.
- No hay traza.


Observaciones al enunciado de la práctica



Precisemos para evitar disgustos
Google: Odiseo Troya

Efectivamente, observaciones y objeciones.
 Quien haya leído el enunciado y guía exigida del pdf , teniendo algo de sentido común, habrá observado dos condiciónes que, por absurdas, dañan la vista.
Quien sepa construir programas en Java, quizás piense como yo, 3. 
Digo 3 por cómo exigen invocar el jar. "A gusto se quedo, la madre que los parió". (En los comentarios podemos discutir esto).

Así que, antes de que se nos desboque nuestro Rocinante o nos amargue la fiesta Odiseo, con el fin de no extenderme demasiado, voy aprecisar:



Por un lado, no voy a hacer ni puñetero caso a la exigencia "fichero jar que muestre en consola traza", cuando están pidiendo , también y previamente, ficheros de salida.


¿El motivo? En mi opinión, ya han emperifollado demasiado el programa con la forma de invocación de parámetros.
 Crear otro parámetro, más, para decir si se quiere la salida por consola o por fichero – Recuerdo: no te han dado ni una sola hora de implementación en Java – me parece que es tocar mucho los cojones al personal.
 Esa la opción del parámetro.
La otra solución sería, hacer un programa y luego borrar partes...
Para quien no sepa programar, es como si alguien te dice "Anda, cávate una piscina. Al lado, cávate otra igual. Una vez cavada la segunda , la llenas de agua y le sacas un par de fotos; tras ello, la vacías y cubres de nuevo el agujero;  por último,  me enseñas las fotos y me llenas la primera de agua que, me bañaré". (Mola esta españa tan cañí, ¿Qué no?)

El día que, en el Senado, les de por preguntar a la UNED sobre esto, a más de un "teacher" de Madrid me gustaría verlo responder jugándose el sueldo la carrera y el prestigio. Pero vamos, esto es "Es-paña" y tengo mis dudas de si, en algún siglo, ocurrirá.
Así que, el programa que os colgaré --con su código fuente-- procedera, en su invocación, a dar salida por ficheros.



Leevas trazas de peirme traza... Por otro lado, a mi entender y dado que piden: análisis, diseño, fuentes y ejecutable,es absurdo en ejecución dibujar cada ensayo --e incluso es absurdo dibujar el tablero ensayo si este es factible, puesto que cada tablero solución final muestra una colección de pasos válidos--.
Esto de la traza, para cualquier intento –resulte conduzca a solución o no -- , es lo que durante las dos asignaturas anteriores de programación se ha vilipendiado. Insistiendo en que, una programación diseñada formalmente tiene completamente controlado lo que ocurre en cada iteración de los bucles programados y el uso de trazas desprestigia al programador.
Así que, a mi modo de ver, la petición de la traza es una tonteria , máxime cuando , repito , cada tablero solución debe que contener el acceso a sus casillas secuenciado.
No veo justificada la petición. Dibujar, a cada intento de salto, un tablero sí que ralentiza algo el programa.
Un caballo siempre tiene 8 movimiento posibles pero, imaginaros en tablero de 100 casillas de lado (10000 casillas en total), andar dibujando a cada salto que se computa 10000 casillas......
Es mi objeción. En este caso, quien aportó las camisetas le pareció que era contravenir demasiado el enuncaido. No me dejó. Por tanto, el programa, sí que dibujará --en modo traza-- un tablero en el archivo por cada movimiento que compute. Amén que, cada tablero, siempre portará la secuencia de sus pasos en las casillas.



Aprovechando la segunda objeción, quiero hacer una observación: el programa lo empecé a implentar con mi Ubuntu. Algunos días de implementación – coincidiendo con festividades Navideñas – lo continué implementando en Windows, concluí la implementación de nuevo en mi casa con mi Ubuntu.
Todos pinzas de madera pero, cada uno las suyas El par de días que lo fuí probando en Windows observé que los ficheros .txt solución generados en mi Ubuntu no se visualizaban correctamente con el Notepad de windows. La visualización era perfecta usando Wordpad.
Quizás este problema se deba a algo que no sabía: cuando se genera un fichero de texto en Ubuntu existen 3 formas de guardarlo y por defecto emplea una tal que los saltos de linea no son interpetables en Windows.
Así que, si usáis Windows para ver los ficheros solución, recordad: Notepad no, Worpad sí.




La última observación antes de empezar:
No confundir con Crepúsculo.... Joer con la LOGSE    Indican en la guía que, el equipo docente recomienda BlueJ como entorno de desarrollo. 
  Yo no he seguido esta recomendación.
 He utilizado el IDE Eclipse en las versiones Indigo para Ubuntu y Juno  para Windows.
  En comentarios, si hay dudas, aclararé como ejecutar con parámetros. Así como problemas  y soluciones al migrar proyectos entre estas versiones desde “pepinos Quores” hasta equipos más humildes como el mío.





Se acabó tanta chachara. Empezamos la chicha.


 ANÁLISIS: elección de algoritmo y costes.



No se ajusta , no se ajustaNo hay criterio de selección de candidatos dentro de las n2 casillas y una ruta sin solución hará que "algoritmo vóraz" finalice. Ergo, planteamiento bajo la directriz de algoritmos voraces descartado.

no hay tiempo 
En esta primera versión , debido a premuras de tiempo, no tomaremos los estudios matemáticos formales ya realizados sobre este problema desde hace unos siglos. Luego, no iremos por la linea de algoritmos "divide y vencerás". Línea que sí podríamos seguir en otras versiones posteriores.


Hablamos de un caballo que parte de una posicion en el tablero (“estado”) y puede
quien mejor
--en caso mejor – saltar a 8 casillas (“nuevos estados”). Parece pues que se ajusta bastante bien a la idea de grafo y árbol. El grado de ramificación en hijos es de 8.
Hablamos, pues, de un algoritmo de exploración de grafos que vaya generando tableros y que nos permita la vuelta atrás si no agotamos los n2 nodos pero si las casillas posibles para un nuevo tablero desde una posición.


   Estudio de costes:

 

Supongamos que, queremos rellenar las n2 casillas del tablero con números entre 1 y n2 (sin repetir) con independencia de las reglas del movimiento de caballo. Las maneras posibles serían (n2)! . Sí , el factorial del cuadrado de n.


Al saber el número de ramificaciones podemos acotar el tamaño del arbol a una mantisa de 8 y un exponente de n2 . Es más, podemos incluso precisar que, no siempre son 8 las ramificaciones posibles pues en ciertas casillas este número merma -- por su ubicación -- y conforme vamos llenando el tablero disminuyen las alternativas.


Tirando de los conocimientos de fundamentos de Inteligencia Artificial en búsqueda y exploración de grafos usaré un algoritmo de busqueda en profundidad con retroceso cronológico.
Por supuesto que, se podría emplear heurística. Reduciendo todavía más las cotas pero como he dicho para desechar divide y vencerás vamos a “no – documentarnos “ y dejarlo para sucesivas versiones.
Concluyo pues que, con este algoritmo y sin heurística alguna, podemos hablar de una cota superior en complejidad temporal de θ (8 n*n )   y de una cota espacial de     θ (n2).





DISEÑO



              
He diseñado el módulo en 4 clases: 'saltocaballo', 'Tablero', 'Secretario' y 'Exploradora'.
 No sé hasta que punto es conveniente mostrar el esquema de cada clase, puesto que aquí ya hay detalles que pertencen al campo de la implementación. Pero, por si a alguien le sirve para tomar confianza, aquí van.


La clase 'Secretario' se encarga de pasar los tableros a ficheros. Podría, inicialmente, considerarse innecesaria como clase y suplirla por un método dentro de la clase Exploradora. Podría. Sin embargo, me ha parecido más claro establecerla como clase e instanciarla en una 'topisto' (elegante telefonista) por si, para futuras versiones, se le requirieran más cosas.

La clase 'saltocaballo' es la clase que lleva el main y gestiona la parametrización de la invocación y computa el problema pidendo, se guarden los resultados de la prueba en un fichero indentificable de acceso secuencial. 






  La clase 'Tablero' intancia tableros. Cada tablero instanciado contiene una secuencia de pasos por sus casillas siendo estas ordenadas. También, entre sus atributos, tiene el de “en que jugada me hallo” y otro atributo que nos permita la vuelta atrás cronológica. La he dotado de un método que nos devuelve un boleano si una posición (x,y) está o no dentro del tablero y adremás es usable. Tiene un contructor para el tablero inicial.


 

La clase 'Exploradora' es la más compleja.
 Hace instancias de 'Tablero' y genera saltos de caballo.
 A la hora de explorar el método trabajará con tipo de datos dinámico, 3.
 Uno lo uso para almacenar las soluciones que vaya encontrando en la invocación. Otro me sirve de rastro o huella y el tercero lo uso para comprobar si he llegado a la solución y si no generar hijo factible. Al generar hijo factible el padre pasa a la “pila” de rastro de mi exploración. Si no llego a solución cada vez que no hay paso factible el método toma la cima de rastro y busca el siguiente salto en la cronología.




Una clase de exploradora
Tablero por defecto
Si las imagines anteriores han servido para perderos, no preocuparse.
 Pongo un par, por ejemplo, de la clase exploradora y otra de la clase tablero y nos vamos a la implementación que es donde de verdad se destapa toda la chicha  y hay que leer y comentar detenidamente. ;-)











IMPLEMENTACIÓN

Voy con los fuentes de menor a mayor complejidad:


Source secretario class





Source Tablero class




Sí, implemento la clase tablero como "serializable". El motivo es que la hora de "explorar" un tablero dado en busca de la solución  voy creando  clones y modificándolos respecto al tablero que examino.


La clase 'saltocaballo'  la paso a odt y os la pego en dos fotos :



Foto 1 de 2


Foto 2 de 2












El último fuente es la clase "Exploradora" que instancio en salto caballo como 'dora'.
Expongo el archivo .java en él, como veis, bastantes métodos son auxiliares:










Foto Exploradora.java 1 de 7


Foto Exploradora.java 2 de 7


Foto de Exploradora.java 3 de 7


Foto de Exploradora.java 4 de 7


Foto de Exploradora.java 5 de 7


Foto de Exploradora.java 6 de 7

Foto Exploradora.java 7 de 7







PROBAR EN ECLIPSE Y HACER EL .JAR




   Con estos 4 fuentes ya todo se reduce a probarlo una vez en el entorno eclipse y construir el programa ejecutable saltocaballo.jar

Ese que, creo yo y no como dice la guía,  debería de invocarse como:
             $> java jar saltocaballo.jar
Y, si se quiere, darle parámetros de entrada.





Entregar el programa y ...
 !A probar las camisetas! ;-)





 No quiero alagar a entrada mucho más. De por sí es técnica y larga.
 Os subiré un enlace para que os descarguéis el .jar y hagáis vuestras probatinas.

 Recordad el coste temporal. Da igual que tengáis un "pepino" de equipo  con tropecientos "quad cores". Como le pongáis lados de tablero por encima de 20,  lo mismo disminuye el paro en España del 25 %  y aún no tenéis solución... !Nah!
    Sí que os agradecería si me haceis llegar los costes de los ficheros con busqueda exhaustiva que por probatinas genereís. Así me daré cuenta de cuanto de desfasado tengo el hardware de mi equipo. (lo ideal sería me mandeis el nombre del fichero generado , procesador de vuestro equipo , memoria ram, sistema operativo y tiempo que ha tardado en generarse el fichero una vez invocado el .jar ;-)


    Respecto a algunas dudas que ya me han ido llegado por correo,  daré mi opinión o cómo lo hice en comentarios.
 !En cuánto tenga algo de tiempo!
Mientras ya sabéis, salida 3,2,1...


SED BUENOS!