उल्टा ऐरे सम

34

आपके कार्यक्रम को इनपुट के रूप में एक सरणी लेना चाहिए।

सरणी:

  1. हमेशा 1 आयामी होगा
  2. केवल पूर्णांक होंगे
  3. खाली हो सकता है

कार्यक्रम को सरणी को उल्टा करना चाहिए, और फिर उदाहरण के लिए तत्वों को मूल में जोड़ना चाहिए:

इनपुट: [1, 2, 3]

मूल: [1, 2, 3]

उलट: [3, 2, 1]

[1, 2, 3]
 +  +  +
[3, 2, 1]

[1+3, 2+2, 3+1]

आउटपुट: [4, 4, 4]

परीक्षण के मामलों:

#In             #Out
[8, 92],        [100, 100]
[1, 2, 3],      [4, 4, 4]
[5, 24, 85, 6], [11, 109, 109, 11]
[],             []
[999],          [1998]

यह कोड-गोल्फ है , सबसे छोटा कोड (बाइट्स में) जीतता है!

code-golf  array-manipulation 
— नूह क्रिस्टीनो
स्रोत
जे 3 बाइट्स। कार्यक्रम टी। टी =: + |।
— रिचर्ड डोनोवन
@ रायचर्ड डोनोवन अच्छा जवाब! क्या आप टिप्पणी के बजाय जवाब के रूप में प्रस्तुत कर सकते हैं कृपया :)
— नूह क्रिस्टीनो

जवाबों:

13

हास्केल , 20 बाइट्स

5 बाइट्स निमि द्वारा सुझाए गए बिंदु तक बदलकर बचाते हैं

zipWith(+)=<<reverse

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

— गेहूं का जादूगर
स्रोत
4
जाओ बिंदु zipWith(+)=<<reverse:।
— नीम जूल
@ नोमी वाह, मैंने ऐसा करने के लिए नहीं सोचा था, लेकिन यह बहुत स्मार्ट है।
— गेहूं जादूगर
मैं सरणी कहां रखूं? मैंने TIO पर दिए गए तर्कों और इनपुट की कोशिश की
— नूह क्रिस्टीनो
@ नोहाक्रिस्टिनो मैंने टीआईओ तय किया। यह एक बिंदु-मुक्त फ़ंक्शन है, इसलिए आप फ़ंक्शन के बाद इनपुट डालते हैं, हालांकि हास्केल को mainसंकलन करने की आवश्यकता होती है ।
— गेहूं जादूगर
3
@maple_shaft: हम फंक्शन मोनाड =<<से उपयोग करते हैं जिसे निम्न के रूप में परिभाषित किया गया है (=<<) f g x = f (g x) x:। यहाँ, infix में लिखा है: (zipWith(+) =<< reverse) x-> zipWith(+) (reverse x) x।
— निम्मी
11

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

+U

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

या

+Ṛ

इसे ऑनलाइन आज़माएं! (साभार @Mr। Xcoder दूसरे कार्यक्रम के लिए)

स्पष्टीकरण, हालांकि यह बहुत आत्म-व्याख्यात्मक है

+U  Main link
+   Add, vectorizing, 
 U                    the input, reversed


+Ṛ  Main link
+   Add, vectorizing,
 Ṛ                    the input, reversed, without vectorizing (same thing for depth-1 lists)

खाली सरणी के लिए [], यह कुछ भी नहीं आउटपुट करता है। वह सही है। एक खाली सूची के जेली का प्रतिनिधित्व सिर्फ कुछ भी नहीं है। ध्यान दें कि एक तत्व के साथ एक सूची में जेली का प्रतिनिधित्व केवल तत्व ही है। संलग्न ŒṘकोड के लिए उत्पादन का अजगर आंतरिक प्रतिनिधित्व को देखने के लिए।

— HyperNeutrino
स्रोत
मुझे 2 मुद्दे मिले। 1) जब इस पर परीक्षण किया जाता है [9]तो 18 आउटपुट के बजाय [18], और 2) जब इसका परीक्षण किया []जाता है तो यह कुछ भी आउटपुट नहीं करता है।
— नूह क्रिस्टीनो
@ नोहाक्रिस्टिनो यह एक पूर्ण कार्यक्रम नहीं है, और उत्तर में इसके लिए पहले से ही एक स्पष्टीकरण है।
— एलिक आउटफोलर
तो मुझे लगता है कि यह ठीक है, यह सिर्फ है कि जेली इसे कैसे आउटपुट करता है
— नूह क्रिस्टिनो
@ नोहाक्रिस्टिनो हाँ। मैंने अपने उत्तर के अंत में एक हिस्सा जोड़ा ताकि आप कोड के अंत में उस परमाणु को देख सकें कि पायथन इसे कैसे प्रिंट करेगा।
— हाइपरनेत्रिनो
+Ṛकाम भी करता है।
— श्री एक्सकोडर
11

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

a=>[...a].map(e=>e+a.pop())

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

— नील
स्रोत
ओह, यार, मैं लगभग वहाँ था , लेकिन मैंने क्लोन करने के लिए प्रसार ऑपरेटर का उपयोग करने के बारे में नहीं सोचा था।
— रिक हिचकॉक
क्या आप इसे जोड़ सकते हैं एम्बेडेड जावास्क्रिप्ट के लिए प्रयास करें?
— नूह क्रिस्टिनो
7

पायथन 2 , 40 बाइट्स

lambda l:[i+j for i,j in zip(l,l[::-1])]

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

अन्य, छोटे पायथन जवाब के साथ एक सूची समझ की जगह लेता है map। काश मैं उस तेजी से करने के लिए सोचा था। ; -;

— totallyhuman
स्रोत
1
मेरे सारे टेस्ट पास कर लेता है!
— नूह क्रिस्टीनो
7

जाप , 7 बाइट्स

mÈ+Ug~Y

इसे ऑनलाइन आज़माएं! -Qआउटपुट सरणी को प्रारूपित करने के लिए ध्वज के साथ ।

व्याख्या

निहित: U= इनपुट सरणी

mÈ

निम्नलिखित फ़ंक्शन द्वारा इनपुट को मैप करें ...

+Ug

सूचकांक में इनपुट सरणी में मान, प्लस ...

~Y

-(index+1), जो सरणी के अंत से तत्व प्राप्त करता है।

— जस्टिन मेरिनर
स्रोत
1
बहुत बढ़िया! मुझे मल्टीपल इनपुट चीज़ पसंद है!
— नूह क्रिस्टीनो
1
मुझे वास्तव में मल्टीपल इनपुट जेप्ट इंटरप्रेटर पसंद है। अच्छी नौकरी!
— ओलिवर
यह वास्तव में अच्छा है :-) मैं उस सुविधा को "आधिकारिक" दुभाषिया में जोड़
— दूंगा
6

पायथन 2 , 33 32 बाइट्स

-1 बाइट @xnor के लिए धन्यवाद

lambda l:[i+l.pop()for i in l*1]

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

— OVS
स्रोत
मेरी सारी परीक्षाएँ अच्छी
— चलीं
क्या असामान्य विधि है। l*1एक बाइट बचाता है।
— xnor
मुझे बराबर समझने में कठिनाई हो रही है l*1, कोई विस्तार
— dhssa
@dhssa l*1सूची की एक प्रति बनाता है l। यदि हम प्रतिलिपि नहीं बनाते हैं, pop()तो वे लूप में पहुँचने से पहले तत्वों को सूची से हटा देंगे।
— अंडा जूल
स्पष्टीकरण के लिए धन्यवाद, मुझे अब मिल गया है। कोडिंग के लिए अच्छी चाल।
— dhssa
5

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

-1 बाइट थेल्कोडर की बदौलत

a=>a.Reverse().Zip(a,(x,y)=>x+y).ToArray()

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

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

using System.Linq;

स्पष्टीकरण के लिए - LINQ में Zip फ़ंक्शन दो संग्रह लेता है और सभी संबंधित तत्वों के लिए दिए गए फ़ंक्शन को निष्पादित करता है, अर्थात। दोनों पहले तत्व एक साथ, दोनों दूसरे तत्व आदि।

— ग्रेज़गोरज़ पुलावस्की
स्रोत
1
अच्छा उत्तर। इनपुट के बारे में टिप्पणी के लिए धन्यवाद।
— नूह क्रिस्टिनो
1
नमस्कार और PPCG में आपका स्वागत है! आपको बाइट काउंट में ट्रेलिंग सेमी कोलोन की जरूरत नहीं है। मेरा मानना ​​है कि आप संग्रह को सीधे Zipकॉल से वापस कर सकते हैं ताकि इसकी कोई आवश्यकता न हो ToArray()। अच्छी नौकरी!
— द लीथाल्कर कोड
@ TheLethalCoder धन्यवाद, और मैंने ToArray () को जोड़ा क्योंकि चुनौती सरणियों के बारे में है, इसलिए मैं चाहता था कि आत्म निहित लैम्ब्डा सरणी -> सरणी हो।
— ग्रेज़गोरज़ पूलावस्की
4

सीजेएम , 7 बाइट्स

{_W%.+}

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

— आउटग्रॉफर को एरिक करें
स्रोत
यह आउटपुट ""के लिए [], कि अजीब है। आपकी गलती सिर्फ भाषा की नहीं है।
— नूह क्रिस्टीनो
@ नोहाक्रिस्टिनो सीजेएम का प्रतिनिधित्व है []।
— एलिक्जेल आउट
हाँ, मेरी चुनौती के लिए एक मानक आउटपुट होना मुश्किल है क्योंकि कई भाषाएं विशेष रूप से अलग-अलग सरणियों को प्रदर्शित करती हैं [], और [4], इसलिए यह ठीक है।
— नूह क्रिस्टीनो
4

APL (Dyalog) , 3 बाइट्स

⌽+⊢

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

व्याख्या

⌽          The argument reversed
+           Plus
⊢          The argument
— क्रिकटी लिथोस
स्रोत
1
ninja'd। मुझे एक एपीएल कीबोर्ड पर जाने की जरूरत है ... xD
— उरियल
@ एरियल मैं हमेशा अपने एपीएल कीबोर्ड पर हूँ: डी
— क्रिति लिथोस
सादगी से प्यार करो। यह ⌽+⊢बिना इनपुट के आउटपुट देता है
— नूह क्रिस्टिनो
@ नोहाक्रिस्टिनो एक खाली इनपुट के साथ निर्दिष्ट है ⍬, खाली वेक्टर। बिना किसी तर्क के, यह ट्रेन को खुद से प्रिंट करता है
— क्रिति लिथोस
4

आर , 17 16 बाइट्स

-1 बाइट धन्यवाद djhurio के लिए

rev(l<-scan())+l

स्टड से पढ़ता है; वेक्टर लौटाता है; numeric(0)खाली सूची के लिए शून्य-लंबाई संख्यात्मक वेक्टर है।

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

— ग्यूसेप
स्रोत
एक खाली "एरे" के लिए यह लौटता हैnumeric(0)
— नूह क्रिस्टीनो
1
@ नोहाक्रिस्टिनो एक खाली वेक्टर को numeric(0)आर। के रूप में दर्शाया गया है
— लीकी नून
कोई बात नहीं। @LeakyNun
— नूह क्रिस्टीनो
1
rev(l<-scan())+l, 16 बाइट्स?
— djhurio
रिकॉर्ड के लिए, R + pryr कार्यात्मक विकल्प सिर्फ एक बाइट लंबा है:pryr::f(rev(x)+x)
— JayCe
3

पॉवरशेल , 26 बाइट्स

($a=$args)|%{+$a[--$i]+$_}

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

कमांड-लाइन तर्कों के रूप में इनपुट लेता है।

— एक छोटा सा सिक्का
स्रोत
क्या आप एक TIO जोड़ सकते हैं? और इस तरह एक नाम के तहत एक लिंक: codegolf.stackexchange.com/a/135427/61877
— नूह क्रिस्टिनो
@ नोहाक्रिस्टिनो: इस तरह? उस चीज़ का अब तक उपयोग नहीं किया गया है, इसलिए मुझे पता नहीं है कि मैंने क्या गलत किया है। वैसे, यदि आप उम्मीद करते हैं कि लोग अपने उत्तरों में एक निश्चित सेवा का उपयोग करेंगे, तो कृपया कार्य विवरण में बताएं।
— जॉय
कोई बात नहीं। यह आवश्यक नहीं है कि यह उत्तर को अधिक उच्च गुणवत्ता वाला बनाता है, और भविष्य के दर्शकों के लिए परीक्षण करना आसान है।
— नूह क्रिस्टीनो
3

सी, 49 बाइट्स

f(a,n,b)int*a,*b;{for(b=a+n;a<b--;a++)*a=*b+=*a;}
— orlp
स्रोत
नहीं a,n,bहोना चाहिए a,b,nया कुछ और?
— एरिक आउटगोल्फर
@EriktheOutgolfer नहीं, bफ़ंक्शन के लिए कोई पैरामीटर नहीं है, गोल्फिंग कारणों से इसमें भरी हुई एक अतिरिक्त परिभाषा है। aपूर्णांक के लिए एक सूचक nहोना चाहिए , और सरणी में कितने पूर्णांक हैं।
— orlp
क्या आप कृपया TIO लिंक जोड़ सकते हैं?
— नूह क्रिस्टीनो
3

पॉवरशेल , 40 32 बाइट्स

($n=$args)|%{$n[-++$i]+$n[$i-1]}

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

व्यक्तिगत कमांड-लाइन तर्कों के रूप में इनपुट लेता है, जिसे पॉवरशेल के लिए मूल सूची प्रारूप में से एक के रूप में अनुमति दी जाती है। फिर प्रत्येक तत्व के माध्यम से लूप (यानी, सूचकांकों के माध्यम से लूपिंग का एक छोटा तरीका), तत्व को पीछे से ( -1मौजूदा अनुक्रमित) से जोड़कर वर्तमान तत्व (0 अनुक्रमित है, इसलिए कमी होती है-1 ) । उन्हें पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

@ बायरेंटिस्ट को 8 बाइट्स से बचा लिया

— AdmBorkBork
स्रोत
यह एक सरणी का उत्पादन नहीं करता है।
— नूह क्रिस्टीनो
1
@ नोहाक्रिस्टिनो पॉवरशेल इनपुट / आउटपुट सामान्य रूप से, अजीब है। यह एक सरणी के रूप में आउटपुट कर रहा है, यह सिर्फ उक्त सरणी को कैप्चर करने के लिए कुछ भी नहीं है, और इसलिए जब निहित Write-Outputहोता है, तो यह प्रति पंक्ति एक आइटम stdout पर चीजें डालता है। उदाहरण के लिए, आप यहां देख सकते हैं कि जब कब्जा किया जाता है, तो वस्तु वास्तव में एक arrayप्रकार है।
— AdmBorkBork
बहुत अच्छा है :) कम से कम यह कोशिश की
— नूह क्रिस्टीनो
मैं मोबाइल पर हूँ और इतनी आसानी से परीक्षण नहीं कर सकते, लेकिन यह 1 बाइट कम दूर करने के लिए नहीं है paramऔर उसके बाद की जगह 1..$nके साथ 1..($n=$args)?
— रिश्वतखोर
@briantist काफी नहीं है, लेकिन आपने मुझे इसके बारे में सोचने का एक अलग तरीका दिया, बाइट्स का एक गुच्छा बचा। धन्यवाद!
— AdmBorkBork
3

जावा 8, 61 57 56 53 बाइट्स

a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}

-1 बाइट और करने के लिए बग तय धन्यवाद @Nevay ।
-3 बाइट्स @ ओलिवरग्रेगायर के लिए धन्यवाद ।

(यह @jkelm के C # उत्तर का एक पोर्ट था (और 4 8 बाइट्स द्वारा गॉल्फ़्ड किया गया था ) , लेकिन अब यह @ OliverGrégoire के लिए एक अलग समाधान है। ।)

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

विधि बाइट को बचाने के लिए इनपुट-सरणी को संशोधित करती है, इसलिए रिटर्न-प्रकार की कोई आवश्यकता नहीं है।

a->{                    // Method with integer-array parameter and no return-type
  for(int l=0,          //  Left-integer (starting at 0)
          r=a.length;   //  Right-integer (starting at the length of the input-array)
      l<r;              //  Loop as long as left is smaller than right
    a[l]=               //   Change the number at the current left index to:
         a[--r]+=a[l++] //    The number at the right index + itself
                        //    (The += adds the number at the left index also to the right index)
                        //    (And the --/++ increases/decreases the indexes by 1,
                        //     until we've reached the middle of the array)
  );                    //  End of loop
}                       // End of method
— केविन क्रूज़सेन
स्रोत
1
आप का उपयोग करके 1 बाइट बचा सकते हैं a->{for(int i=0,l=a.length;i<l/2;a[i]=a[l+~i]+=a[i++]);}।
— नेवई
1
इसके अलावा कोड एक विषम लंबाई 1,2,3( 4,2,4बदले में रिटर्न 4,4,4) के साथ सरणियों के लिए विफल रहता है , लूप को लंबे समय तक चलना होता है 2*i<l, न कि i<l/2।
— नेवई
@ नवीन धन्यवाद मुझे पता था कि यह गोल्फ के लिए संभव होना चाहिए l-i-1, बस इसके साथ नहीं आ सकता है ..
— केविन क्रूज़सेन
2
53 बाइट्स: a->{for(int l=0,r=a.length;l<r;a[l]=a[--r]+=a[l++]);}।
— ओलिवियर ग्रेजायर
1
@ ओलिवियरग्रेगायर धन्यवाद। और आपके lऔर rआपके कार्यान्वयन के लिए समझ में आता है, इसलिए मैंने उन का भी उपयोग किया है (और स्पष्टीकरण जोड़ा है)।
— केविन क्रूज़सेन
2

दरअसल , 4 बाइट्स

;R♀+

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

— आउटग्रॉफर को एरिक करें
स्रोत
बिल्कुल सही, बढ़िया काम।
— नूह क्रिस्टीनो
एरिक, मेरी समस्या को 7 भाषाओं में हल कर रहा है जैसे xD
— नूह क्रिस्टीनो
@NoahCristino हाँ मैं 15 के तहत इसे रखने के लिए कोशिश कर रहा हूँ ...;)
— एरिक Outgolfer
मैं हर प्रस्तुत xD के लिए -1 जोड़ना शुरू करने जा रहा हूँ
— नूह क्रिस्टीनो
2

किसी भी उपसर्ग , 3 बाइट्स

"U+

TryItOnline पर संस्करण! किसी भी उपसर्ग का पुराना संस्करण है, जिसमें कुछ घातक त्रुटियां हैं जैसे कि स्रोत कोड में टाइपोस के कारण सूची को जोड़ने में सक्षम नहीं होना। इसके बजाय GitHub पर कोड का उपयोग करें।

"U+  Program
"    Duplicate top of stack
 U   Reverse top of stack if it is a list (which it should be...)
  +  Add, vectorizing for lists
— HyperNeutrino
स्रोत
2

नीम , 2 बाइट्स

यह एक फ़ंक्शन है जो स्टैक के शीर्ष पर इनपुट लेता है और स्टैक के शीर्ष पर आउटपुट होता है।

𝕓𝔻

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

— Okx
स्रोत
क्या सामान्य इनपुट विधियों के बजाय वास्तविक नीम कोड के माध्यम से इनपुट स्टैक को संशोधित करने की अनुमति है?
— LiefdeWen
@LiefdeWen हाँ, कि I / O मेटा पोस्ट के लिए डिफॉल्ट में अनुमति है।
— ओकेक्स
2

रोदा , 22 बाइट्स

{reverse(_)<>_1|[_+_]}

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

यह एक अनाम फ़ंक्शन है जो किसी सरणी में लेता है और मानों की एक धारा लौटाता है, जिसे TIO लिंक आउटपुट नईलाइन्स पर अलग कर देता है।

व्याख्या

reverse(_)          The array reversed
<>                  interleaved with
_1                  the array itself
                    Push each element to the stream
[_+_]               Pull two values and push their sum
— क्रिकटी लिथोस
स्रोत
मेरे टेस्ट पास करता है! बहुत बढ़िया जवाब।
— नूह क्रिस्टिनो
2

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

@ETHproductions के लिए एक बाइट धन्यवाद सहेजा गया।

a=>a.map((e,i)=>e+a[a.length+~i])

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

— रिक हिचकॉक
स्रोत
मुझे यह पसंद है कि आप परीक्षण के मामलों में कैसे डालते हैं, +2
— नूह क्रिस्टिनो
मुझे लगता है कि आप को बदलने के द्वारा एक बाइट बचा सकते हैं -i-1करने के लिए +~i।
— ETHproductions
@ETHproductions, हाँ, धन्यवाद!
— रिक हिचकॉक
2

PHP, 59 बाइट्स

for(;a&$c=$argv[++$i];)$a[]=$c+$argv[$argc-$i];print_r($a);

कमांड लाइन तर्कों से इनपुट लेता है; खाली इनपुट के लिए खाली आउटपुट

PHP> 7.0 में चेतावनी देता है। यह संस्करण (60 बाइट्स) नहीं है:

for(;++$i<$argc;)$a[]=$argv[$i]+$argv[$argc-$i];print_r($a);
— टाइटस
स्रोत
अच्छा जवाब! :)
— नूह क्रिस्टिनो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.