Определение

Матрица со стрелками - это матрица , в которой все записи равны 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 массив (так как матрица всегда квадратная)
• Строка (вы выбрали интервал, но не злоупотребляйте этим).

Когда дело доходит до предоставления вывода, вы можете либо сообщить истинное / ложное значение, следуя стандартному определению проблемы решения , либо выбрать любые два различных и непротиворечивых значения.

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

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

Falsy:

[[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не являющихся стрелками (допускается, поскольку любые два различных значения могут использоваться для представления значений 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

Обратите внимание, что результирующие индексы уникальны : в списке нет повторяющихся элементов (и с чего бы это? Нет способа разместить два элемента в одной позиции в массиве).

Наконец, мы используем эту нишу, но =помогаем классифицировать себя. Эта монада сравнивает каждый уникальный элемент со всеми другими элементами в массиве. Помните, как я упоминал, было важно, чтобы полученные признаки были уникальными? Поскольку =-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 Language (Mathematica) , 47 байтов

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

Попробуйте онлайн!

Пояснение: Clip@#заменяет все ненулевые числа в матрице на 1 с, затем мы сравниваем это с массивом с размерами {1,1}Tr[1^#]= {Length@#, Length@#}с 0 в положении i,jкогда 1 < i != j > 1и 1 в противном случае.

(Примерно на основе ответа Уриэля .)

Вот еще одна идея, которая на 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 и используют умножение для определения этих истинных / ошибочных значений.

Сначала мы берем первую строку $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если какой-то элемент был неправильным, либо некоторое ненулевое целое число, если это матрица со стрелкой. Мы дважды получаем Boolean-not, чтобы получить то 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 (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;}

Попробуйте онлайн!

Сохранено 5 байтов благодаря Scottinet!

Повторно использовал тестовый код из этого ответа .

Линейно сканирует массив на предмет любых неправильных значений, возвращая 0 для матрицы стрелок и 1 в противном случае. Мы проверяем путем вычисления исключений или того, равен ли элемент в данной позиции нулю и находится ли эта позиция на стрелке.

Кодирование информации двумерного массива в одно измерение приводит к довольно простому набору условий. Если мы позволим iбыть нашим индексом на основе 0 в nразмерном массиве, то i<nописывает первую строку. Точно так же i%n==0описывает первый столбец иi/n==i%n описывает диагональ.

Лучший трюк, который я нашел для обработки возврата - установить нулевое измерение при возникновении ошибки. Это приводит к немедленному завершению цикла, а затем возврат логического отрицания измерения даст нам одно из двух различных значений. Скоттинет нашел способ заставить 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

Haskell , 62 байта

-3 байта благодаря мистеру Xcoder. -13 байт благодаря пользователю 28667. -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

Попробуйте онлайн!

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в matrix ( .e) захватывает первую и kтретью записи (слева и по диагонали) с помощью ,@bkhи (+ ) всех остальных записей с помощью.Db,0k . Если kне 0, чтобы соответствовать первой строке ( Wk), то !не Mвсе из этих записей. После того, как все они были выбраны, убедитесь, что все они верны. ( .As) Если есть 0, где его не должно быть, то соответствующее местоположение будет захвачено как есть и испортит и, и, если есть ненулевое значение, где его не должно быть, оно будет !записано в 0, что тоже ложь.

Тестирование.

-1 байт для обмена ордерами.

Пип , 31 23 22 байта

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

Эта функция принимает двумерный вложенный список чисел. Попробуйте онлайн!

объяснение

Здесь происходит множество сравнений. Первое, что нужно знать, это то, что операторы сравнения в Pip могут быть соединены вместе, как в Python:5>4>3 is 5>4 and 4>3(true), а не (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-координаты». Этот оператор берет число, генерирует квадратную координатную сетку такого размера и отображает функцию для каждой пары координат (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, поэтому внешнее произведение имеет 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

Проверьте это онлайн!

^{Чувак, это возвращает меня к старым добрым временам, когда Джапт регулярно был намного длиннее, чем другие игры в гольф ...}

К (ок) , 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?