Observe que esse desafio não requer manipulação ou entendimento de números complexos.

Dada uma matriz quadrada não vazia onde cada elemento é uma lista inteira de dois elementos (Re, Im), determine (fornecendo quaisquer valores de verdade / falsidade ou quaisquer dois valores consistentes) se isso representa uma matriz hermitiana.

Observe que a entrada é uma matriz 3D de números inteiros; não é uma matriz 2D de números complexos. Se o seu idioma não puder usar uma matriz 3D diretamente, você poderá fazer uma lista simples (e o formato n × n ou n × n × 2, se isso ajudar).

Uma matriz é hermitiana se igualar sua própria transposição de conjugado . Em outras palavras, se você girá-lo na diagonal superior esquerda para inferior direita e negar o segundo elemento de todas as listas de folhas de dois elementos, ele será idêntico à matriz de entrada. Observe que a ordem de virar e negar é irrelevante; portanto, você pode negar primeiro e virar depois.

Exemplo de passeio

Este exemplo usa JSON com espaço em branco supérfluo para facilitar a leitura:

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

Transposição (vire na diagonal NW-SE):

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

Negue os segundos elementos das listas:

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

Como isso é idêntico à entrada, a matriz é hermitiana.

Casos de teste

Hermitian

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

Não-eremita

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

Pega uma matriz 3D de números reais, cria uma matriz 2D de números imaginários, transpõe, conjuga e compara.

Agradecemos a @ Giuseppe por reduzir a contagem de bytes em 23 bytes surpreendentes e a @Vlo no final 1!

Experimente online!

Exemplo:

> 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

Oitava , 39 34 31 bytes

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

Experimente online!

Economizei 3 bytes graças a Luis Mendo, que me informou sobre os esclarecimentos no texto do desafio.

Explicação:

Em MATLAB e Octave, 'é a transposição do complexo conjugado, não a transposição "regular".

Criamos uma variável variável yque é a primeira camada da matriz 3D mais a segunda camada multiplicada pela unidade complexa j, ou seja, uma matriz complexa em que o termo real é a primeira "camada" e o imaginário é a segunda "camada". Em seguida, verificamos se ele se iguala ao complexo conjugado transposto.

Isso produzirá uma matriz contendo apenas 1se for verdadeira e uma matriz contendo pelo menos uma 0se for falsa. Estes são considerados verdadeiros e falsos na oitava (prova) .

Python 2 , 50 bytes

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

Experimente online!

APL (Dyalog Unicode) , 22 15 9 7 bytes

⍉≡⊢∘-\¨

Experimente online!

Função de prefixo tácito.

Agradeço a Adám por 7 bytes no DFN, e a Adám e ErikTheOutgolfer por suportar minha estupidez, ajudando-me a encontrar a versão tácita.

Obrigado a ngn por 2 bytes na versão tácita.

Quão?

⍉≡⊢∘-\¨ ⍝ 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

• Economizou onze bytes graças a JungHwan Min .
• Guardou um byte graças a Martin Ender .
• Economizou sete bytes graças ao alephalpha .
• Economizou cinco bytes graças a alephalpha .
• Salvo três bytes.

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

Experimente online!

Java 8, 137 136 134 134 126 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;}

Retorna 1se Hermitian, 0caso contrário.

Explicação:

Experimente online.

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

Experimente online!

Explicação

[:(+-:|:)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 graças a H.PWiz.

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

Experimente online!

Gelatina ,  6  5 bytes

Z×Ø+⁼

Um link monádico retornando 1para uma entrada Hermitian e 0outros.

Experimente online!

Quão?

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

05AB1E , 9 bytes

øεεX®‚*]Q

Experimente online!

Explicação

ø           # 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}

Experimente online!

Porta da minha resposta Python

Perl 5 , -a0 48 bytes

Contagem antiga: 50 bytes ( +2para a0). Nada mal para uma linguagem que não tem transposição embutida (não tenho ciúmes, nem senhor)

Dê a matriz de entrada no STDIN ,entre a parte real e a imaginária, por exemplo:

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

Imprimirá 1para eremita, nada de diferente

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

Experimente online!

Casca , 7 bytes

=¹mmṀ_T

Experimente online!

Quão?

Observe que †deve funcionar em vez de mm , mas há um bug irritante que me impede de usá-lo :(

= ¹mmṀ_T - Programa completo. Recebe a entrada dos argumentos da linha de comando, como uma lista de listas de tuplas.
  m T - Para cada lista na transposição da entrada ...
   mṀ_ - ... Negue o último valor de cada tupla que eles contêm.
= ¹ - Verifique se é igual à entrada.

JavaScript (ES6), 53 bytes

Guardado 2 bytes graças a @Neil

Retorna falsepara Hermitian ou truepara não-Hermitian.

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

Experimente online!

C (gcc) , 107 103 100 bytes

• Economizou quatro bytes graças ao Steadybox ; golfed A[0]a *Aduas vezes.
• Economizou três bytes graças ao 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;}

Experimente online!

Na verdade , 13 bytes

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

Experimente online!

Como funciona?

Esse envio realmente usa números complexos. Se a entrada como uma matriz de entradas complexas fosse permitida, seriam 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.

Pitão, 9 bytes

qCmm,hk_e

Explicação:

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?

Conjunto de teste .

C,  111   110  108 bytes

Obrigado a Jonathan Frech por salvar um byte e a @ceilingcat por salvar dois 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;}

Experimente online!

C (gcc) ,  106  104 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;}

Experimente online!

Na verdade , 13 bytes

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

Experimente online!

Explicação:

;┬⌠⌠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