Thử thách

Đưa ra một bảng tic-tac-toe ở bất kỳ định dạng nào, xác định xem nó có hợp lệ hay không. Nếu một bảng có thể là kết quả của một trò chơi tic-tac-toe, thì nó là hợp lệ. Ví dụ: bảng này hợp lệ:

XOX
OXO
XOX

tình dục
XXO
OOo

Đầu vào

• Một bảng tic tac toe đầy đủ (9/9) (kết quả, không phải trò chơi).

Quy tắc

• Định dạng đầu vào phải có thể mô tả tất cả 512 bảng đầu vào có thể. Nó phải được chỉ định, cùng với các hướng dẫn để tạo nó nếu nó tối nghĩa / không rõ ràng. Bạn phải nêu các dấu hiệu của bảng cá nhân mặc dù.
• Phải có hai đầu ra có thể, một cho tính hợp lệ và một cho tính vô hiệu.
• Bạn có thể cho rằng bảng không có điểm trống.

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

Có hiệu lực:

XOX
OXO
XOX

XOX
XOX
OXO

XOO
OOX
OXX

OXO
XOX
OXO

Không hợp lệ:

tình dục
tình dục
tình dục

OOo
OOo
OOo

tình dục
OOo
tình dục

OOo
OOX
tình dục

XXO
OXO
OOX

Một sự giúp đỡ nho nhỏ?

Một bảng được coi là hợp lệ (đối với thử thách này) khi và chỉ khi hai điều kiện sau giữ:

• Có 5 X và 4 O, hoặc 4 X và 5 O. Ví dụ:

  tình dục
  OXO
  tình dục

  được coi là không hợp lệ, vì có 7 X và 2 Os.
• Chỉ có người chơi có 5 điểm đã giành chiến thắng, hoặc không ai trong số họ giành được. Ví dụ,

  tình dục
  OOo
  OOX

  được coi là không hợp lệ, vì hàng của Os hoặc hàng Xs sẽ được hình thành đầu tiên. Hai người chơi không thể quay đầu cùng một lúc.

Người chiến thắng hiện tại là ...

... câu trả lời Jelly của ais523 , với 26 byte đáng kinh ngạc!

Thạch , 26 byte

ṢŒrṪ4=$$Ðfx3ðœ-µẆm€6R¤;/µL

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

Các định dạng đầu vào là một chút khác thường; đó là một chuỗi đại diện cho hội đồng quản trị, nhưng với dòng mới của Windows (trả lại vận chuyển theo dòng mới). Ví dụ , XXO\r\nOXO\r\nOOX. (Trên thực tế, bất kỳ chuỗi đệm hai ký tự nào giữa các dòng đều hoạt động, nhưng các dòng mới của Windows có khả năng phòng thủ cao hơn nhiều so với các tùy chọn khác.)

Ý tưởng cơ bản là chúng tôi tìm kiếm các ký tự xuất hiện 4 lần trong đầu vào, nhưng không có ba lần xuất hiện cách đều nhau trong chuỗi gốc. Với hai hoặc nhiều ký tự đệm giữa các đường của lưới 3 × 3, tất cả các đường ngang, dọc và chéo đều cách đều nhau, nhưng không có dòng nào cách đều nhau có thể có ba phần tử.

Giải trình:

Các ðvà µs là các phân tách chuỗi , phân chia chương trình thành nhiều phần độc lập. Tôi đã thay thế chúng bằng các khoảng trắng bên dưới, để làm cho mọi thứ rõ ràng hơn một chút.

ṢŒrṪ4=$$Ðfx3 œ- Ẇm€6R¤;/ L
Ṣ                           sorted version of the input
 Œr                         run-length-encode it
        Ðf                  keep only elements where
   Ṫ                        delete the last element, and it was
    4=                      equal to 4
      $$                    parse Ṫ4= as a group
          x3                repeat each element three times

                Ẇ           all sublists of the input
                 m€         take every nth element of each (€) sublist
                   6R       for each n in 1..6
                     ¤      parse 6R as a group
                      ;/    flatten one level (m€ creates a nested structure)

             œ-             multiset difference
                         L  length of that difference

Nói cách khác, chúng tôi tìm thấy danh sách các ký tự xuất hiện chính xác bốn lần trong đầu vào và tạo một danh sách bao gồm ba bản sao của mỗi ký tự đó; chúng tôi tìm thấy danh sách tất cả các chuỗi con cách đều nhau trong chuỗi gốc; và nếu chúng tôi trừ lần thứ hai từ lần đầu tiên, chúng tôi muốn kết quả có độ dài 1 (tức là một người chơi đã chơi bốn lần nhưng không thắng). Lưu ý rằng khi chúng tôi ở trên lưới 3 × 3 và mọi ô vuông đều đầy, cả hai người chơi đều không thể chơi bốn lần. Trong Jelly, 1 là sự thật, 0 là falsey, vì vậy chúng ta không cần phải làm gì đặc biệt để chuyển đổi danh sách kết quả thành boolean. (Tuy nhiên, điều µLnày là bắt buộc, vì nếu không cả hai “XXX”và “OOO”sẽ có thể là các giá trị đầu ra trung thực và câu hỏi yêu cầu tất cả các bảng hợp lệ cung cấp cùng một đầu ra.)

JavaScript (ES6), 88 87 byte

s=>(a=[...s]).sort()[5]-a[3]&[7,56,73,84,146,273,292,448].every(j=>j&i,i=`0b`+s^~-a[4])

Đưa đầu vào như là một chuỗi của 9 0và 1ký tự và lợi nhuận 1cho hợp lệ, 0cho hợp lệ. Chúng tôi sắp xếp các nhân vật theo thứ tự. Nếu ba ký tự ở giữa bây giờ giống nhau thì bảng không hợp lệ vì có quá nhiều một mảnh. Mặt khác, chúng tôi chuyển đổi bảng gốc thành nhị phân, lật các bit nếu có nhiều 0s hơn 1s. Tại thời điểm này, bảng là hợp lệ nếu 0không có một dòng ba, vì vậy chúng tôi chỉ cần kiểm tra tất cả tám dòng thông qua một loạt các bitmasks. Chỉnh sửa: Đã lưu 1 byte nhờ @ETHproductions.

Python 3, 131 127 125 100 96 byte

Đối với một cách tiếp cận thuật toán khác (và một cách tiếp cận thực sự phù hợp với các ngôn ngữ chơi gôn nhiều byte này với tính năng nén tích hợp), thay vì tính toán nếu bảng có hợp lệ hay không, hãy có một số 512 bit trong đó mỗi bit đại diện cho dù có hay không một bảng cụ thể có hợp lệ hay không và chuyển vào một giá trị nhị phân đại diện cho bảng. Hơn nữa, do tính đối xứng, nửa sau của bảng có thể được loại bỏ, cùng với một loạt các số không:

def z(b):return int('agqozfx67wwye6rxr508ch2i8qicekpreqkap0725pk',36)<<24&1<<b+(b>255)*(511-b-b)

Giá trị thử nghiệm:

X X X
O X O
X X X

Được biểu diễn dưới dạng giá trị nhị phân 0b111010111và hàm trả về giá trị khác không nếu bảng hợp lệ.

Hàng loạt, 140 byte

@set/aXXX=OOO=O=0
@for %%l in (%* %1%2%3 %1%4%7 %1%5%9 %2%5%8 %3%5%7 %3%6%9 %4%5%6 %7%8%9)do @set/a%%l+=1
@cmd/cset/a!XXX*!(O-=5)+!OOO*!~O

Đưa đầu vào thành chín đối số và đầu ra dòng lệnh riêng biệt 1hợp lệ và 0không hợp lệ. Hoạt động bằng cách theo dõi số lần nó nhìn thấy Ovà một dòng trực giao của OOOhoặc XXX. Thuận tiện hàng loạt cho phép chúng tôi thực hiện gián tiếp số học số nguyên, vì vậy chúng tôi không tăng %%lmà thay vào đó là một số biến (mặc dù chúng tôi chỉ quan tâm đến ba biến được đề cập). Sau đó, chúng tôi cần kiểm tra xem Xcó chiến thắng nào không và có năm Ogiây hoặc Okhông thắng và có bốn Ogiây.

Toán học, 82 75 byte

Cảm ơn Martin Ender đã lưu 7 byte!

t=Total;3<(b=#~t~2)<6&&{t[c=If[b>4,1-#,#]],t/@c,Tr@c,Tr@Reverse@c}~FreeQ~3&

Hàm không tên lấy danh sách lồng nhau 3x3 gồm 1 và 0 làm đầu vào và đầu ra Truehoặc False.

Sử dụng một số tính linh hoạt tiện dụng của Totalhàm (ở đây được đánh gôn t): đưa ra một mảng ví dụ e = { {1,2,3} , {4,5,6} , {7,8,9} }, lệnh t[e]tổng hợp ba vectơ (ở đây cho năng suất {12,15,18}); lệnh t/@etổng hợp từng danh sách con riêng lẻ (ở đây cho năng suất {6,15,24}); và lệnh e~t~2tổng hợp tất cả chín yếu tố (ở đây cho năng suất 45).

Vì vậy, trước tiên chúng tôi kiểm tra, với 3<(b=#~t~2)<6, tổng số 1s là 4 hay 5; nếu không chúng ta thoát với False. Nếu vậy, chúng tôi sử dụng c=If[b>4,1-#,#]để buộc có bốn 1 chứ không phải năm. Sau đó, chúng tôi tính tổng các cột t[c], tổng hàng t/@c, tổng của đường chéo chính Tr@cvà tổng của đường chéo đối diện Tr@Reverse~cvà sử dụng ~FreeQ~3để kiểm tra xem 3không xuất hiện ở bất kỳ cấp nào trong các tổng được tính toán đó.

Lưu ý bên thú vị: không giống như hầu hết các lần xuất hiện trên trang web này, ở đây Trkhông được sử dụng để tổng hợp danh sách một chiều mà thực sự được sử dụng như một thiết kế để tính toán dấu vết của ma trận hai chiều!

Pyth - 36 byte

Tôi bao gồm diagas và sử dụng hai chim nhạn thay thế.

JsM+sCBQm@VdU3_BQ?q5KssQ*FJ?qK4!}3JZ

Phòng thử nghiệm

JavaScript (ES6), 101 byte

Lấy đầu vào dưới dạng mặt nạ nhị phân 9 bit trong đó X = 1và O = 0(MSB = ô trên cùng bên trái, LSB = ô dưới cùng bên phải).

n=>[7,56,73,84,146,273,292,448,o=x=0].map((m,i)=>(c-=n>>i&1,m&n^m?m&n||o++:m&&x++),c=4)&&!(c|x&&~c|o)

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

let f =

n=>[7,56,73,84,146,273,292,448,o=x=0].map((m,i)=>(c-=n>>i&1,m&n^m?m&n||o++:m&&x++),c=4)&&!(c|x&&~c|o)

// valid
console.log(f(0b101010101));
console.log(f(0b101101010));
console.log(f(0b100001011));
console.log(f(0b010101010));

// invalid
console.log(f(0b111111111));
console.log(f(0b000000000));
console.log(f(0b111000111));
console.log(f(0b000001111));
console.log(f(0b110010001));

Con trăn 2 158 132 109 92 91 123 byte

def v(b):f=sum(b,());w={x[0]for x in b+zip(*b)+[f[::4],f[-3:1:-2]]if len(set(x))==1};return sum(map(`b`.count,w))==len(w)*5

Đầu vào là một danh sách / bộ hàng, mỗi chuỗi gồm ba chuỗi, ví dụ:
[('X', 'O', 'X'), ('O', 'X', 'O'), ('X', 'O', 'X')]

Đã lưu một số byte bằng cách bỏ qua các đường chéo cho mỗi câu trả lời của @ Maltysen, cũng rút ngắn biểu thức sau đây.

Cảm ơn @vaultah vì đã tiết kiệm 17 18 byte.

Kiểm tra các đường chéo hóa ra là cần thiết, loại bỏ rất nhiều khoản tiết kiệm ở trên.

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

Giải trình

def v(b):
  f=sum(b,())
  w={x[0]for x in b+zip(*b)+[f[::4],f[-3:1:-2]]if len(set(x))==1}
  return sum(map(`b`.count,w))==len(w)*5

flà đầu vào dẹt để cắt.
wchứa các nhân vật với chuỗi chiến thắng.
Đếm số lần xuất hiện của mỗi nhân vật chiến thắng, sẽ là 0 nếu wtrống hoặc 5 nếu len(w)là 1. Tổng 10 khi cả hai có chuỗi chiến thắng là không thể. Người chiến thắng có 5 ngụ ý người thua có 4. Bạn không thể có> 5 mà không có chuỗi chiến thắng.

R, 88 82 byte

x=scan();`if`(sum(x)%in%4:5,all(apply(combn(which(x==(sum(x)<5)),3),2,sum)!=15),F)

Tất cả các kết hợp của ba số nguyên từ 1 đến 9 có tổng bằng 15 là các hàng / cột / đường chéo của hình vuông được hiển thị bên dưới.

2 7 6
9 5 1
4 3 8

Hàm lấy đầu vào là một vectơ của booleans, T cho "X", F cho "O", là biểu diễn phẳng của bảng. NHƯNG, những thứ này được sắp xếp lại sao cho chỉ số của chúng giống với số trong hình vuông, theo thứ tự (2,7,6,9,5,1,4,3,8). Lệnh đó có thể đạt được bằng cách làm phẳng bảng theo cách thông thường, và sau đó cắt bằng c (6,1,8,7,5,3,2,9,4). Vậy đây

X O X
O X O
X O X

được thể hiện dưới dạng:

c(T, F, T, F, T, F, T, F, T)[c(6,1,8,7,5,3,2,9,4)]

đó là:

c(F, T, F, T, T, T, F, T, F)

Chức năng đầu tiên xác định xem có một người chơi có chính xác bốn điểm hay không. Nếu vậy, hàm sẽ sử dụng thực tế của những thứ đó để thêm vào để xác định xem người chơi đó có ba liên tiếp hay không (bảng không hợp lệ nếu người chơi làm như vậy).

Nếu bạn muốn lấy một bảng phẳng theo quy ước làm đầu vào, thay vào đó, mã sẽ trông như thế này:

f=function(x)ifelse(sum(x)%in%4:5,all(apply(combn(c(2,7,6,9,5,1,4,3,8)[which(x==(sum(x)<5))],3),2,sum)!=15),F)

Tôi mới ở đây, lời khuyên sẽ được đánh giá cao.

JavaScript (ES6), 145 139 131 127 byte

s=>!(q="XO"[s.split`O`.length-5])|![...s].some((c,i)=>c==q&!/(.)(\1|..(\1|.(\1|.\1.).)..)\1/.test(s.slice(0,i)+0+s.slice(i+1)))

Đầu vào dưới dạng một chuỗi phân tách không gian, chẳng hạn như "XOX OXO XOX". Đầu ra 1cho một bảng không hợp lệ, 0cho một bảng hợp lệ. Đây rõ ràng không phải là kỹ thuật tốt nhất, ít nhất là không phải với JavaScript ...

Điều này về cơ bản kiểm tra xem cả hai giữ sau:

• Có chính xác 4 hoặc 5 Ogiây, VÀ
• có ít nhất một trong số 5 phần tạo ra một trò chơi chưa quyết định khi bị xóa.

Regex là để kiểm tra xem một trò chơi đã được quyết định chưa. Nó phù hợp với một bảng iff có bất kỳ bước chạy nào có độ dài ba của một ký tự với 0 (hàng), 2 (đường chéo xuống bên phải), 3 (cột) hoặc 4 (đường chéo xuống bên trái) phân tách mỗi cặp.

Kiểm tra đoạn

f=s=>!(q="XO"[s.split`O`.length-5])|![...s].some((c,i)=>c==q&!/(.)(\1|..(\1|.(\1|.\1.).)..)\1/.test(s.slice(0,i)+0+s.slice(i+1)))

g=s=>console.log(f(s))

// Valid boards (outputs 0)
g("XOX OXO XOX")
g("XOX XOX OXO")
g("XOO OOX OXX")
g("OXO XOX OXO")

// Invalid boards (outputs 1)
g("XXX XXX XXX")
g("OOO OOO OOO")
g("XXX OOO XXX")
g("OOO OOX XXX")
g("XXO OXO OOX")

Ruby, 104 99 91 byte

->x{[7,56,448,292,146,73,84,273].none?{|y|b=x.to_i 2;((a=x.count'1')==4?b:a==5?~b:7)&y==y}}

Định dạng đầu vào: chuỗi nhị phân gồm 9 ký hiệu (0 và 1) đại diện cho bảng, ví dụ trường hợp thử nghiệm đầu tiên là 101010101. Trước tiên hãy chuyển đổi nó thành một số nhị phân, kiểm tra xem popcount là 4 hay 5, nếu đó là 5 đảo ngược số đó để chúng ta luôn có 4. Kiểm tra xem ba trong số chúng có được căn chỉnh không (mặt nạ theo chiều ngang, dọc, chéo).

TL; DR : Trả về false nếu người chơi có 4 điểm thắng, ngược lại.

Cảm ơn Jordan cho ý kiến,

Tôi không thể tái tạo chuỗi UTF-8 sẽ lưu một byte khác.

Perl 6 , 103 99 byte

{my \c=%(.flat.Bag.invert)<5>;?all c,|(.[0]===c if [eq] $_ for |.flat[<0 4 8>,<2 4 6>],|$_,|.&zip)}

Một lambda chấp nhận một danh sách các danh sách như (('X','O','X'), ('O','X','O'), ('X','O','X'))và trả về Bool.

Nó hoạt động như thế này:

1. Kiểm tra xem dấu nào xuất hiện chính xác 5 lần và lưu nó vào c. (Nếu không có dấu nào xuất hiện chính xác 5 lần, điều này sẽ chứa giá trị giả)
2. Lặp lại trên tất cả các đường chéo, hàng và cột và lọc ra những cái "chiến thắng" (tức là những cái mà cả ba chữ cái đều bằng nhau) .
3. Kiểm tra xem ccó đúng không, và mỗi dòng chiến thắng là loại c.

PHP, 125 byte

for($p=$n=$argv[1];$p;$p/=2)$i+=$p&1;foreach([7,56,448,73,146,292,273,84]as$m)$n&$m^$m?$n&$m||$o++:$x++;echo!$x|!$o&&2>$i^=4;

Tôi có cùng một ý tưởng với Arnauld : Bảng này hợp lệ nếu có 4 hoặc 5 bit được đặt và Xhoặc Ohoặc không ai có một vệt (nhưng không phải cả hai).

Để tạo đầu vào từ trường thay thế Xbằng 1và Obằng 0, nối các dòng và chuyển đổi nhị phân thành thập phân, cung cấp làm đối số dòng lệnh.

bản in 1hợp lệ; đầu ra trống cho không hợp lệ. Chạy với -r.

phá vỡ

// count set bits
for($p=$n=$argv[1];$p;$p/=2)$i+=$p&1;
    /* ($p/=2 takes longer than $p>>=1, but eventually
       $p will come close enough to 0 for the loop to finish */
// count streaks for X and O
foreach([7,56,448,73,146,292,273,84]as$m)
    $n&$m^$m            // ($n masked with streak)!=streak <=> no streak for X
        ?$n&$m||$o++    // true: O has a streak if ($n masked with streak) is empty
        :$x++;          // false: X has a streak
echo!$x|!$o&&2>$i^=4;   // valid if not both have a streak
                        // AND $i is 4 or 5 (toggle 4 -> result 0 or 1)

Swift, 178 byte

func t(i:String)->Bool{let r=i.characters.filter({$0=="X"}).count;let g=i.characters.split(separator:"\n").map(String.init).contains;return(r==5||r==4)&&(!g("XXX") && !g("OOO"))}

ES6 (Javacript), 130, 138, 117 byte

CHỈNH SỬA:

• Giảm 21 byte nhờ lời khuyên tuyệt vời từ @Neil!
• Phiên bản ban đầu dễ bị lỗi, hiện đã được sửa với giá 8 byte. (Cảm ơn @ETHproductions đã chỉ ra)

Một cách tiếp cận straighforward cực đoan. Có lẽ có thể được chơi golf thêm một chút.

Chấp nhận đầu vào dưới dạng 9 đối số riêng biệt, 1es và 0es

• 1 là cho X
• 0 là cho O

Đối số: 1-3 - hàng đầu tiên, 4-6 - hàng thứ hai, 7-9 - hàng thứ ba.

Chơi gôn

(a,b,c,d,e,f,g,h,j)=>![a+b+c,d+e+f,g+h+j,a+d+g,b+e+h,c+f+j,a+e+j,g+e+c,7].some(x=>x=="7777307777"[a+b+c+d+e+f+g+h+j])

"Giường thử" tương tác

var a=b=c=d=e=f=g=h=j=0;

T=(a,b,c,d,e,f,g,h,j)=>![a+b+c,d+e+f,g+h+j,a+d+g,b+e+h,c+f+j,a+e+j,g+e+c,7].some(x=>x=="7777307777"[a+b+c+d+e+f+g+h+j]);

function test() {
  if(T(a,b,c,d,e,f,g,h,j)) {
     grid.style.backgroundColor='green';
     msg.innerHTML="GOOD"
  } else {
     grid.style.backgroundColor='red';
     msg.innerHTML="BAD"
  }
}

<table id=grid style="background: red">
<thead>
  <tr>
     <td id=msg align="center" colspan="3">BAD</td>
    </tr>
  </thead>
  <tr>
      <td><input type="checkbox" onchange="a=this.checked*1;test();" id="ca"/></td>
      <td><input type="checkbox" onchange="b=this.checked*1;test();" id="cb"/></td>
      <td><input type="checkbox" onchange="c=this.checked*1;test();" id="cc"/></td>
    </tr>
    <tr>
      <td><input type="checkbox" onchange="d=this.checked*1;test();" id="cd"/></td>
      <td><input type="checkbox" onchange="e=this.checked*1;test();" id="ce"/></td>
      <td><input type="checkbox" onchange="f=this.checked*1;test();" id="cf"/></td>
    </tr>
    <tr>
      <td><input type="checkbox" onchange="g=this.checked*1;test();" id="cg"/></td>
      <td><input type="checkbox" onchange="h=this.checked*1;test();" id="ch"/></td>
      <td><input type="checkbox" onchange="j=this.checked*1;test();" id="cj"/></td>
    </tr>
 </table>