Reverse Array Sum

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, the shortest code (in bytes) wins!

Answer 1

Haskell, 20 bytes

5 bytes save by changing to a point free as suggested by nimi

zipWith(+)=<<reverse

Try it online!

Answer 2

Jelly, 2 bytes

+U

Try it online!

or

+Ṛ

Try it online! (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 3

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 4

05AB1E, 2 bytes

Â+

Try it online!

Answer 5

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!

Answer 6

Python 2, 40 bytes

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

Try it online!

The other, shorter Python answer replaces a list comprehension with map. Wish I'd thought to do that faster. ;-;

Answer 7

Japt, 7 bytes

mÈ+Ug~Y

Try it online! 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 8

Ruby, 25 bytes

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

Try it online!

Answer 9

Mathematica, 12 bytes

Reverse@#+#&

Try it online!

Answer 10

Python 2, 33 32 bytes

-1 byte thanks to @xnor

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

Try it online!

Answer 11

Brachylog, 6 bytes

↔;?z+ᵐ

Try it online!

Answer 12

J, 3 bytes

+|.

Reverse, sum.

Try it online!

Answer 13

C# (.NET Core), 61 60 bytes

-1 byte thanks to TheLethalCoder

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

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 14

Vyxal, 2 bytes

Ḃ+

Try it Online!

Ḃ+
Ḃ  # bifurcate, i.e. duplicate and reverse
 + # vectorized addition of two lists

Answer 15

CJam, 7 bytes

{_W%.+}

Try it online!

Answer 16

APL (Dyalog), 3 bytes

⌽+⊢

Try it online!

Explanation

⌽          The argument reversed
+           Plus
⊢          The argument

Answer 17

R, 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!

Answer 18

Clojure, 20 17 bytes

3 bytes saved thanks to @MattPutnam

#(map +(rseq %)%)

Seems to be quite competitive with non-golfing languages.

See it online

Answer 19

Pyth, 3 bytes

+V_

Try it here.

Answer 20

PowerShell, 26 bytes

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

Try it online!

Takes input as command-line arguments.

Answer 21

C, 49 bytes

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

Answer 22

PowerShell, 40 32 bytes

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

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 23

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, but now it's a different shorter solution thanks to @OliverGrégoire.)

Explanation:

Try it here.

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 24

K4 / K (oK), 5 bytes

Solution:

x+|x:

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 25

Factor, 18 bytes

[ dup reverse v+ ]

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 26

tinylisp, ⁴⁴ 39 bytes

(load library
(q((p)(map* a p(reverse p

-5 bytes thanks to @DLosc

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 27

K (ngn/k), 6 bytes

{x+|x}

Try it online!

Answer 28

Ohm, 3 bytes

DR+

Try it online!

Answer 29

Actually, 4 bytes

;R♀+

Try it online!

Answer 30

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