Hay un tipo de n × n matriz W llamada forma canónica básica de Weyr . Dicha matriz se describe por sus bloques y tiene las siguientes propiedades, utilizando el siguiente diagrama de referencia:

• los bloques diagonales principales W _ii son n _i × n _i matrices de la forma λ I _{n i} donde I _{n i} es la matriz de identidad n _i × n _i .
• n ₁ ≥ n ₂ ≥ ... ≥ n _r
• los primeros bloques superdiagonales W _{k-1, k} para k ∈ 2..r son n _k-1 × n _k matrices que son rango de columna completo en forma escalonada reducida , o más simplemente, I _{n k} sentado encima de n _k-1 - n _k filas de ceros.
• todos los otros bloques son 0 matrices.

Por ejemplo:

• Los bloques diagonales principales (amarillo) son tales que n _i son 4, 2, 2 y 1.
• Los primeros bloques superdiagonales están en verde.
• La zona gris consta de todos los otros bloques, que son todos 0 .

Para este desafío asumiremos λ = 1.

Entrada

Una matriz cuadrada con 0s y 1s en cualquier formato conveniente.

Salida

Genere uno de dos valores distintos para saber si la matriz de entrada es Weyr o no Weyr.

Reglas

Este es el código de golf . Pocos bytes en cada idioma gana. Se aplican reglas estándar / lagunas.

Casos de prueba

Presentado como matrices de filas.

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

No 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 bytes

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

Pruébalo en línea!

Python 2 , 270 bytes

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

Pruébalo en línea!

Explicación:

Verifica recursivamente los bloques en busca de identidad y sus bloques superdiagonales.

I comprueba si una matriz es una matriz de identidad

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

Para cada bloque de la matriz de entrada, la función comprueba que es una identidad y que hay otro bloque de matriz de identidad, a la derecha. La siguiente iteración luego mira un bloque de ese tamaño.

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