Votre programme devrait prendre un tableau en entrée.

Le tableau:

1. Sera toujours 1 dimension
2. Ne contiendra que des entiers
3. Peut être vide

Le programme doit inverser le tableau, puis additionner les éléments à l'original, par exemple:

Contribution: [1, 2, 3]

Original: [1, 2, 3]

Renversé: [3, 2, 1]

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

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

Sortie: [4, 4, 4]

Cas de test:

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

C'est code-golf , le code le plus court (en octets) gagne!

Haskell , 20 octets

5 octets économisés en passant à un point libre comme suggéré par nimi

zipWith(+)=<<reverse

Essayez-le en ligne!

Gelée , 2 octets

+U

Essayez-le en ligne!

ou

+Ṛ

Essayez-le en ligne! (merci @ M. Xcoder pour le deuxième programme)

explication, bien que ce soit assez explicite

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

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

Pour un tableau vide [], cela ne génère rien. C'est correct. La représentation par Jelly d'une liste vide n'est tout simplement rien. Notez que la représentation d'une liste avec un seul élément par Jelly n'est que l'élément lui-même. Ajoutez ŒṘau code pour voir la représentation interne de la sortie en Python.

JavaScript (ES6), 27 octets

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 octets

Â+

Essayez-le en ligne!

Python 2, 32 octets

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

Solution alternative sans zip(35 octets):

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

Essayez-le en ligne!

Python 2 , 40 octets

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

Essayez-le en ligne!

L'autre réponse, plus courte en Python, remplace une compréhension de liste par map. J'aurais aimé pouvoir faire ça plus vite. ; -;

Japt , 7 octets

mÈ+Ug~Y

Essayez-le en ligne! avec le -Qdrapeau pour formater le tableau de sortie.

Explication

Implicite: U= tableau d'entrée

mÈ

Mappez l'entrée avec la fonction suivante ...

+Ug

La valeur, plus la valeur dans le tableau d'entrée à l'index ...

~Y

-(index+1), qui obtient des éléments à la fin du tableau.

Ruby , 25 octets

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

Essayez-le en ligne!

Mathematica, 12 octets

Reverse@#+#&

Essayez-le en ligne!

Python 2 , 33 32 octets

-1 octet grâce à @xnor

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

Essayez-le en ligne!

Brachylog , 6 octets

↔;?z+ᵐ

Essayez-le en ligne!

C # (.NET Core) , 61 à 60 octets

-1 octet grâce à TheLethalCoder

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

Essayez-le en ligne!

Le nombre d'octets comprend également:

using System.Linq;

Pour explication - La fonction zip dans LINQ prend deux collections et exécute la fonction donnée pour tous les éléments correspondants, c.-à-d. les deux premiers éléments ensemble, les deux seconds éléments, etc.

CJam , 7 octets

{_W%.+}

Essayez-le en ligne!

APL (Dyalog) , 3 octets

⌽+⊢

Essayez-le en ligne!

Explication

⌽          The argument reversed
+           Plus
⊢          The argument

J, 3 octets

+|.

Inverser, somme.

Essayez-le en ligne!

R , 17 16 octets

-1 octet grâce à djhurio

rev(l<-scan())+l

Lit de stdin; renvoie le vecteur; numeric(0)est le vecteur numérique de longueur nulle pour la liste vide.

Essayez-le en ligne!

Clojure, 20 17 octets

3 octets enregistrés grâce à @MattPutnam

#(map +(rseq %)%)

Semble être assez compétitif avec les langues autres que le golf.

Voir en ligne

Pyth, 3 octets

+V_

Essayez ici.

PowerShell , 26 octets

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

Essayez-le en ligne!

Prend l'entrée en tant qu'argument de ligne de commande.

C, 49 octets

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

PowerShell , 40 32 octets

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

Essayez-le en ligne!

Prend les entrées en tant qu'arguments de ligne de commande individuels, ce qui est autorisé en tant que format de liste natif pour PowerShell. Puis boucle à travers chaque élément (c.-à-d. Une manière plus courte de parcourir les index), en ajoutant l’élément comptant à partir de l’arrière ( -1indexé) à l’élément actuel ( 0indexé, d’où le décrément -1). Ceux-ci sont laissés sur le pipeline et la sortie est implicite.

Sauvegardé 8 octets grâce à @briantist

Java 8, 61 57 56 53 octets

a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}

-1 octet et correction de bogue grâce à @Nevay .
-3 octets grâce à @ OliverGrégoire .

(C’était un port de (et jouions au golf de 4 à 8 octets) de la réponse C # de @jkelm , mais c’est maintenant une solution plus courte différente grâce à @ OliverGrégoire .)

Explication:

Essayez ici.

La méthode modifie le tableau en entrée pour économiser les octets. Aucun type de retour n'est donc nécessaire.

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 octets

DR+

Essayez-le en ligne!

En fait , 4 octets

;R♀+

Essayez-le en ligne!

anyfix , 3 octets

"U+

La version sur TryItOnline! est une version obsolète de anyfix, qui contient quelques erreurs fatales telles que l'impossibilité d'ajouter des listes à cause de fautes de frappe dans le code source. Utilisez le code sur GitHub à la place.

"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 octets

C'est une fonction qui prend les entrées au sommet de la pile et les sorties au sommet de la pile.

𝕓𝔻

Essayez-le en ligne!

Röda , 22 octets

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

Essayez-le en ligne!

Il s'agit d'une fonction anonyme qui récupère un tableau et renvoie un flux de valeurs que le lien TIO génère en sortie, séparées sur des nouvelles lignes.

Explication

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 octets

Enregistré un octet grâce à @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]));

MATL , 3 octets

tP+

Essayez-le en ligne!

Extrêmement simple. tduplique l'entrée. Ple retourne (et l’inverse) et +ajoute les deux tableaux par élément.

PHP, 59 octets

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

prend les arguments de la ligne de commande; sortie vide pour entrée vide

Renvoie un avertissement dans PHP> 7.0. Cette version ne (60 octets) ne:

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