Definición

Una matriz de punta de flecha es una matriz que tiene todas las entradas iguales a 0 , excepto las de la diagonal principal, la fila superior y la columna más a la izquierda. En otras palabras, la matriz debería verse así:

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

Donde cada * es cualquier entrada distinta de cero.

Tarea

Dada una matriz cuadrada de enteros no negativos, verifique si es punta de flecha de acuerdo con la definición anterior.

Es posible que no se toma el tamaño de la matriz como entrada, a menos que el equivalente en su idioma a un arreglo es algo así como un puntero y una longitud (como C). Siempre será al menos 3 x 3.

El código más corto en bytes en cada idioma gana.

Entrada y salida

Puede elegir entre cualquiera de los siguientes formatos para recibir entradas:

• Una matriz en el tipo de matriz nativa (si su idioma tiene uno)
• Una matriz 2D ¹ (una matriz de matrices 1D, cada una correspondiente a una fila)
• Una matriz 1D (ya que la matriz siempre es cuadrada)
• Una cadena (elegiste el espaciado, pero no abuses de esto de ninguna manera).

Cuando se trata de proporcionar resultados, puede informar un valor verdadero / falso siguiendo la definición estándar del problema de decisión , o elegir dos valores distintos y consistentes.

Además, puede tomar entrada y dar salida a través de cualquier método estándar , en cualquier lenguaje de programación , mientras toma nota de que estas lagunas están prohibidas por defecto. Si desea elegir cualquier otro formato o no está seguro acerca de algo, pregunte en los comentarios.

^{_{1: o el equivalente de su idioma (lista, vector, etc.)}}

Ejemplos

Veamos los siguientes ejemplos:

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

Esta es una matriz de punta de flecha (sus programas deben informar un valor verdadero), porque los elementos en la diagonal principal son 1 1 1 1, los de la fila superior 1 2 2 2y los de la columna de la izquierda 1 2 3 4. Todas las demás entradas son 0 , por lo que cumple todas las condiciones.

3 5 6
7 1 0
8 0 0

Esta matriz no es punta de flecha porque hay un 0 en la diagonal principal.

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

Este tampoco es una punta de flecha, porque contiene un 7 en lugar de un 0 .

Más casos de prueba

Verdad:

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

Javascript (ES6), 48 47 bytes

Guardado 1 byte gracias a edc65

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

Devuelve las falsematrices de punta de flecha y las matrices truesin punta de flecha (permitido ya que se pueden usar dos valores distintos para representar verdadero y falso)

Casos de prueba:

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 bytes

-4 bytes gracias a @GalenIvanov.

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

Toma la entrada como una matriz (rango 2).

Pruébalo en línea!

Explicación

Deje que el historial de edición le sirva de lección para no jugar golf y escriba una explicación al mismo tiempo.

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

Explicación visual

Tenga en cuenta que esto se hace en REPL (las entradas se dan comenzando con tres espacios y la salida se da sin espacios iniciales). Debido a eso, a veces omito funciones de composición como @y &dado que las cosas en REPL se evalúan de derecha a izquierda (las funciones son más complejas).

Supongamos que tiene la siguiente matriz de muestra:

   ] 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

Primero, me gustaría explicar (y agradecer) la manera muy inteligente de @GalenIvanov de generar la matriz de identidad, que es la siguiente =&/:@}..

Primero, decapitamos la matriz de entrada ( }.).

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

Luego obtenemos los índices en los que estaría cada fila si las filas se /:ordenaran usando -grade arriba.

   /: }. m
2 1 0

Tenga en cuenta que los índices resultantes son únicos : la lista no tiene elementos duplicados (¿y por qué lo haría? No hay forma de colocar dos elementos en la misma posición en una matriz).

Finalmente, usamos el nicho pero útil: =auto-clasificar. Esta mónada compara cada elemento único con todos los demás elementos en una matriz. ¿Recuerdas cómo mencioné que era importante que las indicaciones resultantes fueran únicas? Dado que =-self-classify realiza las comparaciones en el orden en que aparecen los elementos únicos en la lista, el resultado resultante será la matriz de identidad para una entrada única (es por eso =@i.que puede hacer una matriz de identidad de una longitud determinada).

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

Una vez que tenemos la matriz de identidad, se trata de agregar una fila de unos y una columna de unos, lo que se hace de manera muy simple (si se le da un átomo, es decir, un solo elemento, la ,familia lo repetirá para llenar cuando se agregue) :

   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

Luego simplemente comparamos la matriz de punta de flecha generada con el signo de la matriz de entrada.

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

Wolfram Language (Mathematica) , 47 bytes

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

Pruébalo en línea!

Explicación: Clip@#reemplaza todos los números distintos de cero en la matriz con 1s, luego lo comparamos con una matriz con dimensiones {1,1}Tr[1^#]= {Length@#, Length@#}con 0 en posición i,jcuando 1 < i != j > 1, y 1 en caso contrario.

(Aproximadamente basado en la respuesta de Uriel ).

Aquí hay otra idea que tiene 16 bytes más: siéntase libre de robarla si puede jugar golf:

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

Pruébalo en línea!

APL (Dyalog Classic) , 19 16 15 13 bytes

-1 byte gracias a @ErikTheOutgolfer

( ⎕IO←0)

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

Pruébalo en línea!

-2 bytes gracias a @ngn y @ H.PWiz

¿Cómo?

(Matriz de entrada 2D S )

• ×≡Compruebe si S es positivo solo en ...
• (∧=⌊ ... las diagonales o la fila superior y la columna izquierda ...
• )/¨∘⍳∘⍴... de S .

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

Pruébalo en línea!

Toma datos y los manipula como una matriz de matrices, ya que PowerShell no admite matrices (fuera del soporte de matrices de transformación Direct3D de .NET, que es algo completamente diferente).

Todo el algoritmo se basa en el hecho de que los números distintos de cero son verdaderos y cero es falsey en PowerShell, y utiliza la multiplicación para determinar esos valores de verdad / falsey.

Primero tomamos la primera fila, $a[0]y verificamos si 0es -inesa matriz, la almacenamos en nuestra $ovariable de rendimiento. Si algo en esa fila es cero, entonces $otambién es cero, de lo contrario es uno, hecho por un rápido cast-to-int con +.

A continuación, recorremos de 1arriba a abajo $a.count-1, configurando $xen el camino: vamos a recorrer cada fila de una en una.

En cada iteración establecemos la variable auxiliar $ipara realizar un seguimiento de la fila en la que estamos, luego hacemos un bucle desde 0hasta $xpara iterar cada elemento en esta fila. Dentro del bucle interno, nuevamente estamos multiplicando $o, esta vez seleccionando desde una configuración de tupla como un operador pseudoternario.

El condicional de la tupla !$_-or$_-eq$idice "cuando estamos en la columna 0 o la columna coincide con la fila (es decir, la diagonal principal)" para seleccionar la segunda mitad de la tupla cuando es verdadera o la primera mitad cuando es falsa. La tupla se compone de !($y=$a[$i][$_]), $y. La primera mitad establece $ypara jugar golf la segunda mitad, pero de cualquier manera estamos seleccionando el elemento actual. La primera mitad hace negación booleana, mientras que la segunda mitad solo toma el elemento tal como está. Por lo tanto, si no estamos en la columna 0 ni en la diagonal principal, nos aseguramos de que el elemento sea cero al quitarle el booleano. Del mismo modo, nos aseguramos de que la columna 0 o la diagonal principal no sea cero simplemente tomándola.

Entonces, ahora que hemos iterado a través de cada elemento en la matriz, $oserá 0si algún elemento era incorrecto o algún número entero distinto de cero si es una matriz de punta de flecha. Hacemos doble booleano, no para obtener uno Falseo Truerespectivamente, para que nuestra salida sea coherente, y eso queda en la tubería donde la impresión está implícita.

Jalea , 14 12 bytes

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

-2 bytes de Pietu1998

Pruébalo en línea!

Explicación

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

Use la matriz anterior como entrada de ejemplo.

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

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

Pruébalo en línea!

¿Cómo?

Este va a la inversa:

=/¨∘⍳ - crea la matriz de identidad

1-⍨⍴ - para n - 1

1⍪1, - antepone una columna y una fila de 1s

≡ - se compara con

× - la matriz original, después de que se haya convertido en una firma de elementos sabios

MATL , 15 bytes

gtZyXy,!llY(]X=

La entrada es una matriz (que se usa ;como separador de filas). La salida es 1para punta de flecha, de lo 0contrario.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Pruébalo en línea!

¡Guardado 5 bytes gracias a scottinet!

Reutilizó el código de prueba de esta respuesta .

Escanea linealmente la matriz en busca de valores incorrectos, devolviendo 0 para una matriz de punta de flecha y 1 en caso contrario. Verificamos calculando el exclusivo o si el artículo en una posición dada es cero y si esa posición está en la flecha.

Codificar la información de la matriz 2D en una dimensión conduce a un conjunto bastante simple de condiciones. Si dejamos iser nuestro índice basado en 0 en la nmatriz dimensional, entonces se i<ndescribe la primera fila. Del mismo modo, i%n==0describe la primera columna y i/n==i%ndescribe la diagonal.

El mejor truco que encontré para manejar el retorno es establecer la dimensión a cero cuando se encuentra con un error. Esto hace que el ciclo finalice de inmediato, y luego devolver la negación lógica de la dimensión nos dará uno de dos valores distintos. scottinet encontró la manera de hacer que GCC lo devolviera más amablemente.

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

Pruébalo en línea!

Python 2 , 85 bytes

Tomando la matriz como una matriz 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))

Pruébalo en línea!

R , 78 70 69 68 54 53 bytes

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

Pruébalo en línea!

Portar la respuesta de Luis Mendo es mucho más corto que mi enfoque anterior.

¡Gracias a rturnbull por señalar un error y jugar golf por un byte!

respuesta anterior, 68 bytes:

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

Pruébalo en línea!

La respuesta de duckmayr prueba que todas las entradas en la diagonal principal y la primera fila / columna ( m[i]) son distintas de cero y el resto ( m[-i]) son cero, utilizando una buena aritmética para obtener la diagonal y la primera fila.

Sin embargo, esta respuesta prueba para asegurarse de que (1) las entradas cero no están en la diagonal principal o la primera fila / columna, y (2) que hay, dada una n x nmatriz, 3*n-2entradas distintas de cero.

whichdevuelve los índices donde está su entrada TRUE, y con el opcional arr.ind=T, devuelve una matriz de índices para cada dimensión de matriz, en este caso, dos.

Por lo tanto any(i[,1]==i[,2]), cuando existe un cero en la diagonal y cuando any(i==1)existe un cero en la primera fila o la primera columna.

Finalmente, una pequeña aritmética muestra que el número de entradas distintas de cero debe ser 3*n-2, ndesde la primera columna, n-1desde la diagonal y n-1desde la primera fila.

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

Pruébalo en línea!

Créditos

• Reducido de 92 bytes a 90 por el Sr. Xcoder

Haskell , 62 bytes

-3 bytes gracias al Sr. Xcoder. -13 bytes gracias al usuario 28667. -5 bytes gracias a Zgarb.

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

Pruébalo en línea!

Jalea , 10 bytes

ŒDµḢṠQṭT€E

Pruébalo en línea!

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

¡Gracias a @xnor por jugar golf en 1 byte!

Pruébalo en línea!

Pyth, 22 21 bytes

Definitivamente este no es el lenguaje para la manipulación matricial.

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

Para cada fila by su índice ken la matriz ( .e), toma la primera y la ktercera entrada (lado izquierdo y diagonal) con ,@bkhy ( +) todas las otras entradas con .Db,0k. Sik no corresponde a 0 con la primera fila ( Wk), entonces !no Mtodas esas entradas. Una vez que todos hayan sido seleccionados, asegúrese de que todos sean verdaderos. ( .As) Si hay un 0 donde no debería haberlo, entonces la ubicación correspondiente se tomará como está y desordenará el y, y si hay un valor distinto de cero donde no debería haberlo, se !anotará a 0, que es También falso.

Banco de pruebas.

-1 bytes para intercambiar las órdenes.

Pip , 31 23 22 bytes

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

Esta es una función que toma una lista anidada 2D de números. Pruébalo en línea!

Explicación

Aquí hay muchas comparaciones. Lo primero que debe saber es que los operadores de comparación en Pip se pueden encadenar juntos, como en Python: 5>4>3es 5>4 and 4>3(verdadero), no (5>4)>3(falso). El segundo es que esto no se aplica al ==operador "exactamente igual". Otra diferencia: las comparaciones regulares tienen mayor prioridad que los operadores de asignación MCy MMy pueden ser utilizados en las expresiones lambda, mientras que ==tiene menor precedencia y no puede.

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

Para generar la primera matriz, usamos MC"map-coords". Este operador toma un número, genera una cuadrícula de coordenadas cuadradas de ese tamaño y asigna una función a cada par de coordenadas (x, y), devolviendo una lista de listas de resultados. Por ejemplo,{a+b} MC 3 daría el resultado [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Aquí, el tamaño de la cuadrícula es #a, el tamaño de nuestro argumento original. La función es 0<_!=B>0, que es una forma más corta de escribir {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

Esto devuelve 0 para la primera fila / columna y la diagonal principal, y 1 en otro lugar.

Casco , 12 11 bytes

S≡ȯ´Ṫ§^*=ŀL

Pruébalo en línea!

Explicación

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?

La idea es que Husk define 0 a la potencia de 0 como 1, por lo que el producto externo tiene 1s en la primera fila y columna. Además, 1 a la potencia de cualquier número es 1, por lo que el producto externo tiene 1s en la diagonal. Otras entradas son 0 a la potencia de algún número positivo, que es 0. Esto da una matriz de punta de flecha binaria, que comparamos con la entrada con ≡.

APL + WIN, 36 33 bytes

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

Solicita la entrada en pantalla de una matriz APL 2d.

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

Siempre es emocionante ver dos corchetes de apertura consecutivos.

Versión original:

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

La primera parte funciona assoccolocando elementos diagonales de la submatriz en cero y verificando que todas las filas sean iguales :) Usé un truco similar en el método jacobiano .

La parte concatposterior activa la diagonal + primera fila y columna y comprueba que sean positivas.

Javascript (ES6), 58 bytes

Mi solución para Javascript:

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

No es tan inteligente como la respuesta de Herman , pero sentí que debería publicarlo aquí también.

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 eliminando algunos espacios perdidos y atajos range. Puede que tenga que dejar que esto se asiente para poder pensar en una mejor manera.

-18 bytes gracias a @NikoNyrh, y creando atajos para 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)))))))))

Horrible, simplemente horrible. No sé por qué no puedo entender una solución razonable.

Toma un vector anidado como entrada.

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

Intenté reescribir esto desde cero usando un método diferente, y terminó por más tiempo. En lugar de tallar manualmente las secciones de "descanso" de la matriz, decidí intentar generar todas las coordenadas en la matriz, generar las coordenadas de la punta de flecha, y luego usar clojure.set/differencepara obtener las celdas sin punta de flecha. Desafortunadamente, la llamada a ese incorporado es costosa:

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

Pruébalo en línea!

Versión desempaquetada con 13 bytes:

B|AsF:10i^\=*

Finalmente atado a Husk y golpeado por Jelly por solo un byte ...

Explicación

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 gracias al Sr. Xcoder

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

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)

Pruébalo en línea!

Limpio , 79 bytes

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

Pruébalo en línea!

Japt , 16 bytes

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

¡Pruébelo en línea!

^{Hombre, esto me lleva de vuelta a los viejos tiempos cuando Japt era regularmente mucho más tiempo que otros langos de golf ...}

K (oK) , 27 30 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Debo estar haciendo algo tonto ya que las soluciones APL son menos de la mitad del conteo de bytes ...

Pasaron 24 bytes creando la punta de flecha. orjuntas las siguientes tres 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

Desglose completo:

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?