Lý lịch

^{Bỏ qua "Nhiệm vụ" nếu bạn quen thuộc với Tic-Tac-Toe (Tôi nghĩ hầu hết là vậy!)}

Tic-Tac-Toe là một trò chơi hai người nổi tiếng. Nó bao gồm một bảng 3x3 được lấp đầy dần bởi hai người chơi (làm rõ bên dưới); Người chơi đầu tiên sử dụng nhân vật Xvà người khác sử dụng O. Người chiến thắng là người đầu tiên nhận được 3 ký tự liên tiếp và giống hệt nhau ( Xhoặc O), theo chiều ngang, chiều dọc hoặc đường chéo. Trong trường hợp bảng được lấp đầy và không ai trong số những người chơi quản lý để có được ba nhân vật liên tiếp như đã giải mã ở trên, trò chơi kết thúc bằng hòa. Lưu ý rằng có thể có những điểm trống ở cuối trò chơi, trong trường hợp một trong hai người chơi thắng tổng cộng dưới 9 lần di chuyển (điều này không thể xảy ra trong trường hợp hòa).

Bài tập

Đưa ra một bảng Tic-Tac-Toe ở cuối trò chơi (dưới dạng chuỗi, ma trận, danh sách phẳng gồm 9 giá trị được sắp xếp, bất kỳ định dạng hợp lý nào khác), xác định ai thắng trò chơi.

• Đầu vào sẽ bao gồm các giá trị riêng biệt và nhất quán , một cho X, một cho Ovà một giá trị khác đại diện cho một điểm trống.

• Chương trình của bạn sẽ có thể xuất ra 3 giá trị riêng biệt, nhất quán và không trống: một trong trường hợp Xthắng, một giá trị khác trong trường hợp Othắng hoặc một giá trị khác nếu người chơi bị ràng buộc.

  Vui lòng chỉ định các giá trị này trong câu trả lời của bạn. Bạn có thể giả định rằng đầu vào sẽ là một bảng Tic-Tac-Toe hợp lệ.

Các trường hợp thử nghiệm

X, O, _Là những giá trị đầu vào ở đây; X wins, O winsvà Tielà cho đầu ra.

X O X
O X _
O _ X

Đầu ra : X wins.

X _ O
X O _
X O X

Đầu ra : X wins.

X O X
_ O X
_ O _

Đầu ra : O wins.

X O X
O O X
X X O

Đầu ra : Tie.

Như thường lệ, tất cả các quy tắc tiêu chuẩn của chúng tôi áp dụng. Đây là code-golf , mã ngắn nhất tính theo byte trong mọi ngôn ngữ sẽ thắng!

Thạch ,  16 15  14 byte

U,Z;ŒD$€ẎḄỊÐḟḢ

Một liên kết đơn âm chấp nhận danh sách các danh sách (các hàng - hoặc cột) với các giá trị:

X = 0.155; O = -0.155; _ = 0

Kết quả trả về:

X wins = 1.085; O wins = -1.085; Tie = 0

Lưu ý: sử dụng giá trị 0 cho _và giá trị bằng nhau nhưng ngược lại cho Xvà O, giá trị này (ở đây 0.155) có thể nằm trong phạm vi (1/6, 1/7)(không bao gồm ở cả hai đầu) - Tôi chỉ chọn một giá trị trong phạm vi đó cho kết quả điểm nổi có thể biểu thị chính xác cho các trường hợp thắng.

Hãy thử trực tuyến!

Làm sao?

U,Z;ŒD$€ẎḄỊÐḟḢ - Link: list of lists (as described above)
U              - upend (reverse each row)
  Z            - transpose (get the columns)
 ,             - pair the two
      $€       - last two links as a monad for each of them:
    ŒD         -   diagonals (leading diagonals - notes: 1. only one is of length 3;
               -              2. the upend means we get the anti-diagonals too)
        Ẏ      - tighten (make a single list of all the rows, columns and diagonals)
         Ḅ     - from binary (vectorises) (note that [0.155, 0.155, 0.155]
               -                           converts to 4*0.155+2*0.155+1*0.155 = 1.085
               -                           and [-0.155, -0.155, -0.155]
               -                           converts to 4*-0.155+2*-0.155+1*-0.155 = -1.085
               -                           while shorter lists or those of length three
               -                           with any other mixtures of 0.155, -0.155 and 0
               -                           yield results between -1 and 1
               -                           e.g. [.155,.155,0] -> 0.93)
           Ðḟ  - filter discard if:
          Ị    -   insignificant (if abs(z) <= 1) (discards all non-winning results)
             Ḣ - head (yields the first value from the list or zero if it's empty)

Javascript (ES6), 103 87 byte

a=>"012+345+678+036+147+258+048+246T".replace(/\d/g,n=>a[n]||!1).match(/(\d)\1\1|T/)[0]

Đầu vào

• X được biểu diễn dưới dạng 1
• O được biểu diễn dưới dạng 2
• _ được biểu diễn dưới dạng 0

Đầu ra

• X thắng được thể hiện là "111"
• O thắng được thể hiện là "000"
• Cà vạt được thể hiện là "T"

Giải trình

a=>
    "012+345+678+036+147+258+048+246" // List of indexes for each row
    .replace(/\d/g,n=>a[n]||!1)       // Replace all digits with the value of the cell
    .match(/(\d)\1\1|$/)[0]           // Find the first row filled with the same value

Các trường hợp thử nghiệm

f=
a=>"012+345+678+036+147+258+048+246T".replace(/\d/g,n=>a[n]||!1).match(/(\d)\1\1|T/)[0]
console.log(f([1,2,1,2,1,0,2,0,1]))
console.log(f([1,0,2,1,2,0,1,2,1]))
console.log(f([1,2,1,0,2,1,0,2,0]))
console.log(f([1,2,1,2,2,1,1,1,2]))

Thạch , 18 byte

UŒD;;Z;ŒDµSA⁼3µÐfḢ

Hãy thử trực tuyến!

X= 1, O= -1, _= 0
X thắng = [1, 1, 1], O thắng = [-1, -1, -1], Tie = 0
Nhập dưới dạng danh sách 3 danh sách gồm 3 phần tử trong (1, -1, 0)mỗi.

Con trăn 3 , 73 byte

lambda b:{'XXX','OOO'}&{*b.split(),b[::4],b[1::4],b[2::4],b[::5],b[2::3]}

Hãy thử trực tuyến!

Python 2 , 100 95 92 87 82 77 byte

lambda b:{'XXX','OOO'}&set(b.split()+[b[::4],b[1::4],b[2::4],b[::5],b[2::3]])

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi phân tách dòng mới của XO_

Đầu ra:

• {'XXX'} cho X,
• {'OOO'} cho O
• {} cho một cái cà vạt

Hoạt động bằng cách cắt chuỗi thành cột hàng và đường chéo:

The board:
    1 2 3
    4 5 6
    7 8 9
which is '123\n456\n789' is sliced into:

['123', '456', '789', '147', '258', '369', '159', '357']
rows: b.split() -> ['123', '456', '789']
cols: [b[::4],b[1::4],b[2::4]] -> ['147', '258', '369']
diag: [b[::5],b[2::3]] -> ['159', '357']

sau đó 'XXX'và 'OOO'được kiểm tra đối với các lát.

Đưa đầu vào dưới dạng một chuỗi phân tách dòng mới của XO_

Đầu ra:

• {'XXX'}cho X,
• {'OOO'} cho O
• {} cho một cái cà vạt

Hoạt động bằng cách cắt chuỗi thành cột hàng và đường chéo:

The board:
    1 2 3
    4 5 6
    7 8 9
which is '123\n456\n789' is sliced into:

['123', '456', '789', '147', '258', '369', '159', '357']
rows: b.split() -> ['123', '456', '789']
cols: [b[::4],b[1::4],b[2::4]] -> ['147', '258', '369']
diag: [b[::5],b[2::3]] -> ['159', '357']

sau đó 'XXX'và 'OOO'được kiểm tra đối với các lát.

R, 118 116 115 byte

Cảm ơn @ user2390246 cho hai byte bổ sung.

function(M,b=table,u=unlist(c(apply(M,1,b),apply(M,2,b),b(diag(M)),b(M[2*1:3+1]))))`if`(any(u>2),names(u[u>2]),"T")

Hơi vô dụng:

function(M){
    u=unlist(c(apply(M,1,table), #Contingency table of the rows
             apply(M,2,table), #of the columns
             table(diag(M)), #of the diagonal
             table(M[2*1:3+1]))) #of the opposite diagonal
    `if`(any(u>2),names(u[u>2]),"T") #Give name of element that occurs more than twice in any setting
 }

Trả về Xnếu X thắng, Onếu O thắng và Ttrong trường hợp hòa.

Hãy thử trực tuyến!

Perl 5 , 58 byte

Mã 56 byte + 2 fpr -p0.

$_=eval sprintf'/(.)(.{%s}\1){2}/s||'x4 .'0?$1:T',0,2..4

Hãy thử trực tuyến!

Đầu ra Xvà Ocho chiến thắng, hoặcT cho một tie. Bao gồm một loạt mã tiêu đề / chân trang để kiểm tra tất cả cùng một lúc.

Thay thế, 58 byte

$}.="/(.)(.{$_}\\1){2}/s||"for 0,2..4;$_=eval$}.'0?$1:T'

Hãy thử trực tuyến!

Python 2 , 124 118 117 115 byte

• Đã lưu sáu byte nhờ Erik the Outgolfer ; sử dụng một chuỗi để tránh dấu phẩy.
• Đã lưu một byte nhờ ông Xcoder ; chơi golf [j*3:j*3+3]để [j*3:][:3].
• Đã lưu hai byte bằng cách sử dụng một số ma thuật để nén chuỗi.

def T(B):
 for j in range(8):
	a,b,c=map(int,`0x197bf3c88b2586f4bef6`[j*3:][:3])
	if B[a]==B[b]==B[c]>0:return B[a]

Hãy thử trực tuyến!

Giá trị đầu vào / đầu ra

• X được đại diện như 1
• O được đại diện như 2
• _ được đại diện như None

Python 3 , 173 byte

lambda x:h(x,1)*2or+h(x,0)
h=lambda x,y:g(x,y)or g(zip(*x),y)or x[0][0]==x[1][1]==x[2][2]==y or x[0][2]==x[1][1]==x[2][0]==y
g=lambda x,y:any(all(e==y for e in r)for r in x)

Hãy thử trực tuyến!

• Đầu vào dưới dạng ma trận 1 == X, 0 == O, -1 == _

• Đầu ra dưới dạng một giá trị: 2 == X, 1 == O, 0 == TIE

-8 byte nhờ Erik the Outgolfer

PHP, 70 byte

for($c=95024101938;${${$i++&7}.=$argn[$c%9]}=1<$c/=3;);echo$XXX-$OOO;

Giả định -n(thông dịch mặc định). Ngoài ra yêu cầu -R(thực hiện<code> cho mỗi dòng đầu vào), được tính là một.

Đầu vào được lấy trên một dòng duy nhất (chính xác như trong mô tả vấn đề, ngoại trừ với tất cả khoảng trắng được loại bỏ).

Đầu ra là như sau: 1→ X Thắng, -1→ O Thắng, 0→ Tie.

Hãy thử trực tuyến!

Võng mạc , 49 byte

;
;;
.*(\w)(.)*\1(?<-2>.)*(?(2)(?!))\1.*
$1
..+
T

Hãy thử trực tuyến! Đưa đầu vào dưới dạng chuỗi 11 ký tự gồm 9 Xs, Os hoặc -s trong ba nhóm ba được phân tách bằng ;s, mặc dù liên kết bao gồm một tiêu đề giúp dịch các trường hợp thử nghiệm đã cho sang định dạng này. Hoạt động bằng cách khớp trực tiếp một dòng chiến thắng bằng cách sử dụng một nhóm cân bằng để đảm bảo rằng ba nhân vật phù hợp là tương đương nhau. (Khoảng cách phù hợp là 0 (đường ngang), 4 (đường chéo ngược), 5 (đường dọc) hoặc 6 (đường chéo); các khoảng cách khác sẽ chạm a ;hoặc kéo dài ra ngoài chuỗi.)

Java 8, 112 108 106 104 90 102 93 byte

b->b.replaceAll(".*(X|O)(\\1|...\\1...|.{4}\\1.{4}|..\\1..)\\1.*","$1").replaceAll("..+","T")

+12 byte (90 → 102) do sửa lỗi chỉ kiểm tra một đường chéo thay vì cả hai ..
-9 byte (102 → 93) bằng cách sử dụng replaceAllthay vìmatches .

Đầu vào ở định dạng XOX OX_ O_X, đầu ra X, Ohoặc T.

Giải trình:

Hãy thử nó ở đây.

b->{                   // Method with String as both parameter and return-type
  b.replaceAll(".*(X|O)(\\1|...\\1...|.{4}\\1.{4}|..\\1..)\\1.*",
                       //  If we found a line of X or O:
     "$1")             //   Replace it with either X or O
   .replaceAll("..+",  //  If there are now more than 2 characters left:
     "T")              //   Replace it with T
                       // End of method (implicit / single-line return-statement)

Regex giải thích:

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
.*                                      .*# 0 or more trailing & leading chars
  (X|O)                               \1  # X or O next to those leading/trailing chars
       (\1                                # A single X or O in between (row found)
          |...\1...                       # 3 chars, X or O, 3 chars (column found)
                   |.{4}\1.{4}            # 4 chars, X or O, 4 chars (diagonal TL→BR found)
                              |..\1..)    # 2 chars, X or O, 2 chars (diagonal TR→BL found)

Võng mạc , 127 byte

.*(X|O)\1\1.*
$1
(X|O).. \1.. \1..
$1
.(X|O). .\1. .\1.
$1
..(X|O) ..\1 ..\1
$1
(X|O).. .\1. ..\1
$1
..(X|O) .\1. \1..
$1
..+
_

Hãy thử trực tuyến!

... Tôi đoán bạn có thể gọi lực lượng vũ phu này ... Nghĩ rằng có thể có một số công đức cho nó ...

Võng mạc , 51 byte

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
$1
..+
T

Cổng trả lời Java 8 của tôi . Đầu vào ở định dạng XOX OX_ O_X, đầu ra X, Ohoặc T.

Giải trình:

Hãy thử nó ở đây.

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
.*                                      .*# 0 or more trailing & leading chars
  (X|O)                               \1  # X or O next to those leading/trailing chars
       (\1                                # A single X or O in between (row found)
          |...\1...                       # 3 chars, X or O, 3 chars (column found)
                   |.{4}\1.{4}            # 4 chars, X or O, 4 chars (diagonal TL→BR found)
                              |..\1..)    # 2 chars, X or O, 2 chars (diagonal TR→BL found)

$1                                        #  Replace match of above with either X or O

..+                                       # If there are now 2 or more characters left:
T                                         #  Replace everything with T

J, 34 byte

[:>./[:+./"1(2 1 0},:0 1 2}),(,|:)

Ung dung:

[: >./ [: +./"1 (2 1 0} ,: 0 1 2}) , (, |:)

Giải trình

Mã hóa:

X = 2
O = 3
_ = 1

Chiến lược cấp cao của chúng tôi trước tiên là tạo ra một ma trận mỗi hàng có khả năng giành chiến thắng. Hàng một là đường chéo /, hàng 2 là đường chéo \, ba hàng tiếp theo là các hàng và ba hàng cuối cùng là các cột. Phần này được thực hiện bằng cụm từ (sử dụng Mục sửa đổi }):

(2 1 0},:0 1 2}),(,|:)

Cuối cùng, chúng tôi lấy GCD của mỗi hàng:

+./"1

Nhờ mã hóa của chúng tôi, bất kỳ hàng nào có khoảng trống sẽ có GCD là 1, cũng như bất kỳ hàng nào có chứa bất kỳ kết hợp X và Os nào, bởi vì 2 và 3 là nguyên tố cùng nhau. Vì vậy, tất cả những gì chúng ta cần làm tiếp theo là tìm phần tử tối đa:>./

Nếu trò chơi là hòa, nó sẽ là 1. Nếu người chơi thắng, đó sẽ là số của người chơi đó.

Hãy thử trực tuyến!

JavaScript, 66 byte

([a,b,c,d,e,f,g,h,i])=>e&(a&i|c&g|b&h|d&f)|a&(b&c|d&g)|i&(c&f|g&h)

Giữ cho nó đơn giản.

• Đầu vào: Một chuỗi hoặc mảng số hoặc chuỗi 0tương ứng với một khoảng trắng, 1X và2 O.
• Đầu ra: 0cho một tie, 1cho chiến thắng X, 2cho chiến thắng O.

Mở rộng, nhận xét nhẹ:

( [a,b,c,d,e,f,g,h,i] ) => // Break apart the input into nine variables w/ destructuring
  // Run through all possible win conditions. 1&1&1 -> 1, 2&2&2 -> 2
  e & (             // All victories involving the middle square
    a & i | c & g | // Diagonal lines
    b & h | d & f   // Vertical/horizontal through the middle
  ) | 
  a & ( b & c | d & g ) | // Victories with the top-left square
  i & ( c & f | g & h )   // Victories with the bottom-right square