TicTacToeГра може бути представлена у вигляді рядка , що позначає послідовність позицій , як гравці роблять свій хід.

0 1 2
3 4 5
6 7 8

Припустимо, Xзавжди грає першим.

Тож рядок "012345678" позначає гру

XOX
OXO
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 

Це кодовий гольф, і час виконання повинен бути протягом хвилини. Веселіться!

EDIT: Видалено зайві деталі та просто надрукуйте їх stdout. Не потрібно створювати файл.

Рубін 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) Запишіть у stdout замість файлу
• Редагувати: (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, 224 222 символи

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

На жаль, permutationsфункція від 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: Зберігайте в М числах від 1 до 9. Внутрішньо ця програма використовує 1..9 замість 0..8.
• {... }: функція для отримання всіх перестановок:
  • 1≥⍴⍵:↑,↓⍵: якщо довжина менша або дорівнює 1, поверніть аргумент у вигляді матриці.
  • ⋄↑⍪/⍵,∘∇¨⍵∘~¨⍵: в іншому випадку видаліть кожного символу ⍵з ⍵, отримайте перестановки цього і додайте символ назад.
• ¨↓: для кожної перестановки ...
• {... }: функція, яка дає переможцю за цю перестановку:
  • ⊃,/(,/⍕¨⍵-1),':',{... }⍵: отримайте перестановку у вигляді рядка, при цьому всі числа зменшиться на 1 (щоб отримати необхідний вихід 0..8 замість 1..9), після чого двокрапка, а потім символ, що позначає переможця:
    • ⍉5 2⍴0,⍨⍵: розділіть ходи X від кроків О. Оскільки на О на один хід менше, ніж на X, цей простір заповнюється символом 0, який не використовується і тому не впливає на результат.
    • {... }¨↓: і для плати X, і для дошки O запустіть наступну функцію, яка визначає, чи є виграш в одному з дев'яти кроків часу:
      • (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".
• ↑: зробіть з них матрицю, щоб вони відображалися в окремому рядку.

Пітон Унгольф

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 ++ Ungolfed

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