style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

¡Necesito de sus ayuda!

Que tal! soy nuevo usuario, espero aprender de ustedes y apoyar si es posible. Llevo ya mucho tiempo (me da pena decirlo, pero si es necesario lo dire) arrastranto este programita sin llegar a tener algo funcional, o si pero muy básico. En estos ultimos dias e definido el problema a resolver de una manera más clara (ya que solo lo tenia en mente). Espero alguíen se anime a por lo menos saber que he hecho y me de su opinion.

Planteamiento del problema a resolver

El procedimiento actual de asignación de horarios se realiza semestralmente en base a las demanda de cursos o materias por parte de los estudiantes de acuerdo a la carrera en que estén inscritos éstos. Después cada profesor le es levantado un horario en que indica su disponibilidad para impartir clases. Todas las aulas de clases tienen las mismas características, así que los cursos son asignados en cualquier espacio disponible. Para esta tarea se emplean entre una y tres personas durante varios días en la asignación de estos recursos académicos, apoyándose de una hoja de cálculo de Excel.

El problema que se pretende resolver tiene la particularidad de no tener establecido alguna asignación, más que datos en su estado natural. En este presente trabajo se pretende resolver tres variantes del problema de asignación de horarios; asignaciones de profesores a cursos, de horarios de clases a cursos o materias, de aulas a cursos........

Este problema lo estoy intentando resolver empleando Algoritmos Geneticos. Donde se asignaran profesores a materias, y horarios a materias y que cumplan ciertas restricciones.

Problemas que he tenido según yo

  • He tenido confusion de conceptos sobre el problema, una de las causas por las que no he podido definir claramente el problema a resolver.
  • Desde un principio me he metido directamente al código sin ver el problema global. Conforme escribía código, este crecia y ya ni sabia como integrar o ir añadiendo lo demás código para continuar avanzando y que funcionara. He intentado hacer diagramas UML pero sigo sin lograrlo.
  • He acumulado mucho código con puras modificaciones pero sin mucho avanze, lo que he hecho es cambiar nombres de metodos, escribir y borrar clases o que una clase la cambio por un atributo o viceversa, o si el concepto del que me base para crear la clase no esta claro y vuelta para atras todo el código.
  • ...
  • De una vez les confieso que de Java conozco poco muy poco, he aprendido sobre la marcha. En estos dias me tope con esto http://www.javamexico.org/blogs/oscarryz/aportacion_java_mexico_pcj_como...
    http://www.javamexico.org/foros/comunidad/consejos_desarrollo_de_un_proy...

    lo que me motivo a escribir mi problema ya que vi que hay gente dispuesta ha ayudar, espero que alguien se anime.

    ayuda..

    Ahora lo que quisiera saber es si lo que llevo esta bien, el código, si el análisis que hice esta bien, las clases, mis metodos, atributos. Me gustaria escuchar desde su experiencia los errores que han podido detectar con lo que he descrito. Tengo intención de aquí todo el código que llevo (lo ando modificando de nuevo) y me den su opinion y ya no seguir cometiendo los mismo errores, lo que no sé es si es lo más adecuado. Es seguro que mi pregunta es poco especifica como debe ser, pero espero se vaya definiendo con su ayuda. Les adjunto un archivo de como en estos momentos lo voy a dejar la parte del Algoritmo Genético, estoy tratando de aplicar eso de los 4 pasos, pero noto que me falta mucho, pues no conozco las sintaxis para hacerlo. Ahora que lo pienso es seguro que necesito definir claramente el problema que incluye los conceptos que me serviran para definir mis clases. Siendo sincero de una vez le digo que ando frustrado por este problemita que no he podido abandonar de una vez por todas ya quiero superarlo.

    saludos!!

    AdjuntoTamaño
    diagrama-de-clases.png15.99 KB

    Opciones de visualización de comentarios

    Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
    Imagen de Marce

    algo de ayuda

    Bien @martinillo lo que yo entiendo de tu problema es que en sí no tuviste la curiosidad de investigar un poquito antes de empezar y creo que eso sería lo primero que podrías corregir. La abstracción de cada problema a solucionar es muy particular de cada persona hay quienes son muy buenos para abstraer problemas y separan muy bien sus capas de lógica de negocio, de persistencia y aplicación que es yo creo que lo que tendrás que hacer con tu proyecto. En primera no sé si tu proyecto consiste en una aplicación de escritorio o una aplicación web (por algunos comentarios que pusiste creo que es de escritorio), en este caso yo te recomendaría que si no conoces Java lo primero que hagas es leer un poco sobre POO en Java, aquí en la comunidad hay varios libros ya recomendados que podrían servirte, una vez que domines la teoría sobre POO que yo me imagino ya debes tener conocimiento sobre eso pues ya llevas tiempo con este proyecto podrías hacer tu primeros mininos e ir identificando todos los términos que aprendiste y ponerlos en práctica Clases, herencia, polimorfismo etc., vaya poner en práctica la abstracción de tu proyecto mediante POO; hacer un diagrama de clases te vendría muy bien como primer paso y una vez que definas que clases son las que van a intervenir en el proyecto buscar las relaciones entre ellas y armar todo el cascaron de tú proyecto; posterior a esto podrías hacer el diagrama E-R para la BD (todo esto en base al diagrama que subiste). Después viene la programación y no importa si no tomaste algo en cuenta, si plasmaste las clases principales será muy fácil agregar nuevas clases o nuevos atributos y propiedades.

    Creo en sí que el problema está en conocer un poco el lenguaje y el problema, si se te ha dificultado entender el problema quizá sea por que no conoces lo que el lenguaje te puede dar para resolverlo por eso creo que de primera opción es leer, leer, practicar un poco y ahora si aventarse : ) Y no te sientas mal por que haz cometido errores, podría apostar que la mayoría de los que estamos aquí hemos tenido el mismo problema y nos hemos aventurado sin saber. Otra cosa que te recomendaría es que si te interesa Java deberías ir leyendo poco a poco sobre el lenguaje y practicar un poco conforme te vayan apareciendo nuevas dudas. Bien pues espero te sirva un poco y pues aquí estamos para apoyar. Saludos!!

    Imagen de martinillo

    graciasss!, voy tomando nota

    Agradezco tu ayuda! No entendi bien lo de investigar, lo que he hecho es revisar articulos sobre la teoria de los Algoritmos Genéticos, articulos de otras personas que plantean la resolución de problemas similares (modelos y resultados) sobre el problema general de asignación de horarios, lo que no podido resolver es los fundamentos de este problema para conocerlo mejor. Dime como seria mejor, ya que hay conceptos que veo que son confusos, que uno los maneja y otro no o que no encuentro claramente sus definiciones. Por lo que he notado cada uno plantea su problema a su manera.

    Por otro lado, si he tenido problemas en la obtracción pórque siempre encuentro mal lo que avanzo y cambio la organización del codigo. En lo de las capas, si tengo esos problemas la ultima vez intente hacer una parte gráfica y no supe como organizar el código. Si se trata de una aplicación de escritorio.

    Si conozco esos conceptos de POO, ando leyendo un libro el de Piensa en Java (he encontrado muchos errores de traducción :( ), pero he asimilado poco. Voy ha hacer lo que dices:

  • Leer conceptos sobre POO y despúes aplicarlo en la abstracción de mi problema.
  • Hacer diagrama de clases, establecer relaciones. ¿No entiendo bien lo de cascarón del proyecto? ¿Qué otras cosas formarían parte del cascarón del proyecto?
  • hacer diagrama E-R para la BD. Supongo que es para guardar los datos de entrada con los que voy a trabajar, seria bueno aunque en un principio los estaba implementando con XML.
  • Programar en base al diagrama de clases.
  • Bueno espero haber entendido la solución que me planteastes. Efectivamente hay cosas que no le entiendo al lenguaje Java, me esta costando aprenderlo. Eso me da esperanzas de que también puedo aprender. Gracias por tus valisos consejos. Por ahora trabajare con lo que me has dicho, ya comentaré como voy. Lo que no sé es cómo saber si voy bien, creo que volvere al foro con un nuevo tema los más seguro y espero me puedan ayudar. Gracias por el apoyo.

    Saludos!

    Estaba respondiendote

    Pero mi respuesta se fue alargando tanto que decidí mejor hacer una entrada en el blog: http://bit.ly/AlCodigoEn4PasosConIteraciones Considerarla como mi respuesta.

    Básicamente lo que noto es que te hace falta un proceso de desarrollo un tanto más formal. En ese post, sin pretender ser una definición estricta del proceso de desarrollo de software, describo como puedes aplicar los 4 pasos para pasar del problema el código de una forma iterativa e incremental.

    Es difícil saber si lo que llevas está bien, por que ... erhm.. pues no sabemos que es lo que llevas. Tampoco dices mucha información ( como bien apunta Marce ) sobre que tipo de aplicación necesitas, si es para un desarrollo profesional, si estás aprendiendo etc.

    Sobre los algoritmos genéticos, no conozco mucho, pues son una forma especializada, pero definitivamente será más difícil completar algo avanzado si aún no se tiene algo sencillo.

    Entonces, lee esa entrada en el blog, e intenta aplicarla, espero que te sirva y te dé una idea de como puedes atacar el problema.

    A la lista de Marce yo le añadiría además de programación orientada a objetos, "análisis y diseño orientado a objetos" :) ( Lo puedes encontrar en Internet en inglés como OOA/D )

    Saludos y suerte.

    Imagen de martinillo

    Una vez más

    Graciasss!!. Ya me lei el post que publicastes, pocas personas estan dispuestas a ayudar y tienen sus razones, personas como tu hacen falta (enserio) que nos iluminen. Admito que desde un principio supe que la descripsión del problema que enfrento fue muy vaga y pues asi poco pueden ayudarme como bien comentan, pero no encontré otra manera de escribirla, pero aún asi me han ayudado a identificar mis errores y con lo que ahora me han indicado, en estos momentos ya tengo un panorama general de como llevar a cabo el desarrollo de la solución y una mayor confianza que puedo hacerlo.

    Este proyecto inicio como parte de un pedido de una materia en la Universidad (lo programe en Php, era algo realmente sencillo, pero funcionaba), después el profesor le agrado pórque prometía, asi que me sugirio mejorarlo y utilizar Java para ello, como parte de un proyecto de titulación, pero por desgracia no lo termine, como hasta hoy. Lo que ahora pretendo es terminarlo por cuenta propia como un proyecto personal y al mismo tiempo con ello aprender lo que ello implica.

    Por el código para saber que tal voy, intente preguntarles si seria buena idea subirlo aqui, lo hiba ha hacer, sé que es tonto pedirles eso, cuando tienen nada para hacerlo, una disculpa sino lo logre. Te podría enviar el código (o aquel que este interesado) que tengo para que lo revises y me des una opinión, que hace falta o los errores que cometo de acuerdo a tu experiencia. Sino es ahora puede ser después, y ya lo checas cuando tengas un rato libre. Ahora no me queda más que manos a la obra!!.

    De nuevo les agradezco enormemente por la ayuda!

    Y que hay de los algoritmos genéticos?

    Es parte de lo que quieres hacer y/o a que viene?

    Te recomiendo que lo hagas de la forma más simple que puedas para empezar y después le pongas más silbatos y campanas.

    Me parece que está haciendo falta un tutorial para hacer pantallitas en Java :P ... algún día con más calma.

    Intenta avanzar con eso y cuando tengas preguntas específicas acá te ayudamos.

    Chau!

    Imagen de luxspes

    Sugerencia: Sube el codigo... y agrega mas explicacion

    Por el código para saber que tal voy, intente preguntarles si seria buena idea subirlo aqui, lo hiba ha hacer, sé que es tonto pedirles eso, cuando tienen nada para hacerlo, una disculpa sino lo logre.

    Si, si quieres ayuda, lo mejor seria subirlo... aunque si lo subes todo asi nada mas sin explicacacion, pues tampoco vas a obtener tanta ayuda, lo ideal seria que lo subieras pero que también te aventaras una explicación un poco mas detallada de que es lo que intentas hacer cada clase

    Imagen de martinillo

    Este método

    Es parte de lo que quieres hacer y/o a que viene?

    Algoritmos Genéticos
    Son llamados así porque se inspiran en la evolución biológica y su base genético-molecular. Estos algoritmos hacen evolucionar una población de individuos sometiéndola a acciones aleatorias semejantes a las que actúan en la evolución biológica (mutaciones y recombinaciones genéticas), así como también a una Selección de acuerdo con algún criterio, en función del cual se decide cuáles son los individuos más adaptados, que sobreviven, y cuáles los menos aptos, que son descartados.

    extracto obtenido de la Wikipedia

    Una explicación muy general es que con esta técnica, lo que pretendo es hacer asignación de recursos (horarios, profesores, materias) de tal manera que se cumplan unas restricciones (por ejemplo: que no se solapen las horas de clases que tiene que impartir un mismo profesor...), todo esto a partir de la codificación de las posibles soluciones que se generan en resumén de forma aleatoria hasta encontrar uno solución aceptable determinada siguiendo un criterio.

    Si, si quieres ayuda, lo mejor seria subirlo... aunque si lo subes todo asi nada mas sin explicacacion, pues tampoco vas a obtener tanta ayuda, lo ideal seria que lo subieras pero que también te aventaras una explicación un poco mas detallada de que es lo que intentas hacer cada clase

    Si claro ahora voy a añadirle una explicación, estoy seguro que poco a poco ire aclarando mis problemas con su ayuda.

    ¡Gracias y saludos!

    Imagen de martinillo

    esta es la parte esencial

    del código, en esto es lo que ando ahora, como decia en un principio donde he tenido más problemas es en la abstracción, en la creación de clases, saber si hay coherencia en asociar y crear nuevos atributos y métodos a determinadas clases.

    Es seguro que poco me puedan ayudar con esto, por hace falta como dicen ser muy muy especifico, por eso intentaré hacer lo que anteriomente me comentaron, ya que involucran varias cosas para querer ir mejorando al código (hay que entender el planteamiento del problema como dicen claramente y la parte del AG) y me den sugerencias, o detecten mis errores. De nuevo gracias por cualquier apoyo.

    Aquí el código:

    // AsignacionHorarios.java
    package problema;
    //import algoritmo.Ag;
    import algoritmo.Gen;

    // Con esta clase pretendo contener los datos con los que trabajara el Algoritmo Genético (AG)
    // Por ahora con puras claves, ya despues serian Objetos (Profesor, Horario, Materia o GrupoMateria)
    // estos datos para el (AG) los obtendre asi:
    // getListaClavesGruposMaterias()
    // getListaClavesProfesores()
    // getListaHorariosDisponibles()
    // ...
    public class AsignacionHorarios {

            /*
             * Por ahora esto no lo estoy usando, esto es los dias y las horas de dende se pueden programar o asignar los horarios
             * y además que me serviria para visualizar los horarios.  
            String[][] listaDias = {
                      { "1", "Lunes", },
                      { "2", "Martes", },
                      { "3", "Miercoles", },
                      { "4", "Jueves", },
                      { "5", "Viernes", },
            };     
            String[][] listaHoras = {
                              { "1", "4:00-5:00", },
                              { "2", "5:00-6:00", },
                              { "3", "6:00-7:00", },
                              { "4", "7:00-8:00", },
                              { "5", "8:00-9:00", },
                              { "6", "9:00-10:00", },
                    };
            Curso[] cursos;
            Profesor[] profesores;*/

           
            // las claves de las horas y los dias posibles en que pueden ser asignados los horarios de los profesores y grupos de alumnos  
            static String[] clavesDias = { "1", "2", "3", "4", "5" };      
            static String[] clavesHoras = { "1", "2", "3", "4", "5", "6" };
           
            static int NUMEROHORASREQUERIDASMATERIA = 4;
            // grupos-materias de los que se asignaran sus respectivos profesores y horarios
            // La cadena esta constituida claveGrupoMateria = clave_materia + clave_grupo
            // Ejemplo AC1ISC6A se obtiene a partir de AC1 + ISC6A
            public static String[] clavesGruposMaterias = {
                            "AC1ISC6A", "BD1ISC7A", "ED2ISC6A", "ELBISC3A", "GFCISC6A",     "IA1ISC8A",
                            "IA2ISC9A",     "INEISC6A",     "IS2ISC9A",     "IVOISC3A",     "MCPISC8A",     "ME1ISC9A",
                            "ME2ISC9A",     "PR2ISC3A",     "PS1ISC6A",     "PS2ISC7A",     "RD1ISC7A",     "RSDISC9A",
                            "SO1ISC6A",     "SO2ISC7A",
            };
            // claves de grupos de alumnos que asisten a un mismo numero de semestre y carrera (pueden haber mas de uno con un mismo numero de semestre y carrera)
            public static String[] clavesGrupos = { "ISC6A", "ISC7A", "ISC3A", "ISC8A", "ISC9A" };
            // Ejemplo "ISC6A" significa ISC:Ingenieria en Sistemas Computaciones, 6: Sexto semestre, A: grupo A
           
            public static String[] clavesProfesores = {"6", "23", "26", "29", "46", "67", "36", "68", "71", "20" };        
           
            // Ahora estoy utilizando este arreglo bidimensional que me indica el horario disponible de c/profesor {"clave_profesor", clave_hora-clave_dia,.....}
            public static String[][] clavesHorasClavesDiasDisponibles = {
                      { "6", "2-1", "2-2", "2-3", "2-3", "2-5", "6-1", "6-2", "6-3", "6-4", "6-5" },
                      { "23", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2", "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2", "6-3", "6-4", },                 
                      { "26", "2-1", "2-2", "2-3", "2-4", "2-5", "3-1", "3-2", "3-3", "3-4", "3-5" },
                      { "29", "1-1", "1-2", "1-3", "1-4", "2-1", "2-2",     "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                      { "46", "1-1", "1-2", "1-3", "1-4", "2-1", "2-2",     "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                      { "67", "1-1", "1-2", "1-3", "1-4", "2-1", "2-2",     "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                      { "36", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", },
                      { "68", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                      { "71", "2-1", "2-2", "2-3", "2-4", "3-1", "3-2",     "3-3", "3-4", "4-1", "4-2", "4-3", "4-4", "5-1", "5-2", "5-3", "5-4", "6-1", "6-2",     "6-3", "6-4" },
                      { "20", "2-1", "2-3", "2-5", "3-1", "3-3", "3-5", "4-1", "4-3", "4-5", "5-1", "5-3", "5-5" },
            };
           
            //
            public static String[][] clavesMateriasDeseanImpartir = {
                      { "6", "RD1", "SO1", "SO2" },
                      { "23", "IA1", "IA2", "IS1", "IS2", "ME1", "ME2" },            
                      { "26", "BD1", "PS1" },                
                      { "29", "GFC", "IVO", "ED2", "ME1", "ME2", "PS2" },
                      { "46", "BD1", "ED2", "RSD" },                 
                      { "67", "BD1", "ED2", "ME1", "ME2", "RD1", "SO1" },
                      { "36", "ELB", "LEM", "MCP", "ME1", "ME2", "PR2" },
                      { "68", "INE"},
                      { "71", "INE", "IS1", "IS2" },
                      { "20", "AC1", "LEM", "PS1", "PS2" }
            };     
           
            public AsignacionHorarios(){
                   
                   
            }
            /*
             * Por ahora no he comentado las demas clases para subirlas, aparte que ando haciendo unas modificaciones
            public static void main(String[] args) {
                    // TODO Auto-generated method stub     
                   
                    Ag alg = new Ag(new AsignacionHorarios(), 50, 5, 0.8f, 0.5f);
                    alg.crearPoblacionInicial();
                    //alg.evolucionar();
                           
            }*/

           
    }

    // Gen.java
    package algoritmo;

    // Basicamente lo que hace es contener los valores de los recursos que se asignan

    public class Gen implements Cloneable {
           
            private String[] valores;
           
            public Gen(int longitudValores){               
                    this.valores = new String[longitudValores];
            }
           
            // Permite realizar una copia del Gen
            public Object clone() {
                    Object clon = null;
                    try{
                            clon = super.clone();                  
                    }
                    catch(CloneNotSupportedException e) {
                            System.err.println("Gen no cloneable");
                    }
                    for(int i = 0; i < valores.length; i++)
                            ((Gen)clon).setValor(i, new String(valores[i]));
                    return clon;
            }
           
            public void setValor(int indice, String valor){
                   
                    this.valores[indice] = valor;
            }
           
            public String getValor(int indice) {
                    return valores[indice];
            }
            // Permite extraer una parte de los valores (subarray) que contiene el Gen
            public String[] getValores(int indiceInicia, int indiceTermina) {
                    String[] subarrayStrings = new String[indiceTermina - indiceInicia];
                    for(int i = 0; i < subarrayStrings.length; i++)
                            subarrayStrings[i] = valores[indiceInicia + i];
                    return subarrayStrings;
            }
           
            public String toString() {
                    String cadena = "";
                    for(int i = 0; i < valores.length - 1; i++)
                            cadena += valores[i] + "|";
                    cadena += valores[valores.length - 1];
                    return cadena;
            }
    }

    // Cromosoma.java
    package algoritmo;

    import java.util.ArrayList;

    import problema.AsignacionHorarios;

    // Esta clase representa a un Cromosoma que esta conformado por un conjunto de Genes.
    // Lo que se puede hacer es cruzarse con otro Cromosoma para generar uno nuevo (que puede sufrir una mutación)  
    // Por default no tiene establecido el valor de su fitness (aptitud)

    public class Cromosoma implements Cloneable, Comparable<Cromosoma>{
           
           
            private float fitness;
            private Gen genes[];
           
            // Constructor que me permite crear un nuevo Cromosoma de manera aleatoria (por default)
            public Cromosoma(){
                   
                    // Lo que aqui hago es crear los genes del Cromosoma en base a cada uno de los datos de los grupos-materias
                   
                    genes = new Gen[AsignacionHorarios.clavesGruposMaterias.length];
                    for(int i = 0; i < AsignacionHorarios.clavesGruposMaterias.length; i++)                                
                            setGen(crearNuevoGen(i), i);           
                    fitness = 0; // Inicialmente no se conoce la aptitud (que tan buena solución es) del cromosoma
                   
            }
           
            // Constructor que me permite crear un nuevo Cromosoma pasandole los genes de algún otro Cromosona
            public Cromosoma(Gen[] genes){
                   
                    fitness = 0;
                    this.genes = genes;
            }
           
            // Para crear una copia del Cromosoma actual (desconocia que los objetos son manejados por referencia) 
            public Object clone(){
                   
                    Object clon = null;
                   
                    try{
                            clon = super.clone();
                    }
                    catch(CloneNotSupportedException e){
                            System.err.println("Cromosoma no cloneable");
                    }                      
                    ((Cromosoma)clon).setGenes(genes.clone());     
                    return clon;           
            }
            /**
             * Método de cruza de genes a partir de 2 cromosomas (padres) para crear un nuevo Cromosoma (descendiente)
             * @param pareja
             * @param puntoUnoCruza
             * @param puntoDosCruza
             * @return
             * (REVISAR PUNTOS DE CRUZA, CUANDO SE HACE POR DOS PUNTOS VER COHERENCIA. APLICAR PROBABILIDAD DE CRUZA)
             */

            public Cromosoma cruzar(Cromosoma pareja, int puntoUnoCruza, int puntoDosCruza){
                    Cromosoma descendiente;
                    // Comprueba que los puntos de cruza no caigan en los extremos
                    if(puntoUnoCruza > 0 && puntoUnoCruza < (this.getNumeroGenes() - 1) && puntoDosCruza > 0 && puntoDosCruza < (this.getNumeroGenes() - 1)) {
                            Gen[] genesMios = getGenes();
                            Gen[] genesPareja = pareja.getGenes();
                            Gen[] genesHijo = new Gen[pareja.getNumeroGenes()];            
                            int inicioCadena = 0, finCadena = pareja.getGenes().length;            
                            copiarGenes(genesHijo, genesMios, inicioCadena , puntoUnoCruza);               
                            copiarGenes(genesHijo, genesPareja, puntoUnoCruza, puntoDosCruza);             
                            copiarGenes(genesHijo, genesMios, puntoDosCruza, finCadena);
                            descendiente = new Cromosoma(genesHijo);
                            descendiente.mutar();
                            return descendiente;
                    }
                    // Un punto de cruza
                    else if(puntoUnoCruza > 0 && puntoUnoCruza < (this.getNumeroGenes() - 1)) {
                            return cruzar(pareja, puntoUnoCruza);
                    }
                    else if(puntoDosCruza > 0 && puntoDosCruza < (this.getNumeroGenes() - 1)) {
                            return cruzar(pareja, puntoDosCruza);
                    }
                    // No se realiza la cruza por tanto se devuelve este Cromosoma
                    return this;           
            }
           
           
            // Método de cruza de genes a partir de 2 cromosomas (padres) para crear un nuevo Cromosoma (descendiente).
            //  
            public Cromosoma cruzar(Cromosoma pareja, int puntoCruza){             
                    if(aplicarOperador(Ag.probabilidadjeCruza)) {
                            // Comprobar que el punto de cruza no caiga en ninguno de los dos extremos del Cromosoma
                            if(puntoCruza > 0 && puntoCruza < (this.getNumeroGenes()- 1)) {
                                    Cromosoma descendiente;
                                    Gen[] genesMios = getGenes();
                                    Gen[] genesPareja = pareja.getGenes();
                                    Gen[] genesHijo = new Gen[pareja.getNumeroGenes()];    
                           
                                    int inicioCadena = 0, finCadena = pareja.getGenes().length;
                           
                                    copiarGenes(genesHijo, genesMios, inicioCadena , puntoCruza);          
                                    copiarGenes(genesHijo, genesPareja, puntoCruza, finCadena);
                                    descendiente = new Cromosoma(genesHijo);
                                    descendiente.mutar();
                                    return descendiente;
                            }
                    }
                    return this; // No se realiza la cruza, por tanto se devuelve este Cromosoma
            }
           
            public int getNumeroGenes(){           
                    return genes.length;
            }      
                   
            public Gen getGen(int indice) {
                    return genes[indice];
            }
           
            // Obtiene un conjunto de genes que tienen contenido la subcadena que reciben como parametro  
            public  ArrayList<Gen> getGenes(String contieneSubstring) {
                    ArrayList<Gen> listaGenes = new ArrayList<Gen>();              
                   
                    // Se comprueba antes de recorrer todos los genes sino ya fueron obtenidos sus datos de esta claveGrupo        
                    for(int i = 0; i < this.getNumeroGenes(); i++) {                       
                            String cadenaAnalizar = this.getGen(i).toString();                     
                            if(cadenaAnalizar.contains(contieneSubstring)) {                       
                                    listaGenes.add(this.getGen(i));
                                    System.out.println("gen:" + this.getGen(i));
                            }
                    }              
                    return listaGenes;
            }

            public Gen[] getGenes(){               
                    return genes;          
            }
           
            public float getFitness(){             
                    return fitness;        
            }
           
            public void setGenes(Gen[] genes) {
                    this.genes = genes;
            }

            public void setGen(Gen gen, int indice) {              
                    genes[indice] = gen;
            }

            //Establecer
            public void setFitness(float fitness){         
                    this.fitness = fitness;
            }
           
            public String toString() {
                    String cadena = "";
                    for(int i = 0; i < getNumeroGenes() - 1; i++)
                            cadena += genes[i].toString() + "||";
                    cadena += genes[getNumeroGenes() - 1] + "||" + fitness;
                    return cadena;
            }
           
            /**
             * Permite comparar un Cromosoma con otro en base al fitness (aptitud) obtenido.
             */

            public int compareTo(Cromosoma c) {
                    return (fitness < c.getFitness() ? -1 : (fitness == c.getFitness() ? 0 : 1));          
            }
           
            ////#########  
            /*
             * Aqui hago mis asignaciones de datos:
             *              obtener la materia a hacerle asignaciones
             *              determinar el profesor que la impartira
             *              obtener el horario en que esta disponible
             *             
             *
             * Esta parte de código lo tenia en otra clase (Ag: que es una clase donde corre el algoritmo)
             * He tenido problemas como manejar los datos de entrada, ya que en varias partes los reutilizo (es por eso que los tengo como estaticos)
             */

            private Gen crearNuevoGen(int indiceGrupoMateria) {
                   
                    // Ejemplo gen = |MT1ISC1A|1|1-1|3-4|4-6|5-1| (MT1: clave de la materia) (1:clave del profesor) (1-1, 3-4... : hora de clase dado por la interseción de una clave de hora y una clave de dia)
                   
                    String claveGrupoMateria = AsignacionHorarios.clavesGruposMaterias[indiceGrupoMateria];
                    String claveMateria = claveGrupoMateria.substring(0, 3);
                    ArrayList<String> clavesProfesoresCandidatos = buscarProfesoresDeseanImpartir(claveMateria);
                    String claveProfesorAsignado = clavesProfesoresCandidatos.get(Ag.numeroAleatorio(clavesProfesoresCandidatos.size()));  
                    String[] horarioDisponibleProfesorAsignado = getHorarioDisponible(claveProfesorAsignado);
                   
                    // Se le resta 1 para generar un indice menor a la longitud del arreglo, pero luego se suma 1 al indice aleatorio
                    // devuelto para acceder al valor deseado
                    String horaClase1 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];
                    String horaClase2 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];
                    String horaClase3 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];
                    String horaClase4 = horarioDisponibleProfesorAsignado[Ag.numeroAleatorio(horarioDisponibleProfesorAsignado.length - 1 ) + 1 ];         
                   
                    // crear nuevo gen
                    Gen nuevoGen = new Gen(6);
                   
                    nuevoGen.setValor(0, claveGrupoMateria);
                    nuevoGen.setValor(1, claveProfesorAsignado);
                    nuevoGen.setValor(2, horaClase1);
                    nuevoGen.setValor(3, horaClase2);
                    nuevoGen.setValor(4, horaClase3);
                    nuevoGen.setValor(5, horaClase4);
                    return nuevoGen;               
            }
           
            // Método para obtener los profesores para impartir determinada materia
            private static ArrayList<String> buscarProfesoresDeseanImpartir(String claveMateria) {
                   
                    ArrayList<String> clavesProfesoresDeseanImpartir = new ArrayList<String>();
                   
                    for(int i = 0; i < AsignacionHorarios.clavesMateriasDeseanImpartir.length; i++)
                            for(int j = 1; j < AsignacionHorarios.clavesMateriasDeseanImpartir[i].length; j++)                             
                                    if(AsignacionHorarios.clavesMateriasDeseanImpartir[i][j].equals(claveMateria))
                                            clavesProfesoresDeseanImpartir.add(AsignacionHorarios.clavesMateriasDeseanImpartir[i][0]);                             
                                   
                    return clavesProfesoresDeseanImpartir;
            }
           
            private static String[] getHorarioDisponible(String claveProfesor) {
                                   
                    for(int k = 0; k < AsignacionHorarios.clavesHorasClavesDiasDisponibles.length; k++)
                                    if(claveProfesor == AsignacionHorarios.clavesHorasClavesDiasDisponibles[k][0])
                                            return AsignacionHorarios.clavesHorasClavesDiasDisponibles[k];
                    return null;
            }
    ////#########
           
        // Operador de mutación aún no implementado
            private void mutar() {
                    if(aplicarOperador(Ag.probabilidadMutacion)) { }
                                           
            }
           
            // copio una parte de los genes de genesPadre a genesHijo  
            private void copiarGenes(Gen[] genesHijo, Gen[] genesPadre, int inicioSegmento , int finSegmento){             
                    for(int p = inicioSegmento ; p < finSegmento ; p++)                    
                            genesHijo[p] = (Gen)genesPadre[p].clone();             
            }
           
            // Me indica si aplicar algun operador genético en base a la probabilidad recibida    
            private boolean aplicarOperador(float probabilidad) {
                    if(Ag.numeroAleatorio() < probabilidad)
                            return true;
                    return false;
            }      
    }

    de este documento me ando basando de esta parte http://delta.cs.cinvestav.mx/~ccoello/revistas/genetico.pdf.gz

    style="display:inline-block;width:728px;height:90px"
    data-ad-client="ca-pub-5164839828746352"
    data-ad-slot="7563230308">