Is my Matrix Arrowhead?

Question

Definition

An arrowhead matrix is a matrix that has all entries equal to 0, except the ones on the main diagonal, top row and leftmost column. In other words, the matrix should look like this:

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

Where each * is any non-zero entry.

Task

Given a square matrix of non-negative integers, check whether it is arrowhead according to the definition above.

You may not take the size of the matrix as input, unless your language’s equivalent to an array is something like a pointer and a length (like C). It will always be at least 3 x 3.

The shortest code in bytes in each language wins.

Input and Output

You can pick among any of the following formats for receiving input:

• A matrix in the native matrix type (if your language has one)
• A 2D array¹ (an array of 1D arrays, each corresponding to one row)
• A 1D array (since the matrix is always square)
• A string (you chose the spacing, but please do not abuse this in any way).

When it comes to providing output, you can either report a truthy / falsy value following the standard decision-problem definition, or choose any two distinct and consistent values.

Moreover, you can take input and give output through any standard method, in any programming language, while taking note that these loopholes are forbidden by default. If want to pick any other format or are unsure about something, please ask in the comments.

^{_{1: or your language's equivalent (list, vector, etc.)}}

Examples

Let's look at the following examples:

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

This is an arrowhead matrix (your programs should report a truthy value), because the elements on the main diagonal are 1 1 1 1, those on the top row are 1 2 2 2 and those on the leftmost column are 1 2 3 4. All other entries are 0, so this satisfies all the conditions.

3 5 6
7 1 0
8 0 0

This matrix is not arrowhead because there is a 0 on the main diagonal.

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

This one is not arrowhead either, because it contains a 7 in place of a 0.

More test cases

Truthy:

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

Falsy:

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

• Adalynn: Is it possible that the matrix can contain negative numbers
• Mr. Xcoder: @Zacharý No you may assume they are all non-negative.
• Ian Bush: Pedant: A two dimensional array and a matrix are not the same thing, nor is it the same as an array of arrays. Is input as a two dimensional array acceptable if your language of choice is civilised enough to support multidimensional arrays?
• Mr. Xcoder: @IanBush Yes, a 2D array is totally fine.
• dylnan: @Mr.Xcoder This would be a sufficiently different and interesting challenge if the arrowhead could point in any direction

Answer 1

Javascript (ES6), (削除) 48 (削除ここまで) 47 bytes

Saved 1 byte thanks to edc65

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

Returns false for arrowhead matrices and true for non-arrowhead matrices (allowed since any two distinct values can be used to represent true and false)

Test cases:

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

• Mr. Xcoder: Now that's a truly clever approach!
• edc65: could this work ? f=m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))
• Neil: @edc65 Without the f= of course ;-)

Answer 2

J, _{(削除) 21 (削除ここまで) (削除) 20 (削除ここまで) (削除) 19 (削除ここまで) (削除) 17 (削除ここまで)} 15 bytes

-4 bytes thanks to @GalenIvanov.

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

Takes input as a matrix (rank 2 array).

Try it online!

Explanation

Let the edit history be a lesson to you not to golf and write an explanation at the same time.

* -: 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?

Visual explanation

Note that this is done on the REPL (inputs are given starting with three spaces and output are given without any leading spaces). Because of that, I sometimes omit composition functions like @ and & since things on the REPL are evaluated right-to-left (functions are more complex).

Suppose you have the following sample matrix:

 ] 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

First, I'd like to explain (and give a shoutout to) @GalenIvanov's very clever way of generating the identity matrix, which is the following =&/:@}..

First, we behead the input matrix (}.).

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

Then we get the indices each row would be in were the rows sorted using /:-grade up.

 /: }. m
2 1 0

Note that the resulting indices are unique: the list has no duplicate elements (and why would it? There's no way to place two elements in the same position in an array).

Finally, we use the niche but helpful =-self-classify. This monad compares each unique element to all of the other elements in an array. Remember how I mentioned it was important that the resulting indicies are unique? Since =-self-classify does the comparisons in the order that the unique elements appear in the list, the resulting output will be the identity matrix for a unique input (this is why =@i. is how you can make an identity matrix of a given length).

 = /: }. 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

Once we have the identity matrix, it's a matter of adding a row of ones and a column of ones, which is done very simply (if given an atom - i.e. a single element - the , family will repeat it to fill when it's being added):

 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

Then we simply compare the generated arrowhead matrix to the signum of the input matrix.

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

• Galen Ivanov: Isn't * enough instead of 0@< (for 17 bytes)? Try it
• cole: @GalenIvanov good catch, I think so. Thanks! Time to re-edit the explanation lol.
• Galen Ivanov: I think I found a new way to generate the identity matrix: =&/: When I combined it with }., I got this *-:1,1,.=&/:@}. for 15 bytes Try it online!
• cole: @GalenIvanov brilliant approach (both the use of /:-grade and }.-behead), thank you again! I'll edit it in.
• Galen Ivanov: Hmm, in fact *-:1,1,.=@}. works just fine - no need of fancy way to find the identity matrix. You can generate an identity matrix from the square matrix itself simply by =. So drop one row with }., make the identity matrix with = , add a row and a column with 1 and so on.

Answer 3

Wolfram Language (Mathematica), 47 bytes

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

Try it online!

Explanation: Clip@# replaces all the non-zero numbers in the matrix with 1s, then we compare this to an array with dimensions {1,1}Tr[1^#] = {Length@#, Length@#} with 0 in position i,j when 1 < i != j > 1, and 1 otherwise.

(Roughly based on Uriel's answer.)

Here's another idea that's 16 bytes longer — feel free to steal it if you can golf it down:

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

Try it online!

Answer 4

APL (Dyalog Classic), (削除) 19 (削除ここまで) (削除) 16 (削除ここまで) (削除) 15 (削除ここまで) 13 bytes

-1 byte thanks to @ErikTheOutgolfer

(⎕IO←0)

×ばつ≡(∧=⌊)/ ̈∘⍳∘⍴

Try it online!

-2 bytes thanks to @ngn and @H.PWiz

How?

(2D input matrix S)

• ×ばつ≡ Check whether S is positive only on ...
• (∧=⌊ ... the diagonals or the top row and left column ...
• )/ ̈∘⍳∘⍴ ... of S.

• Uriel: nice utilization of ⍳∘⍴ for cartesian product.
• Erik the Outgolfer: ×≡(=/∨1∊⊢)¨∘⍳∘⍴
• ngn: (=/∨1∊⊢) -> (~≠⌊⌊)/
• H.PWiz: @ngn Even better: (∧=⌊)/, of course both require ⎕IO←0

Answer 5

PowerShell, (削除) 112 (削除ここまで) 108 bytes

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

Try it online!

Takes input and manipulates as an array-of-arrays, since PowerShell doesn't support matrices (outside of the .NET Direct3D transform matrices support, which is something entirely different).

The whole algorithm is based on the fact that non-zero numbers are truthy and zero is falsey in PowerShell, and using multiplication to determine those truthy/falsey values.

We first take the first row, $a[0], and check whether 0 is -in that array, store that into our $output variable. If anything in that row is zero, then the $o is also zero, otherwise it's one, done by a quick cast-to-int with +.

Next we loop from 1 up to $a.count-1, setting $x along the way -- we're going to be looping through each row one at a time.

Each iteration we set helper variable $i to keep track of what row we're on, then loop from 0 to $x to iterate each element in this row. Inside the inner loop, we're again multiplying $o, this time by selecting from a tuple setup as a pseudo-ternary operator.

The tuple's conditional, !$_-or$_-eq$i, says "when we're on the 0th column, or the column matches the row (i.e., the main diagonal)" to select the second half of the tuple when truthy or the first half when falsey. The tuple is composed of !($y=$a[$i][$_]), $y. The first half sets $y for golfing the second half, but either way we're selecting the current element. The first half does Boolean negation on it, while the second half just takes the element as-is. Thus, if we're not on the 0th column nor the main diagonal, we ensure that the element is zero by taking the Boolean-not of it. Similarly, we ensure the 0th column or main diagonal is non-zero by simply taking it.

So now that we've iterated through every element in the matrix, $o is either going to be 0 if some element was incorrect, or some non-zero integer if it is an arrowhead matrix. We double-Boolean-not that to get either False or True respectively, to make our output consistent, and that's left on the pipeline where printing is implicit.

• root: + = [int]? That is nice.
• AdmBorkBork: @root One of the PowerShell tips.

Answer 6

Jelly, (削除) 14 (削除ここまで) 12 bytes

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

-2 bytes from Pietu1998

Try it online!

Explanation

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

Use the above matrix as an example input.

Œ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 Ẹ

• dylnan: @wizzwizz4 I'm not sure what you mean
• dylnan: @wizzwizz4 this code shows how the elements of the matrix are regrouped. It does take the top, left and main diagonal. Is this what you meant?
• wizzwizz4: I meant the actual visual representation of the code that you provided in your explanation. I was trying to be funny but it obviously didn't work. I'll clean up these comments.

Answer 7

APL (Dyalog), (削除) 21 (削除ここまで) (削除) 18 (削除ここまで) 17 bytes

×ばつ≡1⍪1,(=/ ̈∘⍳1-⍨⍴)

Try it online!

How?

This one goes the other way -

=/ ̈∘⍳ - creates the identity matrix

1-⍨⍴ - for n - 1

1⍪1, - prepends a column and a row of 1s

≡ - compares with

×ばつ - the original matrix, after it has gone an element-wise signum-ing

Answer 8

MATL, 15 bytes

gtZyXy,!llY(]X=

Input is a matrix (using ; as row separator). Output is 1 for arrowhead, 0 otherwise.

Try it online! Or verify all test cases.

Explanation

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

• Erik the Outgolfer: What exactly is Indeity matrix?
• cole: @EriktheOutgolfer obviously a matrix containing a deity.
• jld: @cole perhaps related to a matrix over the Elysian field

Answer 9

Python 2, 75 bytes

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

Try it online!

Python 2, 85 bytes

Taking the array as a 1D matrix:

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

Try it online!

• NikoNyrh: Did you mean "1D matrix" in the top solution?
• FlipTack: @NikoNyrh oops, fixed

Answer 10

R, (削除) 78 (削除ここまで) (削除) 70 (削除ここまで) (削除) 69 (削除ここまで) (削除) 68 (削除ここまで) (削除) 54 (削除ここまで) 53 bytes

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

Try it online!

Porting Luis Mendo's answer is much shorter than my former approach.

Thanks to rturnbull for pointing out a bug, and golfing down a byte!

old answer, 68 bytes:

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

Try it online!

duckmayr's answer tests that all entries on the main diagonal and first row/column (m[i]) are nonzero and the rest (m[-i]) are zero, using some nice arithmetic to get the diagonal and the first row.

This answer, however, tests to make sure that (1) zero entries are not on the main diagonal or the first row/column, and (2) that there are, given an n x n matrix, 3*n-2 nonzero entries.

which returns the indices where its input is TRUE, and with the optional arr.ind=T, returns an array of indices for each array dimension, in this case, two.

Hence when any(i[,1]==i[,2]), there exists a zero on the diagonal, and when any(i==1), there exists a zero in the first row or the first column.

Finally, a little arithmetic shows that the number of nonzero entries must be 3*n-2, n from the first column, n-1 from the diagonal, and n-1 from the first row.

• rturnbull: This doesn't seem to work for arrow matrices where the values are not 1. Did you mean all(!m==!d) in the last line?
• Giuseppe: @rturnbull ah! Thank you. R operator syntax is so weird. I really meant (!!m)==d but ! has lower precedence than ==. I think d==!!m should do the trick, though.
• rturnbull: It looks like d!=!m does the same, for one byte less. You can save another byte by using pryr::f syntax rather than function too.
• JayCe: I tried to golf it but the best i can do is still 53.
• Giuseppe: @JayCe nah both your answer and mine can be golfed to 52, and I'm not sure why it didn't occur to me before... I'd post yours as separate; the one-line approach is quite nice and I suspect there may be some more room for improvement in yours

Answer 11

C (gcc), (削除) 80 (削除ここまで) (削除) 75 (削除ここまで) 69 bytes

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

Try it online!

Saved 5 bytes thanks to scottinet! And 6 more thanks to ceilingcat!

Reused the test code from this answer.

Linearly scans the array for any incorrect values, returning 0 for an arrowhead matrix and 1 otherwise. We check by computing the exclusive or of whether the item at a given position is zero and whether that position is on the arrow.

Encoding the information of the 2D array into one dimension leads to a fairly simple set of conditions. If we let i be our 0-based index into the n dimensional array, then i<n describes the first row. Similarly, i%n==0 describes the first column and i/n==i%n describes the diagonal.

The best trick I found for handling the return is to set the dimension to zero when encountering an error. This causes the loop to terminate immediately, then returning the logical negation of the dimension will give us one of two distinct values. scottinet found the way to make GCC return it more nicely.

• scottinet: -2 bytes with some more golfing
• scottinet: and an additional -4 bytes by abusing gcc's way of returning values
• FryAmTheEggman: @scottinet Thanks! I was having trouble figuring out which value I should set to use that trick.
• FryAmTheEggman: Actually, I don't believe your first golf works. It passed the test cases because there was never a zero in the first position. Added a case and reverted that change.
• user58988: int test0[] = {0, 1, 1, 1, 1, 0, 1, 0, 1}; printf("%d\n", f(test0, 3)); Has to return 0 not 1 (if is the 3x3 matrx 011 110 101) because a[0,0] is 0

Answer 12

Python 2, (削除) 92 (削除ここまで) 90 bytes

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

Try it online!

Credits

• Reduced from 92 bytes to 90 by Mr. Xcoder

Answer 13

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

A whole lot of comparisons going on here. The first thing to know is that comparison operators in Pip can be chained together, like in Python: 5>4>3 is 5>4 and 4>3 (true), not (5>4)>3 (false). The second is that this doesn't apply to ==, the "exactly equals" operator. Another difference: regular comparisons have higher precedence than the mapping operators MC and MM and can be used in lambda expressions, while == has lower precedence and can't.

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

To generate the first matrix, we use MC, "map-coords." This operator takes a number, generates a square coordinate grid of that size, and maps a function to each (x,y) coordinate pair, returning a list of lists of the results. For example, {a+b} MC 3 would give the result [[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.

Answer 14

Haskell, 62 bytes

-3 bytes thanks to Mr. Xcoder. -13 bytes thanks to user28667. -5 bytes thanks to Zgarb.

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

Try it online!

• Mr. Xcoder: 80 bytes.... You almost always forget about <1 and such tricks? :P
• user28667: (x==y||x==0||y==0)==(m!!y!!x/=0) should be shorter
• Zgarb: 62 bytes by zipping instead of indexing, and doing x*y<1.

Answer 15

Jelly, 10 bytes

ŒDμḢṠQṭT€E

Try it online!

Answer 16

Pyth, (削除) 22 (削除ここまで) 21 bytes

This is definitely not the language for matrix manipulation.

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

For each row b and its index k in the matrix (.e), grabs the first and kth entries (left side and diagonal) with ,@bkh and (+) all the other entries with .Db,0k. If k isn't 0 to correspond to the first row (Wk), then !not M all of those entries. Once all of those have been selected, make sure all of them are true. (.As) If there's a 0 where there shouldn't be, then the corresponding location will be grabbed as is and mess up the and, and if there's a nonzero where there shouldn't be, it'll be ! notted to 0, which is also false.

Test suite.

-1 bytes for swapping the orders around.

• Mr. Xcoder: Wow this solution is really nice given that Pyth is quite parallel with matrix manipulation. Probably up for another Pyth duel tomorrow :P
• Mr. Xcoder: You might be able to shorten this using either @VQUQ or .DVQUQ For diagonals / deleting diagonals. But that would require a completely different approach. Not sure though... (BTW forgot to update link?)
• Steven H.: @Mr.Xcoder Fixed link, I'll try to mess around with other strategies tomorrow.
• Mr. Xcoder: I arrived at an alternative 21-byter using my VQUQ idea: >.A++hCQhQ.(VQUQsstCt. This seems highly redundant, though. You might be able to tweak it in order to save a few bytes.

Answer 17

APL+WIN, (削除) 36 (削除ここまで) 33 bytes

(↑⍴m)=+/(+⌿m)=×ばつn×ばつn←⍳↑⍴m←⎕

Prompts for screen input of an APL 2d matrix.

Answer 18

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.

Answer 19

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

• Steadybox: Welcome to PPCG!

Answer 20

Python 3, (削除) 72 (削除ここまで) 71 bytes

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

Thanks to @xnor for golfing off 1 byte!

Try it online!

• xnor: I think 0<i!=j>0 saves a byte,
• Dennis: @xnor Thanks! I don't think I've ever re-used a number in a comparison chain...

Answer 21

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

• NikoNyrh: There is quite lot of room for improvement, for example #(drop 1 %) is same as rest and #(not(zero? %)) is same as pos? (as we have non-negative numbers). You might want to have a look at my 128-byte answer, which has similar approacha s this one. After implementing that I realized that it is a lot shorted to deal with index-based access in a for-loop.
• Carcigenicate: @NikoNyrh Ya, I wasn't in a very good groove that day. I don't know how I forgot about rest. I should probably just scrap this attempt and try again.

Answer 22

Stax, 11 bytes ^CP437

ä¢⌠┐xntH↔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

Answer 23

Husk, (削除) 12 11 (削除ここまで) 10 bytes

≡1 ́Ṫ§^*=l·L

Try it online!

Explanation

≡1 ́Ṫ§^*=l·L Input is a k×ばつk array A.
 L The length, k.
 l· 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.
≡1 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 ≡.

Answer 24

R, (削除) 50 (削除ここまで) 49 bytes

• -1 byte thanks to pajonk

function(x,n=1:dim(x)-1)all((!n%o%n*!diag(n))-!x)

Try it online!

This solution is similar to the other existing 2 answers ([1], [2]) but smaller: thanks to outer and using 0-indexing, the upper row as well as the leftmost column are easily populated with 0.

• pajonk: -1 byte by changing != to -.

Answer 25

05AB1E, (削除) 42 (削除ここまで) (削除) 29 (削除ここまで) (削除) 28 (削除ここまで) (削除) 27 (削除ここまで) 21 bytes

Å\IнIøн««PĀi¦€¦D€àsOQ

I've only just started with 05AB1E; matrices aren't my strong suit; nor are they 05AB1E's strong suit.. All and all not a great combination.. (削除) So can without any doubt be golfed quite a bit.. (削除ここまで) EDIT: It indeed can, see this 23 bytes answer of @Mr.Xcoder. EDIT 2: After coming back to this challenge six years later, I was indeed able to golf a few bytes without changing the general approach. ;)

Try it online or verify all test cases.

Explanation:

 # (example input: [[1,2,3,4],[5,6,0,0],[7,0,8,0],[9,0,0,10]])
Å\ # Take the main diagonal of the (implicit) input-matrix
 # → [1,6,8,10]
Iн # Take the first row of the input-matrix
 # → [1,2,3,4]
Iøн # Take the first column of the input-matrix
 # → [1,5,7,9]
«« # Merge the three lists together:
 # → [1,6,8,10,1,2,3,4,1,5,7,9]
 P # Take the product of all three results
 # → 3628800
 Āi # If this product is not 0
 # (which means the diagonal, first row, and first column contained no zeros)
 ¦ # Use the (implicit) input-matrix, and remove its first row
 # → [[5,6,0,0],[7,0,8,0],[9,0,0,10]]
 €¦ # And also remove the first item of each row
 # → [[6,0,0],[0,8,0],[0,0,10]]
 D # Duplicate that
 ۈ # Take the maximum of each
 # → [6,8,10]
 sO # As well as the sum of each
 # → [6,8,10]
 Q # And check if all maximums and sums are equal
 # (this means each column and row only contains two numbers (row/column
 # and diagonal); everything else is a zero)

• Mr. Xcoder: ćsøćsε¾èˆ)¼} ̃OŠ¯)ćs ̃ĀP‹ should save you 6 bytes. Try it online! This is most certainly golfable though, but I don't have time to shorten it further now. But nice approach!
• Kevin Cruijssen: @Mr.Xcoder Nice approach as well! Hmm, but it's so different from my approach that I have the feeling it would be better as a separated answer.. If you want you can post it yourself, or I will add it to my answer, but also leave the 29 byte answer (or 28, since Ā instead of 0› would save a byte - was unable to find the one-char command for >0..)
• Mr. Xcoder: I'll leave that up to you; if you don't include the 23-byter into your answer, I'll post it as a separate one when I get the chance to golf it further. I'm fine either way :)
• Kevin Cruijssen: @Mr.Xcoder Both are also fine by me, so you can post it yourself, since you are the one that came up with it. Let me know when you have, then I will add a link to your shorter 05AB1E answer in mine (and upvote it of course). Normally I wouldn't mind replacing my code with yours, but since the approaches are so different this time you can post it as a separated answer. :) (Have a nice weekend!)
• Mr. Xcoder: Sure, that works. Have a nice weekend too!

Answer 26

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!

• Mr. Xcoder: 79 bytes.
• Giuseppe: Very nice; I managed to find a 78 byter that's doing something very odd but I also found a 76 byte golf of yours.
• Giuseppe: 69 bytes but I improved mine to 68!

Answer 27

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!

Answer 28

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!

• AdmBorkBork: Some golfs -- use param($a) to take input, the -contains can be swapped for an -in and all of the -eq0 can be swapped for !. Finally, you can loop from 1 up to $a.length and get rid of the if($_-ne0) in the loop body.

Answer 29

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!

Answer 30

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!