定义

一个箭头矩阵是一个矩阵，其具有所有条目等于0，除了在主对角线，顶行和最左一列的那些。换句话说，矩阵应如下所示：

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

其中每个*是任何非零条目。

任务

给定非负整数的方阵，请根据上面的定义检查其是否为箭头。

除非您的语言等效于数组，例如指针和长度（例如C），否则您可能不将矩阵的大小作为输入。始终至少为3 x 3。

每种语言中以字节为单位的最短代码获胜。

输入输出

您可以选择以下任何一种格式来接收输入：

• 本机矩阵类型的矩阵（如果您的语言有一种）
• 2D数组¹（1D数组的数组，每个数组对应于一行）
• 一维数组（因为矩阵始终为正方形）
• 字符串（您选择了空格，但请勿以任何方式滥用此字符串）。

在提供输出时，您可以按照标准决策问题定义报告真实/虚假值，也可以选择任意两个不同且一致的值。

此外，您可以使用任何编程语言通过任何标准方法进行输入和输出，同时请注意，默认情况下禁止这些漏洞。如果要选择其他格式或不确定某些内容，请在评论中提问。

^{_{1：或与您的语言等效的语言（列表，向量等）}}

例子

让我们看下面的例子：

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

这是一个箭头矩阵（您的程序应报告真实值），因为主对角线上的元素为1 1 1 1，顶行上的元素为，1 2 2 2最左列的元素为1 2 3 4。所有其他条目均为0，因此它满足所有条件。

3 5 6
7 1 0
8 0 0

此矩阵不是箭头，因为主对角线上有一个0。

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

这个也不是箭头，因为它包含7代替0。

更多测试案例

真相：

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

虚假：

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

由于edc65，节省了1个字节

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

返回false箭头矩阵和true非箭头矩阵（之所以允许，是因为可以使用任意两个不同的值来表示true和false）

测试用例：

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字节

-4个字节，感谢@GalenIvanov。

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

将输入作为矩阵（等级2数组）。

在线尝试！

说明

让编辑历史成为您的课程，不要同时打高尔夫并撰写说明。

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

视觉说明

请注意，这是在REPL上完成的（输入以三个空格开头，输出没有任何前导空格）。因此，有时我会省略诸如@和这样的组合函数，&因为REPL上的内容是从右到左评估的（功能更为复杂）。

假设您具有以下示例矩阵：

   ] 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

首先，我想解释一下@GalenIvanov生成身份矩阵的非常聪明的方法（并大声疾呼），如下所示=&/:@}.。

首先，我们将输入矩阵（}.）斩首。

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

然后我们获得使用/:-grade up 对行进行排序的每一行的索引。

   /: }. m
2 1 0

请注意，结果索引是唯一的：列表没有重复的元素（为什么呢？无法将两个元素放在数组的同一位置）。

最后，我们使用利基市场，但很有帮助- =自我分类。此monad将每个唯一元素与数组中的所有其他元素进行比较。还记得我曾提到过，得出的索引必须唯一是很重要的吗？由于=-self-classify按唯一元素出现在列表中的顺序进行比较，因此结果输出将是唯一输入的单位矩阵（这就是为什么=@i.您可以制作给定长度的单位矩阵）。

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

一旦有了单位矩阵，就可以添加一行的行和一列的行，这非常简单（如果给定原子（即单个元素），则,族在添加时会重复填充） ：

   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

然后，我们仅将生成的箭头矩阵与输入矩阵的符号进行比较。

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

Wolfram语言（Mathematica），47个字节

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

在线尝试！

说明：Clip@#在以1s基质替换所有非零数，那么我们比较这对与维数的数组{1,1}Tr[1^#]= {Length@#, Length@#}在位置上与0 i,j时1 < i != j > 1，否则为1。

（大致基于Uriel的回答。）

这是另一个想法，它长了16个字节-如果可以打高尔夫球，可以随意窃取它：

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

在线尝试！

APL（Dyalog Classic），19 16 15 13字节

-1字节感谢@ErikTheOutgolfer

（⎕IO←0）

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

在线尝试！

-2个字节，感谢@ngn和@ H.PWiz

怎么样？

（二维输入矩阵S）

• ×≡检查S是否仅在...上为正
• (∧=⌊ ...对角线或第一行和左列...
• )/¨∘⍳∘⍴...的小号。

PowerShell中，112 108个字节

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

在线尝试！

由于PowerShell不支持矩阵（.NET Direct3D转换矩阵支持之外，这是完全不同的），因此将输入作为数组进行操作。

整个算法基于以下事实：PowerShell中非零数字为真，零为假，并使用乘法确定这些真/假值。

我们先坐第一排，$a[0]并检查是否0是-in该数组，商店，到我们的$o本安输出变量。如果该行中的任何内容为零，则$o也是零，否则为1，通过使用快速转换为int完成+。

接下来，我们从上到下循环1进行$a.count-1设置$x-我们将一次遍历每一行。

每次迭代我们设置的辅助变量$i来跟踪哪一行我们，然后循环从0以$x遍历该行中的每个元素。在内部循环中，$o这次我们再次乘以，方法是从一个元组设置中选择一个伪三元运算符。

元组的条件，!$_-or$_-eq$i说“当我们在第0列上，或者该列与行匹配（即主对角线）时”，则在为真时选择元组的后半部分，为假时选择元组的后半部分。元组由组成!($y=$a[$i][$_]), $y。上半场设置$y为打高尔夫球，下半场设置为高尔夫，但是无论哪种方式，我们都选择当前元素。上半部分对其执行布尔求和，而下半部分则按原样使用元素。因此，如果我们不在第0列或主对角线上，则可以通过采用Boolean-not来确保该元素为零。同样，我们只需简单地确保第0列或主对角线不为零即可。

因此，既然我们已经遍历了矩阵中的每个元素，$o要么是0某个元素不正确，要么是非零整数（如果是箭头矩阵）。我们使用双重布尔值-而不是分别获取False或True使输出一致，并将其保留在隐式打印的管道上。

果冻，14 12字节

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

Pietu1998中的-2个字节

在线尝试！

说明

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

使用上面的矩阵作为示例输入。

Œ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字节

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

在线尝试！

怎么样？

这是另一种方式-

=/¨∘⍳ -创建身份矩阵

1-⍨⍴ -对于 n - 1

1⍪1, -在列和行前加1

≡ -与

× -原始矩阵，经过元素逐元素签名后

MATL，15字节

gtZyXy,!llY(]X=

输入是一个矩阵（;用作行分隔符）。输出1用于箭头，0否则。

在线尝试！或验证所有测试用例。

说明

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字节

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

在线尝试！

多亏了scottinet，节省了5个字节！

从此答案重用了测试代码。

线性扫描数组是否有不正确的值，箭头矩阵返回0，否则返回1。我们通过计算排他或给定位置的项目是否为零以及该位置是否在箭头上来进行检查。

将2D数组的信息编码为一个维度会导致一组相当简单的条件。如果让i我们成为n维数组中的从0开始的索引，则i<n描述第一行。同样，i%n==0描述第一列并i/n==i%n描述对角线。

我发现处理退货的最佳技巧是在遇到错误时将尺寸设置为零。这将导致循环立即终止，然后返回维度的逻辑取反将为我们提供两个不同的值之一。scottinet找到了使GCC更好地返回的方法。

Python 2，75个字节

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

在线尝试！

Python 2，85个字节

将数组作为一维矩阵：

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

在线尝试！

R，78 70 69 68 54 53字节

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

在线尝试！

移植路易斯·门多的答案比我以前的方法要短得多。

感谢rturnbull指出一个错误，然后打个高尔夫球！

旧答案，68个字节：

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

在线尝试！

duckmayr的答案测试了主对角线和第一行/列（m[i]）上的所有条目都不为零，其余（m[-i]）为零，使用一些不错的算法来获取对角线和第一行。

但是，此答案将进行测试以确保（1）零项不在主对角线或第一行/列上，并且（2）在给定n x n矩阵的情况下，存在3*n-2非零项。

which返回其输入为的索引TRUE，并使用可选参数arr.ind=T，为每个数组维度（在本例中为2）返回一个索引数组。

因此，当时any(i[,1]==i[,2])，对角线上存在零，而当时any(i==1)，第一行或第一列中存在零。

最后，通过一点算术表明3*n-2，n从第一列，n-1对角线和n-1第一行开始，非零项的数量必须为。

Python 2中，92 90个字节

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

在线尝试！

学分

• Xcoder先生从92个字节减少到90个字节

Haskell，62个字节

-3个字节，感谢Xcoder先生。-13个字节感谢user28667。-5个字节感谢Zgarb。

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

在线尝试！

果冻，10字节

ŒDµḢṠQṭT€E

在线尝试！

Python 3中，72 71个字节

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

感谢@xnor打高尔夫球1个字节！

在线尝试！

Pyth，22 21字节

这绝对不是矩阵处理的语言。

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

对于每一行b和它的索引k在矩阵（.e），抓住所述第一和k第条目（左侧和对角线）与,@bkh和（+）中的所有其它条目与.Db,0k。如果k不是0对应于第一行（Wk），则!不是M所有这些条目。一旦所有这些都被选中，请确保所有它们都是正确的。（.As）如果不应有0，那么将按原样抓取相应位置，并将and弄乱，如果不应有非零，则将其!标记为0，即也错了。

测试套件。

-1个字节用于交换订单。

点，31 23 22字节

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

此函数采用2D嵌套数字列表。在线尝试！

说明

这里进行了大量的比较。首先要知道的是，Pip中的比较运算符可以链接在一起，就像在Python中一样：5>4>3是5>4 and 4>3（true），不是(5>4)>3（false）。第二个是，这不适用于==“完全等于”运算符。另一个区别：常规比较的优先级比映射运算符高MC，MM并且可以在lambda表达式中使用，而==优先级较低，不能。

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

为了生成第一个矩阵，我们使用MC“ map-coords”。该运算符获取一个数字，生成该大小的正方形坐标网格，然后将函数映射到每个（x，y）坐标对，并返回结果列表的列表。例如，{a+b} MC 3将给出结果[[0; 1; 2]; [1; 2; 3]; [2; 3; 4]]。

在这里，网格#a的大小为，即原始参数的大小。函数是0<_!=B>0，这是一种较短的编写方式{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

这对于第一行/列和主对角线返回0，在其他位置返回1。

外壳，12 11字节

S≡ȯ´Ṫ§^*=ŀL

在线尝试！

说明

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?

这个想法是，Husk将0的幂定义为0等于1，因此外部乘积的第一行和第一列为1。同样，任何数的幂的1为1，因此外部乘积的对角线为1。其他条目为0等于某个正数的幂，即0。这给出了一个二进制箭头矩阵，我们将其与进行比较≡。

APL + WIN，36 33字节

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

提示屏幕输入APL 2d矩阵。

Clojure，128 95 92 85字节

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

看到两个连续的开括号总是令人兴奋的。

原始版本：

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

第一部分通过assoc将子矩阵的对角元素设置为零，并检查所有行是否相等来工作：)我在Jacobian方法中使用了类似的技巧。

后一部分concat对角线+第一行和第一列进行加密，并检查它们是否为正。

Javascript（ES6），58个字节

我的Java解决方案：

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

不像赫尔曼的回答那么聪明，但是我只是觉得我也应该在这里发布它。

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字节

-6个字节，方法是删除一些遗漏的空格并快捷键 range。我可能不得不坐下来，这样我才能想到一个更好的方法。

@NikoNyrh可以为-18个字节，并为创建快捷方式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)))))))))

糟透了 我不知道为什么我不能围绕一个合理的解决方案来解决问题。

将嵌套向量作为输入。

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

我尝试使用另一种方法从头开始重写它，但结果却更长了。我没有人工雕刻出矩阵的“其余”部分，而是决定尝试生成矩阵中的所有坐标，生成箭头的坐标，然后用于clojure.set/difference获取非箭头单元。不幸的是，对该内置函数的调用非常昂贵：

223字节

(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 个字节^CP437

ä¢⌠┐xⁿtH↔BU

在线尝试！

13字节的解压缩版本：

B|AsF:10i^\=*

最终绑住果壳，被果冻打了一个字节...

说明

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字节

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个字节，感谢Xcoder先生

在线尝试！

C，117字节

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

在线尝试！

PowerShell，186字节

$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

在线尝试！

Perl 5，136 + 2（-ap）= 138字节

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)

在线尝试！

干净，79字节

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

在线尝试！

Japt，16字节

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

在线测试！

^{伙计，这让我回到了过去的美好时光，那时Japt的身高比其他高尔夫球手更长。}

K（oK），27 30字节

解：

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

在线尝试！

说明：

我必须做些愚蠢的事情，因为APL解决方案的字节数不到一半...

创建箭头花费了24个字节。or以下三个矩阵：

/ 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

完整细目：

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?