Falte eine Liste in zwei Hälften

24

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!

code-golf  array-manipulation 
— Weizen-Assistent
quelle
Wenn Sie Ganzzahlen sagen, schließt dies null oder negative Ganzzahlen ein?
— Neil
1
@ Neil Ja, das tut es.
— Weizen-Assistent
2
@ GrzegorzPuławski Du solltest die Liste nicht sortieren. Jede bestellte Sammlung ist erlaubt, zB Vektor oder Array.
— Weizen-Assistent
1
@DavidStarkey Die meisten vernünftigen Listen werden mit einer angemessenen Menge an Speicher nicht überlaufen. Durch Falten wird die Summe nicht erhöht, sodass Listen zu einem Singleton der Summe der ursprünglichen Liste konvergieren.
— Weizen-Zauberer
2
@ WheatWizard Ich weiß nicht, ich habe gehört, es ist unmöglich, eine Liste mehr als sieben Mal in zwei Hälften zu falten.
— Carmeister

Antworten:

9

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.

— xnor
quelle
Oh, ich wurde furchtbar ÷ _ ÷
— Mr. Xcoder
Die "Middle Ground" -Lösung f=lambda l:l[1:]and[l[0]+l.pop()]+f(l[1:])or lhat auch die gleiche Länge ...
— ETHproductions
8

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
— Adnan
quelle
8

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!

— betseg
quelle
3

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.
— Geschäfts-Katze
quelle
2

Mathematica, 88 Bytes

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

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.

— Kelly Lowder
quelle
1

JavaScript (ES6), 41 Byte

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

Code-Snippet anzeigen

— Rick Hitchcock
quelle
1

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)
— Luis Mendo
quelle
1

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
);
— Grzegorz Puławski
quelle
Können Sie Bytes sparen, indem Sie die Länge auf eine Variable setzen und zu einem expliziten Return wechseln?
— TheLethalCoder
@TheLethalCoder leider ist es länger
— Grzegorz Puławski
1

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));
— Byteschieber
quelle
1
Es wurde ein Fehler behoben, der sich aufgrund meiner emotionalen und professionellen Bindung an Variablen eingeschlichen hat. Lassen Sie sich von JS: P
— bytepusher
1

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

— Dave
quelle
Versuchen Sie mit c2<list>, eine Liste in zwei Hälften zu teilen. Ein weiterer Befehl, der nützlich sein könnte, ist .T.
— FryAmTheEggman
— Mr. Xcoder
1

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);
}
— Karl Napf
quelle
1

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
— voidhawk
quelle
Dyalog Extended, 18 Bytes:+⌿(⌊2÷⍨≢)(↑↑⍮⌽⍤↓)⊢
— Adám
— Adám
0

Scala, 91 Bytes

(s:Seq[Int])=>(s.take(s.size/2),s.reverse).zipped.map(_+_)++s.drop(s.size/2).take(s.size%2)
— Phönix
quelle
0

Mathematica , 52

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

JavaScript (ES6), 46 43 Byte

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

Code-Snippet anzeigen

3 Bytes mit Inspiration von Asaf gespeichert .

— Neil
quelle
Nett. Sie können '1 / c [0]' in '[] + c' ändern, um 2 Bytes zu sparen.
— Asaf
@Asaf Eigentlich denke ich c+cfunktioniert das für das dritte Byte.
— Neil
0

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.

— Jakob
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.