Definizione

Una matrice a punta di freccia è una matrice che ha tutte le voci uguali a 0 , tranne quelle sulla diagonale principale, sulla riga superiore e sulla colonna più a sinistra. In altre parole, la matrice dovrebbe apparire così:

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

Dove ogni * è una voce diversa da zero.

Compito

Data una matrice quadrata di numeri interi non negativi, controlla se si tratta di una freccia secondo la definizione sopra.

Si può non prendere la dimensione della matrice come input, a meno equivalente di lingua ad un array è qualcosa come un puntatore e una lunghezza (come il C). Sarà sempre almeno 3 x 3.

Vince il codice più breve in byte in ogni lingua.

Ingresso e uscita

Puoi scegliere uno dei seguenti formati per ricevere input:

• Una matrice nel tipo di matrice nativa (se la tua lingua ne ha una)
• Un array 2D ¹ (un array di array 1D, ciascuno corrispondente a una riga)
• Un array 1D (poiché la matrice è sempre quadrata)
• Una stringa (hai scelto la spaziatura, ma per favore non abusarne in alcun modo).

Quando si tratta di fornire un output, è possibile segnalare un valore di verità / falsità seguendo la definizione standard di problema decisionale o scegliere due valori distinti e coerenti.

Inoltre, puoi prendere input e dare output attraverso qualsiasi metodo standard , in qualsiasi linguaggio di programmazione , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Se vuoi scegliere qualsiasi altro formato o non sei sicuro di qualcosa, chiedi nei commenti.

^{_{1: o l'equivalente della tua lingua (elenco, vettore, ecc.)}}

Esempi

Diamo un'occhiata ai seguenti esempi:

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

Questa è una matrice a punta di freccia (i tuoi programmi dovrebbero riportare un valore veritiero), perché gli elementi sulla diagonale principale sono 1 1 1 1, quelli sulla riga superiore sono 1 2 2 2e quelli sulla colonna più a sinistra 1 2 3 4. Tutte le altre voci sono 0 , quindi questo soddisfa tutte le condizioni.

3 5 6
7 1 0
8 0 0

Questa matrice non è una freccia poiché nella diagonale principale è presente uno 0 .

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

Anche questo non è una punta di freccia, perché contiene un 7 al posto di uno 0 .

Altri casi di test

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

Javascript (ES6), 48 47 byte

Salvato 1 byte grazie a edc65

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

Restituisce falseper matrici punta di freccia e trueper matrici non punta di freccia (consentito poiché è possibile utilizzare due valori distinti per rappresentare vero e falso)

Casi test:

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

J , _{21 20 19 17} 15 byte

-4 byte grazie a @GalenIvanov.

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

Accetta input come matrice (array di livello 2).

Provalo online!

Spiegazione

Lascia che la cronologia delle modifiche sia una lezione per te per non giocare a golf e scrivi una spiegazione allo stesso 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?

Spiegazione visiva

Si noti che questo viene fatto sul REPL (gli input sono dati a partire da tre spazi e l'output è dato senza spazi iniziali). Per questo motivo, a volte ometto funzioni di composizione come @e &poiché le cose su REPL vengono valutate da destra a sinistra (le funzioni sono più complesse).

Supponiamo di avere la seguente matrice di esempio:

   ] 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

In primo luogo, vorrei spiegare (e dare uno shoutout) al modo molto intelligente di GalenIvanov di generare la matrice dell'identità, che è la seguente =&/:@}..

Innanzitutto, decapitiamo la matrice di input ( }.).

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

Quindi otteniamo gli indici in cui ogni riga si troverebbe se le righe ordinate usando /:-grade up.

   /: }. m
2 1 0

Si noti che gli indici risultanti sono unici : l'elenco non ha elementi duplicati (e perché dovrebbe farlo? Non c'è modo di posizionare due elementi nella stessa posizione in un array).

Infine, usiamo la nicchia ma utile =classificare se stessi. Questa monade confronta ogni singolo elemento con tutti gli altri elementi di un array. Ricordi come ho detto che era importante che le indicazioni risultanti fossero uniche? Poiché =-self-classify esegue i confronti nell'ordine in cui gli elementi univoci compaiono nell'elenco, l'output risultante sarà la matrice di identità per un input univoco (ecco perché =@i.è possibile creare una matrice di identità di una determinata lunghezza).

   = /: }. 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 volta che abbiamo la matrice identità, si tratta di aggiungere una riga di una e una colonna di una, cosa che viene fatta in modo molto semplice (se viene dato un atomo - cioè un singolo elemento - la ,famiglia lo ripeterà per riempire quando viene aggiunta) :

   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

Quindi confrontiamo semplicemente la matrice della punta di freccia generata con il signum della matrice di input.

   * 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 byte

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

Provalo online!

Spiegazione: Clip@#sostituisce tutti i numeri diversi da zero nella matrice con 1s, quindi lo confrontiamo con un array con dimensioni {1,1}Tr[1^#]= {Length@#, Length@#}con 0 in posizione i,jquando 1 < i != j > 1e 1 altrimenti.

(Circa basato sulla risposta di Uriel .)

Ecco un'altra idea che è più lunga di 16 byte: sentiti libero di rubarla se riesci a giocare a golf:

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

Provalo online!

APL (Dyalog Classic) , 19 16 15 13 byte

-1 byte grazie a @ErikTheOutgolfer

( ⎕IO←0)

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

Provalo online!

-2 byte grazie a @ngn e @ H.PWiz

Come?

(Matrice di input 2D S )

• ×≡Controlla se S è positivo solo su ...
• (∧=⌊ ... le diagonali o la riga superiore e la colonna di sinistra ...
• )/¨∘⍳∘⍴... di S .

PowerShell , 112 108 byte

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

Provalo online!

Accetta input e manipola come un array di array, poiché PowerShell non supporta le matrici (al di fuori del supporto delle matrici di trasformazione .NET Direct3D, che è qualcosa di completamente diverso).

L'intero algoritmo si basa sul fatto che numeri diversi da zero sono veritieri e zero è falsi in PowerShell e utilizza la moltiplicazione per determinare quei valori di verità / falsità.

Prima prendiamo la prima riga $a[0]e controlliamo se si 0tratta di -inquell'array, lo memorizziamo nella nostra $ovariabile di output. Se qualcosa in quella riga è zero, allora $oè anche zero, altrimenti è uno, fatto da un rapido cast-to-int con +.

Quindi passiamo da un 1punto all'altro $a.count-1, impostandoci $xlungo il percorso: eseguiremo un ciclo alla volta di una riga alla volta.

Ogni iterazione abbiamo impostato helper variabile $iper tenere traccia di ciò remare siamo su, quindi eseguire un ciclo da 0a $xad iterare ogni elemento in questa riga. All'interno del circuito interno, ci stiamo ancora moltiplicando $o, questa volta selezionando da una configurazione di tupla come operatore pseudo-ternario.

La condizione della tupla !$_-or$_-eq$i, "dice quando siamo sulla colonna 0, o la colonna corrisponde alla riga (cioè la diagonale principale)" per selezionare la seconda metà della tupla quando è vera o la prima metà quando è falsa. La tupla è composta da !($y=$a[$i][$_]), $y. La prima metà inizia $ya giocare a golf nella seconda metà, ma in entrambi i casi stiamo selezionando l'elemento corrente. La prima metà fa negazione booleana su di essa, mentre la seconda metà prende l'elemento così com'è. Pertanto, se non siamo sulla colonna 0 né sulla diagonale principale, ci assicuriamo che l'elemento sia zero prendendo il valore booleano, non di esso. Allo stesso modo, ci assicuriamo che la 0ª colonna o diagonale principale sia diversa da zero semplicemente prendendola.

Quindi ora che abbiamo passato in rassegna tutti gli elementi della matrice, $osarà o 0se un elemento fosse errato o un numero intero diverso da zero se si tratta di una matrice a punta di freccia. Doppio booleano, non quello per ottenere uno Falseo Truerispettivamente, per rendere coerente il nostro output, e questo rimane sulla pipeline in cui la stampa è implicita.

Gelatina , 14 12 byte

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

-2 byte da Pietu1998

Provalo online!

Spiegazione

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

Utilizzare la matrice sopra come input di esempio.

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

APL (Dyalog) , 21 18 17 byte

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

Provalo online!

Come?

Questo va dall'altra parte -

=/¨∘⍳ - crea la matrice identità

1-⍨⍴ - per n - 1

1⍪1, - antepone una colonna e una riga di 1 secondo

≡ - confronta con

× - la matrice originale, dopo che è diventata una signum saggia elemento

MATL , 15 byte

gtZyXy,!llY(]X=

L'input è una matrice (usando ;come separatore di riga). L'output è 1per la punta di freccia, 0altrimenti.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

C (gcc) ,80 75 byte

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

Provalo online!

5 byte salvati grazie a Scottinet!

Riutilizzato il codice di prova da questa risposta .

Esegue la scansione lineare dell'array per eventuali valori errati, restituendo 0 per una matrice a punta di freccia e 1 altrimenti. Verifichiamo calcolando l'esclusivo o se l'articolo in una determinata posizione è zero e se quella posizione è sulla freccia.

La codifica delle informazioni dell'array 2D in una dimensione porta a un insieme abbastanza semplice di condizioni. Se lasciamo iessere il nostro indice basato su 0 nnell'array dimensionale, quindi i<ndescriviamo la prima riga. Allo stesso modo, i%n==0descrive la prima colonna e i/n==i%ndescrive la diagonale.

Il trucco migliore che ho trovato per gestire il ritorno è di impostare la dimensione su zero quando si verifica un errore. Questo fa terminare immediatamente il loop, quindi restituire la negazione logica della dimensione ci darà uno di due valori distinti. scottinet ha trovato il modo di fare in modo che GCC lo restituisse più facilmente.

Python 2 , 75 byte

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

Provalo online!

Python 2 , 85 byte

Prendendo l'array come una matrice 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))

Provalo online!

R , 78 70 69 68 54 53 byte

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

Provalo online!

Il porting della risposta di Luis Mendo è molto più breve del mio approccio precedente.

Grazie a rturnbull per aver segnalato un bug e aver giocato a golf un byte!

vecchia risposta, 68 byte:

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

Provalo online!

La risposta di duckmayr verifica che tutte le voci nella diagonale principale e nella prima riga / colonna ( m[i]) siano diverse da zero e il resto ( m[-i]) sia zero, usando un po 'di aritmetica per ottenere la diagonale e la prima riga.

Questa risposta, tuttavia, verifica per assicurarsi che (1) zero voci non siano sulla diagonale principale o sulla prima riga / colonna e (2) che vi siano, date una n x nmatrice, 3*n-2voci diverse da zero.

whichrestituisce gli indici in cui si trova il suo input TRUEe, con l'opzione facoltativa arr.ind=T, restituisce una matrice di indici per ciascuna dimensione della matrice, in questo caso due.

Quindi any(i[,1]==i[,2]), quando esiste uno zero sulla diagonale e quando any(i==1)esiste uno zero nella prima riga o nella prima colonna.

Infine, un po 'di aritmetica mostra che il numero di voci diverse da zero deve essere 3*n-2, ndalla prima colonna, n-1dalla diagonale e n-1dalla prima riga.

Python 2 , 92 90 byte

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

Provalo online!

Crediti

• Ridotto da 92 byte a 90 dal signor Xcoder

Haskell , 62 byte

-3 byte grazie a Mr. Xcoder. -13 byte grazie a user28667. -5 byte grazie a Zgarb.

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

Provalo online!

Gelatina , 10 byte

ŒDµḢṠQṭT€E

Provalo online!

Python 3 , 72 71 byte

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

Grazie a @xnor per giocare a golf a 1 byte!

Provalo online!

Pyth, 22 21 byte

Questo non è sicuramente il linguaggio per la manipolazione delle matrici.

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

Per ogni riga be il suo indice knella matrice ( .e), prende la prima e la kTh voci (lato sinistro e diagonale) con ,@bkhe ( +) tutte le altre voci con .Db,0k. Se knon è 0, corrisponde alla prima riga ( Wk), quindi !non Mtutte quelle voci. Una volta selezionati tutti, assicurati che siano tutti veri. ( .As) Se c'è uno 0 dove non dovrebbe esserci, allora la posizione corrispondente verrà afferrata così com'è e incasinerà la e, e se c'è uno diverso da zero dove non ci dovrebbe essere, verrà !notificato a 0, che è anche falso.

Suite di test.

-1 byte per scambiare gli ordini.

Pip , 31 23 22 byte

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

Questa è una funzione che accetta un elenco di numeri nidificati 2D. Provalo online!

Spiegazione

Un sacco di confronti in corso qui. La prima cosa da sapere è che gli operatori di confronto in Pip possono essere concatenati insieme, come in Python: 5>4>3è 5>4 and 4>3(vero), non (5>4)>3(falso). Il secondo è che questo non si applica all'operatore =="esattamente uguale". Un'altra differenza: regolare i confronti hanno precedenza maggiore rispetto agli operatori di mappatura MCe MMe può essere utilizzato nelle espressioni lambda, mentre ==ha la precedenza più bassa e non può.

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

Per generare la prima matrice, utilizziamo MC"map-coords". Questo operatore prende un numero, genera una griglia di coordinate quadrate di quella dimensione e mappa una funzione per ciascuna coppia di coordinate (x, y), restituendo un elenco di elenchi dei risultati. Ad esempio, {a+b} MC 3darebbe il risultato [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Qui, la dimensione della griglia è #a, la dimensione del nostro argomento originale. La funzione è 0<_!=B>0, che è un modo più breve di scrivere {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

Ciò restituisce 0 per la prima riga / colonna e la diagonale principale e 1 altrove.

Buccia , 12 11 byte

S≡ȯ´Ṫ§^*=ŀL

Provalo online!

Spiegazione

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?

L'idea è che Husk definisce 0 alla potenza di 0 come 1, quindi il prodotto esterno ha 1 s sulla prima riga e colonna. Inoltre, 1 alla potenza di qualsiasi numero è 1, quindi il prodotto esterno ha 1s sulla diagonale. Altre voci sono 0 alla potenza di un numero positivo, che è 0. Questo dà una matrice binaria a punta di freccia, che confrontiamo con l'input ≡.

APL + WIN, 36 33 byte

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

Richiede l'inserimento dello schermo di una matrice APL 2d.

Clojure, 128 95 92 85 byte

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

È sempre emozionante vedere due parentesi quadre consecutive.

Versione originale:

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

La prima parte funziona assocportando a zero gli elementi diagonali della sotto-matrice e verificando che tutte le righe siano uguali :) Ho usato un trucco simile al metodo giacobino .

La parte più concatrecente enata la diagonale + prima riga e colonna e verifica che siano positive.

Javascript (ES6), 58 byte

La mia soluzione per Javascript:

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

Non intelligente come la risposta di Herman , ma mi è sembrato di dover pubblicare anche qui.

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 byte

-6 byte rimuovendo alcuni spazi mancanti e scorciatoie range. Potrei dover lasciarlo sedere così posso pensare a un modo migliore.

-18 byte grazie a @NikoNyrh e creazione di collegamenti per 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)))))))))

Terribile, semplicemente terribile. Non so perché non riesco ad avvolgere la testa intorno a una soluzione ragionevole.

Accetta un vettore nidificato come 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))))

Ho provato a riscriverlo da zero usando un metodo diverso, ed è finito più a lungo. Invece di ritagliare manualmente le sezioni "resto" della matrice, ho invece deciso di provare a generare tutte le coordinate nella matrice, generando le coordinate della punta della freccia, quindi utilizzare clojure.set/differenceper ottenere le celle non punta della freccia. Sfortunatamente, la chiamata a quel built-in è costosa:

223 byte

(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 byte ^CP437

ä¢⌠┐xⁿtH↔BU

Provalo online!

Versione non compressa con 13 byte:

B|AsF:10i^\=*

Finalmente legato Husk e battuto da Jelly di un solo byte ...

Spiegazione

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 byte

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 byte grazie a Mr. Xcoder

Provalo online!

C, 117 byte

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

Provalo online!

PowerShell , 186 byte

$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

Provalo online!

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

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)

Provalo online!

Pulito , 79 byte

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

Provalo online!

Japt , 16 byte

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

Provalo online!

^{Amico, questo mi riporta ai bei vecchi tempi in cui Japt era regolarmente molto più lungo di altri lang del golf ...}

K (oK) , 27 30 byte

Soluzione:

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

Provalo online!

Spiegazione:

Devo fare qualcosa di stupido poiché le soluzioni APL sono meno della metà del conteggio dei byte ...

24 byte spesi per la creazione della punta della freccia. orinsieme le seguenti tre matrici:

/ 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

Ripartizione 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?