Ist meine Matrix Pfeilspitze?


33

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

1
Ist es möglich, dass die Matrix negative Zahlen enthalten kann
Zacharý

2
@ Zacharý Nein, du darfst annehmen, dass sie alle nicht negativ sind .
Mr. Xcoder

Pedant: Ein zweidimensionales Array und eine Matrix sind weder dasselbe noch dasselbe wie ein Array von Arrays. Ist die Eingabe als zweidimensionales Array akzeptabel, wenn Ihre Sprache zivilisiert genug ist, um mehrdimensionale Arrays zu unterstützen?
Ian Bush

@ IanBush Ja, ein 2D-Array ist völlig in Ordnung.
Mr. Xcoder

9
@ Mr.Xcoder Dies wäre eine ausreichend andere und interessante Herausforderung, wenn die Pfeilspitze in eine beliebige Richtung zeigen könnte
dylnan

Antworten:


15

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:


Das ist ein wirklich kluger Ansatz!
Mr. Xcoder

1
könnte das funktionieren f=m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))
edc65

@ edc65 Ohne das f=natürlich;-)
Neil

11

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

2
*Reicht nicht statt 0@<(für 17 Bytes)? Probieren Sie es aus
Galen Ivanov

1
@GalenIvanov guter Fang, ich denke schon. Vielen Dank! Zeit, die Erklärung zu überarbeiten lol.
Cole

1
Ich glaube, ich habe einen neuen Weg gefunden, die Identitätsmatrix zu generieren: =&/:Als ich sie mit kombinierte }., bekam ich sie *-:1,1,.=&/:@}.für 15 Bytes. Probieren Sie es online aus!
Galen Ivanov

1
@GalenIvanov brillanter Ansatz (sowohl die Verwendung von /:-grade und }.-behead), nochmals vielen Dank! Ich werde es in bearbeiten.
Cole

Hmm, in der Tat *-:1,1,.=@}.funktioniert es einwandfrei - es ist kein ausgefallener Weg nötig, die Identitätsmatrix zu finden. Sie können eine Identitätsmatrix aus der Quadratmatrix selbst einfach durch generieren =. Löschen Sie also eine Zeile mit }., erstellen Sie die Identitätsmatrix mit = , fügen Sie eine Zeile und eine Spalte mit 1usw. hinzu.
Galen Ivanov

9

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!


8

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 .

Gute Ausnutzung ⍳∘⍴für kartesisches Produkt.
Uriel

×≡(=/∨1∊⊢)¨∘⍳∘⍴
Erik der Outgolfer

1
(=/∨1∊⊢)->(~≠⌊⌊)/
ngn

2
@ngn Noch besser: (∧=⌊)/natürlich erfordern beide⎕IO←0
H.PWiz

7

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.


+= [int]? Das ist nett.
root

@root Einer der PowerShell-Tipps .
AdmBorkBork

7

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 Ẹ

@ wizzwizz4 Ich bin nicht sicher, was du meinst
dylnan

@ wizzwizz4 diesen Code zeigt, wie die Elemente der Matrix neu gruppiert werden. Es dauert die obere, linke und Hauptdiagonale. Ist es das was du meintest?
Dylnan

Ich meinte die tatsächliche visuelle Darstellung des Codes, den Sie in Ihrer Erklärung angegeben haben. Ich habe versucht lustig zu sein, aber es hat offensichtlich nicht funktioniert. Ich werde diese Kommentare bereinigen.
wizzwizz4

7

APL (Dyalog) , 21 18 17 Bytes

×≡11,(=/¨∘⍳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


6

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

1
Was genau ist Indeity Matrix ?
Erik the Outgolfer

13
@EriktheOutgolfer offensichtlich eine Matrix mit einer Gottheit.
Cole

5
@cole hat vielleicht mit einer Matrix über dem
Elysianischen

5

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.


-2 Bytes mit etwas mehr Golf
Scottinet

und weitere -4 Bytes durch Missbrauch der gcc-Methode zur Rückgabe von Werten
scottinet

@ Scottinet Danke! Ich hatte Probleme herauszufinden, welchen Wert ich einstellen sollte, um diesen Trick anzuwenden.
FryAmTheEggman

Eigentlich glaube ich nicht, dass Ihr erstes Golfspiel funktioniert. Es hat die Testfälle bestanden, weil es auf der ersten Position nie eine Null gab. Es wurde ein Fall hinzugefügt und diese Änderung rückgängig gemacht.
FryAmTheEggman

int test0 [] = {0, 1, 1, 1, 1, 0, 1, 0, 1}; printf ("% d \ n", f (test0, 3)); Muss 0 und nicht 1 zurückgeben (wenn die 3x3-Matrix 011 110 101 ist), da a [0,0] 0 ist
RosLuP


5

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.


Dies scheint nicht für Pfeilmatrizen zu funktionieren, bei denen die Werte nicht 1 sind. Meinten Sie all(!m==!d)in der letzten Zeile?
Turnbull

@rturnbull ah! Vielen Dank. Die R-Operator-Syntax ist so seltsam. Ich meinte wirklich, (!!m)==daber !hat eine niedrigere Priorität als ==. Ich denke, d==!!msollte den Trick machen.
Giuseppe

Es sieht d!=!mgenauso aus, für ein Byte weniger. Sie können ein weiteres Byte speichern, indem Sie stattdessen auch die pryr::fSyntax verwenden function.
Turnbull

Ich habe versucht, Golf zu spielen, aber das Beste, was ich tun kann, sind immer noch 53 .
JayCe

@ JayCe nah, sowohl deine als auch meine Antwort können auf 52 golfen werden, und ich bin mir nicht sicher, warum es mir vorher nicht eingefallen ist ... Ich würde deine als getrennt posten; die einzeilige Ansatz ist sehr schön und ich vermute , es kann etwas mehr Raum für Verbesserungen in Ihnen gehören
Giuseppe




3

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!


Ich denke , 0<i!=j>0speichert ein Byte,
xnor

@ xnor Danke! Ich glaube nicht, dass ich jemals eine Nummer in einer Vergleichskette wiederverwendet habe ...
Dennis

2

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.


1
Wow, diese Lösung ist wirklich nett, da Pyth ziemlich parallel zur Matrixmanipulation ist. Wahrscheinlich für ein weiteres Pyth-Duell morgen: P
Mr. Xcoder 20.12.17

Möglicherweise können Sie dies mit @VQUQoder .DVQUQ Für Diagonalen / Löschen von Diagonalen verkürzen . Das würde aber einen ganz anderen Ansatz erfordern. Nicht sicher, aber ... (BTW vergessen, den Link zu aktualisieren?)
Mr. Xcoder

@ Mr.Xcoder Fixed Link, ich versuche morgen mit anderen Strategien rumzuspielen.
Steven H.

Ich kam an einem anderen 21-byter meine Verwendung VQUQIdee: >.A++hCQhQ.(VQUQsstCt. Dies scheint jedoch überflüssig zu sein. Möglicherweise können Sie es optimieren, um ein paar Bytes zu sparen.
Mr. Xcoder

2

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.


2

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 .


2

APL + WIN, 36 33 Bytes

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

Fordert zur Bildschirmeingabe einer APL 2d-Matrix auf.


2

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.


2

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.


3
Willkommen bei PPCG!
Steadybox

2

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

Es gibt ziemlich viel Raum für Verbesserungen, zum Beispiel #(drop 1 %)ist es dasselbe wie restund #(not(zero? %))dasselbe wie pos?(da wir nicht negative Zahlen haben). Vielleicht möchten Sie einen Blick auf meine 128-Byte-Antwort werfen, die in diesem Fall einen ähnlichen Ansatz hat. Nachdem ich das implementiert hatte, wurde mir klar, dass es sehr kurz ist, sich mit indexbasiertem Zugriff in einer for-Schleife zu befassen.
NikoNyrh

@NikoNyrh Ya, ich war an diesem Tag nicht in einem sehr guten Groove. Ich weiß nicht, wie ich es vergessen habe rest. Ich sollte diesen Versuch wahrscheinlich einfach ausrangieren und es erneut versuchen.
Carcigenicate

2

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



1

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!


2
Einige golfs - Verwendung param($a)zu nehmen Eingang, die -containsfür ein getauscht werden -inund alle die -eq0für getauscht werden !. Schließlich können Sie eine Schleife von 1bis zu $a.lengthund loswerden der if($_-ne0)in der Schleife Körper.
AdmBorkBork

1

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!



1

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


1

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?
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.