Takuzu ist ein Logikspiel, in dem Sie ein Gitter mit Zellen vervollständigen müssen, die 0s und 1s enthalten. Das Gitter muss 3 Regeln folgen:

1. Keine drei horizontalen oder vertikalen aufeinanderfolgenden Zellen können gleich sein.
2. Es muss eine gleiche Anzahl von 0s und sein1 s in jeder Zeile und Spalte geben.
3. Keine zwei Zeilen können gleich sein und keine zwei Spalten können gleich sein.

Schauen wir uns ein fertiges Gitter an:

0011
1100
0101
1010

Wie Sie sehen können, folgt das Board Regel 1, 2und 3. Es gibt keine drei horizontalen oder vertikalen Zellen, die gleich sind, alle Zeilen und Spalten enthalten die gleiche Anzahl von 0s und 1s, und keine zwei Zeilen und keine zwei Spalten sind gleich.

Schauen wir uns ein Gitter an, das nicht gültig ist:

110100
010011
011010
101100
100011
001101

Es gibt eine Reihe von Problemen mit diesem Raster. Beispielsweise 5hat 0eine Zeile drei Sekunden in einer Zeile und eine Spalte 2drei 1Sekunden in einer Zeile, gefolgt von drei 0Sekunden. Daher ist dies kein gültiges Raster.

Aufgabe:

Ihre Aufgabe ist es, ein Programm zu erstellen, das bei einem 2D-Array von n* n 0s und1 erstellen s die Karte überprüft, um festzustellen, ob es sich um eine gültige, fertige Takuzu-Karte handelt.

Beispiele:

0011
1100
0101
1010

Dieses Board folgt allen Regeln und ist daher ein gültiges Takuzu-Board. Sie müssen einen wahrheitsgemäßen Wert dafür zurückgeben.

11
00

Dies ist keine gültige Tafel - die Reihe 1folgt nicht der Regel2 . Sie müssen dafür einen falschen Wert zurückgeben.

100110
101001
010101
100110
011010
011001

Dies ist kein gültiges Board, es schlägt (nur) aufgrund von Regel 3 fehl - die erste und vierte Reihe sind gleich.

110100
001011
010011
101100
100110
011001

Dies ist kein gültiges Board, es schlägt (nur) aufgrund von Regel 3 fehl - die erste und vierte Spalte sind gleich.

011010
010101
101100
010011
100110
101001

Dies ist eine gültige Karte.

Regeln und Spezifikationen:

• Sie können davon ausgehen, dass alle Bretter quadratische Abmessungen haben n * n habenn es sich um eine positive gerade Ganzzahl handelt.
• Sie können davon ausgehen, dass alle Bretter fertig sind.
• Sie können Eingaben als 2D-Array mit Werten für 0und vornehmen1 oder als Zeichenfolge vornehmen.
• Sie müssen für Truthy- und Falsey-Boards konsistente Truthy- und Falsey-Werte ausgeben. Die Werte für "Truthy" und "Falsey" dürfen nicht identisch sein.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Brachylog , 20 bis 18 Bytes

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

Probieren Sie es online!

Erläuterung

≠                           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

Schale , 19 18 Bytes

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

Probieren Sie es online!

1 Byte gespart dank H.PWiz!

Die Hauptidee besteht darin, eine Reihe von Transformationen auf die Eingabe anzuwenden, die Identitäten für eine gültige Karte sind, und zu prüfen, ob das Endergebnis mit der ursprünglichen Eingabe übereinstimmt.

Erläuterung

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

Gelee , 17 Bytes

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

Probieren Sie es online!

-6 Bytes dank Meilen und Jonathan Allan .

Mathematica, 143 Bytes

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

Eingang

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

Python 2 , 127 Bytes

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`

Probieren Sie es online!

Liest eine Liste von n n -Tupeln als Eingabe.

Ich konnte Ausgabe von Exit - Code durch das Schreiben 1/(…)statt , print…aber es fühlt sich scummy. Sollte ich?

Erläuterung

nist die Größe der Tafel; bist eine Liste von Spalten (transponiert von a). Der Rest ist ein langkettiger Vergleich:

• [n/2]*n*2==map(sum,a+b) prüft Regel 2. Jede Zeile und Spalte sollte n / 2 ergeben.
• map(sum,a+b)>len(set(a)) ist immer wahr (liste> int).
• len(set(a))==len(set(b))==n prüft Regel 3.
• n<'0, 0, 0' ist immer wahr (int <str).

• '0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`prüft Regel 1. `a+b`ist die Zeichenfolgendarstellung aller Zeilen und Spalten; für den Beispieleingang auf TIO ist es

  "[(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)]"

  Das `a+b`>'1, 1, 1'in der Mitte ist immer wahr, da diese Zeichenfolge garantiert beginnt "["und größer als ist "1".

Schale , 27 25 Bytes

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

Input ist eine Liste von Listen und Output ist 1für Trueund 0fürFalse

Probieren Sie es online!

Erklärung

                      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

Test 1

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

Test 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

Test 3

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

Retina , 129 89 85 Bytes

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

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

Probieren Sie es online! Gibt 0 für gültig und 1 für ungültig aus. Bearbeiten: 4 Bytes dank @MartinEnder gespeichert. Erläuterung:

.+
$&,$&

Duplizieren Sie jede Zeile mit ,Trennzeichen.

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

Transponiere das erste Duplikat.

.+
$&;$&

Duplizieren Sie erneut, diesmal mit ;Trennzeichen.

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

Löschen Sie alle übereinstimmenden Ziffernpaare, die einem Semikolon vorangehen.

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

Überprüfen Sie, ob eine Spalte oder Zeile eine der Regeln nicht erfüllt. (.)\1\1sucht nach drei identischen Ziffern in einer Reihe, \d,?;sucht nach einer ungepaarten Ziffer und (\D\d+\b).*\2sucht nach einem Duplikat.

Pyth , 31 Bytes

Vielen Dank an @Leaky Nun .

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

Überprüfen Sie alle Testfälle oder versuchen Sie es hier!

Pyth ,  48 46 44  42 Bytes

Dies ist die erste Lösung.

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

Überprüfen Sie alle Testfälle oder versuchen Sie es hier!

& {IQ & {I.TQ.Am & q / d \ 0 / d \ 1! + / D * 3 \ 0 / d * 3 \ 1sC, .T Volles Programm mit impliziter Eingabe.

 {IQ Ist die Eingabe unter Deduplizierung invariant?
& {I.TQ Und ist seine Transponierung auch invariant?
                                        .TQ Transponieren.
                                           Q Die Eingabe.
                                     sC, Zip the above, [^, ^^] (und flatten).
    & Und ist die folgende Bedingung erfüllt?
          Alle Elemente sind wahr, wenn sie über ^^ abgebildet werden.
              q / d \ 0 / d \ 1 Es gibt so viele Nullen wie Einsen.
             &! + / d * 3 \ 0 / d * 3 \ 1 Und es gibt keine Läufe von 3 gleichen Elementen.

MATL , 27 Bytes

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

Die Eingabe ist eine Matrix, die 0und enthält 1. Ausgabe ist0 für falsch, 1für wahr.

Probieren Sie es online! Oder siehe Testfälle: 1 , 2 , 3 , 4 , 5 .

Erläuterung

,       % 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 Bytes

-7 Dank an Giuseppe, der Funktionen nicht ordnungsgemäß aufruft und die Bedingungen wirklich komprimiert

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

Probieren Sie es online!

Dies wendet nur die Regeln auf die Spalten der Matrix an, dann auf die Spalten der Transponierten der Matrix.

Nimmt Eingaben in der Form:

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

Genau so nimmt R 2D-Arrays auf.

Gibt bei Fehlern TRUE und bei Durchläufen FALSE aus.

Perl 6 ,100 93 Bytes

Abzweigungen FTW! Sie sparen 7 Bytes.

Derzeit scheint dies allen anderen Einsendungen zu trotzen, die in nicht-golferischen Sprachen verfasst wurden. Yippie!

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

Probieren Sie es online!

Erläuterung : Es ist ein Block, der die Karte als Liste von Listen aufnimmt. Wir machen eine Transponierung mit [Z] @^a(Liste der Listen mit zip-Operator verkleinern). So @^a,[Z] @^aist eine Liste des Boards und seiner Transponierung. Wir überfliegen es mit fordem genau so funktioniertmap in diesem Fall ist es nur 1 Zeichen billiger.

Im Inneren verbinden wir zuerst die Listen, die Zeilen bilden, zu Strings, sodass wir eine Liste von Strings anstelle von list of lists ( @(.map(*.join))) haben. Dann verwenden wir einen anonymen Block (.&{...} ), in dem wir die Regeln tatsächlich auswerten. Wir werden sie nur zeilenweise auswerten. (Da wir es auch für das ursprüngliche Array und die Transponierung tun.)

So speichern Sie ganz ein paar !‚s, verwenden wir ein bisschen Logik und statt Tests (NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1), wir testen NOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]. Das machen wir im anonymen Block: .repeatedGibt alle Zeilen an, die mehr als einmal vorkommen, dann ordnen wir die Zeilen zu, versuchen, 3 aufeinanderfolgende Symbole mit einem regulären Ausdruck abzugleichen, und subtrahieren die Zählungen von Nullen und Einsen. Diese sind OR'rot mit dem |. (Tatsächlich erzeugt es eine sehr mächtige Sache, die als Junction bezeichnet wird , aber wir verwenden keine ihrer Kräfte :)) Nach alledem erhalten wir eine Liste von 2 "Bools" (nicht zusammengefassten Junctions). Wir schließlich oder sie (mit max) und negieren ( !), was das gewünschte Ergebnis gibt.

J, _{40 38} 55 Bytes

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

Probieren Sie es online!

Definiert eine Funktion, die eine quadratische Matrix als Eingabe verwendet.

Zumindest schlägt es Pyth (fürs Erste ...) (fälschlicherweise). Ich sollte zurückgehen, um das in meinem Code verborgene Emoji zu zählen, da sich J auch gut dafür eignet:

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

Erklärung (etwas veraltet)

Dies sieht anders aus als meine Antwort, und ich werde sie möglicherweise aktualisieren. Teile davon sind immer noch die gleichen - ich habe nur nicht nach Regel 3 und nicht richtig nach Regel 2 gesucht.

Aufgeteilt in einige Funktionen und ungolfed:

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

join_trans

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

Dies verbindet die Transponierung der Matrix mit sich selbst und erzeugt ein Array von Matrizen.

part_3

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

Dies überprüft die Summe der Partitionen von 3 zeilenweise, um festzustellen, ob sie 3 oder 0 ist (da eine dieser beiden Angaben eine ungültige Karte bedeutet), und gibt 1 zurück, wenn dies der Fall ist, und 0, wenn dies nicht der Fall ist. Es funktioniert sowohl auf der Matrix als auch auf der Transponierten, da beide angegeben sind.

f

1 - 2 * ]

Aus Mangel an einem besseren Namen nenne ich das f. Es ersetzt die 0en durch _1 und lässt die 1en unverändert. Damit kann ich eventuell überprüfen, ob die Anzahl der Nullen und Einsen in jeder Zeile und Spalte gleich ist (die Summe jeder Zeile sollte 0 sein).

Main

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

Grundsätzlich nutze ich die Tatsache, dass ich es so eingerichtet habe, dass f join_transund part_3 join_transbeide auf 0 summieren sollten, wenn das Board gültig ist. part_3sollten für eine gültige Karte alle Nullen sein und die Summe von fsollte für eine gültige Karte Null ergeben, was bedeutet, dass die Summe ihrer Summen nur für eine gültige Karte 0 ist.

Haskell , 137 136 127 Bytes

9 Bytes gespart dank 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)

Probieren Sie es online!

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

Gibt zurück, 0wenn es sich um ein gültiges Board handelt. 1wenn es für eine oder mehrere der drei Regeln ungültig ist.

-95 Bytes dank @Nevay .

Erläuterung:

Probieren Sie es hier aus.

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)

Probieren Sie es online!

Nimmt die Eingabe als eine Liste von Zeilen.

05AB1E , 29 Bytes

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

Probieren Sie es online!

Erläuterung

Regel: 3

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

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

Regel 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

Dann nehmen wir das Produkt des Ergebnisses aller 3 Regeln mit P

Dyalog APL, 64 52 51 49 48 Bytes

Benötigt ⎕IO←0

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

Probieren Sie es online!

PHP, 245 + 1 Bytes

ew das ist sperrig. Zeilenumbrüche dienen nur der besseren Lesbarkeit:

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

Nimmt eine einzelne Zeichenfolge ohne Zeilenumbrüche, druckt 1für die Wahrheit, nichts für die Falschheit.

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .