Istnieje rodzaj macierzy n × n W zwanej podstawową formą kanoniczną Weyru . Taka matryca jest opisana za pomocą bloków i ma następujące właściwości, przy użyciu następującego diagramu referencyjnego:

• głównymi blokami diagonalnymi W _ii są macierze n _i × n _i postaci λ I _{n i} gdzie I _{n i} jest macierzą tożsamości n _i × n _i .
• n ₁ ≥ n ₂ ≥ ... ≥ n _r
• pierwsze bloki superdiagonalne W _{k-1, k} dla k ∈ 2..r są macierzami n _k-1 × n _k , które mają pełną rangę kolumny w postaci rzutu o zmniejszonej liczbie wierszy , lub prościej mówiąc, I _{n k} siedzi na n _k-1 - n _k rzędów zer.
• wszystkie pozostałe bloki mają 0 macierzy.

Na przykład:

• Główne ukośne bloki (żółte) są takie, że n _i wynoszą 4, 2, 2 i 1.
• Pierwsze superdiagonalne bloki są zielone.
• Szara strefa składa się ze wszystkich pozostałych bloków, które mają wartość 0 .

Dla tego wyzwania przyjmiemy λ = 1.

Wejście

Matryca kwadratowa z zerami i zerami w dowolnym dogodnym formacie.

Wynik

Wyprowadza jedną z dwóch różnych wartości określających, czy macierzą wejściową jest Weyr, czy nie Weyr.

Zasady

To jest golf golfowy . Wygrywa najmniej bajtów w każdym języku. Obowiązują standardowe zasady / luki.

Przypadki testowe

Przedstawione jako tablice wierszy.

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 bajtów

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

Wypróbuj online!

Python 2 , 270 bajtów

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

Wypróbuj online!

Wyjaśnienie:

Rekurencyjnie sprawdza bloki pod kątem tożsamości i ich superdiagonalnych bloków.

I sprawdza, czy macierz jest matrycą tożsamości

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

Dla każdego bloku macierzy wejściowej funkcja sprawdza, czy jest to tożsamość i czy jest inny blok macierzy tożsamości, po prawej stronie. Następna iteracja sprawdza blok o tym rozmiarze.

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