Визначення

Матриця стрілок - це матриця , у якої всі записи дорівнюють 0 , за винятком записів на головному діагоналі, верхньому рядку та в крайньому лівому стовпчику. Іншими словами, матриця повинна виглядати так:

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

Де кожен * - це будь-який ненульовий запис.

Завдання

Давши квадратну матрицю невід’ємних цілих чисел, перевірте, чи це стрілка згідно з визначенням вище.

Ви не можете приймати розмір матриці як вхідний, якщо еквівалент масиву вашої мови не є таким, як вказівник і довжина (як C). Це завжди буде не менше 3 х 3.

Виграє найкоротший код у байтах на кожній мові.

Вхід і вихід

Ви можете вибрати один із наступних форматів для отримання вводу:

• Матриця типу рідної матриці (якщо у вашій мові є)
• 2D масив ¹ (масив 1D масивів, кожен відповідає одному рядку)
• 1D масив (оскільки матриця завжди квадратна)
• Рядок (ви вибрали інтервал, але будь-яким чином не зловживайте цим).

Що стосується надання результату, ви можете або повідомити про значення truthy / falesy, дотримуючись стандартного визначення проблеми рішення , або вибрати будь-які два чітких і послідовних значень.

Більше того, ви можете приймати дані та давати вихід за допомогою будь-якого стандартного методу на будь- якій мові програмування , беручи до уваги, що ці лазівки заборонені за замовчуванням. Якщо ви хочете вибрати будь-який інший формат або не впевнені в чомусь, будь ласка, запитайте у коментарях.

^{_{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 .

Більше тестових випадків

Truthy:

[[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 байт

Збережено 1 байт завдяки edc65

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 байт

-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

По-перше, я хотів би пояснити (і дати кричати) @ ГаленІванов дуже розумним способом створення матриці ідентичності, який полягає в наступному =&/:@}..

Спочатку обезголовляємо вхідну матрицю ( }.).

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

Мова Вольфрама (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 > 11, інакше.

(Приблизно на основі відповіді Уріеля .)

Ось ще одна ідея, яка на 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

Як?

(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, і використовують множення для визначення цих значень truthy / falsey.

Спочатку беремо перший рядок, $a[0]і перевіряємо, чи 0це -inтой масив, зберігаємо його у нашій $oзмінній utput. Якщо що-небудь у цьому рядку дорівнює нулю, то значення $oтакож дорівнює нулю, інакше це одне, що робиться за допомогою швидкого передавання на int +.

Далі ми обводимо цикл 1вгору $a.count-1, встановлюючи $xпо ходу - ми будемо проводити цикл перегляду кожного ряду по одному.

Кожну ітерацію ми встановлюємо допоміжною змінною, $iщоб відслідковувати, на якому рядку ми перебуваємо, а потім переходимо з циклу 0до, $xщоб повторити кожен елемент у цьому рядку. Всередині внутрішньої петлі ми знову множимо $o, на цей раз, вибравши з настройки кортежу як псевдо-потрійний оператор.

Кортеж умовно, !$_-or$_-eq$iговорить, "коли ми знаходимося на 0-му стовпці, або стовпець відповідає рядку (тобто головній діагоналі)", щоб вибрати другу половину кортежу, коли трибути, або першу половину, коли фальси. Кортеж складається з !($y=$a[$i][$_]), $y. Перша половина $yпризначена для гри в другу половину, але в будь-якому випадку ми вибираємо поточний елемент. Перша половина робить булеве заперечення на ній, тоді як друга половина просто сприймає елемент таким, яким він є. Таким чином, якщо ми не знаходимося на 0-му стовпчику, ані на головній діагоналі, ми гарантуємо, що елемент дорівнює нулю, приймаючи булеве значення - не його. Так само ми гарантуємо, що 0-й стовпець або головна діагональ є не нульовим, просто взявши його.

Отже, тепер, коли ми повторили кожен елемент в матриці, $oце буде або 0якщо якийсь елемент був неправильним, або якесь ненульове ціле число, якщо це матриця стрілки. Ми подвійно булеві - не те, щоб отримати або, Falseабо Trueвідповідно, щоб зробити наш вихід послідовним, і це залишилося на конвеєрі, де друк неявний.

Желе , 14 12 байт

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

-2 байти від Pietu1998

Спробуйте в Інтернеті!

Пояснення

[[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 (Діалог) , 21 18 17 байт

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

Спробуйте в Інтернеті!

Як?

Цей іде іншим шляхом -

=/¨∘⍳ - створює матрицю ідентичності

1-⍨⍴ - за n - 1

1⍪1, - додає стовпчик і рядок 1s

≡ - порівнює з

× - оригінальна матриця після того, як вона перейшла до елементарних знаків

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

Спробуйте в Інтернеті!

Збережено 5 байт завдяки Scottinet!

Використовували тестовий код із цієї відповіді .

Лінійно сканує масив на предмет будь-яких невірних значень, повертаючи 0 для матриці стрілки і 1 в іншому випадку. Ми перевіряємо, обчислюючи ексклюзив або чи є елемент у заданій позиції нульовим і чи є ця позиція на стрілці.

Кодування інформації 2D масиву в один вимір призводить до досить простого набору умов. Якщо ми введемо iнаш індекс на основі 0 в nрозмірний масив, то 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 байт

Приймаючи масив як 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)}

Спробуйте в Інтернеті!

Відповідь Луїса Мендо набагато коротша, ніж мій колишній підхід.

Дякуємо 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повертає масив індексів для кожного розміру масиву, у цьому випадку - два.

Отже, коли 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))

Спробуйте в Інтернеті!

Кредити

• Знижений з 92 байт до 90 містером Xcoder

Хаскелл , 62 байти

-3 байти завдяки панові Xcoder. -13 байт завдяки користувачу28667. -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. Якщо k0 не відповідає першому рядку ( Wk), то !не Mвсі ці записи. Після того, як всі вони були відібрані, переконайтесь, що всі вони є правдивими. ( .As) Якщо є 0, де його не повинно бути, то відповідне місце буде схоплено як є, і зіпсує, і, якщо є ненульовий номер, де його не повинно бути, воно буде !помічено до 0, тобто також хибні.

Тестовий набір.

-1 байт для обміну замовленнями навколо.

Піп , 31 23 22 байт

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

Це функція, яка займає 2D вкладений список номерів. Спробуйте в Інтернеті!

Пояснення

Тут відбувається чимало порівнянь. Перше, що потрібно знати, це те, що оператори порівняння в Pip можуть бути пов'язані між собою, як у Python: 5>4>3є 5>4 and 4>3(true), not (5>4)>3(false). Друге - це не стосується ==оператора "точно дорівнює". Ще одна відмінність: регулярні порівняння мають більш високий пріоритет , ніж оператори відображення 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?

Ідея полягає в тому, що Хеск визначає 0 до сили 0 як 1, тому зовнішній виріб має 1s на першому рядку та стовпці. Також 1 на потужність будь-якого числа дорівнює 1, тому зовнішній добуток має 1s по діагоналі. Інші записи дорівнюють 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діагональних елементів підматриці до нуля та перевірки рівності всіх рядків :) Я використовував аналогічний трюк у методі Якобіана .

concatПізніша частина вводить діагональ + перший рядок і стовпець і перевіряє, чи вони позитивні.

Javascript (ES6), 58 байт

Моє рішення для Javascript:

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. Мені, можливо, доведеться дозволити цьому сидіти, щоб я міг придумати кращий спосіб.

-18 байт завдяки @NikoNyrh та створення ярликів для 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?