Diese Herausforderung ist sehr einfach. Als Eingabe erhalten Sie eine quadratische Matrix, die auf eine beliebige Weise dargestellt wird, und Sie müssen das Punktprodukt der Diagonalen der Matrix ausgeben.

Die Diagonalen im Einzelnen sind die Diagonalen, die von links oben nach rechts unten und von rechts oben nach links unten verlaufen.

Testfälle

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

Gelee , 8 6 Bytes

×UŒDḢS

Probieren Sie es online aus! oder überprüfen Sie alle Testfälle

Wie es funktioniert

×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 Bytes

t!P!*Xds

Eingabeformat ist

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

Probieren Sie es online aus! Oder überprüfen Sie alle Testfälle .

Erläuterung

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 Bytes

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

Testen Sie es auf Ideone .

J, 21 19 Bytes

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

Einfacher Ansatz.

2 Bytes dank @ Lynn gespeichert .

Verwendungszweck

Das Eingabearray wird mit geformt 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

Erläuterung

[:+/(<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 Bytes

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

Probieren Sie es online aus!

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 Bytes

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

Mathematica, 17 Bytes

Tr[#~Reverse~2#]&

APL (Dyalog) , 15 9 Bytes

+/1 1⍉⌽×⊢

Probieren Sie es online aus!

Wie?

+/ - Summe

1 1⍉ - Diagonale von

⌽×⊢ - elementweise Multiplikation der Matrix mit ihrer Umkehrung

Clojure, 57 Bytes

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

Haskell , 80 48 Bytes

Ich mochte meine vorherige Lösung mehr, aber diese ist viel kürzer (macht im Grunde das gleiche wie die Python-Lösung):

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

Probieren Sie es online aus!

J, 18 Bytes

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

Erklärung:

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

í*Å\O

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

í        # 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