정의

화살촉 행렬 A는 행렬 의 모든 항목이 동일 가지고 0 주 대각선 위쪽 행과 왼쪽 열에에 제외한. 다시 말해, 행렬은 다음과 같아야합니다.

* * * * * *
* * 0 0 0
* 0 * 0 0 0
* 0 * 0 0
* 000 * 0
* 0000 *

여기서 각 * 는 0이 아닌 항목입니다.

태스크

음이 아닌 정수의 정사각 행렬이 주어지면 위의 정의에 따라 화살촉인지 확인하십시오.

언어와 배열이 같은 것이 포인터 나 길이와 같은 것이 아닌 한 (예 : C) 행렬 크기를 입력으로 사용할 수 없습니다 . 항상 3 x 3 이상이어야합니다.

각 언어 에서 가장 짧은 바이트 코드 가 이깁니다.

입력과 출력

입력을 받기 위해 다음 형식 중 하나를 선택할 수 있습니다.

• 기본 매트릭스 유형의 매트릭스 (언어가있는 경우)
• 2D 배열 ¹ (각각 하나의 행에 해당하는 1D 배열의 배열)
• 1D 배열 (매트릭스는 항상 정사각형이므로)
• 문자열 (간격을 선택했지만 어떤 식 으로든 남용하지 마십시오).

결과를 제공 할 때 표준 의사 결정 문제 정의에 따라 진실 / 거짓 값을 보고 하거나 두 가지 명확하고 일관된 값을 선택할 수 있습니다.

또한, 당신은 입력을 할 수 있고 어떤을 통해 출력을 제공 표준 방법 어떤에서, 프로그래밍 언어를 주의하면서, 이러한 허점은 기본적으로 금지되어 있습니다. 다른 형식을 선택하거나 확실하지 않은 내용이 있으면 의견을 요청하십시오.

^{_{1 : 또는 귀하의 언어와 동등한 것 (목록, 벡터 등)}}

예

다음 예제를 보자.

1 2 2 2
2 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 9

이것은 0 대신 7 을 포함하기 때문에 화살촉 도 아닙니다 .

더 많은 테스트 사례

진실한 :

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

자바 스크립트 (ES6), 48 47 바이트

edc65 덕분에 1 바이트 절약

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

false화살촉 행렬과 화살촉 true이 아닌 행렬에 대한 반환 값 (두 개의 다른 값을 사용하여 참과 거짓을 나타낼 수 있으므로 허용됨)

테스트 사례 :

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 바이트

@GalenIvanov 덕분에 -4 바이트.

*-: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에서 수행됩니다 (입력은 3 개의 공백으로 시작하고 출력은 선행 공백없이 제공됨). 그 때문에, 같은 나는 가끔 생략 구성 기능 @및 &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의 ID 행렬을 생성하는 매우 영리한 방법을 설명하고 싶습니다 =&/:@}..

먼저 입력 행렬 ( }.)을 참수합니다 .

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

그런 다음 각 행의 인덱스를 /:-grade up을 사용하여 정렬 했습니다.

   /: }. m
2 1 0

결과 인덱스는 고유합니다 .리스트에 중복 요소가 없습니다 (왜 그런가? 배열에서 같은 위치에 두 요소를 배치 할 방법이 없습니다).

마지막으로, 우리는 틈새를 사용하지만 도움이되는 자체 =분류를 사용합니다. 이 모나드는 각각의 고유 한 요소를 배열의 다른 모든 요소와 비교합니다. 결과 지수가 고유하다는 것이 중요하다고 언급 한 것을 기억하십니까? 이후 =-Self-분류는 독특한 요소가 목록에 나타나는 순서대로 비교를 수행합니다 (이유는, 결과 출력은 고유의 입력에 대한 행렬이 될 것입니다 =@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 Language (Mathematica) , 47 바이트

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

온라인으로 사용해보십시오!

설명 : Clip@#행렬의 0이 아닌 모든 숫자를 1로 바꾼 다음 , when 위치에 {1,1}Tr[1^#]= {Length@#, Length@#}가 0 인 차원이 있고 그렇지 않은 경우 1 인 배열과 비교합니다 .i,j1 < i != j > 1

(거의 Uriel의 답변을 기반으로 함 )

16 바이트 더 긴 또 다른 아이디어는 다음과 같습니다. 골프를 탈 수 있다면 자유롭게 훔치십시오.

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

온라인으로 사용해보십시오!

APL (Dyalog Classic) , 19 16 15 13 바이트

@ErikTheOutgolfer 덕분에 -1 바이트

( ⎕IO←0)

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

온라인으로 사용해보십시오!

@ngn 및 @ H.PWiz 덕분에 -2 바이트

방법?

(2D 입력 매트릭스 S )

• ×≡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에서 0이 아닌 숫자가 진실이고 0이 거짓이라는 사실을 기반으로하며 곱셈을 사용하여 이러한 참 / 거짓 값을 결정합니다.

우리는 먼저, 첫 번째 행을 $a[0]하고 있는지 여부를 확인 0하다 -in우리로 저장을하는 것이 해당 배열 $output 변수. 해당 행의 어떤 것이 0이면, $o또한 0입니다 +.

에서 다음으로 루프 1까지가 $a.count-1, 설정 $x길을 따라 - 우리는 한 번에 각 행의 하나를 통해 반복 될 것입니다.

반복 할 때마다 헬퍼 변수 $i를 설정 하여 현재 행을 추적 한 다음 이 행의 각 요소를 반복 0하기 $x위해 반복합니다. 내부 루프 안에서 $o튜플 설정에서 의사 삼항 연산자로 선택하여 다시 곱 합니다.

튜플의 조건부에서는 !$_-or$_-eq$i"0 번째 열에 있거나 열이 행과 일치 할 때 (예 : 기본 대각선)"라고 말하면 튜플의 후반은 진실 일 때 또는 절반은 거짓 일 때 선택합니다. 튜플은로 구성 !($y=$a[$i][$_]), $y됩니다. 전반부는 후반 $y을 골프로 설정 하지만 현재 요소를 선택합니다. 전반부는 부울 부정을 수행하고 후반부는 요소를 그대로 가져옵니다. 따라서 0 번째 열이나 주 대각선에 있지 않으면 Boolean-not을 가져 와서 요소가 0이되도록합니다. 마찬가지로, 우리는 단순히 그것을 취함으로써 0 번째 열 또는 주 대각선이 0이 아닌 것을 보장합니다.

그래서 지금 우리가 행렬의 모든 요소를 통해 반복 했으므로 $o중 하나가 될 것입니다 0그것을 화살촉 매트릭스의 경우 일부 요소가 정확 경우, 또는 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을 반환합니다. 배타적이거나 주어진 위치의 항목이 0인지 여부와 해당 위치가 화살표인지 여부를 계산하여 확인합니다.

2D 배열의 정보를 1 차원으로 인코딩하면 상당히 간단한 조건 세트가됩니다. 우리 해주면 i로 우리의 0 기반 인덱스 될 n차원 배열 한 후 i<n첫 번째 행을 설명한다. 마찬가지로 i%n==0첫 번째 열과 i/n==i%n대각선을 설명합니다.

반환을 처리하기 위해 찾은 가장 좋은 트릭은 오류가 발생할 때 치수를 0으로 설정하는 것입니다. 이로 인해 루프가 즉시 종료되고 치수의 논리적 부정을 반환하면 두 가지 고유 한 값 중 하나가 제공됩니다. scottinet는 GCC가 더 잘 돌려주는 방법을 찾았습니다.

파이썬 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))

온라인으로 사용해보십시오!

파이썬 2 , 85 바이트

배열을 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))

온라인으로 사용해보십시오!

R , 78 70 69 68 54 53 바이트

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

온라인으로 사용해보십시오!

포팅 루이스 Mendo의 대답은 내 이전의 방법보다 훨씬 짧습니다.

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])의 모든 항목 이 0이 아니며 나머지 ( m[-i])가 0인지 테스트합니다 .

그러나이 답변은 (1) 0 번째 항목이 주 대각선이나 첫 번째 행 / 열에 없는지, (2) 0이 아닌 n x n행렬 3*n-2이 주어진 지 확인 합니다.

whichinput이있는 인덱스를 반환하고 TRUE, optional을 사용하면 arr.ind=T각 배열 차원에 대한 인덱스 배열 (이 경우 2)을 반환합니다.

따라서이면 any(i[,1]==i[,2])대각선 any(i==1)에 0이 있고이면 첫 번째 행 또는 첫 번째 열에 0이 있습니다.

마지막으로, 제로 엔트리의 개수이어야 작은 산술 방송 3*n-2, n첫 번째 열에서 n-1대각으로 한 n-1첫 번째 행부터.

파이썬 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))

온라인으로 사용해보십시오!

크레딧

• Mr. Xcoder에 의해 92 바이트에서 90으로 감소

하스켈 , 62 바이트

Mr. Xcoder 덕분에 -3 바이트. user28667 덕분에 -13 바이트 Zgarb 덕분에 -5 바이트

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

온라인으로 사용해보십시오!

파이썬 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))

1 바이트를 골라내는 @xnor에게 감사드립니다!

온라인으로 사용해보십시오!

Pyth, 22 21 바이트

이것은 분명히 매트릭스 조작을위한 언어가 아닙니다.

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

행렬의 각 행 b과 색인 k에 대해 ( .e)의 첫 번째 및 kth 항목 (왼쪽 및 대각선)을 사용 ,@bkh하고 ( +)를 사용하여 다른 모든 항목을 가져옵니다 .Db,0k. k첫 번째 행 ( Wk) 에 해당하는 0이 아닌 경우 해당 항목이 모두있는 !것은 아닙니다 M. 모든 항목이 선택되면 모든 항목이 사실인지 확인하십시오. ( .As)없는 곳에 0이 있으면 해당 위치가있는 그대로 잡고 엉망이되고, 그렇지 않은 곳에 0이 아닌 경우 !0으로 표시됩니다. 또한 거짓.

테스트 스위트.

주문을 교체하기위한 -1 바이트.

핍 , 31 23 22 바이트

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

이것은 2D 중첩 숫자 목록을 취하는 함수입니다. 온라인으로 사용해보십시오!

설명

여기서 많은 비교가 진행됩니다. 알고 가장 먼저하는 일이 핍에서 비교 연산자는 파이썬에서처럼 서로 연결 될 수 있다는 것입니다 : 5>4>3이다 5>4 and 4>3, (진정한)하지 (5>4)>3(거짓). 두 번째는 =="정확히 같음"연산자에 적용되지 않는 것 입니다. 또 다른 차이점 : 일반 비교 매핑 사업자보다 더 높은 우선 순위를 가지고 있습니다 MC및 MM하면서, 람다 표현식에서 사용할 수있는 ==낮은 우선 순위를 가지고 할 수 없습니다.

{                    }  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 매트릭스의 화면 입력 프롬프트.

클로저, 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하위 행렬의 대각선 요소를 0으로 만들고 모든 행이 같은지 확인하여 작동합니다 .) Jacobian 방법 에서 비슷한 트릭을 사용했습니다 .

concat마지막 부분 은 대각선 + 첫 번째 행과 열을 열거하고 양수인지 확인합니다.

자바 스크립트 (ES6), 58 바이트

자바 스크립트에 대한 내 솔루션 :

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^\=*

마침내 Husk를 묶고 1 바이트만으로 Jelly에게 맞았습니다 ...

설명

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

Mr. Xcoder 덕분에 -2 바이트

온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!

펄 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 (확인) , 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?