Lưu ý rằng thách thức này không đòi hỏi phải xử lý hoặc hiểu các số phức.

Đưa ra một ma trận vuông không trống trong đó mọi phần tử là danh sách số nguyên hai phần tử (Re, Im), xác định (đưa ra bất kỳ giá trị trung thực / giả hoặc bất kỳ hai giá trị nhất quán nào) cho dù điều này đại diện cho ma trận Hermiti.

Lưu ý rằng đầu vào là một mảng số nguyên 3D; không phải là một mảng 2D của các số phức. Nếu ngôn ngữ của bạn không thể lấy một mảng 3D trực tiếp, bạn có thể lấy một danh sách phẳng (và hình dạng n × n hoặc n × n × 2 nếu điều đó có ích).

Một ma trận là Hermiti nếu nó bằng chuyển vị liên hợp của chính nó . Nói cách khác, nếu bạn lật nó qua đường chéo trên cùng bên trái sang dưới cùng bên phải và phủ định phần tử thứ hai của tất cả các danh sách lá hai phần tử, nó giống hệt với ma trận đầu vào. Lưu ý rằng thứ tự lật và phủ định là không liên quan, vì vậy bạn có thể phủ định trước và lật sau.

Ví dụ đi bộ

Ví dụ này sử dụng JSON với khoảng trắng thừa để dễ đọc:

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

Transpose (lật ngang đường chéo NA NA SE):

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

Phủ định các yếu tố thứ hai của danh sách lá:

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

Vì đây là giống hệt với đầu vào, ma trận là Hermiti.

Các trường hợp thử nghiệm

Hermiti

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

Không phải Hermiti

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

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

Tạo một mảng 3D gồm các số thực, tạo một mảng 2D gồm các số ảo, hoán vị, liên hợp và so sánh.

Cảm ơn @Giuseppe vì đã giảm số lượng byte bằng 23 byte đáng kinh ngạc và @Vlo cho lần cuối cùng 1!

Hãy thử trực tuyến!

Thí dụ:

> 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

Octave , 39 34 31 byte

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

Hãy thử trực tuyến!

Lưu được 3 byte nhờ Luis Mendo, người đã thông báo cho tôi về việc làm rõ trong văn bản thách thức.

Giải trình:

Trong MATLAB và Octave, ' là chuyển vị phức tạp liên hợp, không phải là chuyển vị "thông thường".

Chúng tôi tạo ra một biến y dòng nội tuyến là lớp đầu tiên của ma trận 3D cộng với lớp thứ hai nhân với đơn vị phức j, tức là ma trận phức trong đó thuật ngữ thực là "lớp" đầu tiên và ảo là "lớp" thứ hai. Sau đó, chúng tôi kiểm tra nếu nó bằng chính nó liên hợp phức tạp chuyển.

Điều này sẽ tạo ra một ma trận chỉ chứa 1nếu đúng và một ma trận chứa ít nhất một ma trận 0nếu sai. Đây được coi là đúng và sai trong Octave (Bằng chứng) .

Python 2 , 50 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 22 15 9 7 byte

⍉≡⊢∘-\¨

Hãy thử trực tuyến!

Hàm tiền tố ngầm.

Cảm ơn Adám vì 7 byte trên Dfn và cả Adám và ErikTheOutgolfer vì đã đưa ra sự ngu ngốc của tôi giúp tôi tìm phiên bản ngầm.

Cảm ơn ngn cho 2 byte trên phiên bản ngầm.

Làm sao?

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

Ngôn ngữ Wolfram (Mathicala) , 45 34 33 26 21 18 byte

• Đã lưu mười một byte nhờ JungHwan Min .
• Đã lưu một byte nhờ Martin Ender .
• Đã lưu bảy byte nhờ alephalpha .
• Lưu năm byte nhờ alephalpha .
• Đã lưu ba byte.

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

Hãy thử trực tuyến!

Java 8, 137 136 134 126 119 byte

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

Trả về 1nếu Hermiti,0 nếu không.

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Hãy thử trực tuyến!

Giải trình

[:(+-:|:)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 byte

-7 byte nhờ H.PWiz.

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

Hãy thử trực tuyến!

Thạch ,  6  5 byte

Z×Ø+⁼

Một liên kết đơn âm trở lại 1cho đầu vào Hermiti và mặt 0khác.

Hãy thử trực tuyến!

Làm sao?

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

05AB1E , 9 byte

øεεX®‚*]Q

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Cổng câu trả lời Python của tôi

Perl 5 , -a0 48 byte

Đếm cũ: 50 byte (+2 cho a0). Không tệ cho một ngôn ngữ không có nội dung chuyển đổi (Tôi không ghen tị chút nào, không có tiếng còi)

Đưa ra ma trận đầu vào trên STDIN với ,giữa phần thực và phần ảo, ví dụ:

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

Sẽ in 1cho ẩn sĩ, không có gì khác

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

Hãy thử trực tuyến!

Husk , 7 byte

=¹mmṀ_T

Hãy thử trực tuyến!

Làm sao?

Lưu ý rằng †nên hoạt động thay vì mm , nhưng có một lỗi khó chịu ngăn tôi sử dụng nó :(

= MmṀ_T - Chương trình đầy đủ. Lấy đầu vào từ dòng lệnh args, như một danh sách các danh sách các bộ dữ liệu.
  m T - Đối với mỗi danh sách trong mục đích ...
   mṀ_ - ... Phủ định giá trị cuối cùng của mỗi bộ dữ liệu mà chúng chứa.
= ¹ - Kiểm tra xem cái này có giống với đầu vào không.

JavaScript (ES6), 53 byte

Đã lưu 2 byte nhờ @Neil

Trả lại falsecho Hermiti hoặc truecho người không phải Hermiti.

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

Hãy thử trực tuyến!

C (gcc) , 107 103 100 byte

• Đã lưu bốn byte nhờ Steadybox ; đánh golf A[0]đến *Ahai lần.
• Lưu ba byte nhờ trần .

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

Hãy thử trực tuyến!

Trên thực tế , 13 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động?

Trình này thực sự sử dụng các số phức. Nếu lấy đầu vào làm ma trận của các mục phức được cho phép, thì nó sẽ là 8 byte .

┬⌠⌠Çá╫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.

Bình thường, 9 byte

qCmm,hk_e

Giải trình:

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?

Bộ thử nghiệm .

C,  111   110  108 byte

Cảm ơn @Jonathan Frech đã lưu một byte và cảm ơn @ceilingcat vì đã lưu hai byte!

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

Hãy thử trực tuyến!

C (gcc) ,  106  104 byte

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

Hãy thử trực tuyến!

Trên thực tế , 13 byte

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

Hãy thử trực tuyến!

Giải trình:

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