Takuzu est un jeu de logique dans lequel vous devez compléter une grille avec des cellules contenant 0s et 1s. La grille doit suivre 3 règles:

1. Trois cellules consécutives horizontales ou verticales ne peuvent pas être identiques.
2. Il doit y avoir un nombre égal de 0s et de 1s dans chaque ligne et colonne.
3. Deux lignes ne peuvent pas être identiques et deux colonnes ne peuvent pas être identiques.

Regardons une grille finie:

0011
1100
0101
1010

Comme vous pouvez le voir, ce tableau suit la règle 1, 2et 3. Il n'y a pas trois cellules horizontales ou verticales identiques, toutes les lignes et colonnes contiennent un nombre égal de 0s et de 1s, et pas deux lignes et pas deux colonnes sont identiques.

Regardons une grille qui n'est pas valide:

110100
010011
011010
101100
100011
001101

Il y a un tas de problèmes avec cette grille. Par exemple, la ligne 5a trois 0s d'affilée et la colonne 2a trois 1s d'affilée, suivies de trois 0s. Par conséquent, ce n'est pas une grille valide.

Tâche:

Votre tâche consiste à créer un programme qui, étant donné un tableau 2D de n* n 0s et 1s, vérifie la carte pour voir s'il s'agit d'une carte Takuzu valide et terminée.

Exemples:

0011
1100
0101
1010

Cette planche suit toutes les règles, et est donc une planche Takuzu valide. Vous devez renvoyer une valeur véridique pour cela.

11
00

Ce tableau n'est pas valide - la ligne 1ne suit pas la règle 2. Vous devez renvoyer une valeur de falsey pour cela.

100110
101001
010101
100110
011010
011001

Ce n'est pas une carte valide, elle échoue (uniquement) en raison de la règle 3 - les première et quatrième lignes sont identiques.

110100
001011
010011
101100
100110
011001

Ce n'est pas une carte valide, elle échoue (uniquement) en raison de la règle 3 - les première et quatrième colonnes sont les mêmes.

011010
010101
101100
010011
100110
101001

Ceci est une carte valide.

Règles et spécifications:

• Vous pouvez supposer que toutes les planches sont de dimensions carrées n * n, où nest un entier pair positif.
• Vous pouvez supposer que toutes les planches sont terminées.
• Vous pouvez prendre l'entrée comme un tableau 2D contenant des valeurs signifiant 0et 1, ou comme une chaîne.
• Vous devez générer des valeurs de vérité et de falsey cohérentes pour les tableaux de vérité et de falsey, et les valeurs représentant "vérité" et "falsey" ne peuvent pas être les mêmes.

C'est le code-golf , donc le code le plus court en octets gagne!

Brachylog , 20 18 octets

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

Essayez-le en ligne!

Explication

≠                           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 octets

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

Essayez-le en ligne!

1 octet économisé grâce à H.PWiz!

L'idée principale est d'appliquer une série de transformations à l'entrée qui sont des identités pour une carte valide et de vérifier si le résultat final est le même que l'entrée d'origine.

Explication

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

Gelée , 17 octets

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

Essayez-le en ligne!

-6 octets grâce à miles et Jonathan Allan .

Mathematica, 143 octets

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

contribution

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

Python 2 , 127 octets

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`

Essayez-le en ligne!

Lit une liste de n n -tuples en entrée.

Je pourrais sortir par le code de sortie en écrivant à la 1/(…)place de print…mais ça me semble moche. Devrais-je?

Explication

nest la taille de la planche; best une liste de colonnes (transposition de a). Le reste est une longue comparaison enchaînée:

• [n/2]*n*2==map(sum,a+b) vérifie la règle 2. Chaque ligne et colonne doit totaliser n / 2.
• map(sum,a+b)>len(set(a)) est toujours vrai (liste> int).
• len(set(a))==len(set(b))==n vérifie la règle 3.
• n<'0, 0, 0' est toujours vrai (int <str).

• '0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`vérifie la règle 1. `a+b`est la représentation sous forme de chaîne de toutes les lignes et colonnes; pour l'exemple d'entrée sur TIO, il est

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

  Le `a+b`>'1, 1, 1'au centre est toujours vrai car cette chaîne est garantie de commencer par "[", ce qui est supérieur à "1".

Husk , 27 25 octets

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

L'entrée est une liste de listes et la sortie est 1pour Trueet 0pourFalse

Essayez-le en ligne!

Explication

                      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

Rétine , 129 89 85 octets

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

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

Essayez-le en ligne! Sorties 0 pour valide, 1 pour invalide. Edit: 4 octets enregistrés grâce à @MartinEnder. Explication:

.+
$&,$&

Dupliquez chaque ligne avec des ,séparateurs.

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

Transposez le premier doublon.

.+
$&;$&

Dupliquez à nouveau, cette fois avec des ;séparateurs.

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

Supprimez toutes les paires de chiffres correspondantes qui précèdent un point-virgule.

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

Vérifiez si une colonne ou une ligne échoue à l'une des règles; (.)\1\1recherche trois chiffres identiques d'affilée, \d,?;recherche un chiffre non apparié et (\D\d+\b).*\2recherche un doublon.

Pyth , 31 octets

Merci beaucoup à @Leaky Nun .

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

Vérifiez tous les cas de test ou essayez-le ici!

Pyth ,  48 46 44  42 octets

Ceci est la solution initiale.

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

Vérifiez tous les cas de test ou essayez-le ici!

& {IQ & {I.TQ.Am & q / d \ 0 / d \ 1! + / D * 3 \ 0 / d * 3 \ 1sC, .T Programme complet avec entrée implicite.

 {IQ L'entrée est-elle invariante sous déduplication?
& {I.TQ Et sa transposition est-elle également invariante?
                                        .TQ Transpose.
                                           Q L'entrée.
                                     sC, zippez ce qui précède, [^, ^^] (et aplatissez).
    & Et la condition suivante est-elle remplie?
          .Am Tous les éléments sont véridiques lors de la cartographie sur ^^.
              q / d \ 0 / d \ 1 Il y a autant de 0 que de 1.
             &! + / d * 3 \ 0 / d * 3 \ 1 Et il n'y a pas d'exécutions de 3 éléments égaux.

MATL , 27 octets

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

L'entrée est une matrice contenant 0et 1. La sortie est 0pour la fausse, 1pour la vérité.

Essayez-le en ligne! Ou voir les cas de test: 1 , 2 , 3 , 4 , 5 .

Explication

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

-7 grâce à Giuseppe, appelant les fonctions dans le désordre et compressant vraiment les conditions

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

Essayez-le en ligne!

Cela applique simplement les règles aux colonnes de la matrice, puis aux colonnes de la transposition de la matrice.

Prend la saisie sous la forme:

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

C'est ainsi que R prend les tableaux 2D.

Sorties VRAI pour les échecs, FAUX pour les passes.

Perl 6 ,100 93 octets

Jonctions FTW! Ils économisent 7 octets.

Pour le moment, cela semble battre toutes les autres soumissions écrites dans des langues non golfiques. Yippie!

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

Essayez-le en ligne!

Explication : c'est un bloc qui prend le tableau comme une liste de listes. On fait une transposition avec [Z] @^a(réduire la liste des listes avec l'opérateur zip). Il en @^a,[Z] @^ava de même pour la liste du conseil d'administration et sa transposition. Nous bouclons dessus avec force qui fonctionne exactement comme map, étant juste 1 char moins cher dans ce cas.

À l'intérieur, nous joignons d'abord les listes constituant des lignes en chaînes, nous avons donc une liste de chaînes au lieu d'une liste de listes ( @(.map(*.join))). Ensuite, nous utilisons un bloc anonyme dessus ( .&{...}), où nous évaluons réellement les règles. Nous les évaluerons uniquement par ligne. (Puisque nous le faisons également pour le tableau d'origine et la transposition.)

Pour en sauver un certain nombre !, nous utilisons un peu de logique et au lieu de tester (NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1), nous testons NOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]. C'est ce que nous faisons dans le bloc anonyme: .repeateddonne toutes les lignes qui se produisent plus d'une fois, puis nous mappons les lignes, essayons de faire correspondre 3 symboles consécutifs à l'aide d'une expression régulière, et soustrayons les nombres de 0 et de 1. Ce sont OR'red avec le |. (En fait, cela crée une chose très puissante appelée jonction , mais nous n'utilisons aucun de ses pouvoirs :)) Après tout cela, nous obtenons une liste de 2 "bools" (jonctions non écroulées). On finit par les (en utilisant max) et en les annulant ( !), ce qui donne le résultat souhaité.

J, _{40 38} 55 octets

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

Essayez-le en ligne!

Définit une fonction prenant une matrice carrée en entrée.

Au moins, il bat Pyth (pour l'instant ...) (à tort). Je devrais revenir à compter les emoji cachés dans mon code car J s'y prête aussi bien:

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

Explication (légèrement obsolète)

Cela semble différent de ma réponse et je pourrai peut-être la mettre à jour. Certaines parties sont toujours les mêmes - je ne vérifiais simplement pas la règle 3 et je vérifiais incorrectement la règle 2 auparavant.

Divisé en quelques fonctions et non golfé:

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

join_trans

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

Cela rejoint la transposition de la matrice à elle-même, créant un tableau de matrices.

part_3

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

Ceci vérifie la somme des partitions de 3 lignes pour voir si elle est 3 ou 0 (car l'une ou l'autre signifie une carte invalide), retournant 1 si elle l'est et 0 sinon. Il opère à la fois sur la matrice et sur sa transposition puisqu'il lui est donné les deux.

F

1 - 2 * ]

Faute d'un meilleur nom, j'appelle cela f. Il remplace les 0 par _1 et laisse les 1 inchangés. C'est pour me permettre de vérifier éventuellement si le nombre de 0 et de 1 est égal dans chaque ligne et colonne (la somme de chacune des lignes doit être 0).

principale

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

Fondamentalement, je tire parti du fait que je l'ai configuré de manière à ce que f join_transet les part_3 join_transdeux devraient totaliser 0 si la carte est valide. part_3doivent être tous des zéros pour une carte valide et la totalité fdoit être égale à zéro pour une carte valide, ce qui signifie que la somme de leurs sommes est 0 uniquement pour une carte valide.

Haskell , 137 136 127 octets

9 octets économisés grâce à 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)

Essayez-le en ligne!

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

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

Retourne 0quand c'est une planche valide; 1s'il n'est pas valide pour une ou plusieurs des trois règles.

-95 octets grâce à @Nevay .

Explication:

Essayez-le ici.

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 octets

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)

Essayez-le en ligne!

Prend l'entrée comme une liste de lignes.

05AB1E , 29 octets

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

Essayez-le en ligne!

Explication

Règle: 3

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

Règle: 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

Règle 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

Ensuite, nous prenons le produit du résultat des 3 règles avec P

Dyalog APL, 64 52 51 49 48 octets

A besoin ⎕IO←0

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

Essayez-le en ligne!

PHP, 245 + 1 octets

ew c'est encombrant. les sauts de ligne sont uniquement destinés à la lecture:

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

Prend une seule chaîne sans retour à la ligne, imprime 1pour la vérité, rien pour la fausse.

Exécuter en tant que pipe avec -nRou l' essayer en ligne .