introduction
Il y a un petit village avec seulement quelques maisons et des champs vides. Les bureaucrates locaux veulent diviser le village en lots de sorte que chaque lot contienne exactement une maison, et les limites des lots forment une belle grille en ligne droite. Votre tâche consiste à déterminer si cela est possible.
La tâche
Votre entrée est un tableau 2D rectangulaire de bits; 1 représente une maison et 0 un champ vide. Sa taille sera d'au moins 1 × 1 et il contiendra au moins un 1. Vous pouvez prendre l'entrée dans n'importe quel format raisonnable (liste imbriquée d'entiers, liste de chaînes, chaîne multiligne, etc.).
Votre programme doit déterminer si le tableau peut être divisé en cellules de grille en utilisant des lignes droites horizontales et verticales de sorte que chaque cellule de grille en contienne exactement un 1. Les cellules de grille peuvent avoir différentes tailles et formes, bien qu'elles soient toujours rectangulaires. Les lignes doivent s'étendre d'un bord du tableau au bord opposé.
Par exemple, ce qui suit est une division valide d'un tableau:
00|0010|01|1
01|0000|00|0
--+----+--+-
00|0000|00|1
01|0010|01|0
--+----+--+-
01|1000|10|1
alors que la division suivante n'est pas valide, car il existe des cellules de grille sans 1 ou plus d'un 1:
00|0010|01|1
--+----+--+-
01|0000|00|0
00|0000|00|1
01|0010|01|0
--+----+--+-
00|1000|10|1
S'il existe une division valide, vous devez afficher une valeur véridique, et sinon une valeur falsifiée.
Règles et notation
Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas gagne.
Cas de test
[[1]] -> True
[[0,1],[1,0]] -> True
[[1,1],[1,0]] -> False
[[1,0,1],[0,1,0]] -> True
[[1,0],[0,1],[0,1]] -> True
[[1,0,0],[0,0,1],[0,1,1]] -> True
[[1,1,1],[1,1,1],[1,1,1]] -> True
[[1,0,1],[0,1,0],[1,0,0]] -> True
[[1,0,0],[1,0,0],[0,1,1]] -> False
[[0,0,0,0,1],[1,0,0,1,0],[0,0,0,1,0]] -> False
[[0,0,1,0,1],[0,0,0,1,0],[0,0,0,0,0]] -> True
[[1,1,0,0,0],[0,0,0,0,0],[1,0,1,0,0]] -> True
[[1,1,0,1,1],[0,1,0,1,1],[1,0,0,0,0]] -> True
[[0,0,0,0,0,0,0],[0,1,1,1,0,1,0],[0,1,0,0,1,0,0],[0,0,0,0,0,0,1],[0,0,1,0,0,0,1],[1,1,0,1,1,0,0]] -> False
[[1,1,0,0,0,0,0],[1,0,1,1,0,1,0],[0,0,0,0,1,0,0],[0,1,0,1,1,0,0],[1,0,0,0,1,1,0],[0,0,0,0,0,1,0]] -> False
[[0,1,0,1,1,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,0],[1,0,0,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,1]] -> True
[[0,1,0,0,1,0,1],[1,0,0,0,1,0,1],[0,0,1,0,1,0,1],[1,0,0,0,1,1,0],[0,0,0,1,1,1,0],[0,1,0,0,1,0,1]] -> True
[[0,1,0,0,1,0,0,1,0],[0,0,0,0,1,1,0,1,0],[1,1,0,0,1,0,0,0,0],[0,0,1,0,1,0,1,0,0],[0,0,1,0,1,0,1,0,0],[0,1,0,0,0,1,0,0,1],[0,1,0,0,0,0,1,0,0]] -> False
[[1,0,1,0,0,1,1,0,1],[0,1,1,0,0,1,1,0,1],[1,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,1,1],[0,1,1,0,1,0,1,0,1],[1,0,1,0,0,1,1,0,1]] -> True
[[1, 0, 1], [0, 1, 0], [1, 0, 0]]
C'était la seule matrice 3x3 pour laquelle ma nouvelle approche échouait.