Tantangan ini sangat sederhana. Anda diberikan sebagai input matriks persegi, direpresentasikan dengan cara apa pun yang waras, dan Anda harus mengeluarkan produk titik diagonal matriks.

Diagonal khusus adalah diagonal yang berjalan dari kiri atas ke kanan bawah dan dari kanan atas ke kiri bawah.

Uji Kasus

[[-1, 1], [-2, 1]]  ->  -3
[[824, -65], [-814, -741]]  ->  549614
[[-1, -8, 4], [4, 0, -5], [-3, 5, 2]]  ->  -10
[[0, -1, 0], [1, 0, 2], [1, 0, 1]]  ->  1

Jelly , 8 6 byte

×UŒDḢS

Cobalah online! atau verifikasi semua kasus uji

Bagaimana itu bekerja

×UŒDḢS  Main link. Argument: M (matrix)

 U      Upend M, i.e., reverse each row.
,       Pair M and upended M.
  ŒD    Yield all diagonals.
    Ḣ   Head; extract the first, main diagonal.
     S  Reduce by sum.

MATL , 8 byte

t!P!*Xds

Format input adalah

[-1, -8, 4; 4, 0 -5; -3, 5, 2]

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

t       % Take input matrix implicitly. Duplicate
!P!     % Flip matrix horizontally
*       % Element-wise product
Xd      % Extract main diagonal as a column vector
s       % Sum. Display implicitly

Python, 47 byte

lambda x:sum(r[i]*r[~i]for i,r in enumerate(x))

Uji di Ideone .

J, 21 19 byte

[:+/(<0 1)|:(*|."1)

Pendekatan lurus ke depan.

Disimpan 2 byte berkat @ Lynn .

Pemakaian

Array input dibentuk menggunakan dimensions $ values.

   f =: [:+/(<0 1)|:(*|."1)
   f (2 2 $ _1 1 _2 1)
_3
   f (2 2 $ 824 _65 _814 _741)
549614
   f (3 3 $ _1 _8 4 4 0 _5 _3 5 2)
_10
   f (3 3 $ 0 _1 0 1 0 2 1 0 1)
1

Penjelasan

[:+/(<0 1)|:(*|."1)    Input: matrix M
              |."1     Reverse each row of M
             *         Multiply element-wise M and the row-reversed M
    (<0 1)|:           Take the diagonal of that matrix
[:+/                   Sum that diagonal and return it=

Julia, 25 byte

~=diag
!x=~x⋅~rotl90(x)

Cobalah online!

JavaScript (ES6), 45 byte

a=>a.reduce((r,b,i)=>r+b[i]*b.slice(~i)[0],0)
a=>a.reduce((r,b,i)=>r+b[i]*b[b.length+~i],0)

R, 26 byte

sum(diag(A*A[,ncol(A):1]))

Mathematica, 17 byte

Tr[#~Reverse~2#]&

APL (Dyalog) , 15 9 byte

+/1 1⍉⌽×⊢

Cobalah online!

Bagaimana?

+/ - jumlah

1 1⍉ - diagonal dari

⌽×⊢ - Elemen perkalian dari matriks dengan itu terbalik

Clojure, 57 byte

#(apply +(map(fn[i r](*(r i)(nth(reverse r)i)))(range)%))

Haskell , 80 48 byte

Saya lebih menyukai solusi saya sebelumnya, tetapi ini jauh lebih pendek (pada dasarnya melakukan hal yang sama dengan solusi Python):

f m=sum[r!!i*r!!(length m-i-1)|(i,r)<-zip[0..]m]

Cobalah online!

J, 18 Bytes

<:@#{+//.@:(*|."1)

Penjelasan:

           (     ) | Monadic hook
            *      | Argument times...
             |."1  | The argument mirrored around the y axis
     +//.@:        | Make a list by summing each of the diagonals of the matrix
    {              | Takes element number...
<:@#               | Calculates the correct index (size of the array - 1)

05AB1E , 5 byte

í*Å\O

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

í        # Reverse each row of the (implicit) input-matrix
         #  i.e. [[-1,-8,4],[4,0,-5],[-3,5,2]] → [[4,-8,-1],[-5,0,4],[2,5,-3]]
 *       # Multiply it with the (implicit) input-matrix (at the same positions)
         #  i.e. [[-1,-8,4],[4,0,-5],[-3,5,2]] and [[4,-8,-1],[-5,0,4],[2,5,-3]]
         #   → [[-4,64,-4],[-20,0,-20],[-6,25,-6]]
  Å\     # Get the diagonal-list from the top-left corner towards the bottom-right
         #  i.e. [[-4,64,-4],[-20,0,-20],[-6,25,-6]] → [-4,0,-6]
    O    # Sum it (and output implicitly)
         #  i.e. [-4,0,-6] → -10