Nous allons plier une liste d'entiers. La procédure à suivre est la suivante. Si la liste est de longueur paire, faites une liste de la moitié de sa longueur où le nième élément de la nouvelle liste est la somme du nième élément de l'ancienne liste et du nième au dernier. dernier élément de l'ancienne liste. Par exemple, si nous avions la liste

[1 2 3 4 5 6 7 8]

Nous le plierions comme ça

 [8 7 6 5]
+[1 2 3 4]
__________
 [9 9 9 9]

Si la liste est de longueur impaire , pour la plier, nous supprimons d'abord l'élément du milieu, plions-le comme s'il était pair et ajoutons l'élément du milieu au résultat.

Par exemple, si nous avions la liste

[1 2 3 4 5 6 7]

Nous le plierions comme ça

 [7 6 5]
+[1 2 3]
__________
 [8 8 8]
++     [4]
__________
 [8 8 8 4]

Tâche

Écrivez un programme ou une fonction qui prend une liste d'entiers en entrée et sort cette liste pliée.

Il s'agit d'une question de code-golf, donc les réponses seront notées en octets, avec moins d'octets étant mieux.

Exemple d'implémentation

Voici une implémentation dans Haskell qui définit une fonction fqui effectue un repli.

f(a:b@(_:_))=a+last b:f(init b)
f x=x

Essayez-le en ligne!

Python , 46 octets

f=lambda l:l[1:]and[l[0]+l[-1]]+f(l[1:-1])or l

Essayez-le en ligne!

Même longueur:

f=lambda l:l[1:]and[l.pop(0)+l.pop()]+f(l)or l

Une solution beaucoup plus courte fonctionne pour les listes de longueur égale (30 octets)

lambda l:[x+l.pop()for x in l]

Essayez-le en ligne!

J'essaie toujours de trouver un moyen court de le corriger pour une longueur impaire.

05AB1E , 5 octets

Code

2ä`R+

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication

2ä        # Split the list into two pieces
  `       # Flatten the stack
   R      # Reverse the second element from the list
    +     # Vectorized addition

Emojicode , 203 octets

🐋🍨🍇🐖🔢🍇🔂i⏩0➗🐔🐕2🍇😀🔡➕🍺🔲🐽🐕i🚂🍺🔲🐽🐕➖🐔🐕➕1i🚂10🍉🍊😛1🚮🐔🐕2🍇😀🔡🍺🔲🐽🐕➗🐔🐕2🚂10🍉🍉🍉

C'était la réponse Emojicode la plus douloureuse au code pour moi. La longueur inutile: /

Essayez-le en ligne!

Japt , 21 18 16 octets

l
íUj°V/2V w)mx

Testez-le en ligne!

Complètement horrible Un peu moins horrible grâce à @Oliver . BRB après avoir implémenté plus de fonctionnalités intégrées et corrigé quelques bugs ...

Gaia , 7 octets

e2÷ev+†

Explication

e        Eval the input (push the list).
 2÷      Split it in half. The first half will be longer for an odd length.
   e     Dump the two halves on the stack.
    v    Reverse the second.
     +†  Element-wise addition. If the first half has an extra element, it is simply appended.

Mathematica, 88 octets

(d=Array[s[[#]]+s[[-#]]&,x=⌊t=Length[s=#]/2⌋];If[IntegerQ@t,d,d~AppendTo~s[[x+1]]])&

Mathematica 57 octets

(#+Reverse@#)[[;;d-1]]&@Insert[#,0,d=⌈Length@#/2⌉+1]&

Insère un zéro au milieu, ajoute la liste à son revers et prend la longueur appropriée.

Japt , 12 octets

å@o +Y*(Z<Ul

Essayez-le en ligne! avec l' -Qindicateur pour afficher le tableau formaté.

Solution alternative, 14 octets

o(½*Ul)c)íU mx

Essayez-le en ligne!

Gelée , 7 octets

œs2U2¦S

Essayez-le en ligne!

-2 grâce à ETHproductions ... et moi le réalisant avant.

JavaScript (Node.js) , 53 octets

x=>x.splice(0,x.length/2).map(y=>y+x.pop()).concat(x)

Essayez-le en ligne!

Une autre suggestion:

JavaScript (Node.js) , 43 octets

f=x=>x+x?[x.pop()+(0|x.shift()),...f(x)]:[]

Essayez-le en ligne!

R , 81 70 68 57 octets

function(l)c((l+rev(l))[1:(w=sum(l|1)/2)],l[w+1][!!w%%1])

Essayez-le en ligne!

fonction anonyme; renvoie le résultat.

Python 3 , 101 octets

lambda l:[sum(x)for x in zip(l[:len(l)//2],l[int(len(l)/2+.5):][::-1])]+[[],[l[len(l)//2]]][len(l)%2]

Essayez-le en ligne!

Python 3 , 70 octets

lambda l:[l[i]+l[~i]for i in range(len(l)//2)]+len(l)%2*[l[len(l)//2]]

Essayez-le en ligne!

JavaScript, 75 71 octets

a=>a.slice(0,n=a.length/2).map(b=>b+a[--z],z=n*2).concat(n%1?a[n|0]:[])

Essayez-le en ligne

Sauvegardé 2 octets grâce à ETHproductions

JavaScript (ES6), 41 octets

f=a=>1/a[1]?[a.shift()+a.pop(),...f(a)]:a

f=a=>1/a[1]?[a.shift()+a.pop(),...f(a)]:a

console.log(JSON.stringify(f([1,2,3,4,5,6,7,8])));
console.log(JSON.stringify(f([1,2,3,4,5,6,7])));

MATL , 9 octets

`6L&)swtn

Essayez-le en ligne!

Comment ça marche

Étant donné un tableau [a b c ... x y z], [a z]appelons le sous- tableau "crust" et[b c ... y z] le le "core".

Le code consiste en une boucle qui supprime la croûte, calcule sa somme et déplace le noyau vers le haut de la pile, prêt pour la prochaine itération. La condition de boucle est le nombre d'éléments dans le sous-tableau central

`       % Do...while
  6L    %   Push [2 -1+1j]. As an index, this is interpreted as 2:end-1
  &)    %   2-output reference indexing: pushes a subarray with the indexed 
        %   elements (core) and another with the ramaining elements (crust)
  s     %   Sum of (crust) subarray
  w     %   Swap. Moves the core subarray to the top
  t     %   Duplicate
  n     %   Number of elements.
        % End (implicit). Procced with next iteration if top of the stack is
        % nonzero; else exit
        % Display stack (implicit)

WendyScript , 72 octets

<<f=>(l){<<r=[]<<b=l.size#i:0->b/2r+=l[i]+l[b-i-1]?b%2!=0r+=l[(b/2)]/>r}

f([1,2,3,4,5,6,7,8]) // => [9,9,9,9]
f([1,2,3,4,5,6,7]) // => [8,8,8,4]

Essayez-le en ligne!

C # (.NET Core) , 118 111 octets

a=>a.Reverse().Zip(a,(c,d)=>c+d).Take(a.Length/2).Concat(a.Skip(a.Length/2).Take(a.Length%2))

Le nombre d'octets comprend également

using System.Linq;

Essayez-le en ligne!

Veuillez saisir des nombres séparés par des virgules ( ,) ou des espaces. Explication:

a =>                                  // Take one input parameter (array)
a.Reverse()                           // Reverse it
.Zip(a, (c, d) => c + d)              // Take every corresponding member of reversed
                                      //    and original, and add them together
.Take(a.Length / 2)                   // Get first half of the collection
.Concat(                              // Add another collection
    a.Skip(a.Length / 2)              // Take input and leave out first half of it
    .Take(a.Length % 2)               // If length is odd, take first element (so the middle)
                                      //    otherwise create an empty collection
);

Perl, 42 38 caractères

sub f {@ a = map {$ + pop} splice @ , 0, @ / 2; @ a, @ }

sub f{(map{$_+pop}splice@_,0,@_/2),@_} 

Essayez par exemple comme ceci:

perl -e 'my @input=(1..9); sub f{(map{$_+pop}splice@_,0,@_/2),@_}  print join(",",f(@input));

Pyth, 18 17 13 octets

V.Tc2Q aYsN;Y

Mon approche originale était

WtQ aY+.)Q.(Q0;+Y

-1 octet merci à M. Xcoder

-4 octets grâce à FryAmTheEggman

C ++ 17, 75 73 71 octets

En tant que lambda sans nom, accepter un conteneur comme vectorou list, revient en modifiant l'entrée:

[](auto&L){for(auto a=L.begin(),b=L.end();a<--b;L.pop_back())*a+++=*b;}

Utilisation de l'opérateur bien connu <--et du triple plus+++

Non golfé et exemple:

#include<iostream>
#include<vector>

using namespace std;

auto f=
[](auto&L){
 for(
  auto a=L.begin(),b=L.end();
  a<--b;
  L.pop_back()
 )
 *a+++=*b;
}
;

void test(auto L) {
 for(auto x:L)cout << x << ", ";
 cout << endl;
 f(L);
 for(auto x:L)cout << x << ", ";
 cout << endl << endl;
}

int main() { 
 vector<int> A = {1,2,3,4,5,6,7,8}, B = {1,2,3,4,5,6,7};
 test(A);
 test(B);
}

J , 22 octets

({.+/@,:|.@}.)~>.@-:@#

Essayez-le en ligne!

APL (Dyalog Unicode) , 21 octets ^SBCS

-3 octets grâce à @ Adám.

(⌊2÷⍨≢)(↑{+⌿↑⍺⍵}∘⌽↓)⊢

Essayez-le en ligne!

Explication:

(⌊2÷⍨≢)(↑{+⌿↑⍺⍵}∘⌽↓)⊢  ⍝ Monadic function train
(⌊2÷⍨≢)                  ⍝ Left portion:
     ≢                   ⍝ Take the length of the input...
  2÷⍨                    ⍝ Divide it by two...
 ⌊                       ⍝ And floor it. This gives our midpoint index. Call it "X"
                      ⊢  ⍝ Right portion: return the original input. Call it "Y"
       (↑{+⌿↑⍺⍵}∘⌽↓)   ⍝ Midddle portion: takes X and Y as arguments
        ↑           ↓    ⍝ Take and drop Y by X. Essentially splits Y in half
                         ⍝ Presents the two halves to the next function
                 ∘⌽     ⍝ Reverse the second half
         {+⌿↑⍺⍵}       ⍝ Final function, takes first half and reversed second half
              ⍺⍵        ⍝ Construct a nested list of first and second halves...
             ↑          ⍝ ...and "mix" them into a matrix. Has the nice property that
                        ⍝ it will pad the first half with a zero if needed.
          +⌿           ⍝ Sum the matrix along the columns, return resulting vector

Lisp commun, 106 octets

(lambda(l)(setf(values a b)(floor(length l)2))`(,@(#1=subseq(mapcar'+ l(reverse l))0 a),@(#1#l a(+ a b))))

Essayez-le en ligne!

JavaScript (Node.js) , 62 octets

a=>a.map((e,i)=>e+a[c=(b=a.length)-i-1]*(c!=i)).slice(0,++b/2)

Essayez-le en ligne!

Scala, 91 octets

(s:Seq[Int])=>(s.take(s.size/2),s.reverse).zipped.map(_+_)++s.drop(s.size/2).take(s.size%2)

Mathematica , 52

(a=#;i=0;(i++;a[[i;;-i]]*=x)&/@a;(Tr@a+O@x^i)[[3]])&

JavaScript (ES6), 46 43 octets

f=(a,[b,...c]=a)=>c+c?[b+c.pop(),...f(c)]:a

f=(a,[b,...c]=a)=>c+c?[b+c.pop(),...f(c)]:a

console.log(f([1,2,3,4,5,6,7,8]).join(', ')) // 9, 9, 9, 9  ✓
console.log(f([1,2,3,4,5,6,7]).join(', '))   // 8, 8, 8, 4  ✓

.as-console-wrapper{max-height:100%!important}

Enregistré 3 octets avec l'inspiration d' Asaf .

Java 8, 93 octets

À deux chiffres! Il s'agit d'un lambda qui prend un int[]et retourne un int[].

l->{int n=l.length,i=0;for(;i<n/2;)l[i]+=l[n-++i];return java.util.Arrays.copyOf(l,n/2+n%2);}

Lambda non golfé

l -> {
    int n = l.length, i = 0;
    for (; i < n / 2; )
        l[i] += l[n - ++i];
    return java.util.Arrays.copyOf(l, n / 2 + n % 2);
}

Assez simple. Il replie la seconde moitié en place sur la première moitié de l'entrée et renvoie une copie de la première moitié uniquement.

Étonnamment, la copie du tableau dans la déclaration de retour semble être le moyen le moins cher de gérer la bizarrerie de l'élément final pour les entrées de longueur impaire.

PHP , 67 octets

function($l){while($l)$o[]=array_shift($l)+array_pop($l);return$o;}

Essayez-le en ligne!