Ihr Programm sollte ein Array als Eingabe nehmen.

Das Array:

1. Wird immer 1 dimensional sein
2. Enthält nur ganze Zahlen
3. Kann leer sein

Das Programm sollte das Array umkehren und dann die Elemente zum Original addieren, zum Beispiel:

Eingang: [1, 2, 3]

Original: [1, 2, 3]

Rückgängig gemacht: [3, 2, 1]

[1, 2, 3]
 +  +  +
[3, 2, 1]

[1+3, 2+2, 3+1]

Ausgabe: [4, 4, 4]

Testfälle:

#In             #Out
[8, 92],        [100, 100]
[1, 2, 3],      [4, 4, 4]
[5, 24, 85, 6], [11, 109, 109, 11]
[],             []
[999],          [1998]

Das ist Code-Golf , der kürzeste Code (in Bytes) gewinnt!

Haskell , 20 Bytes

5 Bytes sparen, indem Sie zu einem von nimi vorgeschlagenen freien Punkt wechseln

zipWith(+)=<<reverse

Probieren Sie es online!

Gelee , 2 Bytes

+U

Probieren Sie es online!

oder

+Ṛ

Probieren Sie es online! (danke @Mr. Xcoder für das zweite Programm)

Erklärung, obwohl es ziemlich selbsterklärend ist

+U  Main link
+   Add, vectorizing, 
 U                    the input, reversed

+Ṛ  Main link
+   Add, vectorizing,
 Ṛ                    the input, reversed, without vectorizing (same thing for depth-1 lists)

Bei einem leeren Array []wird nichts ausgegeben. Das ist richtig. Jellys Darstellung einer leeren Liste ist einfach nichts. Beachten Sie, dass Jellys Darstellung einer Liste mit einem einzelnen Element nur das Element selbst ist. Hängen Sie ŒṘden Code an, um die Python-interne Darstellung der Ausgabe zu sehen.

JavaScript (ES6), 27 Byte

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]

05AB1E , 2 Bytes

Â+

Probieren Sie es online!

Python 2, 32 Bytes

lambda l:map(sum,zip(l,l[::-1]))

Alternative Lösung ohne zip(35 Bytes):

lambda l:map(int.__add__,l,l[::-1])

Probieren Sie es online!

Python 2 , 40 Bytes

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

Probieren Sie es online!

Die andere, kürzere Python-Antwort ersetzt ein Listenverständnis durch map. Ich wünschte, ich hätte gedacht, das schneller zu machen. ; -;

Japt , 7 Bytes

mÈ+Ug~Y

Probieren Sie es online! mit dem -QFlag, um das Ausgabearray zu formatieren.

Erläuterung

Implizit: U= Eingabearray

mÈ

Ordnen Sie die Eingabe mit der folgenden Funktion zu ...

+Ug

Der Wert plus der Wert im Eingabearray am Index ...

~Y

-(index+1), das Elemente vom Ende des Arrays erhält.

Ruby , 25 Bytes

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

Probieren Sie es online!

Mathematica, 12 Bytes

Reverse@#+#&

Probieren Sie es online!

Python 2 , 33 32 Bytes

-1 Byte dank @xnor

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

Probieren Sie es online!

Brachylog , 6 Bytes

↔;?z+ᵐ

Probieren Sie es online!

C # (.NET Core) , 61 - 60 Byte

-1 Byte dank TheLethalCoder

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

Probieren Sie es online!

Die Byteanzahl umfasst auch:

using System.Linq;

Zur Erklärung - Die Zip-Funktion in LINQ verwendet zwei Sammlungen und führt die angegebene Funktion für alle entsprechenden Elemente aus, d. H. beide ersten Elemente zusammen, beide zweiten Elemente usw.

CJam , 7 Bytes

{_W%.+}

Probieren Sie es online!

APL (Dyalog) , 3 Bytes

⌽+⊢

Probieren Sie es online!

Erläuterung

⌽          The argument reversed
+           Plus
⊢          The argument

J, 3 Bytes

+|.

Umgekehrt, Summe.

Probieren Sie es online!

R , 17 16 Bytes

-1 byte dank djhurio

rev(l<-scan())+l

Liest von stdin; gibt den Vektor zurück; numeric(0)ist der numerische Vektor mit der Länge Null für die leere Liste.

Probieren Sie es online!

Clojure, 20 17 Bytes

3 Bytes gespart dank @MattPutnam

#(map +(rseq %)%)

Scheint ziemlich konkurrenzfähig zu sein mit nicht-golfenden Sprachen.

Sehen Sie es online

Pyth, 3 Bytes

+V_

Probieren Sie es hier aus.

PowerShell , 26 Byte

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

Probieren Sie es online!

Übernimmt Eingaben als Befehlszeilenargumente.

C 49 Bytes

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

PowerShell , 40 32 Bytes

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

Probieren Sie es online!

Nimmt Eingaben als einzelne Befehlszeilenargumente an, was als eines der systemeigenen Listenformate für PowerShell zulässig ist. Durchlaufen Sie dann jedes Element (dh eine kürzere Methode zum Durchlaufen der Indizes) und addieren Sie die Anzahl der Elemente von hinten ( -1indexiert) zum aktuellen Element ( 0indexiert, daher die Dekrementierung -1). Diese verbleiben in der Pipeline und die Ausgabe ist implizit.

8 Bytes dank @briantist eingespart

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 und Bugfix dank @Nevay .
-3 Bytes dank @ OliverGrégoire .

(Es war ein Port von @jkelm 's C # -Antwort (und wurde mit 4 bis 8 Bytes belegt) , aber jetzt ist es dank @ OliverGrégoire eine andere, kürzere Lösung .)

Erläuterung:

Probieren Sie es hier aus.

Die Methode ändert das Eingabearray, um Bytes zu speichern, sodass kein Rückgabetyp erforderlich ist.

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

Ohm , 3 Bytes

DR+

Probieren Sie es online!

Eigentlich 4 Bytes

;R♀+

Probieren Sie es online!

Anyfix , 3 Bytes

"U+

Die Version auf TryItOnline! ist eine veraltete Version von anyfix, die einige schwerwiegende Fehler enthält, z. B. das Hinzufügen von Listen aufgrund von Tippfehlern im Quellcode. Verwenden Sie stattdessen den Code auf GitHub.

"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

Dies ist eine Funktion, die Eingaben oben im Stapel und Ausgaben oben im Stapel akzeptiert.

𝕓𝔻

Probieren Sie es online!

Röda , 22 Bytes

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

Probieren Sie es online!

Dies ist eine anonyme Funktion, die ein Array aufnimmt und einen Strom von Werten zurückgibt, die der TIO-Link getrennt über Zeilenumbrüche ausgibt.

Erläuterung

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

JavaScript (ES6), 34 33 Bytes

Dank @ETHproductions ein Byte gespeichert.

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

MATL , 3 Bytes

tP+

Probieren Sie es online!

Sehr einfach. tdupliziert die Eingabe. PKehrt es um und +fügt die beiden Arrays elementweise hinzu.

PHP, 59 Bytes

for(;a&$c=$argv[++$i];)$a[]=$c+$argv[$argc-$i];print_r($a);

Nimmt Eingaben von Befehlszeilenargumenten entgegen. leere Ausgabe für leere Eingabe

Gibt eine Warnung in PHP> 7.0 aus. Diese Version enthält nicht (60 Bytes):

for(;++$i<$argc;)$a[]=$argv[$i]+$argv[$argc-$i];print_r($a);