Definição

Uma matriz de ponta de seta é uma matriz que possui todas as entradas iguais a 0 , exceto as na diagonal principal, linha superior e coluna mais à esquerda. Em outras palavras, a matriz deve ficar assim:

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

Onde cada * é qualquer entrada diferente de zero.

Tarefa

Dada uma matriz quadrada de números inteiros não negativos, verifique se é ponta de seta de acordo com a definição acima.

Você não pode usar o tamanho da matriz como entrada, a menos que o idioma equivalente a uma matriz seja algo como um ponteiro e um comprimento (como C). Sempre será pelo menos 3 x 3.

O código mais curto em bytes em cada idioma vence.

Entrada e saída

Você pode escolher entre qualquer um dos seguintes formatos para receber entrada:

• Uma matriz no tipo de matriz nativa (se o seu idioma tiver um)
• Uma matriz 2D ¹ (uma matriz de matrizes 1D, cada uma correspondendo a uma linha)
• Uma matriz 1D (uma vez que a matriz é sempre quadrada)
• Uma string (você escolheu o espaçamento, mas não abuse disso de forma alguma).

Quando se trata de fornecer saída, é possível relatar um valor de verdade / falsidade seguindo a definição padrão do problema de decisão ou escolher dois valores distintos e consistentes.

Além disso, você pode receber e fornecer resultados através de qualquer método padrão , em qualquer linguagem de programação , observando que essas brechas são proibidas por padrão. Se você quiser escolher outro formato ou não tiver certeza sobre algo, pergunte nos comentários.

^{_{1: ou o equivalente do seu idioma (lista, vetor etc.)}}

Exemplos

Vejamos os seguintes exemplos:

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

Essa é uma matriz de ponta de seta (seus programas devem reportar um valor verdadeiro), porque os elementos na diagonal principal são 1 1 1 1, os da linha superior 1 2 2 2e os da coluna mais à esquerda 1 2 3 4. Todas as outras entradas são 0 , portanto, isso satisfaz todas as condições.

3 5 6
7 1 0
8 0 0

Essa matriz não é uma ponta de seta porque há um 0 na diagonal principal.

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

Este também não é uma ponta de seta, porque contém um 7 no lugar de um 0 .

Mais casos de teste

Verdade:

[[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 graças a edc65

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

Retorna falsepara matrizes de ponta de seta e truepara matrizes que não são de ponta de seta (permitidas, pois quaisquer dois valores distintos podem ser usados ​​para representar verdadeiro e falso)

Casos de teste:

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 graças a @GalenIvanov.

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

Recebe entrada como uma matriz (matriz 2).

Experimente online!

Explicação

Deixe que o histórico de edições seja uma lição para você não jogar golfe e escreva uma explicação ao mesmo tempo.

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

Explicação visual

Observe que isso é feito no REPL (as entradas são fornecidas começando com três espaços e a saída é fornecida sem espaços à esquerda). Por isso, às vezes omito funções de composição como @e, &uma vez que as coisas no REPL são avaliadas da direita para a esquerda (as funções são mais complexas).

Suponha que você tenha a seguinte matriz de amostra:

   ] 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

Primeiro, eu gostaria de explicar (e dar uma mensagem para) a maneira muito inteligente de @ GalenIvanov de gerar a matriz de identidade, que é a seguinte =&/:@}..

Primeiro, decapitamos a matriz de entrada ( }.).

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

Em seguida, obtemos os índices em que cada linha estaria se as linhas fossem classificadas usando /:-grade up.

   /: }. m
2 1 0

Observe que os índices resultantes são únicos : a lista não possui elementos duplicados (e por que faria isso? Não há como colocar dois elementos na mesma posição em uma matriz).

Por fim, usamos o nicho, mas prestamos =auto-classificação. Essa mônada compara cada elemento exclusivo com todos os outros elementos em uma matriz. Lembra como eu mencionei que era importante que as indicações resultantes fossem únicas? Como o =self-classify faz as comparações na ordem em que os elementos exclusivos aparecem na lista, a saída resultante será a matriz de identidade de uma entrada exclusiva (é por isso que =@i.é como você pode criar uma matriz de identidade de um determinado comprimento).

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

Uma vez que tenhamos a matriz de identidade, é uma questão de adicionar uma linha de unidades e uma coluna de unidades, o que é feito de maneira muito simples (se for dado um átomo - ou seja, um único elemento - a ,família o repetirá para preencher quando for adicionado) :

   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

Em seguida, simplesmente comparamos a matriz da ponta de seta gerada com o sinal da 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^#]]&

Experimente online!

Explicação: Clip@#substitui todos os números diferentes de zero na matriz por 1s e, em seguida, comparamos isso com uma matriz com dimensões {1,1}Tr[1^#]= {Length@#, Length@#}com 0 na posição i,jquando 1 < i != j > 1e 1 caso contrário.

(Basicamente baseado na resposta de Uriel .)

Aqui está outra idéia que tem 16 bytes a mais - fique à vontade para roubá-la, se você conseguir:

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

Experimente online!

APL (Dyalog Classic) , 19 16 15 13 bytes

-1 byte graças a @ErikTheOutgolfer

( ⎕IO←0)

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

Experimente online!

-2 bytes graças a @ngn e @ H.PWiz

Quão?

(Matriz de entrada 2D S )

• ×≡Verifique se S é positivo apenas em ...
• (∧=⌊ ... as diagonais ou a linha superior e a coluna esquerda ...
• )/¨∘⍳∘⍴... 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

Experimente online!

Recebe entrada e manipula como uma matriz de matrizes, pois o PowerShell não oferece suporte a matrizes (fora do suporte às matrizes de transformação do .NET Direct3D, o que é algo totalmente diferente).

Todo o algoritmo é baseado no fato de que números diferentes de zero são verdadeiros e zero é falsey no PowerShell, e usando a multiplicação para determinar esses valores de verdade / falsey.

Primeiro pegamos a primeira linha $a[0]e verificamos se essa matriz 0é -inarmazenada em nossa $ovariável utput. Se algo nessa linha é zero, $otambém é zero, caso contrário, é um, feito por uma rápida conversão com int +.

Em seguida, fazemos um loop de 1até $a.count-1, definindo $xao longo do caminho - vamos percorrer cada linha, uma de cada vez.

A cada iteração, definimos a variável auxiliar $ipara rastrear em qual linha estamos, depois passamos de 0para $xpara iterar cada elemento dessa linha. Dentro do loop interno, estamos multiplicando novamente $o, desta vez selecionando uma configuração de tupla como um operador pseudo-ternário.

A condicional da tupla !$_-or$_-eq$i, diz "quando estamos na 0ª coluna, ou a coluna corresponde à linha (ou seja, a diagonal principal)" para selecionar a segunda metade da tupla quando for verdade ou a primeira metade quando falsey. A tupla é composta por !($y=$a[$i][$_]), $y. A primeira metade define $ypara jogar golfe na segunda metade, mas, de qualquer maneira, estamos selecionando o elemento atual. A primeira metade faz negação booleana, enquanto a segunda metade toma o elemento como está. Portanto, se não estivermos na coluna 0 nem na diagonal principal, garantiremos que o elemento seja zero, pegando o Booleano, não. Da mesma forma, garantimos que a 0ª coluna ou a diagonal principal seja diferente de zero, simplesmente utilizando-a.

Portanto, agora que iteramos por todos os elementos da matriz, $oserá 0que algum elemento estava incorreto ou um número inteiro diferente de zero se for uma matriz de ponta de seta. Nós dobramos o valor booleano, não para obter um Falseou outro True, para tornar nossa saída consistente, e isso é deixado no pipeline em que a impressão está implícita.

Geléia , 14 12 bytes

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

-2 bytes de Pietu1998

Experimente online!

Explicação

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

Use a matriz acima como exemplo de entrada.

Œ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-⍨⍴)

Experimente online!

Quão?

Este vai para o outro lado -

=/¨∘⍳ - cria a matriz de identidade

1-⍨⍴ - para n - 1

1⍪1, - precede uma coluna e uma linha de 1s

≡ - compara com

× - a matriz original, depois de passar por uma sinalização por elementos

MATL , 15 bytes

gtZyXy,!llY(]X=

Entrada é uma matriz (usando ;como separador de linhas). A saída é 1para ponta de seta, 0caso contrário.

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Experimente online!

Economizou 5 bytes graças ao scottinet!

Reutilizou o código de teste desta resposta .

Analisa linearmente a matriz em busca de valores incorretos, retornando 0 para uma matriz de ponta de seta e 1 caso contrário. Verificamos calculando o exclusivo ou se o item em uma determinada posição é zero e se essa posição está na seta.

A codificação das informações da matriz 2D em uma dimensão leva a um conjunto de condições bastante simples. Se deixarmos inosso índice com base em 0 na nmatriz dimensional, i<ndescreveremos a primeira linha. Da mesma forma, i%n==0descreve a primeira coluna e i/n==i%ndescreve a diagonal.

O melhor truque que encontrei para lidar com o retorno é definir a dimensão como zero ao encontrar um erro. Isso faz com que o loop termine imediatamente, e retornar a negação lógica da dimensão nos dará um dos dois valores distintos. A scottinet encontrou o caminho para fazer com que o GCC a devolvesse mais bem.

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

Experimente online!

Python 2 , 85 bytes

Tomando o array como uma 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))

Experimente online!

R , 78 70 69 68 54 53 bytes

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

Experimente online!

Portar a resposta de Luis Mendo é muito menor do que minha abordagem anterior.

Obrigado ao rturnbull por apontar um erro e jogar um byte!

resposta antiga, 68 bytes:

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

Experimente online!

A resposta de duckmayr testa que todas as entradas na diagonal principal e na primeira linha / coluna ( m[i]) são diferentes de zero e as demais ( m[-i]) são zero, usando uma boa aritmética para obter a diagonal e a primeira linha.

Essa resposta, no entanto, testa para garantir que (1) zero entrada não esteja na diagonal principal ou na primeira linha / coluna e (2) que haja, dada uma n x nmatriz, 3*n-2entradas diferentes de zero.

whichretorna os índices onde está sua entrada TRUEe, com o opcional arr.ind=T, retorna uma matriz de índices para cada dimensão da matriz, nesse caso, dois.

Portanto any(i[,1]==i[,2]), quando existe um zero na diagonal e quando any(i==1)existe um zero na primeira linha ou na primeira coluna.

Finalmente, um pouco de aritmética mostra que o número de entradas diferentes de zero deve ser 3*n-2, nda primeira coluna, n-1da diagonal e n-1da primeira linha.

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

Experimente online!

Créditos

• Reduzido de 92 bytes para 90 pelo Sr. Xcoder

Haskell , 62 bytes

-3 bytes graças ao Sr. Xcoder. -13 bytes graças a user28667. -5 bytes graças ao Zgarb.

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

Experimente online!

Gelatina , 10 bytes

ŒDµḢṠQṭT€E

Experimente online!

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

Graças a @xnor por jogar fora um byte!

Experimente online!

Pitão, 22 21 bytes

Definitivamente, essa não é a linguagem para manipulação de matrizes.

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

Para cada linha be seu índice kna matriz ( .e), pegue a primeira e a kquinta entradas (lado esquerdo e diagonal) com ,@bkhe ( +) todas as outras entradas com .Db,0k. Se knão for 0 para corresponder à primeira linha ( Wk), !nem Mtodas essas entradas. Depois que todos eles tiverem sido selecionados, verifique se todos eles são verdadeiros. ( .As) Se houver um 0 onde não deveria haver, o local correspondente será agarrado como está e atrapalhará !oe , e se houver um diferente de zero onde não deveria haver, será anotado como 0, que é também falso.

Suíte de teste.

-1 bytes para trocar as ordens.

Pip , 31 23 22 bytes

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

Esta é uma função que utiliza uma lista aninhada de números 2D. Experimente online!

Explicação

Muitas comparações estão acontecendo aqui. A primeira coisa a saber é que os operadores de comparação no Pip podem ser encadeados, como no Python: 5>4>3is 5>4 and 4>3(true), not (5>4)>3(false). A segunda é que isso não se aplica ao ==operador "exatamente igual". Outra diferença: normal comparações têm precedência maior do que os operadores de mapeamento MCe MMe pode ser usado em expressões lambda, enquanto ==tem menor precedência e não pode.

{                    }  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 gerar a primeira matriz, usamos MC"map-coords". Esse operador pega um número, gera uma grade de coordenadas quadradas desse tamanho e mapeia uma função para cada par de coordenadas (x, y), retornando uma lista de listas dos resultados. Por exemplo, {a+b} MC 3daria o resultado [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Aqui, o tamanho da grade é #ao tamanho do nosso argumento original. A função é 0<_!=B>0, que é uma maneira mais curta de escrever {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

Isso retorna 0 para a primeira linha / coluna e a diagonal principal e 1 em outro lugar.

Casca , 12 11 bytes

S≡ȯ´Ṫ§^*=ŀL

Experimente online!

Explicação

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?

A ideia é que Husk defina 0 com a potência de 0 como 1, de modo que o produto externo tenha 1s na primeira linha e coluna. Além disso, 1 na potência de qualquer número é 1, portanto o produto externo possui 1s na diagonal. Outras entradas são 0 à potência de um número positivo, que é 0. Isso fornece uma matriz de ponta de seta binária, com a qual comparamos a entrada ≡.

APL + WIN, 36 33 bytes

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

Solicita a entrada na tela de uma 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))))

É sempre emocionante ver dois colchetes de abertura consecutivos.

Versão original:

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

A primeira parte funciona associnserindo elementos diagonais da sub-matriz em zero e verificando se todas as linhas são iguais :) Usei um truque semelhante no método jacobiano .

A concatúltima parte indica a diagonal + primeira linha e coluna e verifica se são positivas.

Javascript (ES6), 58 bytes

Minha solução para Javascript:

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

Não é tão inteligente quanto a resposta de Herman , mas senti que também deveria postar aqui.

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 removendo alguns espaços perdidos e atalhos range . Talvez eu tenha que deixar isso para que eu possa pensar em uma maneira melhor.

-18 bytes graças a @NikoNyrh e criando atalhos 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)))))))))

Horrível, horrível. Não sei por que não consigo entender minha solução razoável.

Toma um vetor aninhado 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))))

Tentei reescrever isso do zero usando um método diferente, e acabou por mais tempo. Em vez de esculpir manualmente as seções "resto" da matriz, decidi tentar gerar todas as coordenadas na matriz, gerar as coordenadas da ponta da seta e usá clojure.set/difference-las para obter as células que não são da seta. Infelizmente, a chamada para esse built-in é cara:

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

Experimente online!

Versão descompactada com 13 bytes:

B|AsF:10i^\=*

Finalmente empate Husk e derrotado por Jelly por apenas um byte ...

Explicação

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 graças ao Sr. Xcoder

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

Experimente 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

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

Experimente online!

Limpo , 79 bytes

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

Experimente online!

Japonês , 16 bytes

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

Teste online!

^{Cara, isso me leva de volta aos bons velhos tempos, quando o Japt era regularmente muito mais longo do que outras langs do golfe ...}

K (oK) , 27 30 bytes

Solução:

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

Experimente online!

Explicação:

Eu devo estar fazendo algo estúpido, pois as soluções APL são menos da metade da contagem de bytes ...

24 bytes gastos na criação da ponta da seta. orjuntas as três matrizes a seguir:

/ 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

Repartição completa:

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?