Il existe un type de matrice n × n W appelé forme canonique de base de Weyr . Une telle matrice est décrite par ses blocs et possède les propriétés suivantes, à l'aide du diagramme de référence suivant:

• les principaux blocs diagonaux W _ii sont des matrices n _i × n _i de la forme λ I _{n i} où I _{n i} est la matrice d'identité n _i × n _i .
• n ₁ ≥ n ₂ ≥ ... ≥ n _r
• les premiers blocs superdiagonaux W _{k-1, k} pour k ∈ 2..r sont n matrices _{k k-1} × n _k qui sont de rang de colonne complet sous forme d'échelon à rangées réduites , ou plus simplement, I _{n k} assis au-dessus de n _k-1 - n _k rangées de zéros.
• tous les autres blocs sont 0 matrices.

Par exemple:

• Les principaux blocs diagonaux (jaunes) sont tels que les n _i sont 4, 2, 2 et 1.
• Les premiers blocs superdiagonaux sont en vert.
• La zone grise se compose de tous les autres blocs, qui sont tous à 0 .

Pour ce défi, nous supposerons λ = 1.

Contribution

Une matrice carrée avec 0 et 1 dans n'importe quel format pratique.

Production

Sortez l'une des deux valeurs distinctes pour savoir si la matrice d'entrée est Weyr ou non Weyr.

Règles

C'est du code-golf . Le moins d'octets dans chaque langue gagne. Des règles / lacunes standard s'appliquent.

Cas de test

Présenté sous forme de tableaux de lignes.

Weyr:

[[1]] 
[[1,1],[0,1]] 
[[1,0,1,0,0],[0,1,0,1,0],[0,0,1,0,1],[0,0,0,1,0],[0,0,0,0,1]]
[[1,0,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0,0],[0,0,1,0,0,1,0,0,0],[0,0,0,1,0,0,1,0,0],[0,0,0,0,1,0,0,1,0],[0,0,0,0,0,1,0,0,1],[0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]
[[1,0,0,0,1,0,0,0,0],[0,1,0,0,0,1,0,0,0],[0,0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,1,0,0],[0,0,0,0,0,1,0,1,0],[0,0,0,0,0,0,1,0,1],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]

Non-Weyr:

[[0]]
[[1,0],[1,1]]
[[1,0,0,1,0,0],[0,1,0,0,0,0],[0,0,1,0,0,1],[0,0,0,1,0,0],[0,0,0,0,1,0],[0,0,0,0,0,1]]
[[1,0,1,0,0],[0,1,0,0,0],[0,0,1,0,0],[0,0,0,1,0],[0,0,0,0,1]]
[[1,0,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0,0],[0,0,1,0,0,1,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,1,0,0],[0,0,0,0,0,1,0,1,0],[0,0,0,0,0,0,1,0,1],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]

K (ngn / k) , 91 88 84 80 octets

{x~e|(-n)#'(0*x),'(!n)=\:,/(-1_b)+1_0{x#!y}':|-n-':|b:|\@[-1++/|\|+x|e:=n:#x]\0}

Essayez-le en ligne!

Python 2 , 270 octets

lambda m,w=0:{w}&{0,len(m)}and I(m)or any(I([l[:i]for l in m[:i]])*I([l[i:j+i]for l in m[:j]])*(sum(sum(m[:i]+[l[:i]for l in m],[]))==2*i+j)and f([l[i:]for l in m[i:]],j)for i in range(w,len(m))for j in range(1,i+1))
I=lambda m:all(sum(l)==l[i]>0for i,l in enumerate(m))

Essayez-le en ligne!

Explication:

Vérifie récursivement l'identité des blocs et leurs blocs superdiagonaux.

I vérifie si une matrice est une matrice d'identité

I=lambda m:all(sum(l)==l[i]>0for i,l in enumerate(m))

Pour chaque bloc de la matrice d'entrée, la fonction vérifie qu'il s'agit d'une identité, et qu'il y a un autre bloc de matrice d'identité, à sa droite. L'itération suivante examine ensuite un bloc de cette taille.

{w}&{0,len(m)}and I(m)                # if the while matrix is an identity matrix,
                                      # return true (but only the first time or last block)
or
any(
 I([l[:i]for l in m[:i]])                         # the current block is identity
 *I([l[i:j+i]for l in m[:j]])                     # and, the smaller block to the right is identity
 *(sum(sum(m[:i]+[l[:i]for l in m],[]))==2*i+j)   # and everything below and to the right (not the
                                                  # smaller block), are 0
 and f([l[i:]for l in m[i:]],j)                   # and the remaining matrix is alse Weyr(recursively)
 for i in range(w,len(m))             # for each block size i
 for j in range(1,i+1)                # for each smaller right block of size j
)