[Question]
  [
Your program should take an array as input. 
The array:
1. Will always be 1 dimensional
2. Will only contain integers
3. Can be empty
The program should reverse the array, and then add up the elements to the original for example:
**Input:** `[1, 2, 3]`
**Original:** `[1, 2, 3]`
**Reversed:** `[3, 2, 1]`
```
[1, 2, 3]
 +  +  +
[3, 2, 1]
[1+3, 2+2, 3+1]
```
**Output:** `[4, 4, 4]`
---
**Test Cases:**
```
#In             #Out
[8, 92],        [100, 100]
[1, 2, 3],      [4, 4, 4]
[5, 24, 85, 6], [11, 109, 109, 11]
[],             []
[999],          [1998]
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest code (in bytes) wins!
  
[Answer]
# [Haskell](https://www.haskell.org/), 20 bytes
*5 bytes save by changing to a point free as suggested by nimi*
```
zipWith(+)=<<reverse
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oCgzr0RFoyqzIDyzJENDW9PWxqYotSy1qDhVM9pQx0jHWMcw9v9/AA "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
+U
```
[Try it online!](https://tio.run/##y0rNyan8/1879P///9GGOkY6JrEA "Jelly – Try It Online")
or
```
+Ṛ
```
[Try it online!](https://tio.run/##y0rNyan8/1/74c5Z////NzTWMdExBAA)
(thanks @Mr. Xcoder for the second program)
### explanation, though it's pretty self-explanatory
```
+U  Main link
+   Add, vectorizing, 
 U                    the input, reversed
```
```
+Ṛ  Main link
+   Add, vectorizing,
 Ṛ                    the input, reversed, without vectorizing (same thing for depth-1 lists)
```
For empty array `[]`, this outputs nothing. That is correct. Jelly's representation of an empty list is just simply nothing. Note that Jelly's representation of a list with a single element is just the element itself. Append `ŒṘ` to the code to see the Python internal representation of the output.
[Answer]
## 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]
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
Â+
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cJP2///RhjoKRjoKxrEA "05AB1E – Try It Online")
[Answer]
# Python 2, 32 bytes
```
lambda l:map(sum,zip(l,l[::-1]))
```
Alternative solution without `zip` (35 bytes):
```
lambda l:map(int.__add__,l,l[::-1])
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P802JzE3KSVRIccqN7FAo7g0V6cqs0AjRycn2spK1zBWU/N/QVFmXolCmka0hY6lUawmF5xvqGOkY4wsYKpjZKJjYapjhiyIzLa0tIzV/A8A "Python 2 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 40 bytes
```
lambda l:[i+j for i,j in zip(l,l[::-1])]
```
[Try it online!](https://tio.run/##NY09DsMgFIN3TuExUV@H0B8FpJyEMqRqUV9EE5SwpJenlAov1mdLdtjja5llcsMt@fF9f4zw2vBhgltWME3gGR8OjSdvtD52trUpPre4YYARyDI9QUlLf@gIknCqeMl4JvTZrzWrrpSywgpRnn4/ZVeXMqw8R7iG2/QF "Python 2 – Try It Online")
The other, shorter Python answer replaces a list comprehension with `map`. Wish I'd thought to do that faster. ;-;
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 bytes
```
mÈ+Ug~Y
```
[Try it online!](https://codepen.io/justinm53/full/NvKjZr?code=bcgrVWd+WQ==&inputs=WzgsIDkyXQ==,WzEsIDIsIDNd,WzUsIDI0LCA4NSwgNl0=,W10=,Wzk5OV0=,WzEsMCwyXQ==&flags=LVE=) with the `-Q` flag to format the output array.
## Explanation
Implicit: `U` = input array
```
mÈ
```
Map the input by the following function...
```
+Ug
```
The value, plus the value in the input array at index...
```
~Y
```
`-(index+1)`, which gets elements from the end of the array.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 25 bytes
```
->a{[*a].map{|i|i+a.pop}}
```
[Try it online!](https://tio.run/##DcdJCgIxEIXhfU5RS4cyaNqhs9CLxCClpO1A1MIJJMnZY8GD7/3Pz/nXhv2xLQ6U3Yy8vhHnEkuck@YH19qu4f2a8FQHuoynFO8hl1QUw@DClxIkr2pzK@zQ4A6XXsk32Ik9gjXiBsGsEXpxKymz1vo/ "Ruby – Try It Online")
[Answer]
# Mathematica, 12 bytes
```
Reverse@#+#&
```
[Try it online!](https://tio.run/##y00sychMLv6fZvs/KLUstag41UFZW1ntf0BRZl6JgkOagkO1hY6lUS0XkoChjpGOMYqIqY6RiY6FqY4ZAXUoHEtLy9r/AA "Mathics – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~33~~ 32 bytes
-1 byte thanks to @xnor
```
lambda l:[i+l.pop()for i in l*1]
```
[Try it online!](https://tio.run/##PYzLCsMgFET3fsUsk/YSiH0QA/kS6yKllV6wKombfL2RFDubw5mBiVv6BC@znR7Zzd/na4YbNZ9dF0NsWhsWMNjDnXqT03tNKyZogRI9EJQ09JOeIAmXqreiV8JQeK9dpVLKCCPE//z4HY8xLuwTbMNt3gE "Python 2 – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 6 bytes
```
↔;?z+ᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//1HbFGv7Ku2HWyf8/x9tqGOkYxz7PwoA "Brachylog – Try It Online")
[Answer]
# J, 3 bytes
```
+|.
```
Reverse, sum.
[Try it online!](https://tio.run/##y/r/P81WT0G7Ro8rNTkjXyFNwVDBSMEYxrFQsDSCsdXV//8HAA "J – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~61~~ 60 bytes
*-1 byte thanks to [TheLethalCoder](https://codegolf.stackexchange.com/users/38550/thelethalcoder)*
```
a=>a.Reverse().Zip(a,(x,y)=>x+y).ToArray()
```
[Try it online!](https://tio.run/##dZBBS8NAEIXP5lc8etpgkoKoCGkKRfCiXqogWDws20m70O7G3U1sKPntcZMUtVXfZWZ5b79hRthYaEOt4luyBReEp9o62gb7AF6llWqFB6ne0/4tNtxazPp@SHSyjjspUGm5xCOXioVf1neo012pxEQqt3iL0JcpcmQtRzYFT@ZUkbHEwuRVFoxHYLsIddiZO5z7LnnWM2N4zcL2rMOlR/CKGw8tSocMij6GAdjjKsLFZYQbX6/RpBiPMYnjQ3SlyWJNhoJfLF26AZazPhsej8v92bhYs36spx3y4cnKnW61snpDyYuRjpj0u4wwOsE1wb8//Pn9UdI/A3Piy3uqf9oDqQma9hM "C# (.NET Core) – Try It Online")
Byte count also includes:
```
using System.Linq;
```
For explanation - Zip function in LINQ takes two collections and executes given function for all corresponding elements, ie. both first elements together, both second elements etc.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 2 bytes
```
Ḃ+
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuIIrIiwiIiwiWzEsIDIsIDNdIl0=)
```
Ḃ+
Ḃ  # bifurcate, i.e. duplicate and reverse
 + # vectorized addition of two lists
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 7 bytes
```
{_W%.+}
```
[Try it online!](https://tio.run/##S85KzP1fWPe/Oj5cVU@79n9dwv9oQwUjBeNYAA "CJam – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 3 bytes
```
⌽+⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///3/FR24RHPXu1H3UtAnIUTBWMTBQsTBXMAA "APL (Dyalog Unicode) – Try It Online")
### Explanation
```
⌽          The argument reversed
+           Plus
⊢          The argument
```
[Answer]
# [R](https://www.r-project.org/), ~~17~~ 16 bytes
*-1 byte thanks to djhurio*
```
rev(l<-scan())+l
```
Reads from stdin; returns the vector; `numeric(0)` is the zero-length numeric vector for the empty list.
[Try it online!](https://tio.run/##K/r/vyi1TCPHRrc4OTFPQ1NTO@f/fwA)
[Answer]
# Clojure, ~~20~~ 17 bytes
3 bytes saved thanks to @MattPutnam
```
#(map +(rseq %)%)
```
Seems to be quite competitive with non-golfing languages. 
[See it online](https://tio.run/##S87JzyotSv3/X6OgKDOvREEjN7GgjEtBGUQraGsUFacWKqhqqmpyKURHWyhYGsUqRBsqGCkYA2lTBSMTBQtTBTMgG4gsLS1jY7kUNDX//wcA)
[Answer]
# Pyth, 3 bytes
```
+V_
```
[Try it here.](http://pyth.herokuapp.com/?code=%2BV_&input=%5B1%2C+2%2C+3%5D&debug=0)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 26 bytes
```
($a=$args)|%{+$a[--$i]+$_}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0Ml0VYlsSi9WLNGtVpbJTFaV1clM1ZbJb72////pv@NTP5bmP43AwA "PowerShell – Try It Online")
Takes input as command-line arguments.
[Answer]
# C, 49 bytes
```
f(a,n,b)int*a,*b;{for(b=a+n;a<b--;a++)*a=*b+=*a;}
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~40~~ 32 bytes
```
($n=$args)|%{$n[-++$i]+$n[$i-1]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0Mlz1YlsSi9WLNGtVolL1pXW1slM1YbyFLJ1DWMrf3//7/pfyOT/xam/80A "PowerShell – Try It Online")
Takes input as individual command-line arguments, which is allowed as one of the native list format for PowerShell. Then loops through each element (i.e., a shorter way of looping through the indices), adding the element counting from the back (`-1` indexed) to the current element (`0` indexed, hence the decrement `-1`). Those are left on the pipeline and output is implicit.
Saved 8 bytes thanks to @briantist
[Answer]
# 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 and bug-fixed thanks to *@Nevay*.  
-3 bytes thanks to *@OliverGrégoire*.
(It was a port of (and golfed by ~~4~~ 8 bytes) of [*@jkelm*'s C# answer](https://codegolf.stackexchange.com/a/135447/52210), but now it's a different shorter solution thanks to *@OliverGrégoire*.)
**Explanation:**
[Try it here.](https://tio.run/##tZDBboMwEETv@Yo9grCtloYE5FKpH9BcckQcXOKkpsZGxqSKEN9ODebWa5FsWTsavRlvze4M65ar@vI9iabVxkLtNNJbIcm7MezR0V0lWdfBBxNq2AEIZbm5sorDaR4B7lpcoAqcXpTAQurE0V13OsusqOAECnKYGH4brtrMRpD5EzI5I5Krm/2i8tVQVsgyZwXGpozcK6OoDOk4UY9q@0/pUCtxiWxcoeBsjVC3Jdi3WWvM1V2o4j9eGVKUxSNdLIpUwWII/Xx@dJY3RPeWtI5mpQr814nVnr/aV/9f@DOK0ctm9ATFe5Qm6LBZwmbgLMs2XDp2W0d4jxKED@iIcPovWeNunH4B)
The method modifies the input-array to save bytes, so no need for a return-type.
```
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
```
[Answer]
# [K4](https://kx.com/download/) / [K (oK)](https://github.com/JohnEarnest/ok), 5 bytes
**Solution:**
```
x+|x:
```
[Try it online!](https://tio.run/##y9bNz/7/v0K7psLKUMFIwfj/fwA "K (oK) – Try It Online")
**Example:**
```
x+|x:,()
,()
x+|x:8 92
100 100
x+|x:,999
,1998
```
**Explanation:**
Not quite as elegant as the `J` solution, but same kinda thing:
```
x+|x: / the solution
   x: / store input as x
  |   / reverse it
 +    / add to
x     / x
```
[Answer]
# [Factor](https://factorcode.org/), 18 bytes
```
[ dup reverse v+ ]
```
[Try it online!](https://tio.run/##HYuxCsIwGAb3PsW3CwWrlUYfQFxcxEkcQv3UYprGP2mgSp892g4Hd8PddR06SefT4bjf4kWxNPB897Q1PR60FG2ajw5NZz1aHZ555PR4OGEIg5PGBuyy7IsKqsD4lyUKrGYrUaxRldjMNaGUwpguuPUOwkjxRFzgmkpY7ZwZkHvUhlrSDw "Factor – Try It Online")
## Explanation
```
         ! { 1 2 3 }
dup      ! { 1 2 3 } { 1 2 3 }
reverse  ! { 1 2 3 } { 3 2 1 }
v+       ! { 4 4 4 }
```
[Answer]
# [tinylisp](https://github.com/dloscutoff/Esolangs/tree/master/tinylisp), 44 39 bytes
```
(load library
(q((p)(map* a p(reverse p
```
-5 bytes thanks to @DLosc
[Try it online!](https://tio.run/##JYm7DYAgFEV7prjl004UAwu4BwYKEtQnGBOmxyDd@TzhLDFkrpXiZR1i2JNNRZDDRjcRD3RYHmHBlPzrU/bgSu1pGCl@miAxd1SQC7TC2rQnY0z9AA "tinylisp – Try It Online")
## Explanation
An anonymous function that maps the `a` function (addition) over pairwise elements in the input and the reverse of the input, forming a new list.
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 6 bytes
```
{x+|x}
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLs6qu0K6pqOXiSlMwVDBSMFbQV9C1UzABQaCQhYKlEUTE0MAAhIFipgpGJgoWpgpmUAlDoLglBBsCpTU0IeIamkCOpaUlVJWlpQUAsgUUwQ==)
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 3 bytes
```
DR+
```
[Try it online!](https://tio.run/##y8/I/f/fJUj7//9oQx0FIx0F41gA "Ohm – Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 4 bytes
```
;R♀+
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9866NHMBu3//6MNdRSMdBSMYwE "Actually – Try It Online")
[Answer]
# [anyfix](https://github.com/alexander-liao/anyfix), 3 bytes
```
"U+
```
The version on TryItOnline! is an outdated version of anyfix, which contains a few fatal errors such as not being able to add lists because of typos in the source code. Use the code on GitHub instead.
```
"U+  Program
"    Duplicate top of stack
 U   Reverse top of stack if it is a list (which it should be...)
  +  Add, vectorizing for lists
```
]