¿Es mi flecha de matriz?

33

Definición

Una matriz de punta de flecha es una matriz que tiene todas las entradas iguales a 0 , excepto las de la diagonal principal, la fila superior y la columna más a la izquierda. En otras palabras, la matriz debería verse así:

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

Donde cada * es cualquier entrada distinta de cero.

Tarea

Dada una matriz cuadrada de enteros no negativos, verifique si es punta de flecha de acuerdo con la definición anterior.

Es posible que no se toma el tamaño de la matriz como entrada, a menos que el equivalente en su idioma a un arreglo es algo así como un puntero y una longitud (como C). Siempre será al menos 3 x 3.

El código más corto en bytes en cada idioma gana.

Entrada y salida

Puede elegir entre cualquiera de los siguientes formatos para recibir entradas:

  • Una matriz en el tipo de matriz nativa (si su idioma tiene uno)
  • Una matriz 2D 1 (una matriz de matrices 1D, cada una correspondiente a una fila)
  • Una matriz 1D (ya que la matriz siempre es cuadrada)
  • Una cadena (elegiste el espaciado, pero no abuses de esto de ninguna manera).

Cuando se trata de proporcionar resultados, puede informar un valor verdadero / falso siguiendo la definición estándar del problema de decisión , o elegir dos valores distintos y consistentes.

Además, puede tomar entrada y dar salida a través de cualquier método estándar , en cualquier lenguaje de programación , mientras toma nota de que estas lagunas están prohibidas por defecto. Si desea elegir cualquier otro formato o no está seguro acerca de algo, pregunte en los comentarios.

1: o el equivalente de su idioma (lista, vector, etc.)

Ejemplos

Veamos los siguientes ejemplos:

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

Esta es una matriz de punta de flecha (sus programas deben informar un valor verdadero), porque los elementos en la diagonal principal son 1 1 1 1, los de la fila superior 1 2 2 2y los de la columna de la izquierda 1 2 3 4. Todas las demás entradas son 0 , por lo que cumple todas las condiciones.

3 5 6
7 1 0
8 0 0

Esta matriz no es punta de flecha porque hay un 0 en la diagonal principal.

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

Este tampoco es una punta de flecha, porque contiene un 7 en lugar de un 0 .

Más casos de prueba

Verdad:

[[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]]
Sr. Xcoder
fuente
1
¿Es posible que la matriz pueda contener números negativos
Zacharý
2
@ Zacharý No, puede suponer que no son todos negativos .
Sr. Xcoder
Pendiente: una matriz bidimensional y una matriz no son lo mismo, ni es lo mismo que una matriz de matrices. ¿Es aceptable la entrada como una matriz bidimensional si su idioma de elección es lo suficientemente civilizado como para admitir matrices multidimensionales?
Ian Bush
@IanBush Sí, una matriz 2D está totalmente bien.
Sr. Xcoder
9
@ Mr.Xcoder Este sería un desafío suficientemente diferente e interesante si la punta de flecha pudiera apuntar en cualquier dirección
dylnan

Respuestas:

15

Javascript (ES6), 48 47 bytes

Guardado 1 byte gracias a edc65

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

Devuelve las falsematrices de punta de flecha y las matrices truesin punta de flecha (permitido ya que se pueden usar dos valores distintos para representar verdadero y falso)

Casos de prueba:

Herman L
fuente
¡Ahora ese es un enfoque verdaderamente inteligente!
Sr. Xcoder
1
podría funcionar esto? f=m=>m.some((r,y)=>r.some((c,x)=>(x*y&&x!=y)^!c))
edc65
@ edc65 Sin el f=por supuesto;-)
Neil
11

J , 21 20 19 17 15 bytes

-4 bytes gracias a @GalenIvanov.

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

Toma la entrada como una matriz (rango 2).

Pruébalo en línea!

Explicación

Deje que el historial de edición le sirva de lección para no jugar golf y escriba una explicación al mismo tiempo.

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

Explicación visual

Tenga en cuenta que esto se hace en REPL (las entradas se dan comenzando con tres espacios y la salida se da sin espacios iniciales). Debido a eso, a veces omito funciones de composición como @y &dado que las cosas en REPL se evalúan de derecha a izquierda (las funciones son más complejas).

Supongamos que tiene la siguiente matriz de muestra:

   ] 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

Primero, me gustaría explicar (y agradecer) la manera muy inteligente de @GalenIvanov de generar la matriz de identidad, que es la siguiente =&/:@}..

Primero, decapitamos la matriz de entrada ( }.).

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

Luego obtenemos los índices en los que estaría cada fila si las filas se /:ordenaran usando -grade arriba.

   /: }. m
2 1 0

Tenga en cuenta que los índices resultantes son únicos : la lista no tiene elementos duplicados (¿y por qué lo haría? No hay forma de colocar dos elementos en la misma posición en una matriz).

Finalmente, usamos el nicho pero útil: =auto-clasificar. Esta mónada compara cada elemento único con todos los demás elementos en una matriz. ¿Recuerdas cómo mencioné que era importante que las indicaciones resultantes fueran únicas? Dado que =-self-classify realiza las comparaciones en el orden en que aparecen los elementos únicos en la lista, el resultado resultante será la matriz de identidad para una entrada única (es por eso =@i.que puede hacer una matriz de identidad de una longitud determinada).

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

Una vez que tenemos la matriz de identidad, se trata de agregar una fila de unos y una columna de unos, lo que se hace de manera muy simple (si se le da un átomo, es decir, un solo elemento, la ,familia lo repetirá para llenar cuando se agregue) :

   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

Luego simplemente comparamos la matriz de punta de flecha generada con el signo de la matriz de entrada.

   * m
1 1 1 1
1 1 0 0
1 0 1 0
1 0 0 1
   (* m) -: (1, 1,. =&/:@}. m)
1
col
fuente
2
¿No es *suficiente en lugar de 0@<(para 17 bytes)? Pruébalo
Galen Ivanov
1
@GalenIvanov buena captura, creo que sí. ¡Gracias! Es hora de volver a editar la explicación jajaja.
cole
1
Creo que encontré una nueva forma de generar la matriz de identidad: =&/:cuando la combiné }., obtuve esto *-:1,1,.=&/:@}.por 15 bytes. ¡ Pruébelo en línea!
Galen Ivanov
1
@GalenIvanov enfoque brillante (tanto el uso de -grade /:y }.-behead), ¡gracias de nuevo! Lo editaré.
cole
Hmm, de hecho *-:1,1,.=@}.funciona bien, no hay necesidad de una forma elegante de encontrar la matriz de identidad. Puede generar una matriz de identidad a partir de la matriz cuadrada simplemente mediante =. Por lo tanto, suelte una fila con }., cree la matriz de identidad con = , agregue una fila y una columna con, 1etc.
Galen Ivanov
9

Wolfram Language (Mathematica) , 47 bytes

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

Pruébalo en línea!

Explicación: Clip@#reemplaza todos los números distintos de cero en la matriz con 1s, luego lo comparamos con una matriz con dimensiones {1,1}Tr[1^#]= {Length@#, Length@#}con 0 en posición i,jcuando 1 < i != j > 1, y 1 en caso contrario.

(Aproximadamente basado en la respuesta de Uriel ).

Aquí hay otra idea que tiene 16 bytes más: siéntase libre de robarla si puede jugar golf:

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

Pruébalo en línea!

No un arbol
fuente
8

APL (Dyalog Classic) , 19 16 15 13 bytes

-1 byte gracias a @ErikTheOutgolfer

( ⎕IO←0)

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

Pruébalo en línea!

-2 bytes gracias a @ngn y @ H.PWiz

¿Cómo?

(Matriz de entrada 2D S )

  • ×≡Compruebe si S es positivo solo en ...
  • (∧=⌊ ... las diagonales o la fila superior y la columna izquierda ...
  • )/¨∘⍳∘⍴... de S .
Zacharý
fuente
Buena utilización del ⍳∘⍴producto cartesiano.
Uriel
×≡(=/∨1∊⊢)¨∘⍳∘⍴
Erik the Outgolfer
1
(=/∨1∊⊢)->(~≠⌊⌊)/
ngn
2
@ngn Aún mejor: (∧=⌊)/por supuesto, ambos requieren⎕IO←0
H.PWiz
7

PowerShell , 112 108 bytes

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

Pruébalo en línea!

Toma datos y los manipula como una matriz de matrices, ya que PowerShell no admite matrices (fuera del soporte de matrices de transformación Direct3D de .NET, que es algo completamente diferente).

Todo el algoritmo se basa en el hecho de que los números distintos de cero son verdaderos y cero es falsey en PowerShell, y utiliza la multiplicación para determinar esos valores de verdad / falsey.

Primero tomamos la primera fila, $a[0]y verificamos si 0es -inesa matriz, la almacenamos en nuestra $ovariable de rendimiento. Si algo en esa fila es cero, entonces $otambién es cero, de lo contrario es uno, hecho por un rápido cast-to-int con +.

A continuación, recorremos de 1arriba a abajo $a.count-1, configurando $xen el camino: vamos a recorrer cada fila de una en una.

En cada iteración establecemos la variable auxiliar $ipara realizar un seguimiento de la fila en la que estamos, luego hacemos un bucle desde 0hasta $xpara iterar cada elemento en esta fila. Dentro del bucle interno, nuevamente estamos multiplicando $o, esta vez seleccionando desde una configuración de tupla como un operador pseudoternario.

El condicional de la tupla !$_-or$_-eq$idice "cuando estamos en la columna 0 o la columna coincide con la fila (es decir, la diagonal principal)" para seleccionar la segunda mitad de la tupla cuando es verdadera o la primera mitad cuando es falsa. La tupla se compone de !($y=$a[$i][$_]), $y. La primera mitad establece $ypara jugar golf la segunda mitad, pero de cualquier manera estamos seleccionando el elemento actual. La primera mitad hace negación booleana, mientras que la segunda mitad solo toma el elemento tal como está. Por lo tanto, si no estamos en la columna 0 ni en la diagonal principal, nos aseguramos de que el elemento sea cero al quitarle el booleano. Del mismo modo, nos aseguramos de que la columna 0 o la diagonal principal no sea cero simplemente tomándola.

Entonces, ahora que hemos iterado a través de cada elemento en la matriz, $oserá 0si algún elemento era incorrecto o algún número entero distinto de cero si es una matriz de punta de flecha. Hacemos doble booleano, no para obtener uno Falseo Truerespectivamente, para que nuestra salida sea coherente, y eso queda en la tubería donde la impresión está implícita.

AdmBorkBork
fuente
+= [int]? Eso es bueno.
raíz
@root Uno de los consejos de PowerShell .
AdmBorkBork
7

Jalea , 14 12 bytes

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

-2 bytes de Pietu1998

Pruébalo en línea!

Explicación

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

Use la matriz anterior como entrada de ejemplo.

Œ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 Ẹ
dylnan
fuente
@ wizzwizz4 No estoy seguro de lo que quieres decir
dylnan
@ wizzwizz4 este código muestra cómo se reagrupan los elementos de la matriz. Toma la diagonal superior, izquierda y principal. ¿Es esto lo que quisiste decir?
dylnan
Me refería a la representación visual real del código que proporcionó en su explicación. Estaba tratando de ser gracioso, pero obviamente no funcionó. Limpiaré estos comentarios.
wizzwizz4
7

APL (Dyalog) , 21 18 17 bytes

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

Pruébalo en línea!

¿Cómo?

Este va a la inversa:

=/¨∘⍳ - crea la matriz de identidad

1-⍨⍴ - para n - 1

1⍪1, - antepone una columna y una fila de 1s

- se compara con

× - la matriz original, después de que se haya convertido en una firma de elementos sabios

Uriel
fuente
6

MATL , 15 bytes

gtZyXy,!llY(]X=

La entrada es una matriz (que se usa ;como separador de filas). La salida es 1para punta de flecha, de lo 0contrario.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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
Luis Mendo
fuente
1
¿Qué es exactamente la matriz Indeity ?
Erik the Outgolfer
13
@EriktheOutgolfer obviamente una matriz que contiene una deidad.
cole
55
@cole quizás relacionado con una matriz sobre el campo Elysian
jld
5

C (gcc) ,80 75 bytes

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

Pruébalo en línea!

¡Guardado 5 bytes gracias a scottinet!

Reutilizó el código de prueba de esta respuesta .

Escanea linealmente la matriz en busca de valores incorrectos, devolviendo 0 para una matriz de punta de flecha y 1 en caso contrario. Verificamos calculando el exclusivo o si el artículo en una posición dada es cero y si esa posición está en la flecha.

Codificar la información de la matriz 2D en una dimensión conduce a un conjunto bastante simple de condiciones. Si dejamos iser nuestro índice basado en 0 en la nmatriz dimensional, entonces se i<ndescribe la primera fila. Del mismo modo, i%n==0describe la primera columna y i/n==i%ndescribe la diagonal.

El mejor truco que encontré para manejar el retorno es establecer la dimensión a cero cuando se encuentra con un error. Esto hace que el ciclo finalice de inmediato, y luego devolver la negación lógica de la dimensión nos dará uno de dos valores distintos. scottinet encontró la manera de hacer que GCC lo devolviera más amablemente.

FryAmTheEggman
fuente
-2 bytes con algo más de golf
scottinet
y -4 bytes adicionales al abusar de la forma en que gcc devuelve valores
scottinet
@scottinet ¡Gracias! Estaba teniendo problemas para averiguar qué valor debería establecer para usar ese truco.
FryAmTheEggman
En realidad, no creo que tu primer golf funcione. Pasó los casos de prueba porque nunca hubo un cero en la primera posición. Se agregó un caso y se revirtió ese cambio.
FryAmTheEggman
int test0 [] = {0, 1, 1, 1, 1, 0, 1, 0, 1}; printf ("% d \ n", f (prueba0, 3)); Tiene que devolver 0, no 1 (si es la matriz 3x3 011 110 101) porque un [0,0] es 0
RosLuP
5

Python 2 , 75 bytes

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

Pruébalo en línea!

Python 2 , 85 bytes

Tomando la matriz como una matriz 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))

Pruébalo en línea!

FlipTack
fuente
¿Quiso decir "matriz 1D" en la solución superior?
NikoNyrh
@NikoNyrh oops, arreglado
FlipTack
5

R , 78 70 69 68 54 53 bytes

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

Pruébalo en línea!

Portar la respuesta de Luis Mendo es mucho más corto que mi enfoque anterior.

¡Gracias a rturnbull por señalar un error y jugar golf por un byte!

respuesta anterior, 68 bytes:

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

Pruébalo en línea!

La respuesta de duckmayr prueba que todas las entradas en la diagonal principal y la primera fila / columna ( m[i]) son distintas de cero y el resto ( m[-i]) son cero, utilizando una buena aritmética para obtener la diagonal y la primera fila.

Sin embargo, esta respuesta prueba para asegurarse de que (1) las entradas cero no están en la diagonal principal o la primera fila / columna, y (2) que hay, dada una n x nmatriz, 3*n-2entradas distintas de cero.

whichdevuelve los índices donde está su entrada TRUE, y con el opcional arr.ind=T, devuelve una matriz de índices para cada dimensión de matriz, en este caso, dos.

Por lo tanto any(i[,1]==i[,2]), cuando existe un cero en la diagonal y cuando any(i==1)existe un cero en la primera fila o la primera columna.

Finalmente, una pequeña aritmética muestra que el número de entradas distintas de cero debe ser 3*n-2, ndesde la primera columna, n-1desde la diagonal y n-1desde la primera fila.

Giuseppe
fuente
Esto no parece funcionar para matrices de flechas donde los valores no son 1. ¿Quiso decir all(!m==!d)en la última línea?
rturnbull
@rturnbull, ¡ah! Gracias. La sintaxis del operador R es muy extraña. Realmente quise decir, (!!m)==dpero !tiene menor prioridad que ==. Sin d==!!membargo, creo que debería hacer el truco.
Giuseppe
Parece que d!=!mhace lo mismo, por un byte menos. Puede guardar otro byte utilizando la pryr::fsintaxis en lugar de functiontambién.
rturnbull
Traté de jugar al golf, pero lo mejor que puedo hacer es 53 .
JayCe
@ JayCe nah, tanto tu respuesta como la mía se pueden jugar al 52, y no estoy seguro de por qué no se me ocurrió antes ... Publicaría la tuya como separada; el enfoque de una línea es bastante agradable y sospecho que puede haber más margen de mejora en el suyo
Giuseppe
3

Haskell , 62 bytes

-3 bytes gracias al Sr. Xcoder. -13 bytes gracias al usuario 28667. -5 bytes gracias a Zgarb.

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

Pruébalo en línea!

totalmente humano
fuente
1
80 bytes ... ¿Casi siempre te olvidas de <1esos trucos? : P
Sr. Xcoder
1
(x==y||x==0||y==0)==(m!!y!!x/=0)debería ser más corto
user28667
1
62 bytes comprimiendo en lugar de indexar, y haciendo x*y<1.
Zgarb
3

Python 3 , 72 71 bytes

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

¡Gracias a @xnor por jugar golf en 1 byte!

Pruébalo en línea!

Dennis
fuente
Creo que 0<i!=j>0ahorra un byte,
XNOR
@xnor Gracias! Creo que nunca he reutilizado un número en una cadena de comparación ...
Dennis
2

Pyth, 22 21 bytes

Definitivamente este no es el lenguaje para la manipulación matricial.

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

Para cada fila by su índice ken la matriz ( .e), toma la primera y la ktercera entrada (lado izquierdo y diagonal) con ,@bkhy ( +) todas las otras entradas con .Db,0k. Sik no corresponde a 0 con la primera fila ( Wk), entonces !no Mtodas esas entradas. Una vez que todos hayan sido seleccionados, asegúrese de que todos sean verdaderos. ( .As) Si hay un 0 donde no debería haberlo, entonces la ubicación correspondiente se tomará como está y desordenará el y, y si hay un valor distinto de cero donde no debería haberlo, se !anotará a 0, que es También falso.

Banco de pruebas.

-1 bytes para intercambiar las órdenes.

Steven H.
fuente
1
Wow, esta solución es realmente buena dado que Pyth es bastante paralelo con la manipulación de matrices. Probablemente mañana para otro duelo de Pyth: P
Sr. Xcoder
Es posible que pueda acortar esto usando @VQUQo .DVQUQ Para diagonales / eliminar diagonales. Pero eso requeriría un enfoque completamente diferente. Aunque no estoy seguro ... (¿BTW olvidó actualizar el enlace?)
Sr. Xcoder
@ Mr.Xcoder Enlace fijo, intentaré jugar con otras estrategias mañana.
Steven H.
Llegué a una alternativa de 21 byter usando mi VQUQidea: >.A++hCQhQ.(VQUQsstCt. Sin embargo, esto parece muy redundante. Es posible que pueda modificarlo para ahorrar algunos bytes.
Sr. Xcoder
2

Pip , 31 23 22 bytes

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

Esta es una función que toma una lista anidada 2D de números. Pruébalo en línea!

Explicación

Aquí hay muchas comparaciones. Lo primero que debe saber es que los operadores de comparación en Pip se pueden encadenar juntos, como en Python: 5>4>3es 5>4 and 4>3(verdadero), no (5>4)>3(falso). El segundo es que esto no se aplica al ==operador "exactamente igual". Otra diferencia: las comparaciones regulares tienen mayor prioridad que los operadores de asignación MCy MMy pueden ser utilizados en las expresiones lambda, mientras que ==tiene menor precedencia y no puede.

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

Para generar la primera matriz, usamos MC"map-coords". Este operador toma un número, genera una cuadrícula de coordenadas cuadradas de ese tamaño y asigna una función a cada par de coordenadas (x, y), devolviendo una lista de listas de resultados. Por ejemplo,{a+b} MC 3 daría el resultado [[0; 1; 2]; [1; 2; 3]; [2; 3; 4]].

Aquí, el tamaño de la cuadrícula es #a, el tamaño de nuestro argumento original. La función es 0<_!=B>0, que es una forma más corta de escribir {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

Esto devuelve 0 para la primera fila / columna y la diagonal principal, y 1 en otro lugar.

DLosc
fuente
2

Casco , 12 11 bytes

S≡ȯ´Ṫ§^*=ŀL

Pruébalo en línea!

Explicación

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?

La idea es que Husk define 0 a la potencia de 0 como 1, por lo que el producto externo tiene 1s en la primera fila y columna. Además, 1 a la potencia de cualquier número es 1, por lo que el producto externo tiene 1s en la diagonal. Otras entradas son 0 a la potencia de algún número positivo, que es 0. Esto da una matriz de punta de flecha binaria, que comparamos con la entrada con .

Zgarb
fuente
2

APL + WIN, 36 33 bytes

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

Solicita la entrada en pantalla de una matriz APL 2d.

Graham
fuente
2

Clojure, 128 95 92 85 bytes

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

Siempre es emocionante ver dos corchetes de apertura consecutivos.

Versión original:

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

La primera parte funciona assoccolocando elementos diagonales de la submatriz en cero y verificando que todas las filas sean iguales :) Usé un truco similar en el método jacobiano .

La parte concatposterior activa la diagonal + primera fila y columna y comprueba que sean positivas.

NikoNyrh
fuente
2

Javascript (ES6), 58 bytes

Mi solución para Javascript:

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

No es tan inteligente como la respuesta de Herman , pero sentí que debería publicarlo aquí también.

Pedro Corso
fuente
3
Bienvenido a PPCG!
Steadybox
2

Clojure, 212 206 188 bytes

-6 bytes eliminando algunos espacios perdidos y atajos range. Puede que tenga que dejar que esto se asiente para poder pensar en una mejor manera.

-18 bytes gracias a @NikoNyrh, y creando atajos para 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, simplemente horrible. No sé por qué no puedo entender una solución razonable.

Toma un vector anidado como entrada.

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

Intenté reescribir esto desde cero usando un método diferente, y terminó por más tiempo. En lugar de tallar manualmente las secciones de "descanso" de la matriz, decidí intentar generar todas las coordenadas en la matriz, generar las coordenadas de la punta de flecha, y luego usar clojure.set/differencepara obtener las celdas sin punta de flecha. Desafortunadamente, la llamada a ese incorporado es costosa:

223 bytes

(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))))
Carcigenicate
fuente
Hay bastante margen de mejora, por ejemplo, #(drop 1 %)es igual resty #(not(zero? %))es igual que pos?(ya que tenemos números no negativos). Es posible que desee echar un vistazo a mi respuesta de 128 bytes, que tiene un enfoque similar a este. Después de implementar eso, me di cuenta de que es muy corto tratar con el acceso basado en índices en un ciclo for.
NikoNyrh
@NikoNyrh Ya, no estaba muy bien ese día. No sé cómo me olvidé rest. Probablemente debería descartar este intento e intentarlo de nuevo.
Carcigenicate
2

Stax , 11 bytes CP437

ä¢⌠┐xⁿtH↔BU

Pruébalo en línea!

Versión desempaquetada con 13 bytes:

B|AsF:10i^\=*

Finalmente atado a Husk y golpeado por Jelly por solo un byte ...

Explicación

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
Weijun Zhou
fuente
1

R , 81 79 bytes

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 bytes gracias al Sr. Xcoder

Pruébalo en línea!

Duckmayr
fuente
79 bytes .
Sr. Xcoder
Muy agradable; Logré encontrar un byte de 78 que está haciendo algo muy extraño, pero también encontré un tuyo de 76 bytes .
Giuseppe
¡69 bytes pero mejoré el mío a 68!
Giuseppe
1

C, 117 bytes

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

Pruébalo en línea!

Steadybox
fuente
1

PowerShell , 186 bytes

$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

Pruébalo en línea!

raíz
fuente
2
Algunos campos de golf: se utilizan param($a)para recibir información, se -containspueden cambiar por uno -iny todos -eq0se pueden intercambiar !. Finalmente, puede realizar un bucle desde 1arriba $a.lengthy deshacerse del if($_-ne0)cuerpo del bucle.
AdmBorkBork
1

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

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)

Pruébalo en línea!

Xcali
fuente
1

Japt , 16 bytes

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

¡Pruébelo en línea!

Hombre, esto me lleva de vuelta a los viejos tiempos cuando Japt era regularmente mucho más tiempo que otros langos de golf ...

ETHproducciones
fuente
1

K (oK) , 27 30 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Debo estar haciendo algo tonto ya que las soluciones APL son menos de la mitad del conteo de bytes ...

Pasaron 24 bytes creando la punta de flecha. orjuntas las siguientes tres matrices:

/ 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

Desglose completo:

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?
callejero
fuente