Dada una matriz entera de al menos dos elementos, genera el vector matriz (definido a continuación) de la matriz.

Para calcular el vector matriz , primero gire a través de la nmatriz de entrada de tamaño para crear una matriz de tamaño n x n, con el primer elemento de la matriz siguiendo la diagonal principal. Esto forma la porción de la matriz. Para el vector, voltee la matriz de entrada verticalmente. Luego realice la multiplicación normal de la matriz. El vector de salida es el resultado.

Por ejemplo,

a = [1, 2, 3]

Primero, gire la matriz dos veces hacia la derecha, para obtener [3, 1, 2]y [2, 3, 1]luego apílelos para formar una 3x3matriz

[[1, 2, 3]
 [3, 1, 2]
 [2, 3, 1]]

Luego, voltea la matriz verticalmente para formar el vector

[[1, 2, 3]    [[1]
 [3, 1, 2]  x  [2]
 [2, 3, 1]]    [3]]

Realizar la multiplicación matricial habitual

[[1, 2, 3]    [[1]    [[1+4+9]    [[14]
 [3, 1, 2]  x  [2]  =  [3+2+6]  =  [11]
 [2, 3, 1]]    [3]]    [2+6+3]]    [11]]

Y la salida es [14, 11, 11]o [[14], [11], [11]](su elección de si está aplanada o no).

Ejemplo # 2

a = [2, 5, 8, 3]

[[2, 5, 8, 3]    [[2]    [[4+25+64+9]     [[102]
 [3, 2, 5, 8]  x  [5]  =  [6+10+40+24]  =  [80]
 [8, 3, 2, 5]     [8]     [16+15+16+15]    [62]
 [5, 8, 3, 2]]    [3]]    [10+40+24+6]]    [80]]

[102, 80, 62, 80]

Reglas

• Se puede suponer que la entrada y la salida se ajustan al tipo de entero nativo de su idioma.
• La entrada y la salida se pueden dar en cualquier formato conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Jalea , 5 bytes

ṙJṚæ.

Pruébalo en línea!

Explicación

En primer lugar:

donde están los vectores de fila y es un vector de columna .vkx

Esto demuestra que la multiplicación de matrices es solo un producto de puntos entre filas y columnas.

Luego, en realidad se gira hacia la derecha, y se gira hacia la derecha, etc.v1v0vkvk-1

Desde otro ángulo, se gira hacia la izquierda, y se gira hacia la izquierda, etc.v1vnvnv1

Cómo funciona

ṙJṚæ.   input: z (a list of length n)
ṙJ      [rot(z,1), rot(z,2), ..., rot(z,n)] (to the left)
  Ṛ     [rot(z,n), ..., rot(z,2), rot(z,1)]
   æ.   [rot(z,n).z , ..., rot(z,2).z , rot(z,1).z] (dot product)

Python 2 , 68 bytes

lambda x:[sum(map(int.__mul__,x,x[i:]+x[:i]))for i in range(len(x))]

Pruébalo en línea!

Python 2 , 73 bytes

def f(v):r=range(len(v));return[sum(v[i]*(v*2)[i+j]for i in r)for j in r]

Pruébalo en línea!

Pyth , 10 bytes

ms*VQ.>QdU

Banco de pruebas .

Jalea , 9 bytes

LḶN⁸ṙæ×W€

Pruébalo en línea!

Una función que devuelve una matriz vertical. Como programa completo, parece que devuelve una matriz horizontal. Para devolver una matriz horizontal que haría en su LḶN⁸ṙ×⁸S€lugar.

05AB1E , 11 bytes

DgGDÁ})ε*}O

Pruébalo en línea!

Haskell , 49 bytes

f v=sum.zipWith(*)v.fst<$>zip(iterate tail$v++v)v

Pruébalo en línea!

Para una entrada v=[1,2]

• iterate tail$v++v produce la lista [[1,2,1,2],[2,1,2],[1,2],[2],[],...]
• fst<$>zip l ves igual take(length v)ly produce[[1,2,1,2],[2,1,2]]
• sum.zipWith(*)v se mapea en cada elemento y produce el producto de fila de matriz de vectores.

R , 66 62 bytes

sapply(length(n<-scan()):1,function(i)c(n[-(1:i)],n[1:i])%*%n)

Pruébalo en línea!

Mathematica, 35 bytes

Most@FoldList[RotateRight,#,1^#].#&

Pruébalo en línea!

-9 bytes de @No es un árbol

CJam , 17 bytes

{__,,\fm>\f.*::+}

Pruébalo en línea!

GolfScript , 37 bytes

{..,({.)\+}[*]{[1$\]zip{~*}%{+}*}%\;}

Pruébalo en línea!

Python 3 + numpy , 68 bytes

lambda v:dot([roll(v,i)for i in range(len(v))],v)
from numpy import*

Pruébalo en línea!

J , 14 bytes

+/ .*~#\.1&|.]

Pruébalo en línea!

Explicación

+/ .*~#\.1&|.]  Input: array M
      #\.       Length of each suffix, forms the range [len(M), ..., 2, 1]
             ]  Identity, get M
         1&|.   For each 'x' in the suffix lengths, rotate left M  by 'x'
+/ .*~          Dot product with M

APL, 17 bytes

(↑¯1⌽(⍳≢)⌽¨⊂)+.×⍪

Explicación:

(↑¯1⌽(⍳≢)⌽¨⊂)+.×⍪

 ↑                      matrix format of
  ¯1⌽                   right rotate by 1 of
     (⍳≢)               the 1..[length N]
         ⌽¨             rotations of
           ⊂            the enclosed input
             +.×        inner product with
                ⍪       1-column matrix of input

Octava , 34 bytes

@(a)a*toeplitz(a,shift(flip(a),1))

Pruébalo en línea!

Haskell , 56 55 52 bytes

f l=[sum$zipWith(*)l$drop i$l++l|i<-[0..length l-1]]

Pruébalo en línea!

Guardado un byte gracias a @Laikoni

Guardado tres bytes: en l++llugar decycle l

Casco , 11 bytes

mΣ§‡*´ṀKoṫ¢

Pruébalo en línea!

Explicación

mΣ§‡*´ṀKoṫ¢  Implicit input, e.g. [1,2,3]
          ¢  Cycle: [1,2,3,1,2,3,...
        oṫ   Tails: [[1,2,3,1,2,3...],[2,3,1,2,3...],[3,1,2,3...]...
     ´ṀK     Replace each element of input with input: [[1,2,3],[1,2,3],[1,2,3]]
   ‡*        Vectorized multiplication (truncated with respect to shortest list)
  §          applied to the last two results: [[1,4,9],[2,6,3],[3,2,6]]
mΣ           Sum of each row: [14,11,11]

Octava - 67 48 bytes

¡Gracias a Luis Mendo por reducir este código en 19 bytes!

Nota: Este código solo puede ejecutarse en Octave. MATLAB no admite expresiones dentro de funciones que pueden crear variables al mismo tiempo que evalúa las expresiones que las crean.

n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'

El código original en MATLAB se puede encontrar aquí, pero se puede ejecutar en cualquier versión de MATLAB. Este código tiene 67 bytes:

a=input('');n=numel(a)-1;a(mod(bsxfun(@minus,0:n,(0:n)'),n+1)+1)*a'

Explicación

1. a=input('');- Recibe un vector (fila) del usuario a través de la entrada estándar. Debe ingresar el vector en forma de octava (es decir[1,2,3] ).
2. n=numel(...); - Obtiene el número total de elementos en el vector de entrada.
3. x=0:n-1- Crea un vector de fila que aumenta de 0hastan-1 en pasos de 1.
4. (x=0:n-1)-x'- Realiza la transmisión de modo que tengamos una n x nmatriz para que cada fila isean elementos desde 0 hasta n-1con cada elemento en fila isustraído pori .
5. mod(..., n)+1- Asegura que cualquier valor que sea negativo se ajuste a, de nmodo que cada fila icontenga el vector desde 0 hasta desplazado n-1 circularmente a la izquierda pori elementos. Agregamos 1 cuando MATLAB / Octave comienza a indexar vectores o matrices con 1.
6. a(...)- Crea una n x nmatriz donde usando (4), accedemos a los índices correctos del vector de entrada dictados por cada valor de (4), logrando así la matriz que necesitamos.
7. (...)*a'- Realiza la multiplicación de vectores de matriz mediante transposición / volteo apara convertirse en un vector de columna antes de hacer la multiplicación.

Ejecuciones de ejemplo

>> n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'
[1,2,3]

ans =

         14.00
         11.00
         11.00

>> n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'
[2,5,8,3]

ans =

        102.00
         80.00
         62.00
         80.00

Pruébalo en línea!

Javascript 79 bytes

Toma una matriz de entrada y genera una matriz del vector matriz

a=>(b=[...a],a.map(x=>([...b].reduce((m,n,i)=>m+=n*a[i],0,b.push(b.shift())))))

Explicación

a=>(
    b=[...a],                    // copy the input into b
    a.map(x=>(                   // transform a into a new array
        [...b].reduce(           // copy b into a new array and reduce
            (m,n,i)=>m+=n*a[i],  // memo += the element in the array * the ith
                                 // element in a
            0,                   // start memo at 0
            b.push(b.shift())    // shift the first element in b to the end
                                 // not used by reduce, but performing this op
                                 // here saves a few bytes
        )
    ))
)

Clojure, 80 bytes

#(map(fn[_ c](apply +(map * c %)))%(iterate(fn[c](into[(last c)](butlast c)))%))

iterateproduce una secuencia infinita, pero en lugar de usarlo (take (count %) (iterate ...))para detenerlo, lo uso %como argumento adicional para map.

Perl 5 , 65 + 1 (-a) = 66 bytes

@o=@F;for(@o){$r=0;$r+=$_*$F[$i++%@F]for@o;say$r;unshift@F,pop@F}

Pruébalo en línea!

Toma el vector de entrada como números separados por espacios. Emite números separados por salto de línea que representan el vector resultante.

C (gcc) , 126 bytes

i,j;int*f(int*a,int n){int*r=malloc(n*sizeof(int));for(i=0;i<n;i++){r[i]=0;for(j=0;j<n;j++)r[i]+=a[j]*a[(j-i+n)%n];}return r;}

Pruébalo en línea!

Una matriz se puede representar en la entrada como un puntero y una longitud.

Lisp común, 78 bytes

(lambda(x)(loop as i on(append x x)as y in x collect(reduce'+(mapcar'* i x))))

Pruébalo en línea!

Duplique la matriz (en este caso, una lista Lisp) e itere sobre las sublistas con i(usando x, a través y, para detener la iteración). Luego calcule el siguiente elemento del resultado sumando el resultado de multiplicar cada elemento de xcon cada elemento de i(deteniéndose nuevamente cuando finaliza la lista más corta).