Estratégia Mastermind

Eu só consegui encontrar desafios de código-golfe para o Mastermind, então aqui está uma versão de código-desafio que eu gostaria de enfrentar.

Uma estratégia ideal para o jogo Mastermind normal, MM (4,6), foi encontrada por Koyama e Lai em 1993, com um número médio de suposições = 5625/1296 ~ 4,34. MM (5,8) ainda não foi resolvido, mas estima-se que tenha um número médio de suposições ~ 5,5.

Sua tarefa é criar uma estratégia MM (5,8), com 5 furos e 8 cores, cobrindo todas pow(8,5) = 32768as soluções distintas possíveis. Obviamente, não precisa ser o ideal. Você tem duas opções:

1. Poste um programa determinístico que gere a estratégia. O programa deve ser compilável / executável no Windows 7, Mac OS X ou Linux sem nenhum software extra gratuito.
2. Publique sua estratégia (junto com o seu nome StackExchange) em algum lugar da Internet e publique o URL aqui.

Nos dois casos, indique a pontuação (veja abaixo) no cabeçalho da resposta.

A estratégia deve ser codificada de acordo com a seguinte gramática:

strategy : guessing-strategy | known-solution-strategy
guessing-strategy : '{' guess ':' branches '}'
known-solution-strategy : guess
guess : color color color color color
color : 'A'..'H'
branches : '{' branch (',' branch)* '}'
branch : reply ':' strategy
reply : number-of-blacks number-of-whites
number-of-blacks : number-of-key-pegs
number-of-whites : number-of-key-pegs
number-of-key-pegs : '0'..'5'

O algoritmo usado para decidir o número de pinos de teclas preto / branco está descrito em http://en.wikipedia.org/wiki/Mastermind_(board_game)

Observe que a resposta "50" (ou seja, palpite correto) está implícita e não faz parte da gramática.

Pontuação: N = a soma do número de suposições para cada um dos 32768 caminhos / soluções. A estratégia com o N mais baixo ganha. Primeiro tie-break: o menor número máximo de palpites. Segundo tie-break: a primeira resposta postada. A competição termina em 1 de agosto de 2014 às 0:00 GMT .

Um exemplo de estratégia para MM (2,3) com pontuação = 21:

{AB:{10:{AC:{10:AA,01:CB,00:BB}},02:BA,01:{BC:{01:CA}},00:CC}}

Usando esta estratégia, os 9 jogos possíveis serão assim:

• AB 20
• AB 10, CA 20
• AB 10, CA 10, AA 20
• AB 10, CA 01, CB 20
• AB 10, CA 00, BB 20
• AB 02, BA 20
• AB 01, BC 20
• AB 01, BC 01, CA 20
• AB 00, CC 20

Em breve, publicarei um verificador de estratégia MM (5,8) baseado em Java para sua conveniência.

Java

Meu algoritmo para MM (5,8) pontua com 177902 178006 182798 182697 com uma profundidade máxima de 8 9 e precisa de apenas alguns segundos (no meu computador lento).

Um exemplo de saída de uma estratégia para MM (2,3) com score = 21 encontrada por esse algoritmo é semelhante a:

{BC:{00:AA,01:AB:{01:CA},02:CB,10:AC:{00:BB,01:BA,10:CC}}}

Não há nada empolgante com meu algoritmo. Nenhuma invenção. Eu apenas segui as receitas encontradas na rede e as comprimi neste código Java. A única otimização que fiz foi tentar otimizar as linhas de código (de certa forma). É assim:

1. Crie o conjunto inicial S0 de todos os códigos possíveis para o conjunto atual S.
2. O quebra-código encontra uma boa (gananciosa) suposição para S. Cada suposição leva a uma partição P de S, onde cada subconjunto S 'coleta todos os códigos (de S) com a mesma resposta na suposição. Um bom palpite tem uma boa partição, como a que fornece mais informações para o palpite.
3. Adote o bom palpite e seu P. Para cada S 'vazio em P, aplique o quebra-código recursivo (etapa 2).

@ MrBackend: Escrever um verificador é difícil, eu acho. ;-)

import java.util.TreeMap;
import java.util.Vector;

public class MM {
    Vector<String> codeset = new Vector<String>();
    String guess;
    TreeMap<Integer, MM> strategy = new TreeMap<Integer, MM>();

    public String toString() {
        String list="";
        for (Integer reply: strategy.keySet()) {
            if (strategy.get(reply)!=null) list+=(list.length()>0?",":"")+(reply<10?"0":"")+reply+":"+strategy.get(reply);
        }
        if (list.length()>0) return guess+":{"+list+"}"; else return guess;
    }

    MM() { }

    MM(int h, int c) {
        for (int i = 0; i < Math.pow(c, h); i++) {
            String code = "";
            for (int j = 0, p=i; j < h; j++) {
                code+="ABCDEFGH".charAt(p%c);
                p/=c;
            }
            codeset.add(code);
        }
    }

    int replyAccordingToDonaldKnuth(String secret, String guess) {
        int black=0;
        int totalHitsBlackAndWhite=0;
        for (char n = 'A'; n <= 'H'; n++) {
            int a=0, b=0;
            for (int i = 0; i < secret.length(); i++) {
                if (secret.charAt(i)==n) a++;
                if ( guess.charAt(i)==n) b++;
            }
            totalHitsBlackAndWhite+=Math.min(a, b);
        }
        for (int i = 0; i < secret.length(); i++) {
            if (secret.charAt(i) == guess.charAt(i)) black++;
        }
        return 10 * black + (totalHitsBlackAndWhite-black);
    }

    int reply(String secret, String guess) {
        return replyAccordingToDonaldKnuth(secret, guess);
    }

    MM codebreaker(Vector<String> permuts) {
        int fitness=0;
        MM protostrategy=null;
        for (int greedy = 0; greedy < Math.min(permuts.size(), 200); greedy++) {
            MM tmp=partition(permuts, permuts.get(greedy));
            int value=tmp.strategy.size();
            if (fitness<=value) {
                fitness=value;
                protostrategy=tmp;
                protostrategy.guess=permuts.get(greedy);
            }
        }
        if (protostrategy!=null) {
            for (Integer reply: protostrategy.strategy.keySet()) {
                protostrategy.strategy.put(reply, codebreaker(protostrategy.strategy.get(reply).codeset));
            }
        }
        return protostrategy;
    }

    MM partition(Vector<String> permuts, String code) {
        MM protostrategy=new MM();
        for (int c = 0; c < permuts.size(); c++) {
            int reply=reply(permuts.get(c), code);
            if (!protostrategy.strategy.containsKey(reply)) protostrategy.strategy.put(reply, new MM());
            if (permuts.get(c)!=code) protostrategy.strategy.get(reply).codeset.add(permuts.get(c));
        }
        return protostrategy;
    }

    public static void main(String[] args) {
        MM mm = new MM(5,8);
        System.out.println("{"+mm.codebreaker(mm.codeset)+"}");
    }
}

Algumas observações:

1. Nenhuma verificação de consistência é necessária porque os conjuntos S e suas partições são construídos de maneira (auto) consistente.
2. Escolher um bom palpite de S0 (em vez de S) faz sentido. Mas eu não sigo essa abordagem no código atual.
3. Minha busca gananciosa é podada artificialmente para 200 tentativas.
4. Eu sei, "dar mais informações para o palpite" não é muito preciso. A idéia simples é escolher a partição com o maior número de subconjuntos.
5. O resultado depende muito de como você calcula a resposta (..). Finalmente, adaptei a expressão de Donald Knuth.

A estratégia para MM(5,8) pode ser encontrada aqui . O GitHub tem alguns problemas ao exibir linhas que demoram tanto, então clique no botão Raw .

Rubi

Edição: Adicionado alguma lógica para excluir suposições impossíveis. Portanto, as estratégias agora estão em conformidade com o formato fornecido e são muito mais gerenciáveis.

Então, aqui está uma tentativa de fazer isso acontecer. É bastante ingênuo (e não muito legível - ajuda a ler o ramo if / elsif / else de baixo para cima).

Holes, Colors = ARGV.map &:to_i

ColorChars = ('A'..'H').to_a

def is_possible(guess, blacks, result)
    blacks == guess.chars.zip(result.chars).count {|chars| chars[0] == chars[1]}
end

def print_strategy(known_colors, remaining_permutations, next_color)
    char = ColorChars[next_color]
    if remaining_permutations
        guess = remaining_permutations[0]
        print guess
        if remaining_permutations.length > 1
            print ':{'
            (Holes-1).times do |i|
                new_permutations = (remaining_permutations - [guess]).select { |perm| is_possible(guess, i, perm) }
                next if new_permutations.empty?
                print "#{i}#{Holes-i}:"                
                print '{' if new_permutations.length > 1
                print_strategy(known_colors, new_permutations, next_color)
                print '}' if new_permutations.length > 1
                print ',' if i < Holes-2
            end
            print '}'
        end
    elsif known_colors.length == Holes
        print_strategy(known_colors, known_colors.chars.permutation.map(&:join).uniq, next_color)
    elsif next_color == Colors-1
        print_strategy(known_colors+char*(Holes - known_colors.length), remaining_permutations, next_color+1)
    else
        print char*Holes, ':{'

        (Holes - known_colors.length + 1).times do |i|
            break if i == Holes
            print "#{i}0:"
            print '{' if next_color < Colors-2 || i > 0 || known_colors.length > 0
            print_strategy(
                known_colors+char*i,
                remaining_permutations,
                next_color+1
            )
            print '}' if next_color < Colors-2 || i > 0 || known_colors.length > 0
            print ',' if i < (Holes - known_colors.length) && i < Holes-1
        end
        print '}'
    end
end

print '{'
print_strategy('', nil, 0)
puts '}'

Primeiro, eu tento 5 de cada cor: AAAAA, BBBBB, etc. A partir desse figura I quais cores são realmente utilizados no padrão. E então simplesmente tento todas as permutações das cores fornecidas, omitindo aquelas que já foram descartadas pelos pinos pretos.

Aqui está a MM(2,3)estratégia:

{AA:{00:{BB:{00:CC,10:{BC:{02:CB}}}},10:{BB:{00:{AC:{02:CA}},10:{AB:{02:BA}}}}}}

A estratégia para MM(5,8)376KB pode ser encontrada aqui . O GitHub tem alguns problemas ao exibir linhas que demoram tanto, então clique no botão Raw .

Agora, se eu receber um verificador, também posso lhe dizer qual é minha pontuação real. :)