# 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=:+|. – Richard Donovan Feb 10 '19 at 19:13
• @RichardDonovan Nice Answer! Can you submit as an answer instead of a comment please :) – Noah Cristino Feb 11 '19 at 21:10

# Haskell, 20 bytes

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

zipWith(+)=<<reverse


Try it online!

• go pointfree: zipWith(+)=<<reverse. – nimi Jul 24 '17 at 18:19
• @nimi Wow I didn't think to do that but thats pretty smart. – Post Rock Garf Hunter Jul 24 '17 at 18:21
• Where do I put the array? I tried arguments, and input on TIO – Noah Cristino Jul 24 '17 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. – Post Rock Garf Hunter Jul 24 '17 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 Jul 24 '17 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. – Noah Cristino Jul 24 '17 at 18:19
• @NoahCristino It's not a full program, and there's already an explanation for that in the answer. – Erik the Outgolfer Jul 24 '17 at 18:19
• So I guess this is fine, it's just how Jelly outputs it – Noah Cristino Jul 24 '17 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. – HyperNeutrino Jul 24 '17 at 18:24
• +Ṛ works too. – Mr. Xcoder Jul 24 '17 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. – Rick Hitchcock Jul 24 '17 at 19:09
• Can you add the embedded try it for javascript? – Noah Cristino Jul 24 '17 at 23:25

# 05AB1E, 2 bytes

Â+


Try it online!

• Passed all my tests! – Noah Cristino Jul 24 '17 at 18:21
• R+ also works for 2 bytes. – Riley Jul 24 '17 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! – Noah Cristino Jul 24 '17 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! – Noah Cristino Jul 24 '17 at 18:45
• I really like the multiple-input Japt interpreter. Nice job! – Oliver Jul 24 '17 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... – ETHproductions Jul 24 '17 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 :) – Noah Cristino Jul 24 '17 at 20:26
• What an unusual method. l*1 saves a byte. – xnor Jul 24 '17 at 20:53
• I am having difficulties understanding the par l*1, any elaboration – dhssa Jul 26 '17 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 Jul 26 '17 at 8:30
• Thanks for the explanation, I got it now. good trick to know for coding. – dhssa Jul 26 '17 at 23:33

# Brachylog, 6 bytes

↔;?z+ᵐ


Try it online!

• Passes all cases, cool name. – Noah Cristino Jul 24 '17 at 18:37

# 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. – Noah Cristino Jul 24 '17 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! – TheLethalCoder Jul 25 '17 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. – Grzegorz Puławski Jul 25 '17 at 11:47

# CJam, 7 bytes

{_W%.+}


Try it online!

• It outputs "" for [], that's weird. Not your fault just the language. – Noah Cristino Jul 24 '17 at 18:28
• @NoahCristino That's CJam's representation of []. – Erik the Outgolfer Jul 24 '17 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. – Noah Cristino Jul 24 '17 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 – Uriel Jul 24 '17 at 18:33
• @Uriel I am always on my APL keyboard :D – user41805 Jul 24 '17 at 18:35
• Love the simplicity. It outputs ⌽+⊢ with no input – Noah Cristino Jul 24 '17 at 18:39
• @NoahCristino An empty input is specified with ⍬, the empty vector. With no argument, it prints the train by itself – user41805 Jul 24 '17 at 18:39

# J, 3 bytes

+|.


Reverse, sum.

Try it online!

# 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) – Noah Cristino Jul 24 '17 at 18:36
• @NoahCristino an empty vector is represented as numeric(0) in R. – Leaky Nun Jul 24 '17 at 18:58
• That's fine. @LeakyNun – Noah Cristino Jul 24 '17 at 19:01
• rev(l<-scan())+l, 16 bytes? – djhurio Jul 25 '17 at 13:08
• For the record, an R+pryr functional alternative is just one byte longer: pryr::f(rev(x)+x) – JayCe May 3 '18 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. – MattPutnam Jul 26 '17 at 19:07

# Pyth, 3 bytes

+V_


Try it here.

• Yay passes all my tests! – Noah Cristino Jul 24 '17 at 18:20
• Equivalent: sV_ – Mr. Xcoder Jul 24 '17 at 18:25
• @Mr.Xcoder nevermind – Erik the Outgolfer Jul 24 '17 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 – Noah Cristino Jul 24 '17 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 Jul 24 '17 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. – Noah Cristino Jul 24 '17 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? – Erik the Outgolfer Jul 24 '17 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 Jul 24 '17 at 20:13 • Could you please add a TIO link? – Noah Cristino Jul 24 '17 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. – Noah Cristino Jul 24 '17 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. – AdmBorkBork Jul 24 '17 at 18:31 • Good enough then :) atleast it tried – Noah Cristino Jul 24 '17 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)? – briantist Jul 24 '17 at 21:51
• @briantist Not quite, but you did give me a different way of thinking about it, saving a bunch of bytes. Thanks! – AdmBorkBork Jul 25 '17 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++]);}. – Nevay Aug 16 '17 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. – Nevay Aug 16 '17 at 11:03
• @Nevay Thanks. I knew it should be possible to golf l-i-1, just couldn't come up with it.. – Kevin Cruijssen Aug 16 '17 at 11:10
• 53 bytes: a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}. – Olivier Grégoire Aug 16 '17 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). – Kevin Cruijssen Aug 16 '17 at 12:58

# 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. – Noah Cristino Jul 24 '17 at 18:26

# Actually, 4 bytes

;R♀+


Try it online!

• Perfect, great job. – Noah Cristino Jul 24 '17 at 18:43
• Erik, solving my problem in like 7 languages xD – Noah Cristino Jul 24 '17 at 18:43
• @NoahCristino Yeah I'm trying to keep it under 15...;) – Erik the Outgolfer Jul 24 '17 at 18:44
• I'm going to have to start adding a -1 for every submission xD – Noah Cristino Jul 24 '17 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...)
+  Add, vectorizing for lists


# Neim, 2 bytes

This is a function that takes input on the top of the stack and outputs on the top of the stack.

𝕓𝔻


Try it online!

• Is it allowed to modify the input stack via actual Neim code instead of normal input methods? – LiefdeWen Jul 25 '17 at 11:59
• @LiefdeWen Yes, that's allowed in the defaults for I/O meta post. – Okx Jul 25 '17 at 18:15

# Röda, 22 bytes

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


Try it online!

This is an anonymous function that takes in an array and returns a stream of values, which the TIO link outputs separated over newlines.

### Explanation

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

• Passes my tests! Great answer. – Noah Cristino Jul 24 '17 at 20:28

# JavaScript (ES6), 34 33 bytes

Saved a byte thanks to @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]));

• I love how you put in the test cases, +2 – Noah Cristino Jul 24 '17 at 18:25
• I think you can save a byte by changing -i-1 to +~i. – ETHproductions Jul 24 '17 at 21:07
• @ETHproductions, yes, thanks! – Rick Hitchcock Jul 24 '17 at 21:16

# MATL, 3 bytes

tP+


Try it online!

Extremely straightforward. t duplicates the input. P flips (reverses) it, and + adds the two arrays element wise.

# PHP, 59 bytes

for(;a&$c=$argv[++$i];)$a[]=$c+$argv[$argc-$i];print_r($a);  takes input from command line arguments; empty output for empty input Yields a warning in PHP>7.0. This version does not (60 bytes): for(;++$i<$argc;)$a[]=$argv[$i]+$argv[$argc-$i];print_r($a);

• Nice answer! :) – Noah Cristino Jul 25 '17 at 0:57