Stiamo per piegare un elenco di numeri interi. La procedura per farlo è la seguente, se l'elenco è di lunghezza pari, crea un elenco della metà della sua lunghezza in cui l'ennesimo elemento del nuovo elenco è la somma dell'ennesimo elemento del vecchio elenco e dall'ennesimo al ultimo elemento del vecchio elenco. Ad esempio se avessimo l'elenco

[1 2 3 4 5 6 7 8]

Vorremmo piegarlo in questo modo

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

Se l'elenco ha una lunghezza dispari , per piegarlo rimuoviamo prima l'elemento centrale, piegalo come se fosse pari e aggiungiamo l'elemento centrale al risultato.

Ad esempio se avessimo l'elenco

[1 2 3 4 5 6 7]

Vorremmo piegarlo in questo modo

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

Compito

Scrivi un programma o una funzione che accetta un elenco di numeri interi come input e output che l'elenco è piegato.

Questa è una domanda di code-golf, quindi le risposte verranno classificate in byte, con un numero minore di byte migliori.

Implementazione di esempio

Ecco un'implementazione in Haskell che definisce una funzione fche esegue una piega.

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

Provalo online!

Python , 46 byte

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

Provalo online!

Stessa lunghezza:

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

Una soluzione molto più breve funziona per elenchi di lunghezza pari (30 byte)

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

Provalo online!

Sto ancora cercando di trovare un modo breve per correggerlo per una lunghezza dispari.

05AB1E , 5 byte

Codice

2ä`R+

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

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

Emojicode , 203 byte

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

Questa è stata la risposta Emojicode più dolorosa al codice per me. La lunghezza non necessaria: /

Provalo online!

Japt , 21 18 16 byte

l
íUj°V/2V w)mx

Provalo online!

Completamente terribile Leggermente meno terribile grazie a @Oliver . BRB dopo aver implementato più built-in e risolto alcuni bug ...

Gaia , 7 byte

e2÷ev+†

Spiegazione

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 byte

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

Mathematica 57 byte

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

Inserisce uno zero nel punto medio, aggiunge l'elenco al suo rovescio e prende la lunghezza appropriata.

Japt , 12 byte

å@o +Y*(Z<Ul

Provalo online! con il -Qflag per visualizzare l'array formattato.

Soluzione alternativa, 14 byte

o(½*Ul)c)íU mx

Provalo online!

Gelatina , 7 byte

œs2U2¦S

Provalo online!

-2 grazie a ETHproductions ... e me ne sono reso conto prima.

JavaScript (Node.js) , 53 byte

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

Provalo online!

Un altro suggerimento:

JavaScript (Node.js) , 43 byte

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

Provalo online!

R , 81 70 68 57 byte

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

Provalo online!

funzione anonima; restituisce il risultato.

Python 3 , 101 byte

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]

Provalo online!

Python 3 , 70 byte

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

Provalo online!

JavaScript, 75 71 byte

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

Provalo online

Risparmiato 2 byte grazie a ETHproductions

JavaScript (ES6), 41 byte

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 byte

`6L&)swtn

Provalo online!

Come funziona

Dato un array [a b c ... x y z], [a z]chiamiamolo il subarray "crosta" e[b c ... y z] il "core".

Il codice consiste in un ciclo che rimuove la crosta, calcola la sua somma e sposta il nucleo in cima allo stack, pronto per la successiva iterazione. La condizione del loop è il numero di elementi nel subarray principale

`       % 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 byte

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

Provalo online!

C # (.NET Core) , 118 111 byte

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

Il conteggio dei byte include anche

using System.Linq;

Provalo online!

Come input si prega di utilizzare numeri separati da virgole ( ,) o spazio. Spiegazione:

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 caratteri

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

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

Prova ad esempio in questo modo:

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

Pyth, 18 17 13 byte

V.Tc2Q aYsN;Y

Il mio approccio originale era

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

-1 byte grazie a Mr. Xcoder

-4 byte grazie a FryAmTheEggman

C ++ 17, 75 73 71 byte

Come lambda senza nome, accettando un contenitore come vectoro list, ritorna modificando l'input:

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

Utilizzando il noto operatore 'vai a' <--e il triplo plus+++

Ungolfed ed esempio:

#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 byte

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

Provalo online!

APL (Dyalog Unicode) , ^{SBCS da} 21 byte

-3 byte grazie a @ Adám.

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

Provalo online!

Spiegazione:

(⌊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 comune, 106 byte

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

Provalo online!

JavaScript (Node.js) , 62 byte

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

Provalo online!

Scala, 91 byte

(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 byte

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}

Salvato 3 byte con ispirazione da Asaf .

Java 8, 93 byte

Doppie cifre! Questo è un lambda che prende un int[]e restituisce 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 ungolfed

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

Abbastanza semplice. Piega la seconda metà in posizione sulla prima metà dell'input e restituisce una copia solo della prima metà.

Sorprendentemente, la copia dell'array nell'istruzione return sembra essere il modo più economico per gestire la stranezza dell'elemento finale per input di lunghezza dispari.

PHP , 67 byte

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

Provalo online!