Definition

Eine Pfeilspitzenmatrix ist eine Matrix , in der alle Einträge gleich 0 sind , mit Ausnahme der Einträge in der Hauptdiagonale, der oberen Reihe und der ganz linken Spalte. Mit anderen Worten sollte die Matrix so aussehen:

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

Wobei jedes * ein Eintrag ungleich Null ist.

Aufgabe

Überprüfen Sie anhand einer quadratischen Matrix nicht negativer Ganzzahlen, ob es sich um eine Pfeilspitze gemäß der obigen Definition handelt.

Sie können nicht die Größe der Matrix als Eingabe, es sei denn , äquivalent Ihre Sprache ist zu einem Array so etwas wie ein Zeiger und eine Länge (wie C). Es wird immer mindestens 3 x 3 sein.

Der kürzeste Code in Bytes in jeder Sprache gewinnt.

Ein- und Ausgang

Sie können eines der folgenden Formate für den Empfang von Eingaben auswählen:

• Eine Matrix im nativen Matrixtyp (falls Ihre Sprache eine hat)
• Ein 2D-Array ¹ (ein Array von 1D-Arrays, die jeweils einer Zeile entsprechen)
• Ein 1D-Array (da die Matrix immer quadratisch ist)
• Ein String (Sie haben den Abstand gewählt, aber bitte missbrauchen Sie diesen in keiner Weise).

Wenn es um die Ausgabe geht, können Sie entweder einen Wahrheits- / Falschwert gemäß der Standarddefinition für Entscheidungsprobleme melden oder zwei unterschiedliche und konsistente Werte auswählen.

Darüber hinaus können Sie Eingaben und Ausgaben mit jeder Standardmethode und in jeder Programmiersprache vornehmen , wobei zu beachten ist, dass diese Lücken standardmäßig verboten sind. Wenn Sie ein anderes Format auswählen möchten oder unsicher sind, fragen Sie bitte in den Kommentaren.

^{_{1: oder die Entsprechung Ihrer Sprache (Liste, Vektor usw.)}}

Beispiele

Schauen wir uns die folgenden Beispiele an:

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

Dies ist eine Pfeilspitzenmatrix (Ihre Programme sollten einen Wahrheitswert melden), da die Elemente in der Hauptdiagonale 1 1 1 1, die in der oberen Reihe 1 2 2 2und die in der linken Spalte sind 1 2 3 4. Alle anderen Einträge sind 0 , dies erfüllt also alle Bedingungen.

3 5 6
7 1 0
8 0 0

Diese Matrix ist keine Pfeilspitze, da sich auf der Hauptdiagonale eine 0 befindet .

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

Diese ist auch keine Pfeilspitze, da sie eine 7 anstelle einer 0 enthält .

Weitere Testfälle

Wahrheit:

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

Falsch:

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

Dank edc65 1 Byte gespeichert

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

Rückgabe falsefür Pfeilspitzenmatrizen und truefür Nicht-Pfeilspitzenmatrizen (zulässig, da zwei unterschiedliche Werte verwendet werden können, um true und false darzustellen)

Testfälle:

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 dank @GalenIvanov.

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

Nimmt die Eingabe als Matrix (Array Rang 2).

Probieren Sie es online!

Erläuterung

Lassen Sie die Bearbeitungshistorie eine Lektion für Sie sein, nicht Golf zu spielen und gleichzeitig eine Erklärung zu schreiben.

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

Visuelle Erklärung

Beachten Sie, dass dies auf dem REPL gemacht wird (Eingaben beginnen mit drei Leerzeichen und Ausgaben ohne führende Leerzeichen). Aus diesem Grund verzichte ich manchmal auf Kompositionsfunktionen wie @und &da die REPL-Funktionen von rechts nach links ausgewertet werden (Funktionen sind komplexer).

Angenommen, Sie haben die folgende Beispielmatrix:

   ] 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

Zunächst möchte ich @ GalenIvanovs sehr geschickte Art der Generierung der Identitätsmatrix erläutern (und ihm einen Gruß aussprechen). Dies ist die folgende =&/:@}..

Zuerst enthaupten wir die Eingabematrix ( }.).

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

Dann erhalten wir die Indizes, in denen sich jede Zeile befinden würde, wenn die Zeilen mit /:-grade up sortiert würden.

   /: }. m
2 1 0

Beachten Sie, dass die resultierenden Indizes eindeutig sind : Die Liste enthält keine doppelten Elemente (und warum? Es gibt keine Möglichkeit, zwei Elemente in einem Array an derselben Position zu platzieren).

Schließlich nutzen wir die Nische aber hilfreich- =selbst-klassifizieren. Diese Monade vergleicht jedes einzelne Element mit allen anderen Elementen in einem Array. Weißt du noch, wie ich erwähnt habe, dass es wichtig ist, dass die resultierenden Angaben eindeutig sind? Da =-selbstklassifizieren die Vergleiche in der Reihenfolge durchführt, in der die eindeutigen Elemente in der Liste angezeigt werden, ist die resultierende Ausgabe die Identitätsmatrix für eine eindeutige Eingabe (aus diesem Grund =@i.können Sie eine Identitätsmatrix mit einer bestimmten Länge erstellen ).

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

Sobald wir die Identitätsmatrix haben, ist es eine Frage eine Reihe von Einsen des Hinzufügens und eine Spalte von Einsen, die sehr einfach gemacht wird (wenn ein Atom gegeben - dh eines einzelne Element - die ,Familie wird es wiederholen zu füllen , wenn es hinzugefügt werden wird) :

   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

Dann vergleichen wir einfach die erzeugte Pfeilspitzenmatrix mit dem Signum der Eingabematrix.

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

Wolfram-Sprache (Mathematica) , 47 Bytes

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

Probieren Sie es online!

Erklärung: Clip@#Ersetzt alle Zahlen in der Matrix, die nicht Null sind, durch 1 und vergleicht dies mit einem Array mit den Dimensionen {1,1}Tr[1^#]= {Length@#, Length@#}mit 0 an der Position, i,jwenn 1 < i != j > 1und 1 ansonsten.

(Grob basierend auf Uriels Antwort .)

Hier ist eine weitere Idee, die 16 Byte länger ist:

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

Probieren Sie es online!

APL (Dyalog Classic) , 19 16 15 13 Bytes

-1 Byte dank @ErikTheOutgolfer

( ⎕IO←0)

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

Probieren Sie es online!

-2 Bytes dank @ngn und @ H.PWiz

Wie?

(2D Eingangsmatrix S )

• ×≡Prüfen Sie, ob S nur bei ... positiv ist.
• (∧=⌊ ... die Diagonalen oder die obere Reihe und linke Spalte ...
• )/¨∘⍳∘⍴... von 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

Probieren Sie es online!

Nimmt Eingaben und Manipulationen als Array von Arrays, da PowerShell keine Matrizen unterstützt (außerhalb der Unterstützung für .NET Direct3D-Transformationsmatrizen, was etwas völlig anderes ist).

Der gesamte Algorithmus basiert auf der Tatsache, dass Zahlen ungleich Null wahr sind und Null in PowerShell falsch ist, und verwendet die Multiplikation, um diese Wahrheits / Falsch-Werte zu bestimmen.

Wir nehmen zuerst die erste Zeile $a[0]und prüfen, ob 0es sich um -indieses Array handelt. Speichern Sie dies in unserer $output-Variablen. Wenn irgendetwas in dieser Zeile Null ist, dann $oist das auch Null, andernfalls ist es Eins, was durch ein schnelles Cast-to-Int mit gemacht wird +.

Als nächstes gehen wir in einer Schleife von 1oben nach $a.count-1unten, wobei $xwir uns auf dem Weg befinden. Wir werden jede Reihe einzeln durchlaufen.

Bei jeder Iteration setzen wir die Hilfsvariable $i, um zu verfolgen, in welcher Zeile wir uns befinden, und durchlaufen dann die Schleife von 0bis $x, um jedes Element in dieser Zeile zu iterieren. Innerhalb der inneren Schleife multiplizieren wir erneut$o aus einem Tupel-Setup einen pseudoternären Operator auswählen.

Das Tupel ist bedingt, !$_-or$_-eq$i lautet "Wenn wir uns in der 0. Spalte befinden oder wenn die Spalte mit der Zeile (dh der Hauptdiagonale) übereinstimmt", um die zweite Hälfte des Tupels als wahr oder die erste Hälfte als falsch auszuwählen. Das Tupel besteht aus !($y=$a[$i][$_]), $y. Die erste Hälfte ist $yfür das Golfen in der zweiten Hälfte vorgesehen, aber in beiden Fällen wird das aktuelle Element ausgewählt. In der ersten Hälfte wird die Boolesche Negation ausgeführt, während in der zweiten Hälfte das Element unverändert übernommen wird. Wenn wir uns also weder in der 0. Spalte noch in der Hauptdiagonale befinden, stellen wir sicher, dass das Element Null ist, indem wir das Boolesche-Nicht davon nehmen. In ähnlicher Weise stellen wir sicher, dass die 0. Spalte oder Hauptdiagonale nicht Null ist, indem wir sie einfach nehmen.

Nun, da wir alle Elemente in der Matrix durchlaufen haben, $oist dies entweder der Fall, 0wenn ein Element falsch war, oder eine Ganzzahl ungleich Null, wenn es sich um eine Pfeilspitzenmatrix handelt. Wir haben einen doppelten Booleschen Wert - nicht das, um eines Falseoder das Trueandere zu erhalten, um unsere Ausgabe konsistent zu machen, und das verbleibt in der Pipeline, in der das Drucken implizit ist.

Jelly , 14 12 Bytes

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

-2 Bytes von Pietu1998

Probieren Sie es online!

Erläuterung

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

Verwenden Sie die obige Matrix als Beispieleingabe.

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

Probieren Sie es online!

Wie?

Dieser geht den anderen Weg -

=/¨∘⍳ - Erstellt die Identitätsmatrix

1-⍨⍴ - zum n - 1

1⍪1, - Stellt eine Spalte und eine Zeile mit einer 1 voran

≡ - vergleicht mit

× - die ursprüngliche Matrix, nachdem sie elementweise signiert wurde

MATL , 15 Bytes

gtZyXy,!llY(]X=

Die Eingabe ist eine Matrix (die ;als Zeilentrennzeichen verwendet wird). Ausgabe ist10 ansonsten für die Pfeilspitze .

Probieren Sie es online!Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Probieren Sie es online!

5 Bytes gespart dank scottinet!

Wiederverwendung des Testcodes aus dieser Antwort .

Durchsucht das Array linear nach falschen Werten und gibt 0 für eine Pfeilspitzenmatrix und 1 für andere Werte zurück. Wir prüfen, indem wir das Exklusive oder berechnen, ob der Gegenstand an einer bestimmten Position Null ist und ob sich diese Position auf dem Pfeil befindet.

Das Codieren der Informationen des 2D-Arrays in eine Dimension führt zu einem relativ einfachen Satz von Bedingungen. Wenn wir iunseren 0-basierten Index in das ndimensionale Array aufnehmen lassen, i<nwird die erste Zeile beschrieben. Ebenso i%n==0beschreibt die erste Spalte und i/n==i%nbeschreibt die Diagonale.

Der beste Trick, den ich für die Behandlung der Rückgabe gefunden habe, besteht darin, die Dimension auf Null zu setzen, wenn ein Fehler auftritt. Dadurch wird die Schleife sofort beendet. Wenn Sie dann die logische Negation der Dimension zurückgeben, erhalten Sie einen von zwei unterschiedlichen Werten. scottinet hat den Weg gefunden, GCC dazu zu bringen, es besser zurückzugeben.

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

Probieren Sie es online!

Python 2 , 85 Bytes

Nehmen Sie das Array als 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))

Probieren Sie es online!

R , 78 70 69 68 54 53 Bytes

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

Probieren Sie es online!

Porting Luis Mendo Antwort ist viel kürzer als mein früherer Ansatz.

Vielen Dank an rturnbull für das Aufzeigen eines Fehlers und das Abarbeiten eines Bytes!

alte Antwort, 68 Bytes:

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

Probieren Sie es online!

Die Antwort von duckmayr testet, dass alle Einträge in der Hauptdiagonale und in der ersten Zeile / Spalte ( m[i]) ungleich Null sind und der Rest ( m[-i]) Null ist, wobei eine nette Arithmetik verwendet wird, um die Diagonale und die erste Zeile zu erhalten.

Diese Antwort prüft jedoch, ob (1) Null-Einträge nicht in der Hauptdiagonale oder in der ersten Zeile / Spalte vorhanden sind und (2) ob bei einer gegebenen n x nMatrix 3*n-2Nicht-Null-Einträge vorhanden sind.

whichGibt die Indizes zurück, bei denen die Eingabe erfolgt TRUE. Mit der Option "Optional" arr.ind=Twird ein Array von Indizes für jede Arraydimension zurückgegeben, in diesem Fall zwei.

Daher wenn any(i[,1]==i[,2]) der Diagonale eine Null vorhanden ist, und wenn any(i==1)in der ersten Zeile oder in der ersten Spalte eine Null vorhanden ist.

Schließlich wenig Arithmetik zeigt , dass die Anzahl von Nicht - Null - Einträgen muß 3*n-2, nvon der ersten Spalte, n-1von den Diagonalen, und n-1aus der ersten Reihe.

Python 2 , 92 bis 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))

Probieren Sie es online!

Credits

• Von Mr. Xcoder von 92 Byte auf 90 Byte reduziert

Haskell , 62 Bytes

-3 Bytes dank Herrn Xcoder. -13 Bytes dank user28667. -5 Bytes dank Zgarb.

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

Probieren Sie es online!

Gelee , 10 Bytes

ŒDµḢṠQṭT€E

Probieren Sie es 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))

Vielen Dank an @xnor für das Golfen ab 1 Byte!

Probieren Sie es online!

Pyth, 22 21 Bytes

Dies ist definitiv nicht die Sprache für die Matrixmanipulation.

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

Ergreift für jede Zeile bund ihren Index kin der Matrix ( .e) die ersten und kdritten Einträge (linke Seite und Diagonale) mit ,@bkhund ( +) alle anderen Einträge mit .Db,0k. Wenn knicht 0 ist, um der ersten Zeile ( Wk) zu entsprechen , dann sind !nicht Malle diese Einträge vorhanden. Wenn Sie alle ausgewählt haben, stellen Sie sicher, dass sie alle wahr sind. ( .As) Wenn es eine 0 gibt, bei der es keine geben sollte, wird der entsprechende Ort so wie er ist erfasst und das und durcheinander gebracht, und wenn es eine Nicht-Null gibt, bei der es keine geben sollte, wird dies !mit 0 angegeben auch falsch.

Testsuite.

-1 Bytes zum Vertauschen der Aufträge.

Pip , 31 23 22 Bytes

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

Dies ist eine Funktion, die eine in 2D verschachtelte Liste von Zahlen akzeptiert. Probieren Sie es online!

Erläuterung

Viele Vergleiche finden hier statt. Das Erste, was Sie wissen müssen, ist, dass Vergleichsoperatoren in Pip wie in Python miteinander verkettet werden können: 5>4>3ist 5>4 and 4>3(wahr), nicht (5>4)>3(falsch). Das zweite ist, dass dies nicht für ==den Operator "genau gleich" gilt. Ein weiterer Unterschied: Regelmäßige Vergleiche haben eine höhere Priorität als die Mapping-Operatoren MCund MMkönnen in Lambda-Ausdrücken verwendet werden, während sie ==eine niedrigere Priorität haben und dies nicht können.

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

Um die erste Matrix zu erzeugen, verwenden wir MC"Kartenkoordinaten". Dieser Operator nimmt eine Zahl, generiert ein quadratisches Koordinatengitter dieser Größe und ordnet jedem (x, y) Koordinatenpaar eine Funktion zu, die eine Liste mit Listen der Ergebnisse zurückgibt. Zum Beispiel {a+b} MC 3würde das Ergebnis geben [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Hier ist die Größe des Rasters #adie Größe unseres ursprünglichen Arguments. Die Funktion ist 0<_!=B>0, was eine kürzere Schreibweise ist {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

Dies gibt 0 für die erste Zeile / Spalte und die Hauptdiagonale und 1 an anderer Stelle zurück.

Schale , 12 11 Bytes

S≡ȯ´Ṫ§^*=ŀL

Probieren Sie es online!

Erläuterung

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?

Die Idee ist, dass Husk 0 hoch 0 als 1 definiert, sodass das äußere Produkt in der ersten Zeile und Spalte 1s hat. Außerdem ist 1 hoch 1, sodass das äußere Produkt 1s auf der Diagonale hat. Andere Einträge sind 0 hoch einer positiven Zahl, die 0 ist. Dies ergibt eine binäre Pfeilspitzenmatrix, mit der wir die Eingabe vergleichen ≡.

APL + WIN, 36 33 Bytes

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

Fordert zur Bildschirmeingabe einer APL 2d-Matrix auf.

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

Es ist immer wieder aufregend, zwei aufeinanderfolgende öffnende Klammern zu sehen.

Originalfassung:

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

Im ersten Teil werden assocdiagonale Elemente der Submatrix auf Null gesetzt und überprüft, ob alle Zeilen gleich sind :) Ich habe einen ähnlichen Trick bei der Jacobian-Methode angewendet .

Der concatletzte Teil markiert die Diagonale + erste Zeile und Spalte und prüft, ob sie positiv sind.

Javascript (ES6), 58 Byte

Meine Lösung für Javascript:

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

Nicht so schlau wie Hermans Antwort, aber ich hatte das Gefühl, dass ich es auch hier posten sollte.

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 durch Entfernen einiger fehlender Leerzeichen und Verknüpfung range. Möglicherweise muss ich das sitzen lassen, damit ich mir einen besseren Weg ausdenken kann.

-18 Bytes dank @NikoNyrh und Erstellen von Verknüpfungen für 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)))))))))

Schrecklich, nur schrecklich. Ich weiß nicht, warum ich mich nicht um eine vernünftige Lösung kümmern kann.

Nimmt einen verschachtelten Vektor als Eingabe.

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

Ich habe versucht, dies mit einer anderen Methode von Grund auf neu zu schreiben, und es endete länger. Anstatt die "Rest" -Abschnitte der Matrix manuell herauszuschneiden, habe ich stattdessen beschlossen, alle Koordinaten in der Matrix zu generieren, die Koordinaten der Pfeilspitze zu generieren und dann clojure.set/differencedie Nicht-Pfeilspitzenzellen zu erhalten. Leider ist der Anruf zu diesem eingebauten System teuer:

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

Probieren Sie es online!

Entpackte Version mit 13 Bytes:

B|AsF:10i^\=*

Endlich Husk gefesselt und von Jelly mit nur einem Byte geschlagen ...

Erläuterung

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 dank Mr. Xcoder

Probieren Sie es 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;}

Probieren Sie es 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

Probieren Sie es 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)

Probieren Sie es online!

Sauber , 79 Bytes

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

Probieren Sie es online!

Japt , 16 Bytes

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

Online testen!

^{Mann, das bringt mich zurück in die guten alten Zeiten, als Japt regelmäßig viel länger als andere langsame Golfer war ...}

K (ok) , 27 30 Bytes

Lösung:

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

Probieren Sie es online!

Erläuterung:

Ich muss etwas Dummes tun, da die APL-Lösungen weniger als die Hälfte der Byteanzahl sind ...

24 Bytes für die Erstellung der Pfeilspitze. orzusammen die folgenden drei Matrizen:

/ 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

Vollständige Aufschlüsselung:

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?