Định nghĩa

Một ma trận đầu mũi tên là một ma trận có tất cả các mục tương đương với 0 , ngoại trừ những người trên đường chéo chính, hàng đầu tiên và cột tận cùng bên trái. Nói cách khác, ma trận sẽ trông như thế này:

* * * * * *
* * 0 0 0 0
* 0 * 0 0 0
* 0 0 * 0 0
* 0 0 0 * 0
* 0 0 0 0 *

Trong đó mỗi * là bất kỳ mục nhập khác không.

Bài tập

Cho một ma trận vuông của các số nguyên không âm, kiểm tra xem nó có phải là đầu mũi tên theo định nghĩa ở trên không.

Bạn không thể lấy kích thước của ma trận làm đầu vào, trừ khi ngôn ngữ của bạn tương đương với một mảng là một cái gì đó giống như một con trỏ và độ dài (như C). Nó sẽ luôn luôn có ít nhất 3 x 3.

Mã ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng.

Đầu vào và đầu ra

Bạn có thể chọn một trong các định dạng sau để nhận đầu vào:

• Một ma trận trong loại ma trận gốc (nếu ngôn ngữ của bạn có một)
• Mảng 2D ¹ (một mảng gồm các mảng 1D, mỗi mảng tương ứng với một hàng)
• Mảng 1D (vì ma trận luôn vuông)
• Một chuỗi (bạn đã chọn khoảng cách, nhưng xin vui lòng không lạm dụng điều này theo bất kỳ cách nào).

Khi nói đến việc cung cấp đầu ra, bạn có thể báo cáo giá trị trung thực / sai lệch theo định nghĩa vấn đề quyết định tiêu chuẩn hoặc chọn bất kỳ hai giá trị riêng biệt và nhất quán nào.

Hơn nữa, bạn có thể nhận đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào , trong bất kỳ ngôn ngữ lập trình nào , trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Nếu muốn chọn bất kỳ định dạng nào khác hoặc không chắc chắn về điều gì đó, vui lòng hỏi trong các nhận xét.

^{_{1: hoặc tương đương với ngôn ngữ của bạn (danh sách, vectơ, v.v.)}}

Ví dụ

Hãy xem các ví dụ sau:

1 2 2 2
2 1 0 0
3 0 1 0
4 0 0 1

Đây là ma trận đầu mũi tên (các chương trình của bạn phải báo cáo giá trị trung thực), bởi vì các phần tử trên đường chéo chính là 1 1 1 1, các phần tử trên hàng trên cùng là 1 2 2 2và các phần tử trên cột ngoài cùng bên trái là 1 2 3 4. Tất cả các mục khác là 0 , vì vậy điều này thỏa mãn tất cả các điều kiện.

3 5 6
7 1 0
8 0 0

Ma trận này không phải là đầu mũi tên vì có 0 trên đường chéo chính.

9 9 9 9
9 9 0 0
9 7 9 0
9 0 0 9

Cái này cũng không phải là đầu mũi tên, vì nó chứa số 7 thay cho số 0 .

Nhiều trường hợp kiểm tra

Sự thật:

[[1, 1, 1], [1, 1, 0], [1, 0, 1]]
[[1, 2, 3, 4], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]]
[[1, 2, 2, 2], [2, 1, 0, 0], [3, 0, 1, 0], [4, 0, 0, 1]]
[[34, 11, 35, 5], [56, 567, 0, 0], [58, 0, 679, 0], [40, 0, 0, 7]]

Giả mạo:

[[3, 5, 6], [7, 1, 0], [8, 0, 0]]
[[9, 9, 9, 9], [9, 9, 0, 0], [9, 7, 9, 0], [9, 0, 0, 9]]
[[1, 0, 3, 4], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]]
[[1, 6, 3, 4], [13, 2, 0, 6], [29, 0, 1, 0], [2, 0, 0, 4]]

Javascript (ES6), 48 47 byte

Đã lưu 1 byte nhờ edc65

m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))

Trả về falsecho ma trận đầu mũi tên và truecho ma trận không đầu mũi tên (được phép vì bất kỳ hai giá trị riêng biệt nào cũng có thể được sử dụng để thể hiện đúng và sai)

Các trường hợp thử nghiệm:

f=m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))
console.log(f([[1, 1, 1], [1, 1, 0], [1, 0, 1]]))
console.log(f([[1, 2, 3, 4], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]]))
console.log(f([[1, 2, 2, 2], [2, 1, 0, 0], [3, 0, 1, 0], [4, 0, 0, 1]]))
console.log(f([[34, 11, 35, 5], [56, 567, 0, 0], [58, 0, 679, 0], [40, 0, 0, 7]]))
console.log(f([[3, 5, 6], [7, 1, 0], [8, 0, 0]]))
console.log(f([[9, 9, 9, 9], [9, 9, 0, 0], [9, 7, 9, 0], [9, 0, 0, 9]]))
console.log(f([[1, 0, 3, 4], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]]))
console.log(f([[1, 6, 3, 4], [13, 2, 0, 6], [29, 0, 1, 0], [2, 0, 0, 4]]))

J , _{21 20 19 17} 15 byte

-4 byte nhờ @GalenIvanov.

*-:1,1,.=&/:@}.

Lấy đầu vào dưới dạng ma trận (xếp hạng 2 mảng).

Hãy thử trực tuyến!

Giải trình

Hãy để lịch sử chỉnh sửa là một bài học để bạn không chơi golf và viết một lời giải thích cùng một lúc.

* -: 1, 1,. = & /: @ }.  Let m be the input matrix.
            = & /: @ }.  Identity matrix 1 smaller than m.
                     }.    Behead (m without its first row).
                   @       Composed with.
                /:         Grade up (get len(m) - 1 unique elements)
              &            Composed with.
            =              Self-classify (compare equality with
                           unique elements)
        1,.              Prepend a column of 1s
     1,                  Prepend a row of 1s
*                        Signum (0 becomes 0, n > 0 becomes 1)
  -:                     Does it match the generated arrowhead matrix?

Giải thích trực quan

Lưu ý rằng điều này được thực hiện trên REPL (đầu vào được đưa ra bắt đầu bằng ba khoảng trắng và đầu ra được đưa ra mà không có bất kỳ khoảng trắng hàng đầu nào). Do đó, đôi khi tôi bỏ qua các hàm thành phần như @và &vì mọi thứ trên REPL được đánh giá từ phải sang trái (các hàm phức tạp hơn).

Giả sử bạn có ma trận mẫu sau:

   ] m =. 4 4 $ 1 2 3 4 1 1 0 0 1 0 1 0 1 0 0 1
1 2 3 4
1 1 0 0
1 0 1 0
1 0 0 1

Đầu tiên, tôi muốn giải thích (và đưa ra một lời kêu gọi) @ GalenIvanov là cách rất thông minh để tạo ra ma trận danh tính, như sau =&/:@}..

Đầu tiên, chúng ta chặt đầu ma trận đầu vào (}. ).

   }. m
1 1 0 0
1 0 1 0
1 0 0 1

Sau đó, chúng tôi nhận được các chỉ số mà mỗi hàng sẽ ở là các hàng được sắp xếp bằng /: tiến lên.

   /: }. m
2 1 0

Lưu ý rằng các chỉ số kết quả là duy nhất : danh sách không có phần tử trùng lặp (và tại sao nó lại không có cách nào để đặt hai phần tử vào cùng một vị trí trong một mảng).

Cuối cùng, chúng tôi sử dụng =phân khúc thích hợp nhưng hữu ích . Đơn nguyên này so sánh từng yếu tố duy nhất với tất cả các yếu tố khác trong một mảng. Hãy nhớ làm thế nào tôi đã đề cập đến điều quan trọng là các chỉ số kết quả là duy nhất? Vì =tự phân loại thực hiện các phép so sánh theo thứ tự các phần tử duy nhất xuất hiện trong danh sách, kết quả đầu ra sẽ là ma trận nhận dạng cho một đầu vào duy nhất (đây là lý do tại sao =@i.bạn có thể tạo ma trận nhận dạng có độ dài nhất định).

   = /: }. m
1 0 0
0 1 0
0 0 1
   NB. This is what is happening
   (2 = 2 1 0) , (1 = 2 1 0) ,: (0 = 2 1 0)
1 0 0
0 1 0
0 0 1

Khi chúng ta có ma trận danh tính, vấn đề là thêm một hàng và một cột, được thực hiện rất đơn giản (nếu được cung cấp một nguyên tử - tức là một yếu tố duy nhất - ,gia đình sẽ lặp lại để điền vào khi được thêm vào) :

   1,. (=&/:@}. m)
1 1 0 0
1 0 1 0
1 0 0 1
   1, (1,. =&/:@}. m)
1 1 1 1
1 1 0 0
1 0 1 0
1 0 0 1

Sau đó, chúng ta chỉ cần so sánh ma trận đầu mũi tên được tạo với dấu hiệu của ma trận đầu vào.

   * m
1 1 1 1
1 1 0 0
1 0 1 0
1 0 0 1
   (* m) -: (1, 1,. =&/:@}. m)
1

Ngôn ngữ Wolfram (Mathicala) , 47 byte

Clip@#==Array[If[1<#!=#2>1,0,1]&,{1,1}Tr[1^#]]&

Hãy thử trực tuyến!

Giải thích: Clip@#thay thế tất cả các số khác không trong ma trận bằng 1s, sau đó chúng tôi so sánh số này với một mảng có kích thước {1,1}Tr[1^#]= {Length@#, Length@#}với 0 ở vị trí i,jkhi 1 < i != j > 1và 1 khác.

(Dựa vào câu trả lời của Uriel .)

Đây là một ý tưởng khác dài hơn 16 byte - hãy thoải mái đánh cắp nó nếu bạn có thể đánh gôn xuống:

Union@@Array[{1,#}~Tuples~2&,Length@#]==Most@Keys@ArrayRules@#&

Hãy thử trực tuyến!

APL (Dyalog Classic) , 19 16 15 13 byte

-1 byte nhờ @ErikTheOutgolfer

( ⎕IO←0)

×≡(∧=⌊)/¨∘⍳∘⍴

Hãy thử trực tuyến!

-2 byte nhờ @ngn và @ H.PWiz

Làm sao?

(Ma trận đầu vào 2D S )

• ×≡Kiểm tra xem S chỉ dương trên ...
• (∧=⌊ ... các đường chéo hoặc hàng trên cùng và cột bên trái ...
• )/¨∘⍳∘⍴... của S .

PowerShell , 112 108 byte

param($a)$o=+!(0-in$a[0]);1..($x=$a.count-1)|%{$i=$_;0..$x|%{$o*=(!($y=$a[$i][$_]),$y)[!$_-or$_-eq$i]}};!!$o

Hãy thử trực tuyến!

Đưa đầu vào và thao tác dưới dạng một mảng, vì PowerShell không hỗ trợ ma trận (bên ngoài hỗ trợ ma trận biến đổi .NET Direct3D, một thứ hoàn toàn khác).

Toàn bộ thuật toán dựa trên thực tế là các số khác không là số thật và số 0 là falsey trong PowerShell và sử dụng phép nhân để xác định các giá trị trung thực / falsey đó.

Đầu tiên chúng ta lấy hàng đầu tiên, $a[0]và kiểm tra xem 0là -inmảng đó, cửa hàng đó vào chúng tôi $obiến utput. Nếu bất cứ thứ gì trong hàng đó bằng 0, thì số đó $ocũng bằng 0, nếu không, nó là một, được thực hiện bởi một cast-to-int nhanh chóng +.

Tiếp theo, chúng tôi lặp từ 1lên đến $a.count-1, thiết lập $xtrên đường đi - chúng tôi sẽ lặp lại từng hàng một.

Mỗi lần lặp chúng tôi đặt biến helper $iđể theo dõi những gì hàng chúng tôi đang ở trên, sau đó lặp từ 0để $xđể lặp mỗi phần tử trong hàng này. Bên trong vòng lặp bên trong, chúng ta lại nhân lên$o , lần này bằng cách chọn từ một thiết lập tuple làm toán tử giả ba chiều.

Điều kiện của tuple !$_-or$_-eq$i, nói "khi chúng ta ở cột 0 hoặc cột khớp với hàng (nghĩa là đường chéo chính)" để chọn nửa sau của tuple khi trung thực hoặc nửa đầu khi falsey. Các tuple bao gồm !($y=$a[$i][$_]), $y. Nửa đầu tiên thiết lập $yđể chơi golf nửa sau, nhưng dù bằng cách nào, chúng tôi đang chọn yếu tố hiện tại. Nửa đầu thực hiện phủ định Boolean trên nó, trong khi nửa thứ hai chỉ lấy phần tử nguyên trạng. Do đó, nếu chúng ta không ở cột thứ 0 cũng không phải đường chéo chính, chúng tôi đảm bảo rằng phần tử bằng 0 bằng cách lấy Boolean - không phải của nó. Tương tự, chúng tôi đảm bảo cột 0 hoặc đường chéo chính khác không bằng cách lấy nó.

Vì vậy, bây giờ chúng ta đã lặp lại qua mọi phần tử trong ma trận, $osẽ là 0nếu một phần tử không chính xác hoặc một số nguyên khác không nếu nó là ma trận đầu mũi tên. Chúng tôi nhân đôi Boolean - không phải để có được Falsehoặc Truetương ứng, để làm cho đầu ra của chúng tôi nhất quán, và điều đó còn lại trên đường ống nơi in ấn là ẩn.

Thạch , 14 12 byte

ŒDµḢ;Ḣ€Ȧ>FẸ$

-2 byte từ Pietu1998

Hãy thử trực tuyến!

Giải trình

[[9,7,1],
 [7,1,0],
 [7,0,1]]

Sử dụng ma trận trên làm đầu vào ví dụ.

ŒDµḢ;Ḣ€Ȧ>FẸ$
ŒD              Diagonals → [[9, 1, 1], [7, 0], [1], [7], [7, 0]]
  µ             New monadic link
   Ḣ            Head → [9, 1, 1]. Alters diagonals list.
    ;Ḣ€         Append with the head of each of the other diagonals → [9, 1, 1, 7, 1, 7, 7]
       Ȧ        Logical all → 1
         FẸ$    Flatten what's left in diagonals then take logical any → [[0],[],[],[0]] → [0,0] → 0
        >       Matrix is an arrowhead iff result of Ȧ > result of Ẹ

APL (Dyalog) , 21 18 17 byte

×≡1⍪1,(=/¨∘⍳1-⍨⍴)

Hãy thử trực tuyến!

Làm sao?

Cái này đi theo cách khác -

=/¨∘⍳ - tạo ma trận danh tính

1-⍨⍴ - cho n - 1

1⍪1, - chuẩn bị một cột và một hàng 1s

≡ - so sánh với

× - ma trận ban đầu, sau khi nó đã đi qua một yếu tố quan trọng

MATL , 15 byte

gtZyXy,!llY(]X=

Đầu vào là một ma trận (sử dụng ;như dấu phân cách hàng). Đầu ra là 1cho đầu mũi tên, 0nếu không.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

g        % Implicit input. Convert to logical values (nonzero becomes true and
         % zero becomes false)
t        % Duplicate
Zy       % Size
Xy       % Identity matrix of that size
,        % Do twice
  !      %   Transpose
  ll     %   Push 1 twice
  Y(     %   Write 1 at all entries of row 1
]        % End
X=       % Are the two matrices (input and constructed) equal? Implicit display

C (gcc) ,80 75 byte

i;f(A,n)int*A;{for(i=0;i<n*n;i++)n=A[i]>0^(i<n||i%n<1||i/n==i%n)?0:n;n=!n;}

Hãy thử trực tuyến!

Đã lưu 5 byte nhờ scottinet!

Sử dụng lại mã kiểm tra từ câu trả lời này .

Tuyến tính quét mảng cho bất kỳ giá trị không chính xác, trả về 0 cho ma trận đầu mũi tên và 1 nếu không. Chúng tôi kiểm tra bằng cách tính độc quyền hoặc liệu vật phẩm tại một vị trí nhất định có bằng không và liệu vị trí đó có nằm trên mũi tên hay không.

Mã hóa thông tin của mảng 2D thành một chiều dẫn đến một tập hợp các điều kiện khá đơn giản. Nếu chúng ta để ichỉ số dựa trên 0 của chúng ta vào nmảng thứ nguyên, thì i<nmô tả hàng đầu tiên. Tương tự, i%n==0mô tả cột đầu tiên và i/n==i%nmô tả đường chéo.

Thủ thuật tốt nhất tôi tìm thấy để xử lý trả lại là đặt kích thước về 0 khi gặp lỗi. Điều này làm cho vòng lặp chấm dứt ngay lập tức, sau đó trả về phủ định logic của thứ nguyên sẽ cho chúng ta một trong hai giá trị riêng biệt. scottinet đã tìm ra cách để khiến GCC trả lại nó độc đáo hơn.

Python 2 , 75 byte

lambda m,E=enumerate:all((x[j]>0)-(i>0<j!=i)for i,x in E(m)for j,y in E(m))

Hãy thử trực tuyến!

Python 2 , 85 byte

Lấy mảng làm ma trận 1D:

def f(m):s=len(m)**.5;print all((v<1)^(0in(p>s,p%s,p//s-p%s))for p,v in enumerate(m))

Hãy thử trực tuyến!

R , 78 70 69 68 54 53 byte

function(m){d=diag(nrow(m))
d[1,]=d[,1]=1
all(d!=!m)}

Hãy thử trực tuyến!

Chuyển câu trả lời Luis Mendo của là ngắn hơn nhiều so với phương pháp trước đây của tôi.

Nhờ vào rturnbull đã chỉ ra một lỗi và đánh gôn xuống một byte!

câu trả lời cũ, 68 byte:

function(m,i=which(!m,T))all(i[,1]-i[,2],i!=1,sum(m>0)==3*nrow(m)-2)

Hãy thử trực tuyến!

câu trả lời của duckmayr kiểm tra rằng tất cả các mục trên đường chéo chính và hàng / cột đầu tiên (m[i] ) là khác không và phần còn lại ( m[-i]) bằng 0, sử dụng một số số học đẹp để lấy đường chéo và hàng đầu tiên.

Tuy nhiên, câu trả lời này kiểm tra để đảm bảo rằng (1) các mục nhập không nằm trên đường chéo chính hoặc hàng / cột đầu tiên và (2) có, được đưa ra một n x n ma trận, 3*n-2các mục nhập khác không.

whichtrả về các chỉ mục có đầu vào của nó TRUEvà với tùy chọn arr.ind=T, trả về một mảng các chỉ mục cho mỗi thứ nguyên mảng, trong trường hợp này là hai.

Do đó any(i[,1]==i[,2]), khi tồn tại số 0 trên đường chéo và khi nào any(i==1)tồn tại số 0 ở hàng đầu tiên hoặc cột đầu tiên.

Cuối cùng, một số học nhỏ cho thấy số lượng các mục nhập khác phải 3*n-2, ntừ cột đầu tiên, n-1từ đường chéo và n-1từ hàng đầu tiên.

Python 2 , 92 90 byte

def f(m):l=len(m);return all((m[a%l][a/l]<1)^any([a<l,a%l<1,a/l==a%l])for a in range(l*l))

Hãy thử trực tuyến!

Tín dụng

• Giảm từ 92 byte đến 90 của ông Xcoder

Haskell , 62 byte

-3 byte nhờ ông Xcoder. -13 byte nhờ người dùng28667. -5 byte nhờ Zgarb.

z=zip[0..]
f m=and[(i==j||i*j<1)==(a>0)|(i,r)<-z m,(j,a)<-z r]

Hãy thử trực tuyến!

Thạch , 10 byte

ŒDµḢṠQṭT€E

Hãy thử trực tuyến!

Python 3 , 72 71 byte

lambda x,e=enumerate:any(0**n^(0<i!=j>0)for i,r in e(x)for j,n in e(r))

Cảm ơn @xnor vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Pyth, 22 21 byte

Đây chắc chắn không phải là ngôn ngữ để thao tác ma trận.

.As.e+!MWk.Db,0k,@bkh

Đối với mỗi hàng bvà chỉ mục của nó ktrong ma trận ( .e), lấy các kmục nhập đầu tiên và thứ (bên trái và đường chéo) với ,@bkhvà ( +) tất cả các mục nhập khác với .Db,0k. Nếu kkhông phải là 0 để tương ứng với hàng đầu tiên ( Wk), thì !không phải Mtất cả các mục đó. Khi tất cả những thứ đó đã được chọn, hãy chắc chắn rằng tất cả chúng đều đúng. ( .As) Nếu có một 0 nơi không nên có, sau đó vị trí tương ứng sẽ được nắm lấy như là và mess lên và, và nếu có một khác không nơi không nên có, nó sẽ được !notted đến 0, đó là cũng sai.

Bộ thử nghiệm.

-1 byte để hoán đổi các đơn đặt hàng xung quanh.

Pip, 31 23 22 bytes

{0<_!=B>0MC#a==0=_MMa}

This is a function that takes a 2D nested list of numbers. Try it online!

Explanation

Toàn bộ rất nhiều so sánh đang diễn ra ở đây. Điều đầu tiên cần biết là các toán tử so sánh trong Pip có thể được nối lại với nhau, như trong Python: 5>4>3là 5>4 and 4>3(đúng), không phải (5>4)>3(sai). Thứ hai là điều này không áp dụng cho ==toán tử "chính xác bằng". Một điểm khác biệt: thường xuyên so sánh có độ ưu tiên cao hơn so với các nhà khai thác bản đồ MCvà MMvà có thể được sử dụng trong các biểu thức lambda, trong khi ==có độ ưu tiên thấp hơn và không thể.

{                    }  Define a function with argument a:
 0<_!=B>0MC#a            Generate a matrix (as nested lists) that has 0 on the first row,
                          first column, and main diagonal, and 1 elsewhere (see below for
                          details)
               0=_MMa    Map the function 0=_ to the elements of the elements of a,
                          generating a matrix that is 0 where a is nonzero and vice versa
             ==          Test if the two matrices are equal, returning 0 or 1 accordingly

Để tạo ma trận đầu tiên, chúng tôi sử dụng MC"map-coords". Toán tử này lấy một số, tạo ra một lưới tọa độ vuông có kích thước đó và ánh xạ một hàm tới từng cặp tọa độ (x, y), trả về một danh sách các danh sách kết quả. Ví dụ, {a+b} MC 3sẽ cho kết quả [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Here, the size of the grid is #a, the size of our original argument. The function is 0<_!=B>0, which is a shorter way of writing {0 < a != b > 0}:

{        }  Function; a and b are the arguments (in our case, row and column)
 0<a        Return 1 (truthy) if a is greater than 0
    !=b     and a is not equal to b
       >0   and b is greater than 0

This returns 0 for the first row/column and the main diagonal, and 1 elsewhere.

Husk, 12 11 bytes

S≡ȯ´Ṫ§^*=ŀL

Try it online!

Explanation

S≡ȯ´Ṫ§^*=ŀL  Input is a k×k array A.
          L  The length, k.
         ŀ   The range [0,1..k-1].
  ȯ´Ṫ        Outer product with itself by this function:
              Arguments are two numbers x and y.
        =     Equality of x and y
     §^       to the power of
       *      x times y.
S≡           Does the result have the same shape and distribution of truthy values as A?

The idea is that Husk defines 0 to the power of 0 as 1, so the outer product has 1s on the first row and column. Also, 1 to the power of any number is 1, so the outer product has 1s on the diagonal. Other entries are 0 to the power of some positive number, which is 0. This gives a binary arrowhead matrix, which we compare to the input with ≡.

APL+WIN, 36 33 bytes

(↑⍴m)=+/(+⌿m)=+/m←×m×n∘.×n←⍳↑⍴m←⎕

Prompts for screen input of an APL 2d matrix.

Clojure, 128 95 92 85 bytes

#(every? neg?(for[R[(range(count %))]i R j R]((if((set[i(- i j)j])0)- dec)((% i)j))))

It is always exciting to see two consecutive opening brackets.

Original version:

#(and(apply =(map assoc(for[i(rest %)](subvec i 1))(range)(repeat 0)))(every? pos?(concat(map nth %(range))(% 0)(map first %))))

The first part works by associng diagonal elements of the sub-matrix to zero, and checking that all rows are equal :) I used a similar trick at Jacobian method.

Latter part concatenates the diagonal + first row and column and checks that they are positive.

Javascript (ES6), 58 bytes

My solution for Javascript:

m=>m.some((r,i)=>m[0][i]*r[0]*r[i]==0|r.filter(c=>i*c)[2])

Not as clever as Herman's answer, but I just felt like I should post it here too.

isArrowHead=m=>m.some((r,i)=>m[0][i]*r[0]*r[i]==0|r.filter(c=>i*c)[2])

console.log("-----should be false-----")

console.log(isArrowHead([[1, 1, 1], [1, 1, 0], [1, 0, 1]]))
console.log(isArrowHead([[1, 2, 3, 4], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]]))
console.log(isArrowHead([[1, 2, 2, 2], [2, 1, 0, 0], [3, 0, 1, 0], [4, 0, 0, 1]]))
console.log(isArrowHead([[34, 11, 35, 5], [56, 567, 0, 0], [58, 0, 679, 0], [40, 0, 0, 7]]))

console.log("-----should be true-----")

console.log(isArrowHead([[3, 5, 6], [7, 1, 0], [8, 0, 0]]))
console.log(isArrowHead([[9, 9, 9, 9], [9, 9, 0, 0], [9, 7, 9, 0], [9, 0, 0, 9]]))
console.log(isArrowHead([[1, 0, 3, 4], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]]))
console.log(isArrowHead([[1, 6, 3, 4], [13, 2, 0, 6], [29, 0, 1, 0], [2, 0, 0, 4]]))

console.log("-----end-----")

Clojure, 212 206 188 bytes

-6 bytes by removing some missed spaces, and shortcutting range. I might have to let this sit so I can think of a better way.

-18 bytes thanks to @NikoNyrh, and creating shortcuts for map.

(fn[m](let[r range a map z zero?](and(every? #(not(z %))(concat(m 0)(rest(a #(% 0)m))(a get m(r))))(every? z(apply concat(into(a #(take(dec %)%2)(r)(a rest m))(a take-last(r)(reverse(rest m)))))))))

Awful, just awful. I don't know why I can't wrap my head around a reasonable solution.

Takes a nested vector as input.

(defn arrowhead? [matrix]
  (let [; Get the 0th cell of the 0th row, then the 1st cell of the 1st row...
        main-diagonal (map get matrix (range))

        ; Get the 0th cell of each row
        first-col (rest (map #(% 0) matrix))
        arrowhead (concat (matrix 0) first-col main-diagonal)

        ;
        right-rest (map take-last (range) (reverse (rest matrix)))
        left-rest (map #(take (dec %) %2) (range) (map rest matrix))
        rest-matrix (apply concat (into left-rest right-rest))]

    ; And check them
    (and (every? pos? %) arrowhead
         (every? zero? rest-matrix))))

I tried rewriting this from scratch using a different method, and it ended up longer. Instead of manually carving out the "rest" sections of the matrix, I instead decided to try generating all the coordinates in the matrix, generating the coordinates of the arrowhead, then use clojure.set/difference to get the non-arrowhead cells. Unfortunately, the call to that built-in is costly:

223 bytes

(fn[m](let[l(range(count m))g #(get-in m(reverse %))e every? a(for[y l x l][x y])k #(map % l)r(concat(k #(do[% %]))(k #(do[0%]))(k #(do[% 0])))](and(e #(zero?(g %))(clojure.set/difference(set a)(set r)))(e #(pos?(g %)))r)))

(defn arrowhead? [matrix]
  (let [length-range (range (count matrix))
        get-cell #(get-in matrix (reverse %))
        all-coords (for [y length-range
                         x length-range]
                     [x y])

        k #(map % length-range)

        diag (k #(do[% %]))
        top-side (k #(do [0 %]))
        left-side (k #(do [% 0]))
        arrowhead (concat diag top-side left-side)

                   ; 22 bytes! Ouch
        rest-cells (clojure.set/difference (set all-coords) (set arrowhead))]

    (and (every? #(zero? (get-cell %)) rest-cells)
         (every? #(pos? (get-cell %)) arrowhead))))

Stax, 11 bytes^CP437

ä¢⌠┐xⁿtH↔BU

Try it online!

Unpacked version with 13 bytes:

B|AsF:10i^\=*

Finally tied Husk and beaten by Jelly by just one byte ...

Explanation

B                Push tail (all except 1st row) of the input array, then push the head (1st row)
 |A              All elements in the head are truthy
                 This will be used as an accumulator
   sF            For each element in the tail, execute the rest of the program
     :1          All truthy indices
       0i^\      Expected truthy indices (0 and the current row number)
           =     The truthy indices are as expected
            *    Perform logical "and" with the accumulator
                 Implicit output of the final accumulator

R, 81 79 bytes

function(x){n=nrow(x);i=c(seq(1,n^2,n+1),1:n,seq(1,n^2,n));all(x[i]>0,x[-i]<1)}

-2 bytes thanks to Mr. Xcoder

Try it online!

C, 117 bytes

i,j,r;f(A,n)int*A;{for(i=r=0;i<n;++i)for(j=-1;++j<n;(!i||!j||i==j)&&!A[i*n+j]&&++r)i*j&&i-j&&A[i*n+j]&&++r;return!r;}

Try it online!

PowerShell, 186 bytes

$a=$($args);if($a[0]-contains0){0;exit};0..($a.Length-1)|%{if($a[$_][0]-eq0-or$a[$_][$_]-eq0){0;exit};$r=$a[$_];$d=$_;if($_-ne0){1..($r.Length-1)|%{if($r[$_]-ne0-and$_-ne$d){0;exit}}}};1

Try it online!

Perl 5, 136 + 2 (-ap) = 138 bytes

push@a,[@F]}{push@b,"@{$a[0]}"=~/\b0\b/;map{//;map$a[$'][$_]=!$a[$'][$_],0,$';shift@{$a[$']};push@b,@{$a[$']}}1..$#a;say!("@b"=~y/ 0//c)

Try it online!

Clean, 79 bytes

import StdEnv
?[h:m]=prod h>0&&and[u>0&&n!!x>0&&sum n==n!!x\\[u:n]<-m&x<-[0..]]

Try it online!

Japt, 16 bytes

Ëe@!X^!(E*Y*nE
e

Test it online!

^{Man, this takes me back to the good old days when Japt was regularly much longer than other golfing langs...}

K (oK), 27 30 bytes

Solution:

x~a*x|a:a|+(a:1,(#1_x)#0)|=#x:

Try it online!

Explanation:

I must be doing something dumb as the APL solutions are less than half the byte count...

24 bytes spent creating the arrowhead. or together the following three matrices:

/ assume 4x4 matrix
=#x
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

+(a:1,(#1_x)#0)
1 0 0 0
1 0 0 0
1 0 0 0
1 0 0 0

a
1 1 1 1
0 0 0 0
0 0 0 0
0 0 0 0

Full breakdown:

x~a*x|a:a|+(a:1,(#1_x)#0)|=#x: / the solution
                            x: / save input as x
                           #   / count length
                          =    / identity matrix
                         |     / or with
           (            )      / do this together
                      #0       / take from 0
                ( 1_x)         / drop first of x
                 #             / count
              1,               / prepend 1
            a:                 / save as a
          +                    / flip rows/cols
         |                     / or with
        a                      / a
      a:                       / save as a
     |                         / or with
    x                          / x
  a*                           / multiply by arrowhead
x~                             / matches input?