Un TicTacToejeu peut être représenté par une chaîne indiquant la séquence de positions au fur et à mesure que les joueurs se déplacent.

0 1 2
3 4 5
6 7 8

Supposons que Xjoue toujours en premier.

Donc, une chaîne de "012345678" indique le jeu

XOX
OXO
XOX

Remarquez que le jeu est déjà gagné lorsque le joueur Xmarque 6, à ce stade, le jeu se termine, accordant une victoire à X. (c.-à-d. ignorer les coups restants une fois qu'un joueur gagne)

Votre défi (code) est d'imprimer tous les jeux (ordre trié) et ses résultats.

Le format

<movesequence>:<result>\n

par exemple:

012345678:X
012345687:X
012345768:X
...

Indique Xle premier joueur gagnant, Ole deuxième joueur et les Dtirages.

Il y aura 9!(362880) matchs.

Voici quelques données pour vérifier vos résultats.

'X' Wins: 212256 
'O' Wins: 104544 
Draws : 46080 

Il s'agit d'un codegolf et l'exécution devrait durer une minute. S'amuser!

EDIT: Suppression des détails en excès, et imprimez-le simplement stdout. Pas besoin de créer un fichier.

Ruby 1.9, 201 caractères

r=*[*l=0..8,0,3,6,1,4,7,2,5,8,0,4,8,2,4,6].each_slice(3)
w=->a{r.any?{|b|b&a==b}}
[*l].permutation(9){|a|u=[[],[]];i=-1
u[i%2]<<a[i+=1]while !((x=w[u[1]])||o=w[u[0]])&&i<8
puts a*""+":#{x ??X:o ??O:?D}"}

Légèrement joué jusqu'à présent. Prend environ 45 secondes pour terminer ici.

• Edit: (268 -> 249) Ecrire dans stdout au lieu d'un fichier
• Modifier: (249 -> 222) Ne pas pré-remplir le tableau avec les mouvements de chaque joueur.
• Edit: (222 -> 208) Un moyen plus court de savoir si un joueur a gagné
• Edit: (208 -> 213) Retour à 213, la solution précédente était trop lente.
• Edit: (213 -> 201) Quelques réarrangements, suppression des espaces

J, 124 caractères

((],~':',~1":[){&'DOX'@(</+2*>/)@:(<./"1)@:(((2{m/.@|.),(2{m/.),m"1,>./)"2)@(<:@(>:%2|]),:(%(2|>:)))@(3 3$]))"1((i.!9)A.i.9)

X gagnent, O gagnent et tirent les décomptes.

C'était un peu pénible à déboguer cependant. :)

Haskell, 224 222 caractères

import Data.List
p=sort.permutations
a(e:_:z)=e:a z;a z=z
[c,d]%(e:z)|any((`elem`words"012 345 678 036 147 258 048 246").take 3).p.a.reverse$e=c|1<3=[d,c]%z;_%[]='D'
main=putStr$p['0'..'8']>>=(\s->s++':':"OX"%inits s:"\n")

Hélas, la permutationsfonction from Data.Listne produit pas de permutations dans l'ordre lexographique. J'ai donc dû dépenser 6 caractères sur le tri.

APL (139)

Cela peut probablement être raccourci davantage, mais c'était déjà assez difficile. Croyez-le ou non, il s'exécute en environ 45 secondes sur mon ordinateur (à l'exclusion du temps qu'il faut pour tout sortir, lors de la sortie sur l'écran).

↑{⊃,/(,/⍕¨⍵-1),':',{1∊T←↑{∨/↑{⍵∘{⍵≡⍵∧⍺}¨↓⍉(9⍴2)⊤⎕UCS'㗀㐇㔤㑉㔑㑔'}¨↓(M∘.≥M)∧[2]M∊⍵}¨↓⍉5 2⍴0,⍨⍵:'XO'[1+</+/T]⋄'D'}⍵}¨↓{1≥⍴⍵:↑,↓⍵⋄↑⍪/⍵,∘∇¨⍵∘~¨⍵}M←⍳9

Explication:

• M←⍳9: Stockez en M les nombres de 1 à 9. En interne, ce programme utilise 1..9 au lieu de 0..8.
• {... }: une fonction pour obtenir toutes les permutations:
  • 1≥⍴⍵:↑,↓⍵: si la longueur est inférieure ou égale à 1, retournez l'argument sous forme de matrice.
  • ⋄↑⍪/⍵,∘∇¨⍵∘~¨⍵: dans le cas contraire, supprimez chaque caractère ⍵de ⍵, obtenez les permutations de celui-ci et ajoutez-le à nouveau.
• ¨↓: pour chaque permutation ...
• {... }: une fonction qui donne le vainqueur pour cette permutation:
  • ⊃,/(,/⍕¨⍵-1),':',{... }⍵: obtenez la permutation sous forme de chaîne, avec tous les nombres diminués de 1 (pour obtenir la sortie 0..8 requise au lieu de 1..9), suivi de deux points, suivi du caractère indiquant le gagnant:
    • ⍉5 2⍴0,⍨⍵: séparez les coups par X des coups par O. Parce que O a un coup de moins que X, cet espace est rempli par 0, qui n'est pas utilisé et n'influence donc pas le résultat.
    • {... }¨↓: pour la carte X et la carte O, exécutez la fonction suivante qui détermine s'il y a une victoire dans l'un des neuf pas de temps:
      • (M∘.≥M)∧[2]M∊⍵: Générez un bitboard à partir des numéros de mouvement, et andce bitboard avec les chaînes de bits 100000000, 110000000... 111111111pour obtenir l'état de la planche à chacun des neuf moments dans le temps.
      • {... }¨↓: pour chacun d'eux, exécutez la fonction suivante:
        • ⍉(9⍴2)⊤⎕UCS'㗀㐇㔤㑉㔑㑔': obtenez les bitboards pour chaque situation gagnante possible
        • ⍵∘{⍵≡⍵∧⍺}¨↓: andchaque état gagnant avec le bitboard actuel et vérifier si cet état gagnant est toujours là
      • ∨/↑: orceux - ci ensemble, donnant s'il y a une victoire sur ce bitboard
    • 1∊T←↑: créez une matrice 9x2, avec les 9 pas de temps X sur la première ligne et les 9 pas de temps O sur la deuxième ligne. Stockez-le dans T. S'il y a un 1 dans cette matrice, quelqu'un a gagné.
    • :'XO'[1+</+/T]: Si quelqu'un a gagné, donnez «X» ou «O» selon le 1premier.
    • ⋄'D': Si personne n'a gagné, donnez «D».
• ↑: créez une matrice à partir de celles-ci afin qu'elles s'affichent chacune sur une ligne distincte.

Python Ungolfed

from itertools import*
r=range
W=[[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]
def c(B):
    for i in r(8):
                if B[W[i][0]]==B[W[i][1]]==B[W[i][2]]:
                        return 1
        return 0

for i in permutations('012345678',9):
    B=[]
    for j in r(9):
        B.append(-(j+1))
    k=0
    F=1
    for j in r(9):
        k=[1,0][k]
        B[int(i[j])]=k
        if c(B):
            F=0
            break
    print "".join(i),':',[['0','X'][k],'D'][F]

C ++ non golfé

#include<iostream>
using namespace std;
#include<algorithm>

int check(int B[])
{
        for (int i=0;i<3;i++)
                if ((B[3*i]==B[3*i+1]&&B[3*i]==B[3*i+2]) || (B[i]==B[i+3]&&B[i]==B[i+6]))
                        return 1;
        if ((B[2]==B[4]&&B[2]==B[6]) || (B[0]==B[4]&&B[0]==B[8]))
                return 1;
        return 0;               
}
int main()
{
        char c[11]="012345678";
        int B[9],i,j;
        do{
                for (i=0;i<9;i++)B[i]=-(i+1);
                for (i=0,j=1;i<9;i++,j=j?0:1)
                {
                        B[c[i]-'0']=j;
                        if (check(B))
                                break;
                }
                printf("%s:%c\n",c,i<9?j?'X':'O':'D');
        }while (next_permutation(c,c+9));
}

Python 2.7 (237)

from itertools import*
for z in permutations('012345678'):
 k,F=0,[9]*9
 for h in z:
    F[int(h)]=k=1-k
    if any(sum(a)in(0,3)for a in(F[:3],F[3:6],F[6:],F[::3],F[1::3],F[2::3],F[::4],F[2:8:2])):break
 else:k=2
 print"".join(z)+':','OXD'[k]