34
\$\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\$
  • \$\begingroup\$ J 3 bytes. Program is t. t=:+|. \$\endgroup\$ – Richard Donovan Feb 10 at 19:13
  • \$\begingroup\$ @RichardDonovan Nice Answer! Can you submit as an answer instead of a comment please :) \$\endgroup\$ – Noah Cristino Feb 11 at 21:10

58 Answers 58

13
\$\begingroup\$

Haskell, 20 bytes

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

zipWith(+)=<<reverse

Try it online!

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

05AB1E, 2 bytes

Â+

Try it online!

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

Brachylog, 6 bytes

↔;?z+ᵐ

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ Passes all cases, cool name. \$\endgroup\$ – Noah Cristino Jul 24 '17 at 18:37
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\$
  • 1
    \$\begingroup\$ Good answer. Thanks for the comment about the input. \$\endgroup\$ – Noah Cristino Jul 24 '17 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\$ – TheLethalCoder Jul 25 '17 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\$ – Grzegorz Puławski Jul 25 '17 at 11:47
4
\$\begingroup\$

CJam, 7 bytes

{_W%.+}

Try it online!

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

APL (Dyalog), 3 bytes

⌽+⊢

Try it online!

Explanation

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

J, 3 bytes

+|.

Reverse, sum.

Try it online!

\$\endgroup\$
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\$
  • \$\begingroup\$ For an empty "array" it returns numeric(0) \$\endgroup\$ – Noah Cristino Jul 24 '17 at 18:36
  • 1
    \$\begingroup\$ @NoahCristino an empty vector is represented as numeric(0) in R. \$\endgroup\$ – Leaky Nun Jul 24 '17 at 18:58
  • \$\begingroup\$ That's fine. @LeakyNun \$\endgroup\$ – Noah Cristino Jul 24 '17 at 19:01
  • 1
    \$\begingroup\$ rev(l<-scan())+l, 16 bytes? \$\endgroup\$ – djhurio Jul 25 '17 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 '18 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\$
  • \$\begingroup\$ Use rseq instead of reverse. \$\endgroup\$ – MattPutnam Jul 26 '17 at 19:07
3
\$\begingroup\$

Pyth, 3 bytes

+V_

Try it here.

\$\endgroup\$
  • \$\begingroup\$ Yay passes all my tests! \$\endgroup\$ – Noah Cristino Jul 24 '17 at 18:20
  • \$\begingroup\$ Equivalent: sV_ \$\endgroup\$ – Mr. Xcoder Jul 24 '17 at 18:25
  • \$\begingroup\$ @Mr.Xcoder nevermind \$\endgroup\$ – Erik the Outgolfer Jul 24 '17 at 18:28
3
\$\begingroup\$

PowerShell, 26 bytes

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

Try it online!

Takes input as command-line arguments.

\$\endgroup\$
  • \$\begingroup\$ Can you add a TIO? and a link under the name like this one: codegolf.stackexchange.com/a/135427/61877 \$\endgroup\$ – Noah Cristino Jul 24 '17 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 '17 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\$ – Noah Cristino Jul 24 '17 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\$
  • \$\begingroup\$ Shouldn't a,n,b be a,b,n or something? \$\endgroup\$ – Erik the Outgolfer Jul 24 '17 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 '17 at 20:13
  • \$\begingroup\$ Could you please add a TIO link? \$\endgroup\$ – Noah Cristino Jul 24 '17 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\$
  • \$\begingroup\$ it doesn't output an array. \$\endgroup\$ – Noah Cristino Jul 24 '17 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\$ – AdmBorkBork Jul 24 '17 at 18:31
  • \$\begingroup\$ Good enough then :) atleast it tried \$\endgroup\$ – Noah Cristino Jul 24 '17 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 '17 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\$ – AdmBorkBork Jul 25 '17 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\$
  • 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 '17 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 '17 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\$ – Kevin Cruijssen Aug 16 '17 at 11:10
  • 2
    \$\begingroup\$ 53 bytes: a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}. \$\endgroup\$ – Olivier Grégoire Aug 16 '17 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\$ – Kevin Cruijssen Aug 16 '17 at 12:58
2
\$\begingroup\$

Ohm, 3 bytes

DR+

Try it online!

\$\endgroup\$
  • \$\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\$ – Noah Cristino Jul 24 '17 at 18:26
2
\$\begingroup\$

Actually, 4 bytes

;R♀+

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Perfect, great job. \$\endgroup\$ – Noah Cristino Jul 24 '17 at 18:43
  • \$\begingroup\$ Erik, solving my problem in like 7 languages xD \$\endgroup\$ – Noah Cristino Jul 24 '17 at 18:43
  • \$\begingroup\$ @NoahCristino Yeah I'm trying to keep it under 15...;) \$\endgroup\$ – Erik the Outgolfer Jul 24 '17 at 18:44
  • \$\begingroup\$ I'm going to have to start adding a -1 for every submission xD \$\endgroup\$ – Noah Cristino Jul 24 '17 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\$
  • \$\begingroup\$ Is it allowed to modify the input stack via actual Neim code instead of normal input methods? \$\endgroup\$ – LiefdeWen Jul 25 '17 at 11:59
  • \$\begingroup\$ @LiefdeWen Yes, that's allowed in the defaults for I/O meta post. \$\endgroup\$ – Okx Jul 25 '17 at 18:15
2
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ Passes my tests! Great answer. \$\endgroup\$ – Noah Cristino Jul 24 '17 at 20:28
2
\$\begingroup\$

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]));

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

MATL, 3 bytes

tP+

Try it online!

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

\$\endgroup\$
2
\$\begingroup\$

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);
\$\endgroup\$
  • \$\begingroup\$ Nice answer! :) \$\endgroup\$ – Noah Cristino Jul 25 '17 at 0:57

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.