¿Cómo puedo implementar un algoritmo de "20 preguntas"?

Desde la infancia, me he preguntado cómo funciona el juego electrónico 20Q . Piensa en un objeto, cosa o animal (por ejemplo, papa o burro ). Luego, el dispositivo le hace una serie de preguntas como:

• ¿Es más grande que una barra de pan?
• ¿Se encuentra al aire libre?
• ¿Se usa para recreación?

Para cada pregunta, puede responder sí , no , quizás o desconocido . Siempre me imaginé que funciona con inmensos condicionales anidados ( ifdeclaraciones). Sin embargo, creo que es una explicación poco probable debido a su complejidad para el programador.

¿Cómo implementaría tal sistema?

No sé cómo 20Q lo hizo específicamente, pero hay mucha información sobre cómo implementar un juego de 20 preguntas .

Hay muchas formas de resolver esto, pero describiré una manera. Estos juegos pueden implementar algún tipo de árbol de decisión . Para un juego electrónico como 20Q, este árbol sería precalculado y bastante fácil de atravesar. Existen métodos para utilizar los árboles de decisión de aprendizaje en los que el juego puede aceptar nuevos objetos al final de sus preguntas si no puede adivinar lo que el usuario pregunta.

Cuando las preguntas son una serie de respuestas sí o no, terminas con un árbol binario. Cada nodo es una pregunta y las hojas son respuestas. Cuando las preguntas se responden con desconocidas o no seguras, los nodos secundarios se pueden combinar y formular sus preguntas en serie para eliminar aún más las posibles respuestas.

Básicamente este es el proceso:

1. Comience con una lista completa de los objetos. Todos estos pueden comenzar con la misma probabilidad, o pueden ordenarse según la probabilidad de que el objeto fuera elegido en la prueba.
2. Comience con la primera pregunta en el árbol de decisiones. Empújalo a la cola de preguntas.
3. Haga la pregunta en la parte superior de la cola.
4. Respuesta al proceso:
   1. Las respuestas Sí / No eliminan / agregan una cantidad predeterminada de probabilidad de cada respuesta en función de la pregunta.
   2. La respuesta "Quizás" elimina / agrega una fracción de la cantidad predeterminada de un "sí".
   3. "Desconocido" no cambia las probabilidades
5. Una respuesta "Desconocida" o "Quizás" empuja las dos preguntas de los nodos siguientes a la cola de preguntas. Una respuesta "Sí" o "No" simplemente agrega el nodo respectivo sí / no a la cola de preguntas.
6. Vaya al paso 3 hasta que las preguntas o la probabilidad de una sola respuesta superen un umbral predefinido de "certeza".
7. Proporcione la respuesta más probable.

La generación del árbol es probablemente el tema de otra pregunta. Pero básicamente está eligiendo preguntas que dividen las respuestas tanto como sea posible. Ponga las preguntas que dividen las preguntas más equitativamente cerca del principio para que la mayor cantidad de preguntas pueda ser seleccionada más rápido.

La respuesta simple es que el juego portátil 20Q fue creado a partir de la inteligencia artificial que vive en http://20Q.net . En 20Q.net puedes jugar diferentes versiones del juego de Twenty Questions, similar al juguete, excepto que el juego aprende de cada juego jugado. El juguete portátil utiliza los mismos algoritmos de red neuronal. La red neuronal recoge las preguntas para hacer, así como hacer conjeturas. Este enfoque significa que la IA a menudo adivinará correctamente incluso si responde una pregunta diferente de lo que se le ha enseñado. Otra ventaja es que el juego hará preguntas de manera diferente, incluso si estás pensando en lo mismo.

Los algoritmos y la red neuronal del clásico juego inglés (Animal, Vegetal, Mineral) fueron creados en 1988 por Robin Burgener. . . yo.

Gracias por preguntar.

Busqué en Google "código 20q" y encontré esto: http://mosaic.cnfolio.com/B142LCW2008A197

Esta versión es solo para animales, pero las 20 preguntas reales probablemente tengan un algoritmo similar.

Aquí hay una descripción general rápida del código que vinculé:
hay varias respuestas diferentes codificadas en el programa. Luego se les asignan varios atributos VERDADERO o FALSO:

#define ANIMALS_LIST      "daddylonglegs bee penguin eagle giraffe octopus tiger elephant jellyfish bull \nparrot dolphin python crocodile cat leopard monkey zebra sheep rat \nowl spider frog polarbear snail tortoise rabbit salmon rhino fox"
#define MAMMALS                    "0 0 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 1 1 1 0 0 0 1 0 0 1 0 1 1"
#define FLYING_ANIMALS             "1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"
#define WATER_ANIMALS              "0 0 1 0 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 1 1 0 1 0 1 1 0"
#define BEAK                       "0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0"
...

Como puede ver, una abeja no es un mamífero pero sí vuela, etc.

Hay una matriz para cada grupo:

int   mammals[ TOTAL_ANIMALS ] = { 0 };
int   flying_animals[ TOTAL_ANIMALS ] = { 0 };
int   water_animals[ TOTAL_ANIMALS ] = { 0 };
...

Cuando se hace cada pregunta:

  askUserQuestion( guesses, "\nQuestion %d: Is your animal a mammal? \n", mammals );

El programa analiza la definición de la categoría apropiada y rastrea qué animal es el que probablemente esté pensando en función de los valores VERDADERO o FALSO y su respuesta Sí o No a la pregunta.

Esto se hace en:

void askUserQuestion( int guessNumber, char* question, int* animalData );

No es un árbol de decisión masivo o un montón de declaraciones if / else codificadas. Robin Burgener, el inventor, documentó completamente su algoritmo en su solicitud de patente de 2005. Es ingeniosamente simple.