Ce défi est très simple. On vous donne en entrée une matrice carrée, représentée de façon saine, et vous devez sortir le produit scalaire des diagonales de la matrice.

Les diagonales en particulier sont la diagonale allant de haut à gauche à bas à droite et de haut à droite à bas à gauche.

Cas de test

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

Gelée , 8 6 octets

×UŒDḢS

Essayez-le en ligne! ou vérifier tous les cas de test

Comment ça fonctionne

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

t!P!*Xds

Le format d'entrée est

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

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

Testez-le sur Ideone .

J, 21 19 octets

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

Approche directe.

Enregistré 2 octets grâce à @ Lynn .

Usage

Le tableau d'entrée est mis en forme à l'aide de 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

Explication

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

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

Essayez-le en ligne!

JavaScript (ES6), 45 octets

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 octets

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

Mathematica, 17 octets

Tr[#~Reverse~2#]&

APL (Dyalog) , 15 9 octets

+/1 1⍉⌽×⊢

Essayez-le en ligne!

Comment?

+/ - somme

1 1⍉ - diagonale de

⌽×⊢ - multiplication par élément de la matrice avec son inverse

Clojure, 57 octets

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

Haskell , 80 48 octets

J'ai aimé ma solution précédente plus, mais elle est beaucoup plus courte (fait essentiellement la même chose que la solution Python):

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

Essayez-le en ligne!

J, 18 octets

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

Explication:

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

í*Å\O

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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