Wir werden eine Liste von ganzen Zahlen falten. Gehen Sie dazu wie folgt vor: Wenn die Liste gerade ist, erstellen Sie eine Liste mit der Hälfte ihrer Länge, wobei das n-te Element der neuen Liste die Summe aus dem n-ten Element der alten Liste und dem n-ten bis zum-ten ist. letzter Punkt der alten Liste. Zum Beispiel, wenn wir die Liste hätten

[1 2 3 4 5 6 7 8]

Wir würden es so falten

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

Wenn die Liste eine ungerade Länge hat, entfernen wir zum Falten zuerst das mittlere Element, falten es wie gerade und hängen das mittlere Element an das Ergebnis an.

Zum Beispiel, wenn wir die Liste hätten

[1 2 3 4 5 6 7]

Wir würden es so falten

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

Aufgabe

Schreiben Sie ein Programm oder eine Funktion, die eine Liste von ganzen Zahlen als Ein- und Ausgänge verwendet, die gefaltet sind.

Dies ist eine Code-Golf- Frage, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Beispielimplementierung

Hier ist eine Implementierung in Haskell, die eine Funktion definiert f, die eine Faltung ausführt.

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

Probieren Sie es online!

Python , 46 Bytes

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

Probieren Sie es online!

Die gleiche Länge:

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

Eine viel kürzere Lösung funktioniert für Listen mit gerader Länge (30 Byte)

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

Probieren Sie es online!

Ich versuche immer noch, einen kurzen Weg zu finden, um die ungerade Länge zu korrigieren.

05AB1E , 5 Bytes

Code

2ä`R+

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

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

Emojicode , 203 Bytes

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

Dies war für mich die schmerzhafteste Emojicode-Antwort auf den Code. Die unnötige Länge: /

Probieren Sie es online!

Japt , 21 18 16 Bytes

l
íUj°V/2V w)mx

Testen Sie es online!

Völlig schrecklich Etwas weniger schrecklich dank @Oliver . BRB, nachdem ich weitere integrierte Funktionen implementiert und einige Fehler behoben habe ...

Gaia , 7 Bytes

e2÷ev+†

Erläuterung

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 Bytes

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

Mathematica 57 Bytes

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

Fügt am Mittelpunkt eine Null ein, fügt die Liste umgekehrt hinzu und nimmt die entsprechende Länge an.

Japt , 12 Bytes

å@o +Y*(Z<Ul

Probieren Sie es online! mit dem -QFlag, um das formatierte Array anzuzeigen.

Alternative Lösung, 14 Byte

o(½*Ul)c)íU mx

Probieren Sie es online!

Gelee , 7 Bytes

œs2U2¦S

Probieren Sie es online!

-2 dank ETHproductions ... und mir schon mal klar geworden.

JavaScript (Node.js) , 53 Byte

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

Probieren Sie es online!

Ein weiterer Vorschlag:

JavaScript (Node.js) , 43 Byte

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

Probieren Sie es online!

R , 81 70 68 57 Bytes

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

Probieren Sie es online!

anonyme Funktion; gibt das Ergebnis zurück.

Python 3 , 101 Bytes

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]

Probieren Sie es online!

Python 3 , 70 Bytes

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

Probieren Sie es online!

JavaScript, 75 71 Bytes

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

Probieren Sie es online aus

2 Bytes gespart dank 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 Bytes

`6L&)swtn

Probieren Sie es online!

Wie es funktioniert

Nennen [a b c ... x y z]wir ein Array [a z]das "Crust" -Unterarray und [b c ... y z]das "Core" -Unterarray.

Der Code besteht aus einer Schleife, die die Kruste entfernt, ihre Summe berechnet und den Kern an die Spitze des Stapels verschiebt, um für die nächste Iteration bereit zu sein. Die Schleifenbedingung ist die Anzahl der Elemente im Kern-Subarray

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

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

Probieren Sie es online!

C # (.NET Core) , 118 111 Bytes

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

Die Byteanzahl umfasst auch

using System.Linq;

Probieren Sie es online!

Als Eingabe verwenden Sie bitte durch Komma ( ,) oder Leerzeichen getrennte Zahlen . Erläuterung:

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 Zeichen

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

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

Versuchen Sie zum Beispiel so:

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

Pyth, 18 17 13 Bytes

V.Tc2Q aYsN;Y

Mein ursprünglicher Ansatz war

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

-1 Byte danke an Herrn Xcoder

-4 Bytes dank FryAmTheEggman

C ++ 17, 75 73 71 Bytes

Wenn Sie als unbenanntes Lambda einen Container wie vectoroder akzeptieren list, wird dies durch Ändern der Eingabe zurückgegeben:

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

Verwendung des bekannten "Go-to" -Operators <--und des Triple Plus+++

Ungolfed und Beispiel:

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

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

Probieren Sie es online!

APL (Dyalog Unicode) , 21 Byte ^SBCS

-3 Bytes dank @ Adám.

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

Probieren Sie es online!

Erläuterung:

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

Common Lisp, 106 Bytes

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

Probieren Sie es 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)

Probieren Sie es online!

Scala, 91 Bytes

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

3 Bytes mit Inspiration von Asaf gespeichert .

Java 8, 93 Bytes

Zweistellig! Dies ist ein Lambda, der ein nimmt int[]und ein zurückgibt 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);}

Ungolfed Lambda

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

Recht einfach. Die zweite Hälfte wird auf die erste Hälfte der Eingabe geklappt, und es wird nur eine Kopie der ersten Hälfte zurückgegeben.

Überraschenderweise scheint die Array-Kopie in der return-Anweisung die günstigste Möglichkeit zu sein, die letzte Element-Quirk für Eingaben mit ungerader Länge zu behandeln.

PHP , 67 Bytes

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

Probieren Sie es online!