Reverse Array Sum

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

• J 3 bytes. Program is t. t=:+|. Commented Feb 10, 2019 at 19:13

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

zipWith(+)=<<reverse


Try it online!

• go pointfree: zipWith(+)=<<reverse.
– nimi
Commented Jul 24, 2017 at 18:19
• @nimi Wow I didn't think to do that but thats pretty smart. Commented Jul 24, 2017 at 18:21
• Where do I put the array? I tried arguments, and input on TIO Commented Jul 24, 2017 at 18:23
• @NoahCristino I fixed the TIO. This is a point-free function so you just put the input after the function however Haskell requires a main to compile. Commented Jul 24, 2017 at 18:26
• @maple_shaft: we use =<< from the function monad which is defined as: (=<<) f g x = f (g x) x. Here, written in infix: (zipWith(+) =<< reverse) x -> zipWith(+) (reverse x) x.
– nimi
Commented Jul 24, 2017 at 19:23

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
U                    the input, reversed


+Ṛ  Main link
Ṛ                    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.

• I found 2 issues. 1) When tested on [9] it outputs 18 instead of [18], and 2) when tested on [] it doesn't output anything. Commented Jul 24, 2017 at 18:19
• @NoahCristino It's not a full program, and there's already an explanation for that in the answer. Commented Jul 24, 2017 at 18:19
• So I guess this is fine, it's just how Jelly outputs it Commented Jul 24, 2017 at 18:23
• @NoahCristino Yeah. I added a part to the end of my answer so you can put that atom at the end of the code to see how Python would print it. Commented Jul 24, 2017 at 18:24
• +Ṛ works too. Commented Jul 24, 2017 at 18:46

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]

• Oh, man, I was almost there, but I didn't think to use the spread operator to do the clone. Commented Jul 24, 2017 at 19:09
• Can you add the embedded try it for javascript? Commented Jul 24, 2017 at 23:25

05AB1E, 2 bytes

Â+


Try it online!

• Passed all my tests! Commented Jul 24, 2017 at 18:21
• R+ also works for 2 bytes. Commented Jul 24, 2017 at 18:41

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!

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. ;-;

• Passes all my tests! Commented Jul 24, 2017 at 18:20

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.

• Good job! I like the multiple input thing! Commented Jul 24, 2017 at 18:45
• I really like the multiple-input Japt interpreter. Nice job! Commented Jul 24, 2017 at 19:33
• That's really cool :-) I'd add that feature to the "official" interpreter, but with the current design it's sorta unextendable... Commented Jul 24, 2017 at 21:08

Ruby, 25 bytes

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


Try it online!

Mathematica, 12 bytes

Reverse@#+#&


Try it online!

Python 2, 33 32 bytes

-1 byte thanks to @xnor

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


Try it online!

• Passed all my tests good job :) Commented Jul 24, 2017 at 20:26
• What an unusual method. l*1 saves a byte.
– xnor
Commented Jul 24, 2017 at 20:53
• I am having difficulties understanding the par l*1, any elaboration Commented Jul 26, 2017 at 8:23
• @dhssa l*1 makes a copy of the list l. If we would not make a copy, pop() would delete elements from the list before they were accessed in the for loop.
– ovs
Commented Jul 26, 2017 at 8:30
• Thanks for the explanation, I got it now. good trick to know for coding. Commented Jul 26, 2017 at 23:33

Brachylog, 6 bytes

↔;?z+ᵐ


Try it online!

• Passes all cases, cool name. Commented Jul 24, 2017 at 18:37

J, 3 bytes

+|.


Reverse, sum.

Try it online!

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.

• Good answer. Thanks for the comment about the input. Commented Jul 24, 2017 at 23:23
• Hello and welcome to PPCG! You don't need the trailing semi colon in the byte count. I believe you can return the collection straight from the Zip call to so no need for the ToArray(). Nice job! Commented Jul 25, 2017 at 8:29
• @TheLethalCoder Thanks, and I added ToArray() since the challenge is about arrays, so I wanted the self-contained lambda to be array -> array. Commented Jul 25, 2017 at 11:47

Vyxal, 2 bytes

Ḃ+


Try it Online!

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


CJam, 7 bytes

{_W%.+}


Try it online!

• It outputs "" for [], that's weird. Not your fault just the language. Commented Jul 24, 2017 at 18:28
• @NoahCristino That's CJam's representation of []. Commented Jul 24, 2017 at 18:29
• Yup, it's hard to have a standard output for my challenge since many languages display arrays differently especially [], and [4], so it's fine. Commented Jul 24, 2017 at 18:30

APL (Dyalog), 3 bytes

⌽+⊢


Try it online!

Explanation

⌽          The argument reversed
+           Plus
⊢          The argument

• ninja'd. I need to move to an APL keyboard... xD Commented Jul 24, 2017 at 18:33
• @Uriel I am always on my APL keyboard :D Commented Jul 24, 2017 at 18:35
• Love the simplicity. It outputs ⌽+⊢ with no input Commented Jul 24, 2017 at 18:39
• @NoahCristino An empty input is specified with ⍬, the empty vector. With no argument, it prints the train by itself Commented Jul 24, 2017 at 18:39

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!

• For an empty "array" it returns numeric(0) Commented Jul 24, 2017 at 18:36
• @NoahCristino an empty vector is represented as numeric(0) in R. Commented Jul 24, 2017 at 18:58
• That's fine. @LeakyNun Commented Jul 24, 2017 at 19:01
• rev(l<-scan())+l, 16 bytes? Commented Jul 25, 2017 at 13:08
• For the record, an R+pryr functional alternative is just one byte longer: pryr::f(rev(x)+x) Commented May 3, 2018 at 18:21

Clojure, 20 17 bytes

3 bytes saved thanks to @MattPutnam

#(map +(rseq %)%)


Seems to be quite competitive with non-golfing languages.

See it online

• Use rseq instead of reverse. Commented Jul 26, 2017 at 19:07

Pyth, 3 bytes

+V_


Try it here.

• Yay passes all my tests! Commented Jul 24, 2017 at 18:20
• Equivalent: sV_ Commented Jul 24, 2017 at 18:25
• @Mr.Xcoder nevermind Commented Jul 24, 2017 at 18:28

($a=$args)|%{+$a[--$i]+$_}  Try it online! Takes input as command-line arguments. • Can you add a TIO? and a link under the name like this one: codegolf.stackexchange.com/a/135427/61877 Commented Jul 24, 2017 at 18:48 • @NoahCristino: Like this? Haven't used that thing so far, so no idea what I may have done wrong. By the way, if you expect people to use a certain service in their answers, then please state so in the task description. – Joey Commented Jul 24, 2017 at 18:52 • That's fine. It's not required it just makes the answers more high quality, and easier to test out for future viewers. Commented Jul 24, 2017 at 18:54 C, 49 bytes f(a,n,b)int*a,*b;{for(b=a+n;a<b--;a++)*a=*b+=*a;}  • Shouldn't a,n,b be a,b,n or something? Commented Jul 24, 2017 at 20:12 • @EriktheOutgolfer No, b isn't a parameter for the function, just an extra definition stuffed in there for golfing reasons. a must be a pointer to integers, and n must be how many integers there are in the array. – orlp Commented Jul 24, 2017 at 20:13 • Could you please add a TIO link? Commented Jul 24, 2017 at 20:27 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 • it doesn't output an array. Commented Jul 24, 2017 at 18:27 • @NoahCristino PowerShell input/output is, in general, weird. It is outputting as an array, it's just there's nothing capturing said array, and so when the implicit Write-Output happens, it puts things on stdout one item per line. For example, you can see here that, when captured, the object is indeed an array type. Commented Jul 24, 2017 at 18:31 • Good enough then :) atleast it tried Commented Jul 24, 2017 at 18:38 • I'm on mobile and can't test so easily, but isn't it 1 byte shorter to remove the param and then replace 1..$n with 1..($n=$args)? Commented Jul 24, 2017 at 21:51
• @briantist Not quite, but you did give me a different way of thinking about it, saving a bunch of bytes. Thanks! Commented Jul 25, 2017 at 12:54

Java 8, 615756 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

• You can save 1 byte by using a->{for(int i=0,l=a.length;i<l/2;a[i]=a[l+~i]+=a[i++]);}. Commented Aug 16, 2017 at 10:56
• Besides that the code fails for arrays with an odd length 1,2,3 (returns 4,2,4 instead of 4,4,4), the loop has to run as long as 2*i<l, not i<l/2. Commented Aug 16, 2017 at 11:03
• @Nevay Thanks. I knew it should be possible to golf l-i-1, just couldn't come up with it.. Commented Aug 16, 2017 at 11:10
• 53 bytes: a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}. Commented Aug 16, 2017 at 12:05
• @OlivierGrégoire Thanks. And your l and r makes sense for your implementation, so I've used those as well (and added an explanation). Commented Aug 16, 2017 at 12:58

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
x     / x

• Nice! I like the line by line explanation Commented May 3, 2018 at 20:46

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 }


tinylisp, 44 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.

• map* is your friend here: Try it online! Commented Feb 2, 2022 at 22:43

K (ngn/k), 6 bytes

{x+|x}


Try it online!

Ohm, 3 bytes

DR+


Try it online!

• It outputs floats, but I never said it couldn't, so that's fine, and for [] it doesn't output anything but that's just the language. Commented Jul 24, 2017 at 18:26

Actually, 4 bytes

;R♀+


Try it online!

• Perfect, great job. Commented Jul 24, 2017 at 18:43
• Erik, solving my problem in like 7 languages xD Commented Jul 24, 2017 at 18:43
• @NoahCristino Yeah I'm trying to keep it under 15...;) Commented Jul 24, 2017 at 18:44
• I'm going to have to start adding a -1 for every submission xD Commented Jul 24, 2017 at 18:46

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...)