37
\$\begingroup\$

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!

\$\endgroup\$
2
  • \$\begingroup\$ J 3 bytes. Program is t. t=:+|. \$\endgroup\$ Feb 10, 2019 at 19:13
  • 1
    \$\begingroup\$ @RichardDonovan Nice Answer! Can you submit as an answer instead of a comment please :) \$\endgroup\$ Feb 11, 2019 at 21:10

68 Answers 68

13
\$\begingroup\$

Haskell, 20 bytes

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

zipWith(+)=<<reverse

Try it online!

\$\endgroup\$
8
  • 4
    \$\begingroup\$ go pointfree: zipWith(+)=<<reverse. \$\endgroup\$
    – nimi
    Jul 24, 2017 at 18:19
  • \$\begingroup\$ @nimi Wow I didn't think to do that but thats pretty smart. \$\endgroup\$
    – Wheat Wizard
    Jul 24, 2017 at 18:21
  • \$\begingroup\$ Where do I put the array? I tried arguments, and input on TIO \$\endgroup\$ Jul 24, 2017 at 18:23
  • \$\begingroup\$ @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. \$\endgroup\$
    – Wheat Wizard
    Jul 24, 2017 at 18:26
  • 3
    \$\begingroup\$ @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. \$\endgroup\$
    – nimi
    Jul 24, 2017 at 19:23
12
\$\begingroup\$

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.

\$\endgroup\$
6
  • \$\begingroup\$ 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. \$\endgroup\$ Jul 24, 2017 at 18:19
  • \$\begingroup\$ @NoahCristino It's not a full program, and there's already an explanation for that in the answer. \$\endgroup\$ Jul 24, 2017 at 18:19
  • \$\begingroup\$ So I guess this is fine, it's just how Jelly outputs it \$\endgroup\$ Jul 24, 2017 at 18:23
  • \$\begingroup\$ @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. \$\endgroup\$
    – hyper-neutrino
    Jul 24, 2017 at 18:24
  • \$\begingroup\$ +Ṛ works too. \$\endgroup\$
    – Mr. Xcoder
    Jul 24, 2017 at 18:46
11
\$\begingroup\$

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]

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

05AB1E, 2 bytes

Â+

Try it online!

\$\endgroup\$
2
  • \$\begingroup\$ Passed all my tests! \$\endgroup\$ Jul 24, 2017 at 18:21
  • \$\begingroup\$ R+ also works for 2 bytes. \$\endgroup\$
    – Riley
    Jul 24, 2017 at 18:41
9
\$\begingroup\$

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!

\$\endgroup\$
0
7
\$\begingroup\$

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

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Passes all my tests! \$\endgroup\$ Jul 24, 2017 at 18:20
7
\$\begingroup\$

Japt, 7 bytes

mÈ+Ug~Y

Try it online! with the -Q flag to format the output array.

Explanation

Implicit: U = input array

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.

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

Ruby, 25 bytes

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

Try it online!

\$\endgroup\$
6
\$\begingroup\$

Mathematica, 12 bytes

Reverse@#+#&

Try it online!

\$\endgroup\$
6
\$\begingroup\$

Python 2, 33 32 bytes

-1 byte thanks to @xnor

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

Try it online!

\$\endgroup\$
6
  • \$\begingroup\$ Passed all my tests good job :) \$\endgroup\$ Jul 24, 2017 at 20:26
  • \$\begingroup\$ What an unusual method. l*1 saves a byte. \$\endgroup\$
    – xnor
    Jul 24, 2017 at 20:53
  • \$\begingroup\$ I am having difficulties understanding the par l*1, any elaboration \$\endgroup\$
    – dhssa
    Jul 26, 2017 at 8:23
  • \$\begingroup\$ @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. \$\endgroup\$
    – ovs
    Jul 26, 2017 at 8:30
  • \$\begingroup\$ Thanks for the explanation, I got it now. good trick to know for coding. \$\endgroup\$
    – dhssa
    Jul 26, 2017 at 23:33
5
\$\begingroup\$

Brachylog, 6 bytes

↔;?z+ᵐ

Try it online!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Passes all cases, cool name. \$\endgroup\$ Jul 24, 2017 at 18:37
5
\$\begingroup\$

J, 3 bytes

+|.

Reverse, sum.

Try it online!

\$\endgroup\$
0
5
\$\begingroup\$

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.

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Good answer. Thanks for the comment about the input. \$\endgroup\$ Jul 24, 2017 at 23:23
  • 1
    \$\begingroup\$ 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! \$\endgroup\$ Jul 25, 2017 at 8:29
  • \$\begingroup\$ @TheLethalCoder Thanks, and I added ToArray() since the challenge is about arrays, so I wanted the self-contained lambda to be array -> array. \$\endgroup\$ Jul 25, 2017 at 11:47
5
\$\begingroup\$

Vyxal, 2 bytes

Ḃ+

Try it Online!

Ḃ+
Ḃ  # bifurcate, i.e. duplicate and reverse
 + # vectorized addition of two lists
\$\endgroup\$
4
\$\begingroup\$

CJam, 7 bytes

{_W%.+}

Try it online!

\$\endgroup\$
3
  • \$\begingroup\$ It outputs "" for [], that's weird. Not your fault just the language. \$\endgroup\$ Jul 24, 2017 at 18:28
  • \$\begingroup\$ @NoahCristino That's CJam's representation of []. \$\endgroup\$ Jul 24, 2017 at 18:29
  • \$\begingroup\$ 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. \$\endgroup\$ Jul 24, 2017 at 18:30
4
\$\begingroup\$

APL (Dyalog), 3 bytes

⌽+⊢

Try it online!

Explanation

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

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!

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

Clojure, 20 17 bytes

3 bytes saved thanks to @MattPutnam

#(map +(rseq %)%)

Seems to be quite competitive with non-golfing languages.

See it online

\$\endgroup\$
1
  • \$\begingroup\$ Use rseq instead of reverse. \$\endgroup\$
    – MattPutnam
    Jul 26, 2017 at 19:07
3
\$\begingroup\$

Pyth, 3 bytes

+V_

Try it here.

\$\endgroup\$
3
  • \$\begingroup\$ Yay passes all my tests! \$\endgroup\$ Jul 24, 2017 at 18:20
  • \$\begingroup\$ Equivalent: sV_ \$\endgroup\$
    – Mr. Xcoder
    Jul 24, 2017 at 18:25
  • \$\begingroup\$ @Mr.Xcoder nevermind \$\endgroup\$ Jul 24, 2017 at 18:28
3
\$\begingroup\$

PowerShell, 26 bytes

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

Try it online!

Takes input as command-line arguments.

\$\endgroup\$
3
  • \$\begingroup\$ Can you add a TIO? and a link under the name like this one: codegolf.stackexchange.com/a/135427/61877 \$\endgroup\$ Jul 24, 2017 at 18:48
  • \$\begingroup\$ @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. \$\endgroup\$
    – Joey
    Jul 24, 2017 at 18:52
  • \$\begingroup\$ That's fine. It's not required it just makes the answers more high quality, and easier to test out for future viewers. \$\endgroup\$ Jul 24, 2017 at 18:54
3
\$\begingroup\$

C, 49 bytes

f(a,n,b)int*a,*b;{for(b=a+n;a<b--;a++)*a=*b+=*a;}
\$\endgroup\$
3
  • \$\begingroup\$ Shouldn't a,n,b be a,b,n or something? \$\endgroup\$ Jul 24, 2017 at 20:12
  • \$\begingroup\$ @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. \$\endgroup\$
    – orlp
    Jul 24, 2017 at 20:13
  • \$\begingroup\$ Could you please add a TIO link? \$\endgroup\$ Jul 24, 2017 at 20:27
3
\$\begingroup\$

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

\$\endgroup\$
5
  • \$\begingroup\$ it doesn't output an array. \$\endgroup\$ Jul 24, 2017 at 18:27
  • 1
    \$\begingroup\$ @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. \$\endgroup\$ Jul 24, 2017 at 18:31
  • \$\begingroup\$ Good enough then :) atleast it tried \$\endgroup\$ Jul 24, 2017 at 18:38
  • \$\begingroup\$ 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)? \$\endgroup\$
    – briantist
    Jul 24, 2017 at 21:51
  • \$\begingroup\$ @briantist Not quite, but you did give me a different way of thinking about it, saving a bunch of bytes. Thanks! \$\endgroup\$ Jul 25, 2017 at 12:54
3
\$\begingroup\$

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
\$\endgroup\$
6
  • 1
    \$\begingroup\$ 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++]);}. \$\endgroup\$
    – Nevay
    Aug 16, 2017 at 10:56
  • 1
    \$\begingroup\$ 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. \$\endgroup\$
    – Nevay
    Aug 16, 2017 at 11:03
  • \$\begingroup\$ @Nevay Thanks. I knew it should be possible to golf l-i-1, just couldn't come up with it.. \$\endgroup\$ Aug 16, 2017 at 11:10
  • 2
    \$\begingroup\$ 53 bytes: a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}. \$\endgroup\$ Aug 16, 2017 at 12:05
  • 1
    \$\begingroup\$ @OlivierGrégoire Thanks. And your l and r makes sense for your implementation, so I've used those as well (and added an explanation). \$\endgroup\$ Aug 16, 2017 at 12:58
3
\$\begingroup\$

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
\$\endgroup\$
1
  • \$\begingroup\$ Nice! I like the line by line explanation \$\endgroup\$ May 3, 2018 at 20:46
3
\$\begingroup\$

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 }
\$\endgroup\$
3
\$\begingroup\$

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.

\$\endgroup\$
2
  • 2
    \$\begingroup\$ map* is your friend here: Try it online! \$\endgroup\$
    – DLosc
    Feb 2 at 22:43
  • \$\begingroup\$ @DLosc Thank you! \$\endgroup\$
    – chunes
    Feb 2 at 22:47
2
\$\begingroup\$

Ohm, 3 bytes

DR+

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ 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. \$\endgroup\$ Jul 24, 2017 at 18:26
2
\$\begingroup\$

Actually, 4 bytes

;R♀+

Try it online!

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

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
\$\endgroup\$
2
\$\begingroup\$

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!

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

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.