Tenga en cuenta que este desafío no requiere manejo o comprensión de números complejos.

Dada una matriz cuadrada no vacía donde cada elemento es una lista entera de dos elementos (Re, Im), determine (dando cualquier valor verdadero / falso o cualquiera de los dos valores consistentes) si esto representa una matriz hermitiana.

Tenga en cuenta que la entrada es una matriz 3D de enteros; no una matriz 2D de números complejos. Si su idioma no puede tomar una matriz 3D directamente, puede tomar una lista plana (y la forma n × n o n × n × 2 si eso ayuda).

Una matriz es hermitiana si es igual a su propia transposición conjugada . En otras palabras, si lo voltea sobre su diagonal superior izquierda a inferior derecha y niega el segundo elemento de todas las listas de hojas de dos elementos, es idéntico a la matriz de entrada. Tenga en cuenta que el orden de voltear y negar es irrelevante, por lo que puede negar primero y voltear después.

Ejemplo de recorrido

Este ejemplo usa JSON con espacios en blanco superfluos para facilitar la lectura:

[[ [2, 0] , [2, 1] , [4, 0] ],
 [ [2,-1] , [3, 0] , [0, 1] ],
 [ [4, 0] , [0,-1] , [1, 0] ]]

Transposición (voltear a través de NW-SE diagonal):

[[ [2, 0] , [2,-1] , [4, 0] ],
 [ [2, 1] , [3, 0] , [0,-1] ],
 [ [4, 0] , [0, 1] , [1, 0] ]]

Negar los segundos elementos de las listas de hojas:

[[ [2, 0] , [2, 1] , [4, 0] ],
 [ [2,-1] , [3, 0] , [0, 1] ],
 [ [4, 0] , [0,-1] , [1, 0] ]]

Como esto es idéntico a la entrada, la matriz es hermitiana.

Casos de prueba

Ermitaño

[[[2,0],[2,1],[4,0]],[[2,-1],[3,0],[0,1]],[[4,0],[0,-1],[1,0]]]

[[[1,0],[2,0]],[[2,0],[1,0]]]

[[[1,0],[2,-3]],[[2,3],[1,0]]]

[[[42,0]]]

No ermitaño

[[[2,0],[2,1],[4,0]],[[2,-1],[3,0],[0,1]],[[4,0],[0,-1],[1,-1]]]

[[[0,1],[0,2]],[[0,2],[0,1]]]

[[[1,0],[2,3]],[[2,3],[1,0]]]

[[[3,2]]]

R, 71 48 47 bytes

function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)

Toma una matriz 3D de números reales, crea una matriz 2D de números imaginarios, transpone, conjuga y compara.

¡Gracias a @Giuseppe por reducir el recuento de bytes en la asombrosa cantidad de 23 bytes, y a @Vlo por el último 1!

Pruébalo en línea!

Ejemplo:

> A <- array(c(2,2,4,2,3,0,4,0,1,0,-1,0,1,0,-1,0,1,0),dim=c(3,3,2))
> A
, , 1

     [,1] [,2] [,3]
[1,]    2    2    4
[2,]    2    3    0
[3,]    4    0    1

, , 2

     [,1] [,2] [,3]
[1,]    0    1    0
[2,]   -1    0    1
[3,]    0   -1    0

> f <- function(A)all(Conj(t(B<-A[,,1]+A[,,2]*1i))==B)
> f(A)
[1] TRUE

Octava , 39 34 31 bytes

@(x)(y=x(:,:,1)+j*x(:,:,2))==y'

Pruébalo en línea!

Ahorré 3 bytes gracias a Luis Mendo, quien me informó sobre las aclaraciones en el texto del desafío.

Explicación:

En MATLAB y Octave, ' es la transposición del complejo conjugado, no la transposición "regular".

Creamos una variable y línea que es la primera capa de la matriz 3D más la segunda capa multiplicada con la unidad compleja j, es decir, una matriz compleja donde el término real es la primera "capa", y el imaginario es la segunda "capa". Luego verificamos si es igual al conjugado complejo transpuesto.

Esto generará una matriz que contiene solo 1si es verdadera, y una matriz que contiene al menos una 0si es falsa. Estos se consideran verdaderos y falsos en Octave (Proof) .

Python 2 , 50 bytes

lambda m:[[[a,-b]for a,b in l]for l in zip(*m)]==m

Pruébalo en línea!

APL (Dyalog Unicode) , 22 15 9 7 bytes

⍉≡⊢∘-\¨

Pruébalo en línea!

Función de prefijo tácito.

Gracias a Adám por 7 bytes en el Dfn, y a Adám y ErikTheOutgolfer por aguantar mi estupidez. ayudándome a encontrar la versión tácita.

Gracias a ngn por 2 bytes en la versión tácita.

¿Cómo?

⍉≡⊢∘-\¨ ⍝ Anonymous tacit function.
      ¨ ⍝ Apply to each element of the argument:
     \  ⍝ Cumulative reduction, using
  ⊢∘-   ⍝ Ignore the first element, then negate the second
 ≡      ⍝ And match
⍉       ⍝ To the argument's transposition.

Wolfram Language (Mathematica) , 45 34 33 26 21 18 bytes

• Once bytes guardados gracias a JungHwan Min .
• Salvó un byte gracias a Martin Ender .
• Guardado siete bytes gracias a alephalpha .
• Guardado cinco bytes gracias a alephalpha .
• Guardado tres bytes.

#==#&[#.{1,I}]&

Pruébalo en línea!

Java 8, 137 136 134 126 119 bytes

m->{int r=1,l=m.length,i=l,j;for(;i-->0;)for(j=l;j-->0;)r=m[i][j][0]!=m[j][i][0]|m[i][j][1]!=-m[j][i][1]?0:r;return r;}

Devuelve 1si Hermitian, de lo 0contrario.

Explicación:

Pruébalo en línea.

m->{                 // Method with 3D integer-array as parameter and boolean return-type
  int r=1,           //  Flag-integer `r`, starting at 1
      l=m.length,    //  The size of the 3D input array
      i=l,j;         //  Index-integers
  for(;i-->0;)       //  Loop over the rows
    for(j=l;j-->0;)  //   Inner loop over the columns
      r=m[i][j][0]!=m[j][i][0] 
                     //    If the first numbers diagonally aren't equal,
        |m[i][j][1]!=-m[j][i][1]?
                     //    or the second numbers aren't negatives of each other:
         0           //     Set the flag `r` to 0
        :            //    Else:
         r;          //     Leave the flag `r` the same
  return r;}         //  Return the flag `r`

J , 14 bytes

[:(+-:|:)j./"1

Pruébalo en línea!

Explicación

[:(+-:|:)j./"1  Input: 3d array
         j./"1  Reduce by complex combine at rank 1
[:              Cap, operate on the 2d array of complex values
   +              Conjugate
      |:          Transpose
    -:            Match?

Haskell , 50 bytes

-7 bytes gracias a H.PWiz.

(==)<*>map(map((0-)<$>)).foldr(zipWith(:))e
e=[]:e

Pruébalo en línea!

Jalea ,  6  5 bytes

Z×Ø+⁼

Un enlace monádico que regresa 1para una entrada hermitiana y de lo 0contrario.

Pruébalo en línea!

¿Cómo?

Z×Ø+⁼ - Link: list of lists of lists, M
Z     - transpose
  Ø+  - literal = [1,-1]
 ×    - multiply (vectorises)
    ⁼ - equal to M?

05AB1E , 9 bytes

øεεX®‚*]Q

Pruébalo en línea!

Explicación

ø           # transpose
 ε          # apply to each 2-d array
  ε         # apply to each pair
   X®‚*     # multiply by [1,-1]
       ]    # end apply(s)
        Q   # compare to input for equality

Ruby , 46 bytes

->m{m.transpose.map{|l|l.map{|a,b|[a,-b]}}==m}

Pruébalo en línea!

Puerto de mi respuesta de Python

Perl 5 , -a0 48 bytes

Conteo anterior: 50 bytes ( +2paraa0 ). No está mal para un idioma que no tiene transposición incorporada (no estoy celoso en absoluto, no señor)

Dé la matriz de entrada en STDIN ,entre la parte real e imaginaria, por ejemplo:

2,0 2,1 4,0
2,-1 3,0 0,1
4,0 0,-1 1,0

Se imprimirá 1para ermitaño, nada de lo contrario

#!/usr/bin/perl -a0
say@F~~[map/(\S+,)(\S+)/gc?$1.-$2:(),(/.+/g)x@F]

Pruébalo en línea!

Casco , 7 bytes

=¹mmṀ_T

Pruébalo en línea!

¿Cómo?

Tenga en cuenta que †debería funcionar en lugar de mm , pero hay un error molesto que me impide usarlo :(

= ¹mmṀ_T - Programa completo. Toma información de los argumentos de la línea de comando, como una lista de listas de tuplas.
  m T - Para cada lista en la transposición de la entrada ...
   mṀ_ - ... Niega el último valor de cada tupla que contienen.
= ¹ - Verifique si esto es lo mismo que la entrada.

JavaScript (ES6), 53 bytes

Guardado 2 bytes gracias a @Neil

Devoluciones falsepara Hermitian o truepara no Hermitian.

m=>m.some((r,y)=>r.some(([a,b],x)=>m[x][y]!=a+[,-b]))

Pruébalo en línea!

C (gcc) , 107 103 100 bytes

• Guardado cuatro bytes gracias a Steadybox ; Golfizado A[0]a *Ados veces.
• Guardado tres bytes gracias a ceilingcat .

j,k,r;f(A,s)int***A;{for(r=0,j=s;j--;)for(k=s;k--;)r|=*A[j][k]-*A[k][j]|A[j][k][1]+A[k][j][1];A=!r;}

Pruébalo en línea!

Realmente , 13 bytes

┬⌠⌠Çá╫k⌡M⌡Mß=

Pruébalo en línea!

¿Cómo funciona?

Esta presentación en realidad hace uso de números complejos. Si se permitiera la entrada como una matriz de entradas complejas, sería de 8 bytes .

┬⌠⌠Çá╫k⌡M⌡Mß=  –> Full program.
┬              –> Transpose.
 ⌠       ⌡M    –> For each list in the input's transpose do the following:
  ⌠    ⌡M         –> For each two-element list of the form [a, b]...
   Ç              –> Turn it into a complex number (a+bi).
    á             –> Find its complex conjugate: Push (a-bi).
     ╫k           –> Push [Re(N), Im(N)], so [a, -b].
           ß=  –> Check whether the result equals the input.

Pyth, 9 bytes

qCmm,hk_e

Explicación:

qCmm,hk_ekdQQ  Autofill variables
    ,hk_ek     [a,-b]...
  mm      dQ    ...for each [a,b] in the input (m...Q)'s rows (m...d).
 C             Transpose.
q           Q  Is this result equal to the original?

Banco de pruebas .

C,  111   110  108 bytes

¡Gracias a @Jonathan Frech por guardar un byte y gracias a @ceilingcat por guardar dos bytes!

i,j,r;f(A,n)int*A;{for(r=i=0;i<n*2;i+=2)for(j=n*2;j;r|=A[i*n+j]-A[j*n+i]|A[i*n-~j]+A[j*n-~i])j-=2;return!r;}

Pruébalo en línea!

C (gcc) ,  106104  bytes

i,j,r;f(A,n)int*A;{for(r=i=0;i<n*2;i+=2)for(j=n*2;j;r|=A[i*n+j]-A[j*n+i]|A[i*n-~j]+A[j*n-~i])j-=2;A=!r;}

Pruébalo en línea!

En realidad , 13 bytes

;┬⌠⌠d±@q⌡M⌡M=

Pruébalo en línea!

Explicación:

;┬⌠⌠d±@q⌡M⌡M=
;              make a copy
 ┬             transpose copy
  ⌠⌠d±@q⌡M⌡M   for each row:
   ⌠d±@q⌡M       for each cell in row:
    d              remove last element from list
     ±             swap sign
      @q           insert at end of list
            =  compare equality with original