C'è un tipo di matrice n × n W chiamata forma canonica di Weyr di base . Tale matrice è descritta dai suoi blocchi e ha le seguenti proprietà, usando il seguente diagramma di riferimento:

• i principali blocchi diagonali W _ii sono n _i × n _i matrici della forma λ I _{n i} dove I _{n i} è la matrice di identità n _i × n _i .
• n ₁ ≥ n ₂ ≥ ... ≥ n _r
• i primi blocchi superdiagonali W _{k-1, k} per k ∈ 2..r sono n _k-1 × n _k matrici che sono rango di colonna completo in forma di scaglione ridotto di riga , o più semplicemente, I _{n k} seduti sopra n _k-1 : n _k righe di zeri.
• tutti gli altri blocchi sono 0 matrici.

Per esempio:

• I blocchi diagonali principali (gialli) sono tali che n _i sono 4, 2, 2 e 1.
• I primi blocchi superdiagonali sono in verde.
• La zona grigia è composta da tutti gli altri blocchi, che sono tutti 0 .

Per questa sfida assumeremo λ = 1.

Ingresso

Una matrice quadrata con 0 e 1 in qualsiasi formato conveniente.

Produzione

Stampa uno dei due valori distinti per stabilire se la matrice di input è Weyr o no Weyr.

Regole

Questo è code-golf . Vince il minor numero di byte in ogni lingua. Si applicano le regole / scappatoie standard.

Casi test

Presentato come array di righe.

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 byte

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

Provalo online!

Python 2 , 270 byte

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

Provalo online!

Spiegazione:

Controlla ricorsivamente i blocchi per l'identità e i loro blocchi superdiagonali.

I controlla se una matrice è una matrice di identità

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

Per ogni blocco della matrice di input, la funzione verifica che sia un'identità e che esista un altro blocco della matrice di identità, alla sua destra. La successiva iterazione quindi esamina un blocco di quelle dimensioni.

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