Bir tamsayı listesi katlayacağız. Bunu yapma prosedürü aşağıdaki gibidir: Liste eşit uzunluktaysa, yeni listenin ’maddesinin eski listenin item maddesinin ve the ila eski listenin son maddesi. Mesela listemiz olsaydı

[1 2 3 4 5 6 7 8]

Öyle katlayacağız

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

Liste tuhaf bir uzunluktaysa, katlamak için önce ortadaki öğeyi kaldırır, eşitmiş gibi katlar ve ortadaki öğeyi sonuçlara ekleriz.

Mesela listemiz olsaydı

[1 2 3 4 5 6 7]

Öyle katlayacağız

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

Görev

Girdi olarak tam sayıların listesini alan ve katlanmış olan listenin çıktılarını gösteren bir program veya işlev yazın.

Bu bir kod-golf sorusudur, bu yüzden cevaplar daha az byte daha iyi olacak şekilde byte olarak puanlanır.

Örnek uygulama

İşte Haskell'de fkatlama yapan bir işlevi tanımlayan bir uygulama .

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

Çevrimiçi deneyin!

Python , 46 bayt

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

Çevrimiçi deneyin!

Aynı uzunluk:

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

Uzun listeler için çok daha kısa bir çözüm çalışıyor (30 bayt)

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

Çevrimiçi deneyin!

Hala tek uzunluğu düzeltmek için kısa bir yol bulmaya çalışıyorum.

05AB1E , 5 bayt

kod

2ä`R+

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

açıklama

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

Emojicode , 203 bayt

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

Bu benim için kod için en acı Emojicode cevap oldu. Gereksiz uzunluk: /

Çevrimiçi deneyin!

Japt , 21 18 16 bayt

l
íUj°V/2V w)mx

Çevrimiçi test edin!

Tamamen korkunç @Oliver sayesinde biraz daha az korkunç . BRB daha fazla uygulama yaptıktan ve bazı hataları giderdikten sonra ...

Gaia , 7 bayt

e2÷ev+†

açıklama

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 bayt

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

Mathematica 57 Bayt

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

Orta noktaya sıfır ekler, listeyi tersine ekler ve uygun uzunluğu alır.

Japt , 12 bayt

å@o +Y*(Z<Ul

Çevrimiçi deneyin! -QBiçimlendirilmiş diziyi görüntülemek için bayrakla işaretleyin.

Alternatif çözüm, 14 bayt

o(½*Ul)c)íU mx

Çevrimiçi deneyin!

Jöle , 7 bayt

œs2U2¦S

Çevrimiçi deneyin!

-2 ETHproductions sayesinde ... ve daha önce farkına varıyorum .

JavaScript (Node.js) , 53 bayt

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

Çevrimiçi deneyin!

Başka bir öneri:

JavaScript (Node.js) , 43 bayt

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

Çevrimiçi deneyin!

R , 81 70 68 57 bayt

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

Çevrimiçi deneyin!

adsız işlev; sonucu döndürür.

Python 3 , 101 bayt

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]

Çevrimiçi deneyin!

Python 3 , 70 bayt

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

Çevrimiçi deneyin!

JavaScript, 75 71 bayt

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

Çevrimiçi deneyin

ETHproductions sayesinde 2 bayt kurtardı

JavaScript (ES6), 41 bayt

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 bayt

`6L&)swtn

Çevrimiçi deneyin!

Nasıl çalışır

Bir dizi Verilen [a b c ... x y z], bırakıldığında yukarı [a z]"kabuk" altdizilim çağırılabilir ve[b c ... y z] "çekirdek" SubArray.

Kod, kabuğu kaldıran, toplamını hesaplayan ve bir sonraki tekrarlamaya hazır olan çekirdeği yığının en üstüne taşıyan bir döngüden oluşur. Döngü koşulu, çekirdek alt dizideki öğelerin sayısıdır

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

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

Çevrimiçi deneyin!

C # (.NET Core) , 118 111 bayt

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

Bayt sayısı da içerir

using System.Linq;

Çevrimiçi deneyin!

Girdi olarak lütfen virgülle ( ,) veya boşlukla ayrılmış sayıları kullanın . Açıklama:

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 karakter

alt f {@ a = harita {$ + pop} splice @ , 0, @ / 2; @ a, @ }

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

Örneğin şöyle deneyin:

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

Pyth, 18 17 13 bayt

V.Tc2Q aYsN;Y

Benim orijinal yaklaşımım

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

Bay Xcoder sayesinde -1 bayt

FryAmTheEggman sayesinde -4 bayt

C ++ 17, 75 73 71 bayt

Adsız lamda olarak, vectorveya benzeri bir kabı kabul etmek list, girişi değiştirerek geri döner:

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

İyi bilinen 'gider' operatörünü <--ve üçlü artı'yı kullanma+++

Ungolfed ve örnek:

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

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

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 21 bayt ^SBCS

@ Adám sayesinde -3 bayt.

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

Çevrimiçi deneyin!

Açıklama:

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

Ortak Lisp, 106 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 62 bayt

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

Çevrimiçi deneyin!

Scala, 91 bayt

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

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}

Asaf'tan ilham alınarak 3 bayt kurtarıldı .

Java 8, 93 bayt

Çift haneli! Bu bir alır int[]ve bir döndürür bir lambda 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);
}

Oldukça açık. İkinci yarıyı girişteki ilk yarıya katlar ve sadece ilk yarıdan bir kopyasını döndürür.

Şaşırtıcı bir şekilde, return ifadesindeki dizi kopyası, tuhaf uzunluktaki girdiler için son öğe tuhaflığını kullanmanın en ucuz yolu gibi görünüyor.

PHP , 67 bayt

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

Çevrimiçi deneyin!