Takuzu est un jeu de logique dans lequel vous devez compléter une grille avec des cellules contenant 0
s et 1
s. La grille doit suivre 3 règles:
- Trois cellules consécutives horizontales ou verticales ne peuvent pas être identiques.
- Il doit y avoir un nombre égal de
0
s et de1
s dans chaque ligne et colonne. - 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
, 2
et 3
. Il n'y a pas trois cellules horizontales ou verticales identiques, toutes les lignes et colonnes contiennent un nombre égal de 0
s et de 1
s, 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 5
a trois 0
s d'affilée et la colonne 2
a trois 1
s d'affilée, suivies de trois 0
s. 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
0
s et 1
s, 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 1
ne 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ùn
est 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
0
et1
, 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!
Réponses:
Brachylog ,
2018 octetsEssayez-le en ligne!
Explication
la source
false
pour ce ?Husk ,
1918 octetsEssayez-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
la source
)
Gelée , 17 octets
Essayez-le en ligne!
-6 octets grâce à miles et Jonathan Allan .
la source
µZ$⁺
chose: p ... et 17 octets en échangeant un peu: D maintenant j'ai battu brachylog heheMathematica, 143 octets
contribution
la source
Python 2 , 127 octets
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 deprint…
mais ça me semble moche. Devrais-je?Explication
n
est la taille de la planche;b
est une liste de colonnes (transposition dea
). 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 estLe
`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"
.la source
[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`>x
, ce qui est 2 octets plus court que la division et se traduit par unNameError
pour des entrées véridiques.Husk ,
2725 octetsL'entrée est une liste de listes et la sortie est
1
pourTrue
et0
pourFalse
Essayez-le en ligne!
Explication
Test 1
Test 2
Test 3
la source
Rétine ,
1298985 octetsEssayez-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.Transposez le premier doublon.
Dupliquez à nouveau, cette fois avec des
;
séparateurs.Supprimez toutes les paires de chiffres correspondantes qui précèdent un point-virgule.
Vérifiez si une colonne ou une ligne échoue à l'une des règles;
(.)\1\1
recherche trois chiffres identiques d'affilée,\d,?;
recherche un chiffre non apparié et(\D\d+\b).*\2
recherche un doublon.la source
(...).*
dernière étape est juste de le faire,max(matches,1)
vous pouvez enregistrer trois octets en utilisant1
plutôt un dans la configuration..\b\d+\b
peut l'être\D\d+\b
..*
que j'avais utilisé auparavant mais que je ne pensais pas utiliser une configuration pour limiter le résultat, merci!Pyth , 31 octets
Merci beaucoup à @Leaky Nun .
Vérifiez tous les cas de test ou essayez-le ici!
Pyth ,
48 46 4442 octetsCeci est la solution initiale.
Vérifiez tous les cas de test ou essayez-le ici!
la source
MATL , 27 octets
L'entrée est une matrice contenant
0
et1
. La sortie est0
pour la fausse,1
pour la vérité.Essayez-le en ligne! Ou voir les cas de test: 1 , 2 , 3 , 4 , 5 .
Explication
la source
R ,
114107 octets-7 grâce à Giuseppe, appelant les fonctions dans le désordre et compressant vraiment les conditions
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:
C'est ainsi que R prend les tableaux 2D.
Sorties VRAI pour les échecs, FAUX pour les passes.
la source
mean(y)-.5
à l'intérieur de laf
fonction interne pour obtenir les moyens plutôt quecolMeans
, et renduesg
anonymes. Il ajoutera des avertissements pour la conversiondouble
enlogical
dans l'appel àany
mais c'est OK.Perl 6 ,
10093 octetsJonctions FTW! Ils économisent 7 octets.
Pour le moment, cela semble battre toutes les autres soumissions écrites dans des langues non golfiques. Yippie!
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] @^a
va de même pour la liste du conseil d'administration et sa transposition. Nous bouclons dessus avecfor
ce qui fonctionne exactement commemap
, é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 testonsNOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]
. C'est ce que nous faisons dans le bloc anonyme:.repeated
donne 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 utilisantmax
) et en les annulant (!
), ce qui donne le résultat souhaité.la source
J,
403855 octetsEssayez-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
Cela rejoint la transposition de la matrice à elle-même, créant un tableau de matrices.
part_3
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
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
Fondamentalement, je tire parti du fait que je l'ai configuré de manière à ce que
f join_trans
et lespart_3 join_trans
deux devraient totaliser 0 si la carte est valide.part_3
doivent être tous des zéros pour une carte valide et la totalitéf
doit être égale à zéro pour une carte valide, ce qui signifie que la somme de leurs sommes est 0 uniquement pour une carte valide.la source
*/@,@,&(~:,(0~:3|3+/\]),#=2*+/)|:
Haskell ,
137136127 octets9 octets économisés grâce à Lynn!
Essayez-le en ligne!
la source
all
en unand
:l x=x==nub x&&and[sum y*2==length x&¬(j[0,0,0]y||j[1,1,1]y)|y<-x]
j=isSubSequenceOf
pourj x=isSubSequenceOf[x,x,x]
?j a b
invoquer (et de le définir) commea#b
?Java 8,
350326325312303299298259255 octetsRetourne
0
quand c'est une planche valide;1
s'il n'est pas valide pour une ou plusieurs des trois règles.-95 octets grâce à @Nevay .
Explication:
Essayez-le ici.
la source
Python 3, 187 octets
Essayez-le en ligne!
Prend l'entrée comme une liste de lignes.
la source
05AB1E , 29 octets
Essayez-le en ligne!
Explication
Règle: 3
Règle: 2
Règle 1
Ensuite, nous prenons le produit du résultat des 3 règles avec
P
la source
Dyalog APL,
6452514948 octetsA besoin
⎕IO←0
Essayez-le en ligne!
la source
PHP, 245 + 1 octets
ew c'est encombrant. les sauts de ligne sont uniquement destinés à la lecture:
Prend une seule chaîne sans retour à la ligne, imprime
1
pour la vérité, rien pour la fausse.Exécuter en tant que pipe avec
-nR
ou l' essayer en ligne .la source