Su programa debe tomar una matriz como entrada.

La matriz:

1. Siempre será 1 dimensional
2. Solo contendrá enteros
3. Puede estar vacío

El programa debe revertir la matriz y luego agregar los elementos al original, por ejemplo:

Entrada: [1, 2, 3]

Original: [1, 2, 3]

Invertido: [3, 2, 1]

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

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

Salida: [4, 4, 4]

Casos de prueba:

#In             #Out
[8, 92],        [100, 100]
[1, 2, 3],      [4, 4, 4]
[5, 24, 85, 6], [11, 109, 109, 11]
[],             []
[999],          [1998]

Este es el código de golf , gana el código más corto (en bytes).

Haskell , 20 bytes

Ahorro de 5 bytes cambiando a un punto libre como lo sugiere nimi

zipWith(+)=<<reverse

Pruébalo en línea!

Jalea , 2 bytes

+U

Pruébalo en línea!

o

+Ṛ

Pruébalo en línea! (Gracias @ Mr. Xcoder por el segundo programa)

explicación, aunque es bastante evidente

+U  Main link
+   Add, vectorizing, 
 U                    the input, reversed

+Ṛ  Main link
+   Add, vectorizing,
 Ṛ                    the input, reversed, without vectorizing (same thing for depth-1 lists)

Para una matriz vacía [], esto no genera nada. Eso es correcto. La representación de Jelly de una lista vacía es simplemente nada. Tenga en cuenta que la representación de Jelly de una lista con un solo elemento es solo el elemento en sí. Agregue ŒṘal código para ver la representación interna de Python de la salida.

JavaScript (ES6), 27 bytes

a=>[...a].map(e=>e+a.pop())

f=
a=>[...a].map(e=>e+a.pop())

console.log(f([8, 92])) // [100, 100]
console.log(f([1, 2, 3])) // [4, 4, 4]
console.log(f([5, 24, 85, 6])) // [11, 109, 109, 11]
console.log(f([])) // []
console.log(f([999])) //[1998]

05AB1E , 2 bytes

Â+

Pruébalo en línea!

Python 2, 32 bytes

lambda l:map(sum,zip(l,l[::-1]))

Solución alternativa sin zip(35 bytes):

lambda l:map(int.__add__,l,l[::-1])

Pruébalo en línea!

Python 2 , 40 bytes

lambda l:[i+j for i,j in zip(l,l[::-1])]

Pruébalo en línea!

La otra respuesta más corta de Python reemplaza una comprensión de lista con map. Ojalá hubiera pensado hacer eso más rápido. ; -;

Japt , 7 bytes

mÈ+Ug~Y

Pruébalo en línea! con la -Qbandera para formatear la matriz de salida.

Explicación

Implícito: U= matriz de entrada

mÈ

Asigne la entrada mediante la siguiente función ...

+Ug

El valor, más el valor en la matriz de entrada en el índice ...

~Y

-(index+1), que obtiene elementos desde el final de la matriz.

Rubí , 25 bytes

->a{[*a].map{|i|i+a.pop}}

Pruébalo en línea!

Mathematica, 12 bytes

Reverse@#+#&

Pruébalo en línea!

Python 2 , 33 32 bytes

-1 byte gracias a @xnor

lambda l:[i+l.pop()for i in l*1]

Pruébalo en línea!

Brachylog , 6 bytes

↔;?z+ᵐ

Pruébalo en línea!

C # (.NET Core) , 61 60 bytes

-1 byte gracias a TheLethalCoder

a=>a.Reverse().Zip(a,(x,y)=>x+y).ToArray()

Pruébalo en línea!

El recuento de bytes también incluye:

using System.Linq;

Para explicación: la función Zip en LINQ toma dos colecciones y ejecuta una función dada para todos los elementos correspondientes, es decir. los dos primeros elementos juntos, los dos segundos elementos, etc.

CJam , 7 bytes

{_W%.+}

Pruébalo en línea!

APL (Dyalog) , 3 bytes

⌽+⊢

Pruébalo en línea!

Explicación

⌽          The argument reversed
+           Plus
⊢          The argument

J, 3 bytes

+|.

Reverso, suma.

Pruébalo en línea!

R , 17 16 bytes

-1 byte gracias a djhurio

rev(l<-scan())+l

Lee de stdin; devuelve el vector; numeric(0)es el vector numérico de longitud cero para la lista vacía.

Pruébalo en línea!

Clojure, 20 17 bytes

3 bytes guardados gracias a @MattPutnam

#(map +(rseq %)%)

Parece ser bastante competitivo con los idiomas que no son de golf.

Véalo en línea

Pyth, 3 bytes

+V_

Pruébalo aquí

PowerShell , 26 bytes

($a=$args)|%{+$a[--$i]+$_}

Pruébalo en línea!

Toma datos como argumentos de línea de comandos.

C, 49 bytes

f(a,n,b)int*a,*b;{for(b=a+n;a<b--;a++)*a=*b+=*a;}

PowerShell , 40 32 bytes

($n=$args)|%{$n[-++$i]+$n[$i-1]}

Pruébalo en línea!

Toma datos como argumentos de línea de comandos individuales, lo que está permitido como uno de los formatos de lista nativos para PowerShell. Luego recorre cada elemento (es decir, una forma más corta de recorrer los índices), agregando el elemento que cuenta desde atrás ( -1indexado) al elemento actual ( 0indexado, de ahí el decremento -1). Esos quedan en la tubería y la salida es implícita.

Guardado 8 bytes gracias a @briantist

Java 8, 61 57 56 53 bytes

a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}

-1 byte y corrección de errores gracias a @Nevay .
-3 bytes gracias a @ OliverGrégoire .

(Era un puerto de (y golfizado por 4 8 bytes) de la respuesta C # de @jkelm , pero ahora es una solución más corta diferente gracias a @ OliverGrégoire ).

Explicación:

Pruébalo aquí

El método modifica la matriz de entrada para guardar bytes, por lo que no es necesario un tipo de retorno.

a->{                    // Method with integer-array parameter and no return-type
  for(int l=0,          //  Left-integer (starting at 0)
          r=a.length;   //  Right-integer (starting at the length of the input-array)
      l<r;              //  Loop as long as left is smaller than right
    a[l]=               //   Change the number at the current left index to:
         a[--r]+=a[l++] //    The number at the right index + itself
                        //    (The += adds the number at the left index also to the right index)
                        //    (And the --/++ increases/decreases the indexes by 1,
                        //     until we've reached the middle of the array)
  );                    //  End of loop
}                       // End of method

Ohm , 3 bytes

DR+

Pruébalo en línea!

En realidad , 4 bytes

;R♀+

Pruébalo en línea!

anyfix , 3 bytes

"U+

La versión en TryItOnline! es una versión desactualizada de anyfix, que contiene algunos errores fatales, como no poder agregar listas debido a errores tipográficos en el código fuente. Use el código en GitHub en su lugar.

"U+  Program
"    Duplicate top of stack
 U   Reverse top of stack if it is a list (which it should be...)
  +  Add, vectorizing for lists

Neim , 2 bytes

Esta es una función que toma la entrada en la parte superior de la pila y las salidas en la parte superior de la pila.

𝕓𝔻

Pruébalo en línea!

Röda , 22 bytes

{reverse(_)<>_1|[_+_]}

Pruébalo en línea!

Esta es una función anónima que toma una matriz y devuelve una secuencia de valores, que el enlace TIO genera en líneas separadas.

Explicación

reverse(_)          The array reversed
<>                  interleaved with
_1                  the array itself
                    Push each element to the stream
[_+_]               Pull two values and push their sum

JavaScript (ES6), 34 33 bytes

Guardado un byte gracias a @ETHproductions.

a=>a.map((e,i)=>e+a[a.length+~i])

let f=

a=>a.map((e,i)=>e+a[a.length+~i])

console.log(f([8,92]));
console.log(f([1,2,3]));
console.log(f([5, 24, 85, 6]));
console.log(f([]));
console.log(f([999]));

MATL , 3 bytes

tP+

Pruébalo en línea!

Extremadamente sencillo. tduplica la entrada Plo voltea (lo invierte) y +agrega el elemento de dos matrices sabiamente.

PHP, 59 bytes

for(;a&$c=$argv[++$i];)$a[]=$c+$argv[$argc-$i];print_r($a);

toma datos de los argumentos de la línea de comandos; salida vacía para entrada vacía

Produce una advertencia en PHP> 7.0. Esta versión no (60 bytes):

for(;++$i<$argc;)$a[]=$argv[$i]+$argv[$argc-$i];print_r($a);