एन-डायमेंशनल सरणी को उल्टा करें

Question

विवरण

एक फ़ंक्शन या प्रोग्राम लिखें, जो एक सरणी (या सूची) दिया गया है, जिसमें केवल पूर्णांक, रिटर्न या आउटपुट में सभी उप-तत्वों के साथ एक सरणी है। यही है, सबसे गहरी सरणी के सभी तत्वों को उल्टा करें, फिर दूसरा सबसे गहरा, आदि। आयामों को निर्दिष्ट करने की आवश्यकता नहीं है, लेकिन फ़ंक्शन या प्रोग्राम को आपकी प्रोग्रामिंग भाषा के मूल प्रारूप में दांतेदार सरणियों के लिए काम करना चाहिए ।

---

उदाहरण

इस:

[[1,2], [3,4]]

यह बन जाएगा:

[[4,3], [2,1]]

---

इस:

[[[ 1, 2, 3], [ 4, 5, 6], [ 7, 8, 9]],
 [[10,11,12], [13,14,15], [16,17,18]],
 [[19,20,21], [22,23,24], [25,26,27]],
 [[28,29,30], [31,32,33], [34,35,36]],
 [[37,38,39], [40,41,42], [43,44,45]],
 [[46,47,48], [49,50,51], [52,53,54]]]

यह बन जाएगा:

[[[54,53,52], [51,50,49], [48,47,46]],
 [[45,44,43], [42,41,40], [39,38,37]],
 [[36,35,34], [33,32,31], [30,29,28]],
 [[27,26,25], [24,23,22], [21,20,19]],
 [[18,17,16], [15,14,13], [12,11,10]],
 [[ 9, 8, 7], [ 6, 5, 4], [ 3, 2, 1]]]

---

इस:

[[[1,2]],
 [[3,4], [5]],
 [[6,7,8], [9], [10,11]],
 [[[12,13], [14,15]], [16], [17,18,19,20]],
 [21]]

यह बन जाएगा:

[[21],
 [[20,19,18,17], [16], [[15,14], [13,12]]],
 [[11,10], [9], [8,7,6]],
 [[5], [4,3]],
 [[2,1]]]

---

बक्शीश

यह कुछ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषाओं में उत्तरोत्तर प्रोत्साहित करेगा ...

-50% बाइटकाउंट यदि आपका प्रोग्राम अपने सदस्य के विभिन्न प्रकारों के साथ एक सरणी (या सूची) के रूप में ले सकता है (ये ऑब्जेक्ट के रूप में हो सकता है) और सफलतापूर्वक सभी सरणियों को उल्टा कर दें।

इस:

[["Foo",["Bar",1]],
  2,
 ["Baz"],
 [[["Qux"],3],3.14]]

यह बन जाएगा:

[[3.14,[3,["Qux"]]],
 ["Baz"],
  2,
 [[1,"Bar"],"Foo"]]

Comments

अपने बोनस उदाहरण में, आप स्ट्रिंग्स को परमाणुओं के रूप में मानते हैं। मेरा तर्क है कि वे उप-सरणी हैं, और इस प्रकार उलटा भी होना चाहिए। यह वास्तव में है कि मेरे एपीएल समाधान सामान्य स्ट्रिंग्स को खिलाए जाने पर क्या करता है, क्योंकि एपीएल में एक स्ट्रिंग डेटाटाइप नहीं है, केवल चरित्र डेटाैटिप्स। स्ट्रिंग्स इसलिए एक आयामी चरित्र सरणियाँ हैं। यदि आप तार को सामान्य क्रम में रखना चाहते हैं, तो आपको बस उन्हें प्रदर्शन प्रपत्र के साथ ऑब्जेक्ट बनाना होगा।

— आदम

@ N @ क्या आप मानते हैं कि -50% Bytecount बहुत उदार है? मैं विभिन्न डेटा प्रकारों के लिए -30% बाइटकाउंट की तर्ज पर कुछ कर सकता हूं, और कुछ -10% बाइटकाउंट को स्ट्रिंग्स को उलटने के लिए, -15% बाइटकाउंट को पूर्णांक प्रकार (123 -> 321) और उलटने के लिए -15% बाइटकाउंट के लिए। एक अस्थायी प्रकार (3.14 -> 41.3)।

— मि। रिपब्लिक

मैं आमतौर पर बोनस को नापसंद करता हूं। पूर्णांकों और फ़्लोटर्स को उलट देना दिलचस्प है।

— आदम

इसे अभी के लिए छोड़ दें, लेकिन अगली बार, आप सैंडबॉक्स का उपयोग ऐसी चीजों का पता लगाने के लिए कर सकते हैं।

— आदम

बोनस के बारे में ...

— मार्टिन एंडर

Answer 1

पायथ, 11 - 50% = 5.5 बाइट्स

L?+IbY_yMbb

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट ।

यह एक फ़ंक्शन को परिभाषित करता है y। अतिरिक्त 3 बाइट्स <newline>yQकेवल फ़ंक्शन को इनपुट सूची के साथ कॉल करते हैं और इसलिए उन्हें बाइट्स कुल की गणना करने की आवश्यकता नहीं है।

स्पष्टीकरण:

L?+IbY_yMbb
L             define a function y(b), that returns:
 ?+IbY           if b + [] == b (test if b is a list):
      _yMb           recursively call y on all elements in b, then reverse the list
          b      else: b

Answer 2

दिल्लोग एपीएल , 14 - 50% = 7 बाइट्स

{∇¨⍣(×|≡⍵)⌽⍵}

⌽⍵रिवर्स तर्क
⍣(×|≡⍵)यदि तर्क एक परमाणु नहीं है ([पूर्ण] गहराई का संकेत) ...
∇¨... प्रत्येक तत्व (उल्टे तर्क का) के लिए फ़ंक्शन लागू करें।

यदि ⎕ML←3(IBM शैली), जो APL2 से माइग्रेट किए गए सिस्टम पर मामला है, तो एक बाइट को हटाकर बचाया जा सकता है |।

APL ऑनलाइन प्रयास करें ।

जिज्ञासा के लिए, प्रस्तावित इंट और फ्लोट रिवर्सिंग:

{∇¨⍣(×≡⍵){0::⌽⍵⋄⍎⌽⍕⍵}⍵}

आंतरिक कार्य:

0::⌽⍵यदि कोई त्रुटि होती है, तो बस फिर से तर्क करें
⍎⌽⍕कि स्ट्रिंग, रिवर्स, संख्या में करें

Answer 3

प्रोलॉग, 40 - 50% = 20 बाइट्स

a(X,Y):-reverse(X,Z),maplist(a,Z,Y);X=Y.

यह पुनरावर्ती कॉल विधेय a/2के साथ maplist/3, सूची के प्रत्येक सदस्य के लिए, जब तक reverse/2विफल रहता है (यानी पिछले तत्व एक सूची नहीं था)।

Answer 4

अजगर 2, 40 - 50% = 20

f=lambda x:map(f,x)[::-1]if"">x>[]else x

बोनस प्राप्त करने के लिए मूल तरीके से आवश्यक कुछ मामूली संशोधनों की ही आवश्यकता होती है। इस तथ्य का उपयोग करता है कि सभी सूचियां खाली स्ट्रिंग से कम हैं, और सभी संख्या खाली सूची से कम हैं।

सभी परीक्षण मामले

Comments

बस ध्यान दें कि बोनस के बिना संस्करण है f=lambda x:map(f,x)[::-1]if x>[]else x।

— mbomb007

Answer 5

एमएसीएस लिस्प, 46 बाइट्स * 0.5 = 23

(defun g(x)(if(atom x)x(mapcar'g(reverse x))))

उपयोग उदाहरण: (g '((1 2) 3 (four 5)))->((5 four) 3 (2 1))

क्लासिक पुनरावर्ती दृष्टिकोण: यदि तर्क एक सूची नहीं है, तो इसे अपरिवर्तित ले लो, यदि यह एक सूची है, तो सूची के रिवर्स पर फ़ंक्शन को मैप करें।

Answer 6

गणितज्ञ, 34/2 = 17 बाइट्स

Quiet[Reverse//@#]/.Reverse->(#&)&

या बस Reverse//@#&अगर आप त्रुटियों की एक टन चाहते हैं और Reverseहर जगह है।

Answer 7

क्लोजर 43/2 = 21.5 बाइट्स

(defn f[x](if(coll? x)(reverse(map f x))x))

Answer 8

जावास्क्रिप्ट ईएस 6, 42 - 50% = 21 बाइट्स

मेरा स्कोर कई मायनों में सही है। एक फ़ंक्शन को लागू करता है rजो पुन: अपने इनपुट के सदस्यों पर पुन: लागू होता है।

r=a=>Array.isArray(a)?a.reverse().map(r):a

यदि हम मानते हैं कि किसी वस्तु के पास कोई संपत्ति नहीं है pop, तो यह (31 - 50% = 15.5) हो जाता है, देव-नल के लिए धन्यवाद:

r=a=>a.pop?a.reverse().map(r):a

या, यदि हम मानते हैं कि वस्तु में एक reverseसंपत्ति है, तो हम ऐसा कर सकते हैं (35 - 50% = 17.5):

r=a=>a[R="reverse"]?a[R]().map(r):a

Comments

मुझे लगता है कि आप इस तरह से एक सरणी के लिए सुरक्षित रूप से जांच कर सकते हैं a.pop?a.reverse().map(r):a:। यह मानते हुए कि void 0ऑब्जेक्ट्स और कस्टम ऑब्जेक्ट्स को संभालने की कोई आवश्यकता नहीं है ।

— १।

Answer 9

लुआ, 111 99 * .5 = 55.5 49.5 बाइट्स

function r(a)local t={}for i,v in next,a do t[#a+1-i]=type(v)=="table"and r(v)or v end return t end

अच्छी पुनरावृत्ति

Answer 10

CJam, 20 बाइट्स * 50% = 10

{_`0='[={W%{F}%}&}:F

नामित ब्लॉक को परिभाषित करता है जिसे Fस्टैक के शीर्ष पर एक सरणी पर लागू किया जा सकता है (या कुछ और, जिस स्थिति में यह एक नो-ऑप है)।

इसका परीक्षण यहां करें।

Answer 11

ब्रेकीलॉग , 5 - 50% = 2.5 बाइट्स

ċ↔↰ᵐ|

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

         The input
ċ        which is a list
 ↔       reversed
   ᵐ     with each element
  ↰      passed through this same predicate
    |    is the output. If the input isn't a list,
         it is the output.

चूंकि ↔तार और पूर्णांक को उल्टा भी कर सकते हैं, इसलिए हमें गैर-सूचियों को स्पष्ट रूप से विफल करना होगा ċ।

Answer 12

वोल्फ्राम भाषा (गणितज्ञ) , 23 -50% = 11.5 बाइट्स

#/.List->Reverse@*List&

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

ListMathematica ( {...}) में समतुल्य हैं List[...]। @*रचना संचालक है, इसलिए प्रत्येक सूची को इनपुट ( = ) में होने वाली हर सूची Listको Reverse@*Listउलट देता है ।Reverse@*List[...]Reverse[{...}]

---

24 -50% = 12 बाइट्स

#~Reverse~Range@Depth@#&

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

केवल Listएस पर काम नहीं करता है ।

Answer 13

क्लोजर, 38 बाइट्स

(और मुझे लगता है कि एक बोनस है, लेकिन क्लोजर एक गतिशील भाषा है इसलिए यह मुफ्त में आता है)

(fn f[x](if(seq? x)(map f(into()x))x))

यह एक अच्छी शुरुआत है लेकिन इन अनुकूलन को नियोजित नहीं किया है:

• अनाम fnनाम के साथ अनाम फ़ंक्शन को परिभाषित करें defn। लेकिन हमें अभी भी fपुनरावृत्ति के लिए "स्कोप" नाम की आवश्यकता है
• वेक्टर के बजाय एक सूची के रूप में इनपुट लें, तो हम seq?इसके बजाय उपयोग कर सकते हैंcoll?
• के (into () ...)बजाय का उपयोग करेंreverse
• xमैपिंग से पहले रिवर्स करें , फिर हमें उतनी जगह की आवश्यकता नहीं है

Answer 14

रूबी , 32 - 50% = 16 बाइट्स

पुनरावर्ती कार्य। किसी संख्या या स्ट्रिंग की कोशिश करने पर उस ट्रिगर rescueको पकड़ने के लिए उपयोग करके इनपुट के माध्यम से एक सरणी होने पर चेक करने की तुलना में 2 बाइट्स छोटा हो जाता है ।NoMethodErrorreversemapa==[*a]

f=->a{a.reverse.map(&f)rescue a}

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