Sistema Experto tipo akinator

[gbarretop]

Hola buenas tardes..

en la escuela me mandaron hacer un proyecto el cual es de selección tipo el programa de adivinanza akinator.

Se desea que realice una investigación de cinco (5) anfibios de diferentes tipos dentro del género urodelo, el cual deben tener semejanzas entre ellas para poder realizar comparaciones y generar una sola conclusión del mismo. El usuario debe responder a 10 preguntas y dependiendo de sus respuestas dar una conclusión de cual de los 5 anfibios la persona esta pensando.

El profesor sugirió hacerlo por IF y ELSE..

Asimismo, al finalizar el interrogatorio y haya arrojado una posible respuesta, el sistema debe estar en la capacidad de repetir nuevamente el interrogatorio.

Quisiera que alguien me ayudara con un ejemplo de como puedo realizar este codigo ya que no tengo los conocimientos para ello.

Agradeciendo su pronta respuesta..

[Fuzzylog]

Pues, en principio, debes tener a los 5 anfibios con una serie de caracteristicas concretas. Algunas comunes y otras no comunes, en base a las cuales debes preparar las preguntas.

Sobre las preguntas, puedes hacer 10 preguntas sobre diferentes caracteristicas e ir sumando puntos a los anfibios que se correspondan con el signo de la respuesta, y devolver finalmente el anfibio que más puntuación tenga, o hacer un interrogatorio orientado, con preguntas que van desde lo más genérico a lo más específico, y permitiendo al usuario rehacer la respuesta dada anteriormente. En este último caso el sistema va a descartar automáticamente los anfibios que no cumplan con las condiciones impuestas por la respuesta del usuario, centrándose en los que queden, y te podría permitir alcanzar una respuesta en menos de 10 preguntas seguramente, aunque si fuese tipo akinator también podría realizar más de 10 preguntas xD.

[razpeitia]

Hay varias maneras de solucionar esto:

1.- Una seria de IF ELSE anidados, pero recuerda esto es exponencial si son 10 preguntas y suponiendo que cada una solamente tenga 2 opciones, al final tendrás 2 ** 10 (1024) posibles finales. Supongo que habra finales donde no esta pensando en ningún anfibio.
2.- Puedes hacer una tabla de puntajes tal como te dijeron allá arriba. Toma en cuenta que también hay la posibilidad de empates de puntajes, usando esta solución.
3.- Puedes modelar este problema con un DAG, que es mas o menos como lo modelan en los video juegos.
4.- Puedes implementar un akinator de verdad usando redes neuronales y mucho entr\enamiento, pero como supongo que vas empezando no lo veo viable. Dejo esta lectura de todos modos. http://stats.stackexchange.com/quest...yes-classifier

Hace tiempo respondí a una pregunta similar en el foro de python.

http://www.forosdelweb.com/f130/prog...-solo-1014127/

[gbarretop]

Muchas gracias por las respuestas.. Termine haciéndolo con IF ELSE condicionados a las respuestas que debería tener para que sea el anfibio correspondiente, pondré de igual manera el código aquí para que lo evalúen y me puedan decir para la próxima que podría cambiar o como se hace realmente.

Código:

/*
public class SistemaExperto {//clase del sistemaexperto

    public static void main (String[] args){ 
    SistemaExperto_inicio();
    }
    
    public static void SistemaExperto_inicio(){
    int op;//inicializacion de la variable op 
    BufferedReader lee = new BufferedReader(new InputStreamReader( System.in)); 
        try{ 
            System.out.println("Bienvenido al sistema experto de adivinanzas\n\nLa dinamica es la siguiente:\n     *Te presentare 5 anfibios del genero urodelo.\n     *Debes memorizar uno de ellos recordando siempre sus caracteristicas, y yo tratare de adivinar\n      mediante preguntas en cual estas pensando.\n     *Si tu respuesta es afirmativa responde con: 1, si es negativa responde con: 0\n\nElige una opción para comenzar:\n1.- Iniciar sistema experto\n2.- Salir\n\nRespuesta:" ); 
            op = Integer.parseInt(lee.readLine());
            if (op == 1 || op == 2) {//Creo condición si escribio 1 o 2
                switch (op){
                    case 1:
                    Adivinar();
                    break;
                    case 2:
                    System.out.println("\n*******-Nos vemos luego-*******\n" );
                    System.exit(op);
                    break;
                }
            }else{
            System.out.println("\n*******-Ups.. parece que has ingresado un valor no valido-*******\n\n            *******-Intentemoslo nuevamente-*******\n");
            SistemaExperto_inicio();
            }
        }catch(IOException e){
            System.out.println("\n*******-Ups.. parece que has ingresado un valor no valido-*******\n\n            *******-Intentemoslo nuevamente-*******\n");
            SistemaExperto_inicio();
        }catch (Exception e){ 
            System.out.println("\n*******-Ups.. parece que has ingresado un valor no valido-*******\n\n            *******-Intentemoslo nuevamente-*******\n");
            SistemaExperto_inicio();
        }
    }
    
    public static void Adivinar (){//clase Adivinar
        int p;
        int p1;
        int p2;
        int p3;
        int p4;
        int p5;
        int p6;
        int p7;
        int p8;
        int p9;
        int p10;
        int p11;
        BufferedReader leep = new BufferedReader(new InputStreamReader( System.in));
        try{
            Informacion();
            System.out.println("\nElije una opción:\n1- Comenzar\n2.- Me arrepenti, no quiero jugar más\n\nRespuesta:" );
            p = Integer.parseInt(leep.readLine()); 
        switch (p){
        case 1:
        System.out.println("\n- ¿Tu anfibio tiene como caracteristica especial, sensores en su cabeza, la cual utiliza para cazar a sus presas?" );
        p1 = Integer.parseInt(leep.readLine());
        if (p1 == 1 || p1 == 0){
            System.out.println("\n- ¿Tu anfibio pasa por una etapa de metamorfosis?" );
            p2 = Integer.parseInt(leep.readLine());
            if (p2 == 0 || p2 == 1){
                System.out.println("\n- ¿Tu anfibio tiene 5 dedos en sus patas posteriores y 4 en las patas inferiores?" );
                p3 = Integer.parseInt(leep.readLine());
            if (p3 == 0 || p3 == 1){
                System.out.println("\n- ¿Tu anfibio carece de pulmones y respira a través de su piel?" );
                p4 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p4 == 0 || p4 == 1){
                System.out.println("\n- ¿Tu anfibio tiene habilidades para cazar en la noche?" );
                p5 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p5 == 0 || p5 == 1){
                System.out.println("\n- ¿Tu anfibio realiza su fecundación de manera externa?" );
                p6 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p6 == 0 || p6 == 1){
                System.out.println("\n- ¿Tu anfibio tiene dientes angulosos?" );
                p7 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p7 == 0 || p7 == 1){
                System.out.println("\n- ¿Tu anfibio muda su cola cada 6 meses?" );
                p8 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p8 == 0 || p8 == 1){
                System.out.println("\n- ¿Tu anfibio tiene una caracteristica que posee patrones cromáticos para defensa contra su depredador?" );
                p9 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p9 == 0 || p9 == 1){
                System.out.println("\n- ¿Tu anfibio es completamente acuatico?" );
                p10 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p10 == 0 || p10 == 1){
                System.out.println("\n- ¿Tu anfibio es de 4 patas?" );
                p11 = Integer.parseInt(leep.readLine());/*se cambia el valor de lee a adiv*/
            if (p11 == 0 || p11 == 1){
                if (p1 == 1 && p2 == 0 && p3 == 0 && p4 == 0 && p5 == 1 && p6 == 1 && p7 == 0 && p8 == 0 && p9 == 0 && p10 == 0 && p11 == 1){
                System.out.println("\n*******-Salamandra Gigante-*******\n" );
                JuguemosNuevamente();
                }else if (p1 == 0 && p2 == 1 && p3 == 0 && p4 == 0 && p5 == 0 && p6 == 1 && p7 == 0 && p8 == 0 && p9 == 0 && p10 == 0 && p11 == 1){
                    System.out.println("\n*******-Salamandra Asiatica-*******\n" );
                    JuguemosNuevamente();
                }else if (p1 == 0 && p2 == 0 && p3 == 0 && p4 == 1 && p5 == 0 && p6 == 0 && p7 == 0 && p8 == 0 && p9 == 0 && p10 == 0 && p11 == 1){
                    System.out.println("\n*******-Salamandra Apulmonada-*******\n" );
                    JuguemosNuevamente();
                }else if (p1 == 0 && p2 == 0 && p3 == 1 && p4 == 0 && p5 == 0 && p6 == 1 && p7 == 0 && p8 == 1 && p9 == 1 && p10 == 0 && p11 == 1){
                    System.out.println("\n*******-Salamándrinos-*******\n" );
                    JuguemosNuevamente();
                }else if (p1 == 0 && p2 == 0 && p3 == 0 && p4 == 0 && p5 == 1 && p6 == 1 && p7 == 0 && p8 == 0 && p9 == 0 && p10 == 1 && p11 == 0){
                    System.out.println("\n*******-Anfiumas-*******\n" );
                    JuguemosNuevamente();
                }else{
                    System.out.println("Estoy seguro que no has memorizado bien las caracteristicas del anfibio que seleccionastes.\nIntentemoslo una vez más" );   
                }
            }}}}}}}}}}}else{
                System.out.println("\n*******-Ups.. parece que has ingresado un valor no valido, recuerda que si tu respuesta\n        es afirmativa debes responder con 1, y si es negativa debes responder con 0-*******\n\n                          *******-Intentemoslo nuevamente-*******");   
                Adivinar();
        }
        break;
        case 2:
        System.out.println("\n*******-Nos vemos luego-*******\n" );
        System.exit(p);
        break;
        }
        }catch(IOException e){
            System.out.println("\n*******-Ups.. parece que has ingresado un valor no valido, recuerda que si tu respuesta\n        es afirmativa debes responder con 1, y si es negativa debes responder con 0-*******\n\n                          *******-Intentemoslo nuevamente-*******");
            Adivinar();
        }catch (Exception e){ 
            System.out.println("\n*******-Ups.. parece que has ingresado un valor no valido, recuerda que si tu respuesta\n        es afirmativa debes responder con 1, y si es negativa debes responder con 0-*******\n\n                          *******-Intentemoslo nuevamente-*******");
            Adivinar();
        } 
    }
    
    public static void Informacion(){
        System.out.println("\n*******-Memoriza las caracteristicas de los siguientes anfibios y comienza el juego-*******" );
        System.out.println("\n*Las anfiumas (Amphiuma): Exhiben un estilo de vida completamente acuático, un cuerpo alargado, sin extremidades.\n Exhiben, además, hábitos nocturnos para cazar, siendo depredadores generalistas. Fecundación externa.\n" );
        System.out.println("*La salamandra gigante del Japón (Andrias japonicus) es una especie de anfibio urodelo de la familia Cryptobranchidae.\n Debido a su escaso sentido de la vista, usa sensores en su cabeza para cazar a su presa en las noches.\n Fecundación de manera externa, es una especie de 4 patas.\n" );
        System.out.println("*Las salamandras asiáticas (Hynobiidae) son un clado de anfibios caudados primitivos.\n Presentan dientes angulosos, fecundación externa (siendo los huevos depositados en bolsas) y una metamorfosis completa, es una especie de 4 patas.\n" );
        System.out.println("*Las salamandras apulmonadas (Plethodontidae) las especies de esta familia son de tamaño reducido,\n careciendo de pulmones. Al no poseer pulmones respiran a través de la piel y los epitelios ubicados en la cavidad bucofaríngea.\n La fecundación es interna y es una especie de 4 patas.\n" );
        System.out.println("*Los salamándridos (Salamandridae) son también conocidos como salamandras o tritones.\n Presentan cuatro extremidades con cinco dedos en las posteriores y cuatro en las anteriores, una cola cada 6 meses y\n por lo general patrones cromáticos llamativos en la piel como medio de disuasión ante potenciales depredadores. Es una especie de 4 patas.\n" );
    }
}

[Xerelo]

Echándole un vistazo rápido se me ocurre la siguiente mejora (para que el código sea menos embarullado)

1. Meter todas las preguntas en un array, de forma que ejecutas un for que recorra el array haciendo las preguntas.

2. Guardas en un array la contestación de cada pregunta coincidiendo en posición pregunta y respuesta.

3. Como las preguntas son sí o no (0 o 1) juntas todas las respuestas en una cadena, de forma que tienes un número en binario 01010111.

4. Conviertes el número de binario a normal y te da un número único que identifica al animal. Esto será cierto ya que cada pregunta se corresponde con una posición binaria, por lo que es imposible que dos animales tengan el mismo número ya que en tu caso siempre haces todas las preguntas.

Esto vale para este caso, pero si las preguntas estuviesen condicionadas a las respuestas, habría que hacer algunas modificaciones. Me refiero a esto

http://es.wikipedia.org/wiki/%C3%81rbol_binario

Típico ejercicio de nodos enlazados.