सूची को आधा में मोड़ो

24

हम पूर्णांकों की सूची को मोड़ने जा रहे हैं। ऐसा करने की प्रक्रिया इस प्रकार है, यदि सूची समान लंबाई की है, तो उसकी आधी लंबाई की एक सूची बनाएं जहां नई सूची का nth आइटम पुरानी सूची के nth आइटम और nth-to- का योग है पुरानी सूची का अंतिम आइटम। उदाहरण के लिए यदि हमारे पास सूची थी

[1 2 3 4 5 6 7 8]

हम इसे इस तरह मोड़ेंगे

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

यदि सूची विषम लंबाई की है, तो इसे मोड़ने के लिए हम पहले मध्य वस्तु को हटाते हैं, इसे मोड़ते हैं जैसे कि यह भी था और परिणाम के लिए मध्य वस्तु को जोड़ते हैं।

उदाहरण के लिए यदि हमारे पास सूची थी

[1 2 3 4 5 6 7]

हम इसे इस तरह मोड़ेंगे

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

कार्य

एक प्रोग्राम या फ़ंक्शन लिखें जो पूर्णांक की सूची को इनपुट के रूप में लेता है और उस सूची को आउटपुट करता है जो मुड़ा हुआ है।

यह एक कोड-गोल्फ प्रश्न है, इसलिए उत्तर बाइट्स में स्कोर किए जाएंगे, कम बाइट्स बेहतर होने के साथ।

नमूना कार्यान्वयन

यहां हास्केल में एक कार्यान्वयन है जो एक फ़ंक्शन को परिभाषित करता है fजो एक गुना प्रदर्शन करता है।

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

इसे ऑनलाइन आज़माएं!

code-golf  array-manipulation 
— गेहूं का जादूगर
स्रोत
जब आप पूर्णांक कहते हैं, तो क्या इसमें शून्य या नकारात्मक पूर्णांक शामिल हैं?
— नील
1
@ नील यह करता है।
— गेहूं जादूगर
2
@ GrzegorzPuławski आपको सूची को क्रमबद्ध नहीं करना चाहिए। किसी भी ऑर्डर किए गए संग्रह की अनुमति है, जैसे वेक्टर या सरणी।
— गेहूं जादूगर
1
@DavidStarkey अधिकांश उचित सूचियाँ स्मृति की उचित मात्रा के साथ अतिप्रवाह नहीं करेंगी। तह वास्तव में योग को बढ़ाता नहीं है इसलिए सूची मूल सूची के योग के एक सिंगलटन में परिवर्तित हो जाएगी।
— गेहूं जादूगर
2
@WheatWizard मैं इसके बारे में नहीं जानता, मैंने सुना है कि किसी भी सूची को आधे से अधिक 7 बार मोड़ना असंभव है।
— कार्मिस्टर

जवाबों:

9

पायथन , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक ही लंबाई:

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

सम-लंबाई सूची (30 बाइट) के लिए बहुत छोटा समाधान काम करता है

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

इसे ऑनलाइन आज़माएं!

मैं अभी भी विषम लंबाई के लिए इसे ठीक करने के लिए एक छोटा रास्ता खोजने की कोशिश कर रहा हूं।

— XNOR
स्रोत
ओह, मुझे बहुत अच्छा लगा ÷ _
— Mr.
"मिडिल ग्राउंड" समाधान f=lambda l:l[1:]and[l[0]+l.pop()]+f(l[1:])or lभी समान लंबाई है ...
— ETHproductions
8

इमोजीकोड , 203 बाइट्स

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

यह मेरे लिए कोड करने के लिए सबसे दर्दनाक इमोजीकोड उत्तर था। अनावश्यक लंबाई: /

इसे ऑनलाइन आज़माएं!

— betseg
स्रोत
4

जाप , 21 18 16 बाइट्स


l
íUj°V/2V w)mx

इसे ऑनलाइन टेस्ट करें!

पूरी तरह से भयानक थोड़ा कम भयानक @ धन्यवाद करने के लिए धन्यवाद । BRB के बाद मैं अधिक बिल्ट-इन्स लागू करता हूँ और कुछ बग्स को ठीक करता हूँ ...

— ETHproductions
स्रोत
3

गैया , 7 बाइट्स

e2÷ev+†

व्याख्या

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.
— बिजनेस कैट
स्रोत
2

गणितज्ञ, 88 बाइट्स

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

गणितज्ञ 57 बाइट्स

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

मध्य बिंदु पर एक शून्य सम्मिलित करता है, सूची को इसके विपरीत में जोड़ता है और उचित लंबाई लेता है।

— केली लोडर
स्रोत
2

जेली , 7 बाइट्स

œs2U2¦S

इसे ऑनलाइन आज़माएं!

-2 ETHproductions के लिए धन्यवाद ... और मुझे पहले एहसास हुआ।

— आउटगोल्फर को एरिक करें
स्रोत
ETH सही था, 7 बाइट्स
— श्री ज़्कोडर
@ETHproductions धन्यवाद, हालाँकि मैंने अपना कंप्यूटर बंद करने के बाद पहले ही पता लगा लिया था।
— आउटगॉल्फ
1

जावास्क्रिप्ट (ईएस 6), 41 बाइट्स

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

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
1

MATL , 9 बाइट्स

`6L&)swtn

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

एक सरणी को देखते हुए [a b c ... x y z], [a z]"क्रस्ट" सबर्रे कहा जाना चाहिए और[b c ... y z] "कोर" सब्रे ।

कोड में एक लूप होता है जो क्रस्ट को हटाता है, इसकी राशि की गणना करता है, और कोर को स्टैक के शीर्ष पर ले जाता है, अगले पुनरावृत्ति के लिए तैयार होता है। लूप स्थिति कोर सबअरे में तत्वों की संख्या है

`       % 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)
— लुइस मेंडो
स्रोत
1

सी # (.NET कोर) , 118 111 बाइट्स

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

बाइट काउंट में भी शामिल हैं

using System.Linq;

इसे ऑनलाइन आज़माएं!

इनपुट के रूप में कृपया कॉमा ( ,) या स्थान के साथ अलग किए गए नंबरों का उपयोग करें । स्पष्टीकरण:

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
);
— ग्रेज़गोरज़ पुलावस्की
स्रोत
क्या आप चर को लंबाई सेट करके और स्पष्ट रिटर्न पर स्विच करके बाइट्स बचा सकते हैं?
— द लीथलकोडर 8
@ लीथलकोडर दुर्भाग्य से यह लंबा है
— ग्रेज़गोरज़ पुलावस्की
1

पर्ल, 42 38 चर

उप f {@ a = नक्शा {$ + पॉप} ब्याह @ , 0, @ / 2, @ ए, @ } ;

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

उदाहरण के लिए कोशिश करें:

perl -e 'my @input=(1..9); sub f{(map{$_+pop}splice@_,0,@_/2),@_}  print join(",",f(@input));
— bytepusher
स्रोत
1
एक त्रुटि है कि चर के लिए मेरे भावनात्मक और पेशेवर लगाव के कारण crept। जेएस: पी द्वारा बहिष्कृत होने से इनकार
— bytepusher
1

पायथ, 18 17 13 बाइट्स

V.Tc2Q aYsN;Y

मेरा मूल दृष्टिकोण था

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

-1 बाइट मिस्टर एक्सकोडर की बदौलत

-4 बाइट्स FryAmTheEggman को धन्यवाद

— डेव
स्रोत
c2<list>एक सूची को आधे में विभाजित करने के लिए उपयोग करने का प्रयास करें । एक और आदेश जो उपयोगी हो सकता है .T।
— फ्राईअमईएग्गमैन
17 बाइट्स:WtQ aY+.)Q.(Q0;+Y
— मिस्टर एक्सकोडर
1

सी ++ 17, 75 73 71 बाइट्स

अनाम लैम्ब्डा के रूप में, जैसे कंटेनर को स्वीकार करना vector या list, इनपुट को संशोधित करके लौटाता है:

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

जाने-माने 'गो-टू' ऑपरेटर <--और ट्रिपल प्लस का उपयोग करना+++

अधूरा और उदाहरण:

#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);
}
— कार्ल नेफ
स्रोत
1

एपीएल (Dyalog यूनिकोड) , 21 बाइट्स SBCS

-3 बाइट्स @ Adám को धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

(⌊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
स्रोत
Dyalog विस्तारित, 18 बाइट्स:+⌿(⌊2÷⍨≢)(↑↑⍮⌽⍤↓)⊢
— Adám
प्रशिक्षण, 21 बाइट्स: (⌊2÷⍨≢)(↑{+⌿↑⍺⍵}∘⌽↓)⊢`
— एडम
0

स्काला, 91 बाइट्स

(s:Seq[Int])=>(s.take(s.size/2),s.reverse).zipped.map(_+_)++s.drop(s.size/2).take(s.size%2)
— अचंभा
स्रोत
0

जावास्क्रिप्ट (ईएस 6), 46 43 बाइट्स

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

कोड स्निपेट दिखाएं

आसफ से प्रेरणा लेकर 3 बाइट्स बचाए ।

— नील
स्रोत
अच्छा लगा। आप 2 बाइट्स को बचाने के लिए '1 / c [0]' को '[] + c' में बदल सकते हैं।
— आसफ
@ आसफ दरअसल मुझे लगता है c+c है कि तीसरी बाइट के लिए काम करता है।
— नील
0

जावा 8, 93 बाइट्स

दहाई का आंकड़ा! यह एक लंबोदर है जो एक int[]रिटर्न लेता है और एक रिटर्न देता है 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);}

अघोषित लंबोदर

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

काफी निष्कपट। यह इनपुट के पहले हाफ में दूसरी छमाही को मोड़ता है और सिर्फ पहले हाफ की कॉपी लौटाता है।

हैरानी की बात है कि रिटर्न स्टेटमेंट में सरणी कॉपी विषम-लंबाई इनपुट के लिए अंतिम तत्व क्विक को संभालने का सबसे सस्ता तरीका है।

— जेकब
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.