33
\$\begingroup\$

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 array1 (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]]
\$\endgroup\$
  • 1
    \$\begingroup\$ Is it possible that the matrix can contain negative numbers \$\endgroup\$ – Zacharý Dec 20 '17 at 19:14
  • 2
    \$\begingroup\$ @Zacharý No you may assume they are all non-negative. \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 19:15
  • \$\begingroup\$ 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? \$\endgroup\$ – Ian Bush Dec 20 '17 at 20:07
  • \$\begingroup\$ @IanBush Yes, a 2D array is totally fine. \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 20:09
  • 9
    \$\begingroup\$ @Mr.Xcoder This would be a sufficiently different and interesting challenge if the arrowhead could point in any direction \$\endgroup\$ – dylnan Dec 21 '17 at 1:27

40 Answers 40

15
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ Now that's a truly clever approach! \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 20:08
  • 1
    \$\begingroup\$ could this work ? f=m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c)) \$\endgroup\$ – edc65 Dec 20 '17 at 22:21
  • \$\begingroup\$ @edc65 Without the f= of course ;-) \$\endgroup\$ – Neil Dec 21 '17 at 1:04
11
\$\begingroup\$

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
\$\endgroup\$
  • 2
    \$\begingroup\$ Isn't * enough instead of 0@< (for 17 bytes)? Try it \$\endgroup\$ – Galen Ivanov Dec 20 '17 at 19:57
  • 1
    \$\begingroup\$ @GalenIvanov good catch, I think so. Thanks! Time to re-edit the explanation lol. \$\endgroup\$ – cole Dec 20 '17 at 19:58
  • 1
    \$\begingroup\$ 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! \$\endgroup\$ – Galen Ivanov Dec 20 '17 at 22:04
  • 1
    \$\begingroup\$ @GalenIvanov brilliant approach (both the use of /:-grade and }.-behead), thank you again! I'll edit it in. \$\endgroup\$ – cole Dec 20 '17 at 22:10
  • \$\begingroup\$ 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. \$\endgroup\$ – Galen Ivanov Dec 20 '17 at 22:17
9
\$\begingroup\$

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!

\$\endgroup\$
8
\$\begingroup\$

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.
\$\endgroup\$
  • \$\begingroup\$ nice utilization of ⍳∘⍴ for cartesian product. \$\endgroup\$ – Uriel Dec 20 '17 at 21:47
  • \$\begingroup\$ ×≡(=/∨1∊⊢)¨∘⍳∘⍴ \$\endgroup\$ – Erik the Outgolfer Dec 21 '17 at 12:33
  • 1
    \$\begingroup\$ (=/∨1∊⊢) -> (~≠⌊⌊)/ \$\endgroup\$ – ngn Jan 13 '18 at 12:58
  • 2
    \$\begingroup\$ @ngn Even better: (∧=⌊)/, of course both require ⎕IO←0 \$\endgroup\$ – H.PWiz Feb 13 '18 at 3:23
7
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ + = [int]? That is nice. \$\endgroup\$ – root Dec 21 '17 at 20:34
  • \$\begingroup\$ @root One of the PowerShell tips. \$\endgroup\$ – AdmBorkBork Dec 21 '17 at 21:26
7
\$\begingroup\$

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 Ẹ
\$\endgroup\$
  • \$\begingroup\$ @wizzwizz4 I'm not sure what you mean \$\endgroup\$ – dylnan Dec 22 '17 at 21:09
  • \$\begingroup\$ @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? \$\endgroup\$ – dylnan Dec 23 '17 at 16:34
  • \$\begingroup\$ 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. \$\endgroup\$ – wizzwizz4 Dec 23 '17 at 16:38
7
\$\begingroup\$

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

\$\endgroup\$
6
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ What exactly is Indeity matrix? \$\endgroup\$ – Erik the Outgolfer Dec 20 '17 at 20:10
  • 13
    \$\begingroup\$ @EriktheOutgolfer obviously a matrix containing a deity. \$\endgroup\$ – cole Dec 20 '17 at 20:11
  • 5
    \$\begingroup\$ @cole perhaps related to a matrix over the Elysian field \$\endgroup\$ – jld Dec 21 '17 at 1:51
5
\$\begingroup\$

C (gcc), 80 75 bytes

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

Try it online!

Saved 5 bytes thanks to scottinet!

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.

\$\endgroup\$
  • \$\begingroup\$ -2 bytes with some more golfing \$\endgroup\$ – scottinet Dec 21 '17 at 9:28
  • \$\begingroup\$ and an additional -4 bytes by abusing gcc's way of returning values \$\endgroup\$ – scottinet Dec 21 '17 at 9:29
  • \$\begingroup\$ @scottinet Thanks! I was having trouble figuring out which value I should set to use that trick. \$\endgroup\$ – FryAmTheEggman Dec 21 '17 at 15:23
  • \$\begingroup\$ 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. \$\endgroup\$ – FryAmTheEggman Dec 21 '17 at 15:32
  • \$\begingroup\$ 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 \$\endgroup\$ – RosLuP Jan 13 '18 at 10:08
5
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ Did you mean "1D matrix" in the top solution? \$\endgroup\$ – NikoNyrh Dec 22 '17 at 12:11
  • \$\begingroup\$ @NikoNyrh oops, fixed \$\endgroup\$ – FlipTack Dec 22 '17 at 13:35
5
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ 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? \$\endgroup\$ – rturnbull Dec 22 '17 at 7:17
  • \$\begingroup\$ @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. \$\endgroup\$ – Giuseppe Dec 22 '17 at 11:53
  • \$\begingroup\$ 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. \$\endgroup\$ – rturnbull Dec 22 '17 at 20:27
  • \$\begingroup\$ I tried to golf it but the best i can do is still 53. \$\endgroup\$ – JayCe Jun 5 '18 at 13:39
  • \$\begingroup\$ @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 \$\endgroup\$ – Giuseppe Jun 5 '18 at 14:07
3
\$\begingroup\$

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

\$\endgroup\$
3
\$\begingroup\$

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!

\$\endgroup\$
  • 1
    \$\begingroup\$ 80 bytes.... You almost always forget about <1 and such tricks? :P \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 20:31
  • 1
    \$\begingroup\$ (x==y||x==0||y==0)==(m!!y!!x/=0) should be shorter \$\endgroup\$ – user28667 Dec 20 '17 at 21:44
  • 1
    \$\begingroup\$ 62 bytes by zipping instead of indexing, and doing x*y<1. \$\endgroup\$ – Zgarb Dec 21 '17 at 0:01
3
\$\begingroup\$

Jelly, 10 bytes

ŒDµḢṠQṭT€E

Try it online!

\$\endgroup\$
3
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ I think 0<i!=j>0 saves a byte, \$\endgroup\$ – xnor Dec 23 '17 at 0:30
  • \$\begingroup\$ @xnor Thanks! I don't think I've ever re-used a number in a comparison chain... \$\endgroup\$ – Dennis Dec 23 '17 at 0:37
2
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ Wow this solution is really nice given that Pyth is quite parallel with matrix manipulation. Probably up for another Pyth duel tomorrow :P \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 21:24
  • \$\begingroup\$ 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?) \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 21:42
  • \$\begingroup\$ @Mr.Xcoder Fixed link, I'll try to mess around with other strategies tomorrow. \$\endgroup\$ – Steven H. Dec 20 '17 at 22:24
  • \$\begingroup\$ 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. \$\endgroup\$ – Mr. Xcoder Dec 21 '17 at 14:37
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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 .

\$\endgroup\$
2
\$\begingroup\$

APL+WIN, 36 33 bytes

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

Prompts for screen input of an APL 2d matrix.

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
  • 3
    \$\begingroup\$ Welcome to PPCG! \$\endgroup\$ – Steadybox Dec 22 '17 at 16:20
2
\$\begingroup\$

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))))
\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – NikoNyrh Dec 22 '17 at 15:28
  • \$\begingroup\$ @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. \$\endgroup\$ – Carcigenicate Dec 22 '17 at 15:35
2
\$\begingroup\$

Stax, 11 bytesCP437

ä¢⌠┐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
\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ 79 bytes. \$\endgroup\$ – Mr. Xcoder Dec 20 '17 at 19:50
  • \$\begingroup\$ 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. \$\endgroup\$ – Giuseppe Dec 20 '17 at 19:59
  • \$\begingroup\$ 69 bytes but I improved mine to 68! \$\endgroup\$ – Giuseppe Dec 20 '17 at 21:31
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
  • 2
    \$\begingroup\$ 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. \$\endgroup\$ – AdmBorkBork Dec 20 '17 at 21:24
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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?
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.