Como posso implementar um algoritmo de "20 perguntas"?

Desde a infância, eu me pergunto como o jogo eletrônico 20Q funcionava. Você pensa em um objeto, coisa ou animal (por exemplo, batata ou burro ). O dispositivo faz uma série de perguntas como:

• É maior que um pedaço de pão?
• É encontrado ao ar livre?
• É usado para recreação?

Para cada pergunta, você pode responder sim , não , talvez ou desconhecido . Eu sempre imaginei que funcionasse com imensas condicionais aninhadas ( ifdeclarações). No entanto, acho que é uma explicação improvável devido à sua complexidade para o programador.

Como eu implementaria esse sistema?

Não sei como o 20Q fez isso especificamente, mas há muitas informações sobre como implementar um jogo de 20 perguntas .

Existem muitas maneiras de resolver isso, mas descreverei uma maneira. Esses jogos podem implementar algum tipo de árvore de decisão . Para um jogo eletrônico como o 20Q, essa árvore seria pré-computada e bastante fácil de percorrer. Existem métodos para usar as árvores de decisão de aprendizado em que o jogo pode aceitar novos objetos no final das perguntas, se não conseguir adivinhar o que o usuário está perguntando.

Quando as perguntas são uma série de respostas sim ou não, você acaba com uma árvore binária. Cada nó é uma pergunta e as folhas são respostas. Quando as perguntas são respondidas com incógnita ou não, os nós filhos podem ser combinados e suas perguntas podem ser feitas em série para selecionar ainda mais as respostas possíveis.

Basicamente, este é o processo:

1. Comece com uma lista completa dos objetos. Todos podem começar com a mesma probabilidade ou podem ser classificados pela probabilidade do objeto ser escolhido no teste.
2. Comece com a primeira pergunta na árvore de decisão. Empurre-o para a fila de perguntas.
3. Faça a pergunta no topo da fila.
4. Resposta do processo:
   1. Respostas Sim / Não remove / adiciona uma quantidade predeterminada de probabilidade de cada resposta com base na pergunta.
   2. A resposta "Talvez" remove / adiciona uma fração da quantidade predeterminada de um "sim".
   3. "Desconhecer" não altera as probabilidades
5. Uma resposta "Desconhecido" ou "Talvez" envia as duas perguntas dos nós seguintes para a fila de perguntas. Uma resposta "Sim" ou "Não" apenas adiciona o respectivo nó sim / não na fila de perguntas.
6. Vá para a etapa 3 até que as perguntas ou a probabilidade de uma única resposta estejam além de um limite predefinido de "certeza".
7. Forneça a resposta mais provável.

Gerar a árvore é provavelmente o tópico de outra pergunta. Mas basicamente é escolher perguntas que dividam as respostas o máximo possível. Coloque as perguntas que dividem as perguntas da mesma maneira no início, para que o maior número de perguntas possa ser selecionado mais rapidamente.

A resposta simples é que o jogo portátil 20Q foi criado a partir da inteligência artificial existente em http://20Q.net . No 20Q.net, você pode jogar diferentes versões do jogo Twenty Questions, semelhante ao brinquedo, exceto que o jogo aprende com todos os jogos disputados. O brinquedo portátil usa os mesmos algoritmos de rede neural. A rede neural escolhe as perguntas a serem feitas, bem como faz suposições. Essa abordagem significa que a IA geralmente adivinhar corretamente, mesmo se você responder a uma pergunta de maneira diferente da que foi ensinada. Outra vantagem é que o jogo fará perguntas de maneira diferente a cada jogo, mesmo se você estiver pensando na mesma coisa.

Os algoritmos e a rede neural do clássico jogo de inglês (Animal, Vegetal, Mineral) foram criados em 1988 por Robin Burgener. . . mim.

Obrigado por perguntar.

Pesquisei no Google "código 20q" e encontrei o seguinte: http://mosaic.cnfolio.com/B142LCW2008A197

Esta versão é apenas para animais, mas as 20 perguntas reais provavelmente têm um algoritmo semelhante.

Aqui está uma rápida visão geral do código que vinculei:
Existem várias respostas diferentes codificadas no programa. Vários atributos VERDADEIRO ou FALSO são atribuídos a eles:

#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 você pode ver, uma abelha não é um mamífero, mas voa etc.

Há uma matriz para cada grupo:

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

Quando cada pergunta é feita:

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

O programa analisa a definição da categoria apropriada e rastreia qual animal é mais provável aquele em que você está pensando, com base nos valores VERDADEIRO ou FALSO e na resposta Sim ou Não inserida à pergunta.

Isso é feito em:

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

Não é uma árvore de decisão massiva ou um monte de instruções if / else codificadas. Robin Burgener, o inventor, documentou completamente seu algoritmo em seu pedido de patente de 2005. É engenhosamente simples.