一个TicTacToe游戏可以用一个字符串来表示，该字符串表示玩家移动时的位置顺序。

0 1 2
3 4 5
6 7 8

假设X总是先播放。

因此，字符串“ 012345678”表示游戏

XOX
氧代
XOX

请注意，当玩家X标记时，该游戏已经获胜6，这时游戏结束，向授予胜利X。（即，一旦玩家获胜，忽略其余的举动）

您面临的挑战（代码）是打印所有游戏（排序顺序）及其结果。

格式

<movesequence>:<result>\n

例如：

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

表示X第一个玩家获胜，O第二个玩家和D平局。

将有9!（362880）个游戏。

这是一些数据以验证您的结果。

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

这是一个代码高尔夫，运行时应在一分钟之内。玩得开心！

编辑：删除了多余的详细信息，然后将其打印在上stdout。无需创建文件。

Ruby 1.9，201个字符

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}"}

到目前为止打了一点高尔夫球。大约需要45秒才能完成。

• 编辑：（268-> 249）写入标准输出而不是文件
• 编辑：（249-> 222）不要用每个玩家的移动来预先填充数组。
• 编辑：（222-> 208）找出玩家是否获胜的更短方法
• 编辑：（208-> 213）回到213，以前的解决方案太慢了。
• 编辑：（213-> 201）某些重新排列，删除了空格

J，124个字符

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

X赢，O赢和平局计数签出。

虽然调试起来有点痛苦。:)

Haskell，224222个字符

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")

permutationsfrom ，来自的功能Data.List不会按字典顺序产生排列。所以我不得不花6个字符。

APL（139）

可以将其缩短得更多，但实际上很难。信不信由你，它在我的计算机上运行了大约45秒钟（不包括输出到屏幕上输出所有内容所花费的时间）。

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

说明：

• M←⍳9：在M中存储从1到9的数字。在内部，该程序使用1..9而不是0..8。
• {... }：获取所有排列的函数：
  • 1≥⍴⍵:↑,↓⍵：如果长度小于或等于1，则将参数作为矩阵返回。
  • ⋄↑⍪/⍵,∘∇¨⍵∘~¨⍵：否则，请⍵从中删除每个字符⍵，获取该字符的排列，然后再添加该字符。
• ¨↓：对于每个排列...
• {... }：为该排列排列的获胜者提供的功能：
  • ⊃,/(,/⍕¨⍵-1),':',{... }⍵：以字符串形式获取排列，所有数字均减1（以获得所需的0..8而不是1..9的输出），其后是冒号，然后是表示获胜者的字符：
    • ⍉5 2⍴0,⍨⍵：将X的移动与O的移动分开。由于O的移动小于X，因此该空间由填充，该空间0未使用，因此不会影响结果。
    • {... }¨↓：对于X板和O板，运行以下功能来确定在9个时间步之一中是否有获胜：
      • (M∘.≥M)∧[2]M∊⍵：生成移动数字的棋盘，并and与该位串棋盘100000000，110000000... 111111111得到董事会的状态在每个九个瞬间的时间。
      • {... }¨↓：对于每个选项，运行以下功能：
        • ⍉(9⍴2)⊤⎕UCS'㗀㐇㔤㑉㔑㑔'：针对每种可能的获胜情况获取位板
        • ⍵∘{⍵≡⍵∧⍺}¨↓：and使用当前位板的每个获胜状态，并检查所述获胜状态是否仍然存在
      • ∨/↑：or这些加在一起，给出该位板上是否有胜利
    • 1∊T←↑：制作一个9x2矩阵，第一行有9个X时间步长，第二行有9个O时间步长。将其存储在T中。如果此矩阵中有1，则表示有人赢了。
    • :'XO'[1+</+/T]：如果某人赢了，则根据谁先赢取“ X”或“ O” 1。
    • ⋄'D'：如果没有人赢，给'D'。
• ↑：从这些矩阵中制作一个矩阵，以便将它们分别显示在单独的行上。

虚假的Python

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 ++非高尔夫

#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]