Définition

Une matrice en pointe de flèche est une matrice dont toutes les entrées sont égales à 0 , à l'exception de celles de la diagonale principale, de la rangée du haut et de la colonne la plus à gauche. En d'autres termes, la matrice devrait ressembler à ceci:

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

Où chaque * est une entrée non nulle.

Tâche

Étant donné une matrice carrée d’entiers non négatifs, vérifiez si elle correspond à une flèche conformément à la définition ci-dessus.

Vous ne pouvez pas prendre la taille de la matrice en tant qu'entrée, sauf si l'équivalent linguistique d'un tableau ressemble à un pointeur et à une longueur (comme C). Ce sera toujours au moins 3 x 3.

Le code le plus court en octets dans chaque langue gagne.

Entrée et sortie

Vous pouvez choisir l’un des formats suivants pour recevoir des entrées:

• Une matrice dans le type de matrice natif (si votre langue en a une)
• Un tableau 2D ¹ (un tableau de tableaux 1D, chacun correspondant à une ligne)
• Un tableau 1D (puisque la matrice est toujours carrée)
• Une chaîne (vous avez choisi l'espacement, mais s'il vous plaît, n'abusez pas de cette manière).

Lorsqu'il s'agit de fournir une sortie, vous pouvez signaler une valeur de vérité / fausseté conformément à la définition standard du problème de décision ou choisir deux valeurs distinctes et cohérentes.

De plus, vous pouvez entrer et donner des sorties à l'aide de n'importe quelle méthode standard , dans n'importe quel langage de programmation , tout en prenant note que ces failles sont interdites par défaut. Si vous voulez choisir un autre format ou si vous n'êtes pas sûr de quelque chose, veuillez le demander dans les commentaires.

^{_{1: ou l'équivalent de votre langue (liste, vecteur, etc.)}}

Exemples

Regardons les exemples suivants:

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

Il s'agit d'une matrice en pointe de flèche (vos programmes doivent indiquer une valeur de vérité), car les éléments de la diagonale principale sont 1 1 1 1, ceux de la ligne supérieure sont 1 2 2 2et ceux de la colonne la plus à gauche 1 2 3 4. Toutes les autres entrées sont 0 , cela satisfait donc toutes les conditions.

3 5 6
7 1 0
8 0 0

Cette matrice n'est pas une flèche car il y a un 0 sur la diagonale principale.

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

Celui-ci n'est pas non plus une pointe de flèche, car il contient un 7 à la place d'un 0 .

Plus de cas de test

Vérité

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

Fausseté:

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

Enregistré 1 octet grâce à edc65

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

Retourne falsepour les matrices en pointe de flèche et truepour les matrices sans pointe de flèche (autorisé, car deux valeurs distinctes peuvent être utilisées pour représenter vrai et faux)

Cas de 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 octets

-4 octets grâce à @GalenIvanov.

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

Prend les entrées sous forme de matrice (tableau de rang 2).

Essayez-le en ligne!

Explication

Laissez l’historique des modifications vous servir de leçon pour ne pas jouer au golf et rédigez une explication en même temps.

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

Explication visuelle

Notez que ceci est fait sur le REPL (les entrées sont données en commençant par trois espaces et les sorties sont données sans espaces en tête). Pour cette raison, j’ignore parfois les fonctions de composition comme @et &puisque les éléments de la réplique sont évalués de droite à gauche (les fonctions sont plus complexes).

Supposons que vous ayez l'exemple de matrice suivant:

   ] 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

Tout d’abord, je voudrais expliquer (et saluer) @ la façon très intelligente de GalenIvanov de générer la matrice d’identité, qui est la suivante =&/:@}..

Tout d'abord, nous décapitons la matrice d'entrée ( }.).

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

Ensuite, nous obtenons les indices dans /:lesquels chaque ligne se trouverait si les lignes étaient triées avec -grade up.

   /: }. m
2 1 0

Notez que les index résultants sont uniques : la liste ne contient aucun élément en double (et pourquoi? Il n'y a aucun moyen de placer deux éléments à la même position dans un tableau).

Enfin, nous utilisons la niche mais utile =-self-classify. Cette monade compare chaque élément unique à tous les autres éléments d'un tableau. N'oubliez pas que j'ai mentionné qu'il était important que les indicateurs résultants soient uniques. Puisque =-self-classify effectue les comparaisons dans l'ordre dans lequel les éléments uniques apparaissent dans la liste, le résultat obtenu sera la matrice d'identité pour une entrée unique (c'est pourquoi =@i.vous pouvez créer une matrice d'identité d'une longueur donnée).

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

Une fois que nous avons la matrice d'identité, il suffit d'ajouter une rangée et une colonne, ce qui est fait très simplement (si un atome est attribué - c'est-à-dire un seul élément - la ,famille le répétera pour le remplir quand il sera ajouté) :

   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

Ensuite, nous comparons simplement la matrice de pointe de flèche générée au signe de la matrice d’entrée.

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

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

Essayez-le en ligne!

Explication: Clip@#remplace tous les nombres non nuls de la matrice par 1, puis on compare cela à un tableau de dimensions {1,1}Tr[1^#]= {Length@#, Length@#}avec 0 en position i,jquand 1 < i != j > 1, et 1 sinon.

(Approximativement basé sur la réponse d'Uriel .)

Voici une autre idée de 16 octets de plus - n'hésitez pas à la voler si vous pouvez jouer au golf:

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

Essayez-le en ligne!

APL (Dyalog Classic) , 19 16 15 13 octets

-1 octet grâce à @ErikTheOutgolfer

( ⎕IO←0)

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

Essayez-le en ligne!

-2 octets grâce à @ngn et @ H.PWiz

Comment?

(Matrice d'entrée 2D S )

• ×≡Vérifiez si S est positif uniquement sur ...
• (∧=⌊ ... les diagonales ou la rangée du haut et la colonne de gauche ...
• )/¨∘⍳∘⍴... de S .

PowerShell , 112 108 octets

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

Essayez-le en ligne!

Accepte les entrées et les manipule sous forme de tableau de tableaux, étant donné que PowerShell ne prend pas en charge les matrices (en dehors de la prise en charge des matrices de transformation .NET Direct3D, ce qui est totalement différent).

L’ensemble de l’algorithme est basé sur le fait que les nombres non nuls sont vrais et que zéro est falsey dans PowerShell, et que l’on utilise la multiplication pour déterminer ces valeurs vérité / falsey.

Nous prenons d’abord la première ligne $a[0]et vérifions si ce tableau 0est stocké -indans notre $ovariable utput. Si quelque chose dans cette ligne est zéro, alors le $oest aussi zéro, sinon c'est un, fait par une conversion rapide avec int +.

Boucle suivante nous de 1jusqu'à $a.count-1, la mise $xsur le chemin - nous allons être une boucle à travers chaque ligne un à la fois.

À chaque itération, nous définissons une variable d'assistance $ipour garder une trace de la ligne sur laquelle nous nous trouvons, puis d'une boucle 0à $xpour itérer chaque élément de cette ligne. Dans la boucle interne, nous nous multiplions à nouveau $o, cette fois en sélectionnant une configuration de tuple en tant qu'opérateur pseudo-ternaire.

Le tuple est conditionnel, !$_-or$_-eq$iindique "lorsque nous sommes sur la 0ème colonne, ou que la colonne correspond à la ligne (c'est-à-dire la diagonale principale)" pour sélectionner la seconde moitié du tuple lorsque la vérité est ou la première moitié lorsque Falsey. Le tuple est composé de !($y=$a[$i][$_]), $y. La première moitié définit $ypour jouer au golf la seconde moitié, mais de toute façon, nous sélectionnons l'élément actuel. La première moitié effectue une négation booléenne dessus, alors que la seconde moitié prend l'élément tel quel. Ainsi, si nous ne sommes pas sur la 0e colonne ni sur la diagonale principale, nous nous assurons que l'élément est à zéro en prenant le booléen-not. De même, nous nous assurons que la 0ème colonne ou diagonale principale est non nulle en la prenant simplement.

Donc, maintenant que nous avons parcouru tous les éléments de la matrice, cela $opeut être le 0cas si un élément est incorrect ou un entier non nul s'il s'agit d'une matrice en tête de flèche. Nous double-Boolean - pas cela pour obtenir l'un Falseou l' autre True, pour rendre notre sortie cohérente, et cela reste sur le pipeline où l'impression est implicite.

Gelée , 14 à 12 octets

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

-2 octets de Pietu1998

Essayez-le en ligne!

Explication

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

Utilisez la matrice ci-dessus comme exemple d'entrée.

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

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

Essayez-le en ligne!

Comment?

Celui-ci va dans l'autre sens -

=/¨∘⍳ - crée la matrice d'identité

1-⍨⍴ - pour n - 1

1⍪1, - ajoute une colonne et une ligne de 1

≡ - compare avec

× - la matrice d'origine, après avoir passé au niveau élémentaire

MATL , 15 octets

gtZyXy,!llY(]X=

L'entrée est une matrice (utilisant ;comme séparateur de lignes). La sortie est 1pour la pointe de la flèche, 0sinon.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

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

Essayez-le en ligne!

5 octets sauvés grâce à scottinet!

Réutilisé le code de test de cette réponse .

Analyse linéairement le tableau à la recherche de valeurs incorrectes, en renvoyant 0 pour une matrice en tête de flèche et 1 sinon. Nous vérifions en calculant l'exclusivité ou si l'élément à une position donnée est zéro et si cette position est sur la flèche.

Le codage des informations du tableau 2D dans une dimension conduit à un ensemble de conditions relativement simple. Si nous laissons iêtre notre index de base 0 dans le ntableau dimensionnel, alors i<ndécrit la première ligne. De même, i%n==0décrit la première colonne et i/n==i%ndécrit la diagonale.

La meilleure astuce que j'ai trouvée pour gérer le retour consiste à définir la dimension à zéro en cas d'erreur. Cela provoque la fin de la boucle immédiatement, puis le retour de la négation logique de la dimension nous donnera l'une des deux valeurs distinctes. Scottinet a trouvé le moyen de faire revenir GCC plus facilement.

Python 2 , 75 octets

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

Essayez-le en ligne!

Python 2 , 85 octets

En prenant le tableau comme une 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))

Essayez-le en ligne!

R , 78 70 69 68 54 53 octets

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

Essayez-le en ligne!

Porting La réponse de Luis Mendo est beaucoup plus courte que mon ancienne approche.

Merci à rturnbull pour avoir signalé un bug et avoir joué un octet!

réponse ancienne, 68 octets:

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

Essayez-le en ligne!

La réponse de duckmayr vérifie que toutes les entrées de la diagonale principale et de la première ligne / colonne ( m[i]) sont non nulles et que les autres ( m[-i]) sont égales à zéro, en utilisant une belle arithmétique pour obtenir la diagonale et la première ligne.

Cette réponse, cependant, vérifie que (1) zéro entrée ne figure pas sur la diagonale principale ou la première ligne / colonne, et (2) qu’il existe, avec une n x nmatrice, des 3*n-2entrées non nulles.

whichrenvoie les index où son entrée est TRUE, et avec l'option optionnelle arr.ind=T, retourne un tableau d'indices pour chaque dimension de tableau, dans ce cas, deux.

Donc, quand any(i[,1]==i[,2]), il existe un zéro sur la diagonale, et quand any(i==1), il existe un zéro dans la première ligne ou la première colonne.

Enfin, un peu d'arithmétique montre que le nombre d'entrées non nulles doit être 3*n-2, à npartir de la première colonne, n-1de la diagonale et n-1de la première ligne.

Python 2 , 92 90 octets

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

Essayez-le en ligne!

Crédits

• Réduit de 92 octets à 90 par M. Xcoder

Haskell , 62 octets

-3 octets grâce à M. Xcoder. -13 octets grâce à user28667. -5 octets grâce à Zgarb.

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

Essayez-le en ligne!

Gelée , 10 octets

ŒDµḢṠQṭT€E

Essayez-le en ligne!

Python 3 , 72 71 octets

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

Merci à @xnor d'avoir joué 1 octet!

Essayez-le en ligne!

Pyth, 22 à 21 octets

Ce n'est certainement pas le langage pour manipuler la matrice.

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

Pour chaque ligne bet son index kdans la matrice ( .e), saisit les première et kième entrées (côté gauche et diagonale) avec ,@bkhet ( +) toutes les autres entrées avec .Db,0k. Si kest de 0 pour correspondre à la première ligne ( Wk), puis !pas Mtoutes ces entrées. Une fois que tous ceux-ci ont été sélectionnés, assurez-vous qu'ils sont tous vrais. ( .As) S'il y a un 0 où il ne devrait pas y en avoir, alors l'emplacement correspondant sera saisi tel quel et gâcher le et, et s'il y a un non nul où il ne devrait pas y en avoir, il sera !noté à 0, qui est aussi faux.

Suite de tests.

-1 octets pour permuter les commandes.

Pip , 31 23 22 octets

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

C'est une fonction qui prend une liste de nombres imbriquée en 2D. Essayez-le en ligne!

Explication

Beaucoup de comparaisons sont faites ici. La première chose à savoir est que les opérateurs de comparaison dans Pip peuvent être chaînés ensemble, comme dans Python: 5>4>3is 5>4 and 4>3(true), not (5>4)>3(false). La seconde est que cela ne s'applique pas à ==l'opérateur "exactement égal à". Une autre différence: comparaisons régulières ont une priorité plus élevée que les opérateurs de cartographie MCet MMet peuvent être utilisés dans les expressions lambda, tout ==a une priorité plus faible et ne peut pas.

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

Pour générer la première matrice, nous utilisons MC"map-coords". Cet opérateur prend un nombre, génère une grille de coordonnées carrées de cette taille et mappe une fonction sur chaque paire de coordonnées (x, y) en renvoyant une liste de listes de résultats. Par exemple, {a+b} MC 3donnerait le résultat [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Ici, la taille de la grille est #ala taille de notre argument initial. La fonction est 0<_!=B>0, ce qui est une manière plus courte d'écrire {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

Cela retourne 0 pour la première ligne / colonne et la diagonale principale, et 1 ailleurs.

Husk , 12 à 11 octets

S≡ȯ´Ṫ§^*=ŀL

Essayez-le en ligne!

Explication

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'idée est que Husk définit 0 à la puissance de 0 sur 1, de sorte que le produit externe comporte 1 sur la première ligne et la première colonne. De plus, 1 à la puissance de tout nombre est 1, ainsi le produit extérieur a 1 sur la diagonale. Les autres entrées sont 0 à la puissance d'un nombre positif, ce qui est 0. Cela donne une matrice de tête de flèche binaire, que nous comparons à l'entrée avec ≡.

APL + WIN, 36 33 octets

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

Invites pour la saisie à l'écran d'une matrice APL 2d.

Clojure, 128 95 92 85 octets

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

Il est toujours excitant de voir deux parenthèses d’ouverture consécutives.

Version originale:

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

La première partie fonctionne en intégrant assocà zéro les éléments diagonaux de la sous-matrice et en vérifiant que toutes les lignes sont égales :) J'ai utilisé une astuce similaire à la méthode jacobienne .

concatCette dernière partie indique la diagonale + la première ligne et la colonne et vérifie qu’elles sont positives.

Javascript (ES6), 58 octets

Ma solution pour Javascript:

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

Pas aussi intelligent que la réponse de Herman , mais je me suis juste dit que je devrais la poster ici aussi.

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 octets

-6 octets en supprimant certains espaces manquants et raccourcis range. Je devrais peut-être laisser cela de côté pour pouvoir penser à un meilleur moyen.

-18 octets grâce à @NikoNyrh, et création de raccourcis pour map.

(fn[m](let[r range a map z zero?](and(every? #(not(z %))(concat(m 0)(rest(a #(% 0)m))(a get m(r))))(every? z(apply concat(into(a #(take(dec %)%2)(r)(a rest m))(a take-last(r)(reverse(rest m)))))))))

Horrible, juste horrible. Je ne sais pas pourquoi je ne peux pas me résoudre une solution raisonnable.

Prend un vecteur imbriqué en entrée.

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

J'ai essayé de réécrire cela à partir de zéro en utilisant une méthode différente, et ça a fini plus longtemps. Au lieu de découper manuellement les sections "restantes" de la matrice, j'ai plutôt décidé d'essayer de générer toutes les coordonnées de la matrice, en générant les coordonnées de la pointe de la flèche, puis de les utiliser clojure.set/differencepour obtenir les cellules autres que la tête de la flèche. Malheureusement, l'appel à cette fonction intégrée est coûteux:

223 octets

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

ä¢⌠┐xⁿtH↔BU

Essayez-le en ligne!

Version décompressée avec 13 octets:

B|AsF:10i^\=*

Enfin, Husk est attaché et battu par Jelly d'un octet à la fois ...

Explication

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 octets

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 octets merci à M. Xcoder

Essayez-le en ligne!

C, 117 octets

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

Essayez-le en ligne!

PowerShell , 186 octets

$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

Essayez-le en ligne!

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

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)

Essayez-le en ligne!

Propre , 79 octets

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

Essayez-le en ligne!

Japt , 16 octets

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

Testez-le en ligne!

^{Cela me ramène au bon vieux temps où Japt était régulièrement beaucoup plus long que les autres langues de golf ...}

K (oK) , 27 à 30 octets

Solution:

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

Essayez-le en ligne!

Explication:

Je dois faire quelque chose de stupide, car les solutions APL représentent moins de la moitié du nombre d'octets ...

24 octets consacrés à la création de la pointe de flèche. orensemble les trois matrices suivantes:

/ 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

Ventilation complète:

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?