Takuzuは、0sと1s を含むセルでグリッドを完成させる必要があるロジックゲームです。グリッドは3つのルールに従う必要があります。

1. 3つの水平または垂直の連続したセルを同じにすることはできません。
2. 等しい数でなければなりません 01各行と列に sとs。
3. 2つの行が同じであったり、2つの列が同じであったりすることはできません。

完成したグリッドを見てみましょう。

0011
1100
0101
1010

あなたが見ることができるように、このボードは、ルールを次の1、2そして3。同じ3つの水平または垂直セルはありません。すべての行と列には同じ数の0sと1s が含まれ、2つの行と2つの列は同じではありません。

無効なグリッドを見てみましょう。

110100
010011
011010
101100
100011
001101

このグリッドには多くの問題があります。たとえば、行に5は3つ0のsがあり、列に2は3つ1のsがあり、その後に3が続き0ます。したがって、これは有効なグリッドではありません。

仕事：

あなたの仕事は、n* n 0の2D配列と1 sボードを検証して、それが有効な完成したTakuzuボードかどうかを確認ことです。

例：

0011
1100
0101
1010

このボードはすべての規則に従っているため、有効なTakuzuボードです。このために真実の値を返さなければなりません。

11
00

これは有効なボード行で1はありません2。ルールはルールに従いません。これにはfalsey値を返す必要があります。

100110
101001
010101
100110
011010
011001

これは有効なボードではありません。ルール3により失敗（のみ）します-1行目と4行目は同じです。

110100
001011
010011
101100
100110
011001

これは有効なボードではありません。ルール3が原因で（のみ）失敗します-1列目と4列目は同じです。

011010
010101
101100
010011
100110
101001

これは有効なボードです。

ルールと仕様：

• すべてのボードが次元の平方であると仮定できます。n * nここでnは、正の偶数の整数です。
• すべてのボードが完成していると想定できます。
• あなたが意味する値を含む2次元配列として入力がかかる場合があります0し、1として、または文字列としてます。
• 真実と偽のボードに対して一貫した真実と偽の値を出力する必要があります。「真実」と「偽」を表す値は同じにはできません。

これはcode-golfなので、バイト単位の最短コードが勝ちです！

Brachylog、20 18バイト

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

オンラインでお試しください！

説明

≠                           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

殻、19 18バイト

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

オンラインでお試しください！

H.PWizのおかげで1バイト節約！

主なアイデアは、有効なボードのIDである一連の変換を入力に適用し、最終結果が元の入力と同じかどうかを確認することです。

説明

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

ゼリー、17バイト

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

オンラインでお試しください！

マイルとジョナサンアランのおかげで-6バイト。

Mathematica、143バイト

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

入力

[{{0、0、1、1}、{1、1、0、0}、{0、1、0、1}、{1、0、1、0}}]

Python 2、127バイト

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`

オンラインでお試しください！

n nのリストを読み取りますタプルの入力としてます。

の1/(…)代わりに書くことで終了コードで出力できますprint…が、それは不器用に感じます。したほうがいい？

説明

nボードのサイズです。b列のリストです（転置a）。残りは1つの長い連鎖比較です。

• [n/2]*n*2==map(sum,a+b) ルール2をチェックします。各行と列の合計はn / 2になります。
• map(sum,a+b)>len(set(a)) 常に真です（リスト> int）。
• len(set(a))==len(set(b))==n ルール3をチェックします。
• n<'0, 0, 0' 常に真です（int <str）。

• '0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`ルール1をチェック`a+b`します。すべての行と列の文字列表現です。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)]"

  `a+b`>'1, 1, 1'この文字列がで開始することが保証されているので中央には、常に真である"["よりも大きいです、"1"。

殻、27 25バイト

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

入力はリストのリストであり、出力は1for Trueおよび0forですFalse

オンラインでお試しください！

説明

                      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

テスト1

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

テスト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

テスト3

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

網膜、129 89 85バイト

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

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

オンラインでお試しください！有効な場合は0、無効な場合は1を出力します。編集：@MartinEnderのおかげで4バイトを保存しました。説明：

.+
$&,$&

各行を,区切り記号で複製します。

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

最初の複製を転置します。

.+
$&;$&

今度は;セパレータを使用して再度複製します。

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

セミコロンの前にある一致する数字のペアをすべて削除します。

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

列または行がいずれかのルールに違反していないかどうかを確認してください。(.)\1\1連続する3つの同じ数字を\d,?;チェックし、ペアになっていない数字を(\D\d+\b).*\2チェックし、重複をチェックします。

Pyth、31バイト

@Leaky Nunに感謝します。

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

すべてのテストケースを確認するか、ここで試してください！

Pyth、 48 46 44  42バイト

これが最初の解決策です。

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

すべてのテストケースを確認するか、ここで試してください！

＆{IQ＆{I.TQ.Am＆q / d \ 0 / d \ 1！+ / d * 3 \ 0 / d * 3 \ 1sC、.T暗黙的な入力を伴う完全なプログラム。

 {IQ重複排除の下で入力不変はありますか？
＆{I.TQそしてその転置不変量もありますか？
                                        .TQトランスポーズ。
                                           Q入力。
                                     sC、上記のZip、[^、^^]（およびフラット化）。
    ＆そして、次の条件が満たされていますか？
          .Am ^^を介してマッピングする場合、すべての要素は真実です。
              q / d \ 0 / d \ 1 1と同じ数の0があります。
             ＆！+ / d * 3 \ 0 / d * 3 \ 1そして、3つの等しい要素の実行はありません。

MATL、27バイト

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

入力が含む行列である0と1。出力は0虚偽、1真実です。

オンラインでお試しください！またはテストケースを参照してください。 1、 2、 3、 4、 5。

説明

,       % 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、114107バイト

-7ジュゼッペのおかげで、関数を順不同で呼び出し、実際に条件を圧縮しています

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

オンラインでお試しください！

これは、マトリックスの列に規則を適用し、次にマトリックスの転置の列に適用します。

次の形式で入力を受け取ります。

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

これは、Rが2D配列を取得する方法です。

失敗の場合はTRUE、合格の場合はFALSEを出力します。

Perl 6、100 93バイト

ジャンクションFTW！7バイト節約します。

当分の間、これは非ゴルフ言語で書かれた他のすべての提出物を破っているようです。イッピー！

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

オンラインでお試しください！

説明：ボードをリストのリストとするブロックです。転置を行います[Z] @^a（zip演算子を使用してリストのリストを削減します）。だから、@^a,[Z] @^aボードとその転置のリストです。でそれ以上の私たちは、ループfor正確に同じように動作しているmapだけで、この場合、1つの文字安価であること、。

内部では、最初に行を構成するリストを文字列に結合します。そのため、リストのリストではなく文字列のリストがあります（@(.map(*.join))）。次に、その上で匿名ブロックを使用し（.&{...}）、そこで実際にルールを評価します。行ごとにのみ評価します。（元の配列と転置についても同様ですので。）

かなりのものを保存するために!、少しのロジックを使用し、テストの代わりに(NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1)testを実行しNOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]ます。それが匿名ブロックで行うことです：.repeated2回以上発生するすべての行を指定し、行をマッピングし、正規表現を使用して3つの連続するシンボルを一致させ、0と1のカウントを減算します。これらはとのOR'red |です。（実際にはjunctionと呼ばれる非常に強力なものを作成しますが、そのパワーは使用しません:)）このすべての後、2つの「bools」（崩壊していないjunction）のリストを取得します。最終的にまたはそれらを（を使用してmax）否定し（!）、これは望ましい結果をもたらします。

J、_{40 38} 55バイト

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

オンラインでお試しください！

入力として正方行列をとる関数を定義します。

少なくとも、Pythを（今のところ...）（間違って）打ち負かしています。Jもそれに適しているため、コードに隠された絵文字のカウントに戻る必要があります。

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

説明（やや時代遅れ）

これは私の答えとは異なって見え、更新することができます。その一部はまだ同じです-以前はルール3をチェックしておらず、ルール2を不適切にチェックしていませんでした。

いくつかの関数に分割し、未使用：

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

join_trans

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

これにより、行列の転置自体が結合され、行列の配列が作成されます。

part_3

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

これは、行ごとに3つのパーティションの合計をチェックして、3または0（これらは無効なボードを意味するため）かどうかを確認し、そうであれば1を返し、そうでなければ0を返します。行列と転置の両方が指定されているため、両方で動作します。

f

1 - 2 * ]

より良い名前がないため、私はこれを呼び出しますf。0を_1に置き換え、1を変更しません。これは、最終的に、各行と列で0と1の数が等しいかどうかを確認できるようにするためです（各行の合計は0でなければなりません）。

メイン

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

基本的に、私は私がそうすることを、それを設定したという事実に活用f join_transし、part_3 join_transボードが有効なときに限り、両方が0に合計する必要があります。part_3有効なボードの場合はすべてゼロであり、有効なボードの場合は全体がfゼロになる必要があります。つまり、有効なボードの場合のみ合計が0になります。

ハスケル、137の 136 127バイト

Lynnのおかげで9バイト節約されました！

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)

オンラインでお試しください！

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

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];}

Returns 0 when it's a valid board; 1 if it's invalid for one or more of the three rules.

-95 bytes thanks to @Nevay.

Explanation:

Try it here.

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 bytes

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)

Try it online!

Takes input as a list of lines.

05AB1E, 29 bytes

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

Try it online!

Explanation

Rule: 3

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

Rule: 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

Rule: 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

Then we take the product of the result of all 3 rules with P

Dyalog APL, 64 52 51 49 48 bytes

Requires ⎕IO←0

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

Try it online!

PHP, 245+1 bytes

ew this is bulky. linebreaks are for reading convenience only:

$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;

Takes a single string without newlines, prints 1 for truthy, nothing for falsy.

Run as pipe with -nR or try it online.