Takuzu là một trò chơi logic trong đó bạn phải hoàn thành một lưới với các ô chứa 0s và 1s. Lưới phải tuân theo 3 quy tắc:

1. Không có ba ô ngang hoặc dọc liên tiếp có thể giống nhau.
2. Phải có một số 0s và 1s bằng nhau trong mỗi hàng và cột.
3. Không có hai hàng nào có thể giống nhau và không có hai cột nào có thể giống nhau.

Hãy nhìn vào một lưới hoàn chỉnh:

0011
1100
0101
1010

Như bạn có thể thấy, bảng này tuân theo quy tắc 1, 2và 3. Không có ba ô ngang hoặc dọc giống nhau, tất cả các hàng và cột chứa một số 0s và 1s bằng nhau , và không có hai hàng và không có hai cột giống nhau.

Hãy xem xét một lưới không hợp lệ:

110100
010011
011010
101100
100011
001101

Có một loạt các vấn đề với lưới điện này. Ví dụ: hàng 5có ba 0s liên tiếp và cột 2có ba 1s liên tiếp, theo sau là ba 0s. Do đó, đây không phải là một lưới hợp lệ.

Bài tập:

Nhiệm vụ của bạn là tạo ra một chương trình, với một mảng 2D n* n 0và 1s, xác minh bảng để xem đó có phải là bảng Takuzu hợp lệ hay không.

Ví dụ:

0011
1100
0101
1010

Bảng này tuân theo tất cả các quy tắc, và do đó là một bảng Takuzu hợp lệ. Bạn phải trả lại một giá trị trung thực cho điều này.

11
00

Đây không phải là một bảng hợp lệ - hàng 1không tuân theo quy tắc 2. Bạn phải trả lại một giá trị falsey cho điều này.

100110
101001
010101
100110
011010
011001

Đây không phải là một bảng hợp lệ, nó thất bại (chỉ) do quy tắc 3 - hàng đầu tiên và thứ tư là như nhau.

110100
001011
010011
101100
100110
011001

Đây không phải là một bảng hợp lệ, nó thất bại (chỉ) do quy tắc 3 - các cột đầu tiên và thứ tư là như nhau.

011010
010101
101100
010011
100110
101001

Đây là một bảng hợp lệ.

Quy tắc và thông số kỹ thuật:

• Bạn có thể giả sử rằng tất cả các bảng là hình vuông có kích thước n * n, trong đó nmột số nguyên chẵn dương.
• Bạn có thể giả định rằng tất cả các bảng đã hoàn thành.
• Bạn có thể lấy đầu vào dưới dạng mảng 2D chứa các giá trị biểu thị 0và 1hoặc dưới dạng chuỗi.
• Bạn phải đưa ra các giá trị trung thực và falsey nhất quán cho các bảng trung thực và falsey, và các giá trị đại diện cho "sự thật" và "falsey" không thể giống nhau.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Brachylog , 20 18 byte

≠\≠,?¬{∋s₃=|∋ọtᵐ≠}

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

Giải trình

≠                           All rows are different
 \                          Transpose
  ≠                         All columns are different
   ,?                       Append the list of rows to the list of columns
     ¬{          }          It is impossible that:
       ∋                      A row/column of the matrix…
        s₃=                   …contains a substring of 3 equal elements
           |                Or that:
            ∋ọ                The occurences of 1s and 0s in a row/column…
              tᵐ≠             …are not equal

Husk , 19 18 byte

S=‼(Tf§=LṁDum(ṁ↑2g

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

Lưu 1 byte nhờ H.PWiz!

Ý tưởng chính là áp dụng một loạt các biến đổi cho đầu vào là các định danh cho một bảng hợp lệ và kiểm tra xem kết quả cuối cùng có giống với đầu vào ban đầu hay không.

Giải trình

S=‼(Tf§=LṁDum(ṁ↑2g
            m(ṁ↑2g    in each line, take at most two items for each sequence of equal items
           u          remove duplicate lines
     f§=LṁD          keep only those lines where the sum of each element doubled is equal to the length of the line
    T                 transpose the matrix (swap rows with columns)
  ‼                   do all the previous operations again
S=                    check if the final result is equal to the original input

Thạch , 17 byte

-*S;E3Ƥ€F$TȯQZµ⁺⁼

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

-6 byte nhờ dặm và Jonathan Allan .

Toán học, 143 byte

And@@Flatten@(((s=#;Equal@@(Count[s,#]&/@{0,1})&&FreeQ[Subsequences@s,#]&/@{{1,1,1},{0,0,0}})&/@#)&&(DeleteDuplicates@#==#)&/@{#,Transpose@#})&

đầu vào

[{{0, 0, 1, 1}, {1, 1, 0, 0}, {0, 1, 0, 1}, {1, 0, 1, 0}}]

Python 2 , 127 byte

a=input()
n=len(a)
b=zip(*a)
print[n/2]*n*2==map(sum,a+b)>len(set(a))==len(set(b))==n<'0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`

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

Đọc một danh sách n n -tuples làm đầu vào.

Tôi có thể xuất ra bằng mã thoát bằng cách viết 1/(…)thay vì print…nhưng nó cảm thấy cặn bã. Tôi có nên

Giải trình

nlà kích thước của bảng; blà một danh sách các cột (hoán vị của a). Phần còn lại là một so sánh dài chuỗi:

• [n/2]*n*2==map(sum,a+b) kiểm tra quy tắc 2. Mỗi hàng và cột phải tổng bằng n / 2.
• map(sum,a+b)>len(set(a)) luôn luôn đúng (danh sách> int).
• len(set(a))==len(set(b))==n kiểm tra quy tắc 3.
• n<'0, 0, 0' luôn luôn đúng (int <str).

• '0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`kiểm tra quy tắc 1. `a+b`là biểu diễn chuỗi của tất cả các hàng và cột; ví dụ đầu vào trên TIO

  "[(0, 0, 1, 1), (1, 1, 0, 0), (0, 1, 0, 1), (1, 0, 1, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 1), (1, 0, 1, 0)]"

  Các `a+b`>'1, 1, 1'ở trung tâm luôn luôn đúng kể từ chuỗi này được đảm bảo để bắt đầu với "[", mà là lớn hơn "1".

Husk , 27 25 byte

Λ§&Λȯ¬VEX3§&Λ§=#0#1S=uSeT

Đầu vào là danh sách các danh sách và đầu ra là 1cho Truevà0 choFalse

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

Giải thích

                      SeT    Create a list with the input and itself transposed
Λ                            Is the following function true for all in the list
 §&                          And the results of the following functions
   Λȯ¬VEX3                     Test for rule 1
          §&                   The and of:
            Λ§=#0#1                Test for rule 2
                   S=u             Test for rule 3

Kiểm tra 1

Λȯ¬VEX3
Λ         Is it True for all ...
   V      Are any of the ...
     X3   Substrings of length 3 ...
    E     All equal
 ȯ¬       Logical not

Kiểm tra 2

Λ§=#0#1
Λ         Is it true for all that ...
 §=       The results of the two functions are equal
   #0         Number of 0s
     #1       Number of 1s

Bài kiểm tra 3

S=u
S=    Is the result of the following function equal two its argument
  u   Remove duplicates

Võng mạc , 129 89 85 byte

.+
$&,$&
O#$`.(?=.*,)
$.%`
.+
$&;$&
+`(01|10)(?=.*;)

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

Hãy thử trực tuyến! Đầu ra 0 cho hợp lệ, 1 cho không hợp lệ. Chỉnh sửa: Đã lưu 4 byte nhờ @MartinEnder. Giải trình:

.+
$&,$&

Nhân đôi mỗi hàng với ,dấu phân cách.

O#$`.(?=.*,)
$.%`

Chuyển đổi bản sao đầu tiên.

.+
$&;$&

Nhân đôi một lần nữa, lần này với ;dấu phân cách.

+`(01|10)(?=.*;)

Xóa tất cả các cặp chữ số trùng khớp trước dấu chấm phẩy.

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

Kiểm tra xem liệu bất kỳ cột hoặc hàng nào thất bại bất kỳ quy tắc nào; (.)\1\1kiểm tra ba chữ số giống nhau liên tiếp, \d,?;kiểm tra một chữ số chưa ghép và (\D\d+\b).*\2kiểm tra trùng lặp.

Bình thường , 31 byte

Cảm ơn rất nhiều đến @Leaky Nun .

.Asm++mqy/k\0lQdm<hk3srL8d{Id,C

Xác nhận tất cả các trường hợp thử nghiệm hoặc Thử tại đây!

Pyth ,  48 46 44  42 byte

Đây là giải pháp ban đầu.

&{IQ&{I.TQ.Am&q/d\0/d\1!+/d*3\0/d*3\1sC,.T

Xác nhận tất cả các trường hợp thử nghiệm hoặc Thử tại đây!

& {IQ & {I.TQ <& q / d \ 0 / d \ 1! + / D * 3 \ 0 / d * 3 \ 1sC, .T Chương trình đầy đủ với đầu vào ẩn.

 {IQ Có phải là bất biến đầu vào dưới sự lặp lại?
& {I.TQ Và nó cũng bất biến chuyển vị?
                                        .TQ Chuyển vị.
                                           Q Đầu vào.
                                     sC, Zip ở trên, [^, ^^] (và làm phẳng).
    & Và điều kiện sau đây có được đáp ứng không?
          .Am Tất cả các yếu tố là trung thực khi ánh xạ trên ^^.
              q / d \ 0 / d \ 1 Có nhiều 0 như 1s.
             &! + / d * 3 \ 0 / d * 3 \ 1 Và không có 3 phần tử bằng nhau.

MATL , 27 byte

,G@?!]tEqts~w7BZ+|3<bXBSdvA

Đầu vào là một ma trận chứa 0và 1. Đầu ra là 0cho giả, 1cho sự thật.

Hãy thử trực tuyến! Hoặc xem các trường hợp thử nghiệm: 1 , 2 , 3 , 4 , 5 .

Giải trình

,       % Do twice. First iteration will use the input, second its transpose
  G     %   Push input
  @     %   Push iteration index: first 0, then 1
  ?     %   If nonzero
    !   %     Transpose
  ]     %   End
  t     %   The top of the stack contains the input or its transpose. Duplicate
  Eq    %   Convert to bipolar form, i.e. replace 0 by -1
  t     %   Duplicate
  s     %   Sum of each column
  ~     %   Negate. If all results are true, condition 2 is fulfilled
  w     %   Swap. Moves copy of bipolar input/transposed input to top
  7B    %   Push [1 1 1], obtained as 7 converted to binary
  Z+    %   2D convolution. Gives a matrix of the same size as the input
  |3<   %   Is each entry less than 3 in absolute value? If all results are true,
        %   condition 1 is fulfilled
  b     %   Bubble up. Moves copy of input/transposed input to top
  XB    %   Convert each row from binary to a number
  Sd    %   Sort, consecutive differences. If all results are nonzero, condition 3
        %   is fulfilled
  v     %   Concatenate all results so far into a column vector
  A     %   True if all entries are nonzero
        % End (implicit). Display (implicit)

R , 114 107 byte

-7 cảm ơn Giuseppe, gọi các chức năng không theo thứ tự và thực sự nén các điều kiện xuống

function(x)any(f(x),f(t(x)))
f=function(x)c(apply(x,1,function(y)max(rle(y)$l)>2+mean(y)-.5),duplicated(x))

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

Điều này chỉ áp dụng các quy tắc cho các cột của ma trận, sau đó là các cột chuyển vị của ma trận.

Có đầu vào ở dạng:

matrix(c(0,0,1,1,1,1,0,0,0,1,0,1,1,0,1,0), ncol=4)

Đó chỉ là cách R lấy mảng 2D.

Đầu ra TRUE cho các thất bại, FALSE cho các đường chuyền.

Perl 6 ,100 93 byte

Giao điểm FTW! Họ tiết kiệm 7 byte.

Hiện tại, điều này dường như đang đánh bại tất cả các bài nộp khác được viết bằng các ngôn ngữ không phải là golf. Yippie!

{!max (@(.map(*.join)).&{.repeated| |.map:{$_~~/000|111/|.comb(0)-.comb(1)}}for @^a,[Z] @^a)}

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

Giải thích : Đó là một khối lấy bảng làm danh sách các danh sách. Chúng tôi thực hiện chuyển đổi với [Z] @^a(giảm danh sách danh sách với toán tử zip). Vì vậy, @^a,[Z] @^amột danh sách của hội đồng quản trị và chuyển đổi của nó. Chúng tôi lặp lại với fornó hoạt động chính xác như thế nào map, chỉ rẻ hơn 1 char trong trường hợp này.

Bên trong, trước tiên chúng ta tham gia các danh sách cấu thành các hàng thành chuỗi, vì vậy chúng ta có danh sách các chuỗi thay vì danh sách các danh sách ( @(.map(*.join))). Sau đó, chúng tôi sử dụng một khối ẩn danh trên nó ( .&{...}), nơi chúng tôi thực sự đánh giá các quy tắc. Chúng tôi sẽ đánh giá họ chỉ hàng khôn ngoan. (Vì chúng tôi làm điều đó cho mảng ban đầu và chuyển vị là tốt.)

Để tiết kiệm khá nhiều !, chúng tôi sử dụng một chút logic và thay vì kiểm tra (NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1), chúng tôi kiểm tra NOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]. Đó là những gì chúng tôi làm trong khối ẩn danh: .repeatedcung cấp cho tất cả các hàng xảy ra nhiều lần, sau đó chúng tôi ánh xạ qua các hàng, cố gắng khớp 3 biểu tượng liên tiếp bằng cách sử dụng biểu thức chính quy và trừ các số 0 và 1. Đây là OR'red với |. (Trên thực tế, nó tạo ra một thứ rất mạnh gọi là đường giao nhau , nhưng chúng ta không sử dụng bất kỳ quyền hạn nào của nó :)) Sau tất cả những điều này, chúng ta nhận được một danh sách gồm 2 "bool" (các nút giao không bị chặn). Cuối cùng chúng tôi hoặc họ (sử dụng max) và phủ định ( !), cho kết quả mong muốn.

J, _{40 38} 55 byte

0=[:([:+/^:_(3(0=3|+/)\"1 ]),:-.@~:,:#=[:+/"1+:@])|:,:]

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

Xác định hàm lấy ma trận vuông làm đầu vào.

Ít nhất là nó đánh bại Pyth (bây giờ ...) (một cách sai lầm). Tôi nên quay lại đếm biểu tượng cảm xúc ẩn trong mã của mình vì J cũng cho vay chính nó:

[: /^: :1 |: :] :-.@ :# :@] :~@

Giải thích (hơi lỗi thời)

Điều này có vẻ khác với câu trả lời của tôi và tôi có thể cập nhật nó. Các phần của nó vẫn giống nhau - Tôi chỉ không kiểm tra quy tắc 3 và kiểm tra không đúng quy tắc 2 trước đây.

Chia thành một vài chức năng và không được cung cấp:

join_trans  =. |: ,: ]
part_3      =. 3 (0 = 3 | +/)\"1 ]
f           =. 1 - 2 * ]
main        =. 0 = [: ([: +/^:_ part_3 , f) join_trans

tham gia

|: ,: ]
|:       Transpose
   ,:    Laminated to
      ]  Input

Điều này kết hợp chuyển vị của ma trận với chính nó, tạo ra một mảng ma trận.

phần_3

3 (0 = 3 | +/)\"1 ]
                  ]  Input (matrix and transpose)

Cái này kiểm tra tổng các phân vùng của 3 hàng-khôn để xem nó là 3 hay 0 (vì một trong hai bảng này có nghĩa là một bảng không hợp lệ), trả về 1 nếu nó là 0 và ngược lại. Nó hoạt động trên cả ma trận và chuyển vị của nó vì nó được cung cấp cả hai.

f

1 - 2 * ]

Vì thiếu một cái tên tốt hơn, tôi gọi nó f. Nó thay thế số 0 bằng _1 và giữ nguyên số 1. Điều này là để cho phép tôi cuối cùng kiểm tra xem số 0 và 1 có bằng nhau ở mỗi hàng và cột không (tổng của mỗi hàng phải là 0).

chủ yếu

0 = [: ([: +/^:_ part_3 , f) join_trans
                             join_trans  Join transpose to input
                 part_3 , f              Apply the validity checks and join them
           +/^:_                         Sum until it converges
0 =                                      Equate to 0

Về cơ bản, tôi tận dụng thực tế là tôi đã thiết lập nó f join_transvà part_3 join_transcả hai nên tổng bằng 0 nếu bảng này hợp lệ. part_3nên là tất cả các số 0 cho một bảng hợp lệ và toàn bộ fnên tổng bằng 0 cho một bảng hợp lệ, có nghĩa là tổng của các khoản tiền của họ là 0 chỉ cho một bảng hợp lệ.

Haskell , 137 136 127 byte

9 byte được lưu nhờ Lynn!

import Data.List
j=isSubsequenceOf
l x=x==nub x&&and[sum y*2==length x&&not(j[0,0,0]y||j[1,1,1]y)|y<-x]
g x=l x&&l(transpose x)

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

Java 8, 350 326 325 312 303 299 298 259 255 byte

int r,z,c,p,i,j,k,d,u,v=1;int c(int[][]b){v(b);k=v-=u=1;v(b);return r;}void v(int[][]b){String m="",x;for(d=b.length;j<d|k<d;k+=u,j+=v,r=m.contains(x)|z!=0?1:r,m+=x)for(x="#",c=0,k*=u,j*=v;j<d&k<d;z+=i|i-1,c*=i^p^1,x+=p=i,r=++c>2?1:r,k+=v,j+=u)i=b[k][j];}

Trả về 0khi đó là một bảng hợp lệ;1nếu nó không hợp lệ cho một hoặc nhiều trong ba quy tắc.

-95 byte nhờ @Nevay .

Giải trình:

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

int r,z,c,p,i,j,k,d,u,v=1;
                     // Temp integers on class-level

int c(int[][]b){     // Method (1) with int-matrix parameter and int return-type
  v(b);              //  Validate the rows
  k=v-=u=1;          //  Switch rows with columns, and reset `u` to 1
  v(b);              //  Validate the columns
  return r;          //  Return the result
}                    // End of method (1)

void v(int[][]b){    // Separated method (2) with int-matrix parameter and no return-type
  String m="",s;     //  Two temp Strings to validate uniqueness of rows
  for(d=b.length;    //  Set the dimension of the matrix to `d`
      j<d|k<d        //  Loop (1) as long as either `j` or `k` is smaller than `d`
    ;                //   After every iteration:
     k+=u,j+=v       //    Increase the loop-indexes
     r=m.contains(s) //    If we've found a duplicated row,
     |z!=0?          //    or if the amount of zeroes and ones on this row aren't equal
      1:r,           //     Set `r` to 1 (invalid due to either rule 2 or 3)
     m+=s)           //    Append the current row to the String `m`
    for(s=",",       //   Set String `x` to a separator-character
        c=0,         //   Reset the counter to 0
        k*=u,j*=v,   //   Increase the loop-indexes
        j<d&k<d      //   Inner loop (2) as long as both `j` and `k` are smaller than `d`
     ;               //    After every iteration:
      z+=i|i-1,      //     Increase or decrease `z` depending on whether it's a 0 or 1
      c*=i^p^1,      //     Reset `c` if current digit `i` does not equal previous `p`
      s+=p=i,        //     Set previous `p` to current digit, and append it to String `s`
      r=++c>2?       //     If three of the same adjacent digits are found:
         1:r;        //      Set `r` to 1 (invalid due to rule 1)
        k+=v,j+=u)   //      Increase the loop-indexes
      i=b[k][j];     //    Set `i` to the current item in the matrix
                     //   End of inner loop (2) (implicit / single-line body)
                     //  End of loop (2) (implicit / single-line body)
}                    // End of separated method (2)

Python 3, 187 byte

lambda m,c=lambda m:all([len({*m})==len(m),sum(~-("000"in x)*~-("111"in x)and x.count("1")==x.count("0")for x in m)==len(m)]):c(["".join(x[i]for x in m)for i in range(len(m[0]))])and c(m)

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

Lấy đầu vào là một danh sách các dòng.

05AB1E , 29 byte

ø‚D€ÙQIDøì©O·IgQP®εŒ3ù€Ë_P}PP

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

Giải trình

Quy tắc: 3

ø‚        # pair the input with the zipped input
  D       # duplicate
   €Ù     # deduplicate each
     Q    # check for equality with the unmodified copy

Quy tắc: 2

IDøì          # prepend zipped input to input
    ©         # store a copy in register for rule 1
     O        # sum each row/column
      ·       # double
       IgQ    # check each for equality to length of input
          P   # product

Quy tắc 1

®ε            # apply to each row/column in register
  Œ3ù         # get sublists of length 3
     €Ë       # check each if all elements are equal
       _      # logical not
        P     # product
         }    # end apply
          P   # product

Sau đó, chúng tôi lấy sản phẩm của kết quả của cả 3 quy tắc với P

Thuốc nhuộm APL, 64 52 51 49 48 byte

Đòi hỏi ⎕IO←0

{⍲/{(∨/∊⍷∘⍵¨3/¨⍳2)∧((⊢≡∪)↓⍵)∧∧/(≢=2×+/)⍵}¨⍵(⍉⍵)}

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

PHP, 245 + 1 byte

ew này là cồng kềnh. ngắt dòng chỉ để đọc thuận tiện:

$t=_;foreach($a=($i=str_split)($s=$argn)as$i=>$c)$t[$i/($e=strlen($s)**.5)+$i%$e*$e]=$c;
for(;$k++<2;$s=$t)$x|=preg_match("#000|111|(\d{"."$e}).*\\1#s",chunk_split($s,$e))
|($m=array_map)(array_sum,$m($i,$i($s,$e)))!=array_fill(0,$e,$e/2);echo!$x;

Có một chuỗi không có dòng mới, bản in 1 cho trung thực, không có gì cho giả.

Chạy như ống với -nRhoặc thử trực tuyến .