पृष्ठभूमि

जेली अंकगणित परमाणु स्वचालित रूप से वेक्टर होते हैं। वास्तव में, x + y को तब भी अच्छी तरह से परिभाषित किया जाता है जब x और y संख्याएं या संख्याओं के रैग्ड एरे होते हैं। जेली का स्रोत कोड एक जेनेरिक वेक्टर का उपयोग करके इस व्यवहार को लागू करता है, लेकिन इस चुनौती के लिए, हम केवल पूर्णांक और नेस्टेड पूर्णांक सरणियों पर विचार करेंगे।

परिभाषाएं

X की गहराई को 0 के रूप में परिभाषित करें यदि x पूर्णांक है, तो 1 के रूप में यदि यह पूर्णांकों का (संभवतः खाली) समतल सरणी है, और n + 1 के रूप में यदि इसमें गहराई का कम से कम एक तत्व n और गहराई के कोई तत्व नहीं है > एन ।

इस तरह, 1 की गहराई 0 , [] और [1] और [1, 1] की गहराई 1 है , [[], []] और [[1], [1]] और [[1]] और [1 ] , []] गहराई २ है , [१, [१, [१]]] गहराई ३ है , आदि।

ऑपरेशन x + y को निम्नानुसार परिभाषित किया गया है।

यदि x और y में गहराई 0 है , तो उनका योग वापस करें।
यदि x और y में समान लेकिन सकारात्मक गहराई है, तो x के सभी आइटम्स और y के संबंधित आइटम्स के लिए पुनरावर्ती + लागू करें ।

यदि x और y की लंबाई अलग-अलग है, तो लंबी सारणी की पूंछ को sums के सरणी में जोड़ दें।

परिणाम लौटाओ।
यदि एक्स के गहराई से सख्ती से छोटा होता है y के गहराई, रिकर्सिवली लागू + करने के लिए एक्स और के सभी आइटम्स y , और परिणाम लौटने।

विपरीत करें यदि y की गहराई x की तुलना में कड़ाई से कम है ।

उदाहरण के लिए, ऑपरेशन [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] पर विचार करें ।

बाएं तर्क की गहराई 2 है , जबकि सही तर्क की गहराई 3 है , इसलिए हम गणना करते हैं [1, [2, 3], [4]] + [[10, 20], [30], 40, 50 ]] और [१, [२, ३], [४]] + ६० ।
- [१, [२, ३], [४]] और [[१०, २०], [३०], ४०, ५०] दोनों की गहराई २ है , इसलिए हम १ + [१०, २०] , [२, ३] की गणना करते हैं । + [३०] और [४] + ४० ।
  - 1 + [10, 20] = [1 + 10, 1 + 20] = [11, 21]
  - [२, ३] + [३०] = [२ + ३०, ३] = [३२, ३]
    
    ध्यान दें कि 3 अछूता रहता है, क्योंकि इसमें एक मेल तत्व नहीं है।
  - [४] + ४० = [४ + ४०] = [४४]
  50 तो परिणाम है, उससे मिलते-जुलते तत्व नहीं है [[[11, 21], [32, 3], [44], 50]] ।
- [१, [२, ३], [४]] + ६० = [१ + ६०, [२, ३] + ६०, [४] + ६०] = [६१, [२ + ६०, ३ + ६०], [] 4 + 60]] , जिसके परिणामस्वरूप [61, [62, 63], [64]] ।
अंतिम परिणाम है [[[११, २१], [३२, ३], [४४], ५०], [६१, [६२, ६३], [६४]] ।

कार्य

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

यदि आपकी भाषा में कई प्रकार के प्रकार (सूचियाँ, टुपल्स, वैक्टर आदि) हैं, तो आप उनमें से किसी को भी अपने उत्तर के लिए चुन सकते हैं। वापसी प्रकार को तर्क प्रकार से मेल खाना चाहिए।

उबाऊ और अपराजेय समाधानों को रोकने के लिए, यदि किसी भाषा में अंतर्निहित ऑपरेशन के रूप में यह सटीक ऑपरेशन है, तो आप उस भाषा का उपयोग नहीं कर सकते हैं।

अन्य सभी भाषाओं के सभी बिल्ट-इन की अनुमति है। यदि आपकी पसंद की भाषा इसे अनुमति देती है, तो आप बिल्ट-इन अतिरिक्त को अधिभार और / या फिर से परिभाषित कर सकते हैं।

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

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

0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]

अधिक परीक्षण मामलों को उत्पन्न करने के लिए, आप इस जेली कार्यक्रम का उपयोग कर सकते हैं ।

— डेनिस
स्रोत

क्या होगा अगर हमारी भाषा रैग्ड एरे का समर्थन नहीं करती है? क्या हमें इनपुट का पुनर्गठन करने की अनुमति है या क्या हमें रैगर्ड एरे को लागू करना चाहिए? या शायद सिर्फ एक अलग भाषा का उपयोग करें?

— मील

इनपुट के पुनर्गठन से आपका क्या मतलब है ?

— डेनिस

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

— मील

सरणियाँ भी विषम हो सकती हैं, इसलिए मानों को भरने के लिए उन्हें आयताकार बनाने के लिए पर्याप्त नहीं होगा। अंतिम उपाय के रूप में, हमेशा स्ट्रिंग्स पर काम करने का विकल्प होता है, लेकिन यह शायद बहुत जटिल है।

— डेनिस

3

अरे, अच्छा शीर्षक! .. अब जब कि Google ने मुझे इसे पाने में मदद की :-)

— लुइस मेंडू

3

पायथ, 42 बाइट्स

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

परीक्षण सूट

अंतिम 4 बाइट्स केवल इनपुट पर फ़ंक्शन को चलाते हैं।

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

L?sIb0heSyM+b0
                  Define y(b), a helper function to calculate the depth.
 ?                Ternary:
  sIb             If b is invariant under the s function, which is only the case
                  if s is an int.
     0            The depth is 0.
           +b0    Add a 0 on to b. This handles the edge case where b is [].
         yM       Map each to their depth
       eS         Take the max.
      h           Add one.

M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ
M                               Define g(G, H), which calculates the Jelly +.
 ?                              Ternary:
       ,GH                      Form [G, H].
      J                         Save it to J.
    yM                          Map each to its depth.
  qF                            Check if they are equal.
          ?yG                   If so, check if the depth is nonzero.
               .tJ0             If so, transpose J, pairing each element of each
                                argument with the corresponding element of the
                                other. Pad with zeroes.
             gM                 Map each to its Jelly +.
                   +GH          If the depths are zero, return the normal sum.
                         yDJ    If the depths are different, order J by depth.
                      gLF       Apply the function which left-maps the Jelly +
                                function to the two values. The first is
                                treated as a constant, while the second varies
                                over elements over the second values.

— isaacg
स्रोत

7

एपीएल, 44 बाइट्स

{1=≡⍺⍵:⍺+⍵⋄=/∆←|≡¨⍺⍵:⊃∇¨/↓↑⍺⍵⋄</∆:⍺∘∇¨⍵⋄⍵∇⍺}

एपीएल के +सरणियों पर वितरित करता है, लेकिन एक अलग तरीके से कि यह वास्तव में इस्तेमाल नहीं किया जा सकता है। हालाँकि, एक अंतर्निहित गहराई फ़ंक्शन ( ≡) है।

स्पष्टीकरण:

1=≡⍺⍵:⍺+⍵: यदि ⍺ ⍵दोनों की गहराई शून्य है (और इसलिए की गहराई ⍺ ⍵1 है), उन्हें जोड़ें।
∆←|≡¨⍺⍵: दोनों की गहराई का पूर्ण ले ⍺और ⍵और उन्हें में स्टोर ∆। ( ≡यदि सभी तत्वों की गहराई समान नहीं है तो एक नकारात्मक मान देता है।)
=/∆: अगर उनकी गहराई समान है:
- ↓↑⍺⍵: लंबी सरणी से मिलान करने के लिए शून्य के साथ सबसे छोटा सरणी पैड
- ⊃∇¨/: दोनों सरणियों पर फ़ंक्शन वितरित करें
</∆: यदि की गहराई से ⍺कम है ⍵:
- ⍺∘∇¨⍵: बाँध ⍺और फिर नक्शा⍵
⍵∇⍺: यदि और कुछ नहीं (तो इससे ⍵अधिक गहरा है ⍺), तर्कों को स्वैप करें और फिर से प्रयास करें।

— मारीनस
स्रोत

3

कभी-कभी मुझे लगता है कि मुझे एपीएल ठीक है। तब मुझे इस तरह की एक कृति दिखाई देती है और मुझे एहसास होता है कि मैं इसे बमुश्किल जानता हूं।

— एलेक्स ए।

क्या एपीएल अक्षर वास्तव में बाइट्स के रूप में गिना जाता है?

— मेटलिम

@metalim APL की विरासत कोड पृष्ठ हैं जो कुछ दशकों से यूनिकोड से पहले हैं। उन में, प्रत्येक चरित्र एक एकल बाइट है।

— डेनिस

फिर समाधान के साथ एन्कोडिंग प्रकार प्रदान किया जाना चाहिए। बस IMO।

— मेटेलिम

@metalim मैंने एक लिंक जोड़ा।

— अदम

5

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

d=Depth
x_~f~y_/;d@x>d@y:=y~f~x
x_~f~y_/;d@x<d@y:=x~f~#&/@y
x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]
x_~f~y_=x+y

एक पुनरावर्ती कार्य को परिभाषित fकरता है जो योग की गणना करता है। मैथेमेटिका के पैटर्न के मिलान का उपयोग करते हुए, यह फ़ंक्शन चार अलग-अलग परिभाषाओं से बना है:

x_~f~y_/;d@x>d@y:=y~f~x

यदि xइससे अधिक की गहराई है y, तो तर्कों को स्वैप करें, ताकि हमें केवल एक दिशा में वितरण को संभालना पड़े (जो हम कर सकते हैं, क्योंकि जोड़ सराहनीय है)।

x_~f~y_/;d@x<d@y:=x~f~#&/@y

की गहराई तो xकम की है कि Thann है y, प्रत्येक मान की जगह #में yसाथ f[x,#]जो असमान गहराई के तर्कों के लिए वितरण का ख्याल रखता है,।

x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]

अन्यथा, यदि एक तर्क एक सूची है (जिसका अर्थ है कि दूसरी भी एक सूची है, क्योंकि हम जानते हैं कि उनकी समान गहराई है), हम दोनों तर्कों को एक सूची में रखते हैं, उन्हें एक ही लंबाई के साथ पैड करते हैं PadRight[..., Automatic](जो बस एक को भरता है आयताकार बनाने के लिए शून्य के साथ दांतेदार सरणी), और फिर दो सूचियों से संबंधित जोड़े MapThreadपर लागू fकरने के लिए उपयोग करें ।

और अंत में, आधार मामला:

x_~f~y_=x+y

यदि अन्य पैटर्न में से कोई भी मेल नहीं खाता है, तो हमें दो नंबर जोड़ने की कोशिश करनी चाहिए, इसलिए हम ऐसा करते हैं।

— मार्टिन एंडर
स्रोत

5

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

data L=S Int|V{v::[L]}
d(V z)=1+maximum(d<$>S 0:z);d _=0
S x!S y=S$x+y
x!y|d x<d y=V$(x!)<$>v y|d x>d y=y!x|1<2=V$v x#v y
(x:a)#(y:b)=x!y:a#b;a#b=a++b

व्याख्या

पहली पंक्ति एक बीजीय डेटा प्रकार को परिभाषित करती है L, जो या तो एक Sकालर (एक Int) या एक Vईक्टर (एस की सूची युक्त ) है L, जिसे रिकॉर्ड गेटर का उपयोग करके एक्सेस किया जाता हैv किया जाता है, जो एक आंशिक फ़ंक्शन है L → [L]।)

दूसरी पंक्ति गहराई फ़ंक्शन को परिभाषित करती है : एक Vट्रैक्टर की गहराई एक से अधिक है और इसकी अधिकतम गहराई है। मैं S 0सदिश में मानों को प्राथमिकता देता हूं , ताकिdepth [] == 1 + maximum [depth (S 0)] == 1 । "कुछ और" (एक अदिश) की गहराई है 0।

तीसरी पंक्ति आधार मामले को परिभाषित करती है ! (अतिरिक्त कार्य): स्केलर्स का योग एक स्केलर है।

पांचवीं पंक्ति एक प्रकार का परिभाषित करती है zipWith (!) उस जिसमें सबसे लंबी सूची से तत्वों को चुना जाता है जब उनमें से एक खाली होता है।

चौथी लाइन तीन मामलों में विभाजित है:

x!y | d x<d y = V$(x!)<$>v y
    | d x>d y = y!x
    | True    = V$v x#v y

अगर की गहराई से गहराई xसे कम है y, (x!)के तत्वों पर नक्शा y। (का उपयोग vवैध होने की गारंटी है, के रूप में d(y) ≥ 1)
अगर की गहराई x अधिक सख्त है, तो तर्कों को पलटें और पुनः आरंभ करें।
यदि उनकी गहराई समान है, तो तर्कों को एक साथ जोड़ दें (!)। (आधार का उपयोग vवैध होने की गारंटी है, क्योंकि मामले d(x) = d(y) = 0को आधार मामले के रूप में संभाला गया था।)

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

instance Show L where
  show (S x) = show x
  show (V x) = show x

lArg = V [S 1, V [S 2, V [S 3, V [S 4]]]]
rArg = V [S 10, V [S 20]]

तब show (lArg ! rArg) == "[[11,[21]],[[12,[22]],[13,[24]]]]"।

— लिन
स्रोत

मैंने अभी तय किया है कि, ^ ^ (मैंने पठनीयता के लिए लाइनों की अदला-बदली की है, लेकिन मैंने इसे गलत तरीके से किया है ...) ऐसा importइसलिए है क्योंकि Ideone का एक पुराना Haskell कंपाइलर है। जीएचसी के आधुनिक संस्करण डाल दिए <$>गए हैं Prelude, इसलिए आपको Control.Applicativeइन दिनों इसका उपयोग करने के लिए आयात करने की आवश्यकता नहीं है ।

— लिन

ए जी मेरे अन्य कार्यों के रूप में एक ही समय में बहुत सारे संपादन करता है: पी और निश्चित रूप से, यह अब ठीक लगता है, लेकिन मुझे यह बहुत अजीब लगता है जो एक संकलन त्रुटि का कारण बनता है। क्या फंक्शन के सभी पैटर्न मैचिंग बिट्स लगातार होने चाहिए?

— FryAmTheEggman

यह बिल्कुल सही है।

— लिन

ठीक है, आपकी सभी मदद के लिए धन्यवाद :) "मुझे किसी दिन इस भाषा की फांसी मिलेगी" - 7 साल पहले FryAmTheEggman।

— FryAmTheEggman

4

जावा, 802 794 754 746 बाइट्स

मैंने स्ट्रिंग्स पर काम करने की चुनौती के लिए "डेनिस ♦ को" अंतिम उपाय के रूप में "लेने का फैसला किया क्योंकि यह शायद" बहुत जटिल "था। इसके अलावा, गोल्फ के लिए सबसे खराब भाषा में।

इनपुट में एरे को अल्पविराम से अलग किया गया है, जो चौकोर कोष्ठक से घिरा है, और बिना व्हाट्सएप के।

कार्यों के साथ पूर्ण कार्यक्रम एक वर्ग में और परीक्षण मामलों के साथ लिपटे

import java.util.*;
List<String>p(String s){List r=new ArrayList<String>();String p="";int l=0;for(char c:s.substring(1,s.length()-1).toCharArray()){l+=c=='['?1:c==']'?-1:0;if(c==','&&l<1){r.add(p);p="";}else p+=c;}if(p!="")r.add(p);return r;}
int d(String s){int l=0;if(s.contains("[")){for(String c:p(s))l=d(c)>l?d(c):l;l++;}return l;}
String f(String x,String y){int i=0;String r="";if(d(x)<1&&d(y)<1)r+=Integer.valueOf(x)+Integer.valueOf(y);else{r="[";if(d(x)<d(y))for(String k:p(y))r+=(i++<1?"":",")+f(x,k);else if(d(x)>d(y))for(String k:p(x))r+=(i++<1?"":",")+f(k,y);else for(;i<p(x).size()||i<p(y).size();i++)r+=(i<1?"":",")+(i<p(x).size()&&i<p(y).size()?f(p(x).get(i),p(y).get(i)):i<p(x).size()?p(x).get(i):p(y).get(i));r+="]";}return r;}

मैं इसे C ++ में बाद में पोर्ट कर सकता हूं क्योंकि यह दूसरी भाषा है जो मुझे पता है कि रैग्ड सरणियों का समर्थन नहीं करता है, क्योंकि मैं ~~बहुत आश्वस्त~~ हूं यह लगभग निश्चित रूप से इस उत्तर से छोटा होगा। यह ज्यादातर अवधारणा का प्रमाण था लेकिन किसी भी गोल्फिंग टिप्स की सराहना की जाएगी!

@ User902383 से -31 बाइट्स एक परिवर्तित चरित्र सरणी पर एक फॉर्चून का उपयोग करने का सुझाव देते हैं, और फिर मैंने अंतिम भाग में यदि ब्लॉक को फिर से व्यवस्थित करने से थोड़ा अधिक बचाया।

— मान स्याही
स्रोत

यह प्रभावशाली है।

— डेनिस

मुझे लगता है कि यदि आप स्ट्रिंग से प्राप्त फॉरेस्ट लूप गर्त चार सरणी के साथ अपने छोरों को बदलते हैं, तो आप काफी बाइट बचा सकते हैं।

— user902383

1

इर्र ... जावा रैग्ड ऐरे का समर्थन करता है; मुझे यकीन नहीं है कि आप इसका क्या मतलब है। उपयोग करें Object[], जिसमें या तो नेस्टेड है Object[]या Integer। या सिर्फ गैर-जेनेरिक सूची।

— रॉबर्ट फ्रेजर

4

पायथन 2.7, 261 209 202 198 191 185 197 181 बाइट्स

FGITW तुच्छ समाधान

संपादित करें: बेशक @ डेनिस इसे धड़कता है

लैंबडा एक्सप्रेशंस के टिप्स के साथ 57 बाइट्स बचाने के लिए @LeakyNun, और 2 बाइट्स बेवजह कोष्ठक से।

के typeबजाय उपयोग करने के लिए सुझाव के कारण 4 बाइट्स के लिए @ Adnan के लिए धन्यवादisinstance

@ बयाना के साथ 7 बाइट्स के लिए धन्यवाद -~औरmap

@FryAmTheEggman के लिए धन्यवाद z>=[]इसके बजायtype

+12 बाइट्स को लैम्ब्डा को अगर और में बदलना है तो एक प्रमुख बग को ठीक करें

-16 बाइट्स की बदौलत @ केविन लाउ - केनी नहीं

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

d=lambda z:z==[]or z>[]and-~max(map(d,z))
p=lambda x,y:p(y,x)if d(x)>d(y)else(x+y if d(x)<1 else[p(a,b)for a,b in zip(x,y)]+x[len(y):]+y[len(x):])if d(x)==d(y)else[p(a,x)for a in y]

— नीला
स्रोत

यह पायथन 2.7 पर स्विच करने और लिखने के लिए भी छोटा हैz==[]or`z`>']'and ...

— लिन

इसके अलावा, मुझे लगता है कि एक बाइट के max(d(a)+1for a in z)साथ प्रतिस्थापित करना -~max(d(a)for a in z)एक बाइट बचाता है (क्योंकि आप पहले अंतरिक्ष हटा सकते हैं max)। जो तब बस है -~max(map(d,z))।

— लिन

अजगर 2 पर स्विच करना आपको बदल सकते हैं कि में और भी अधिक की बचत होती है [p(a,b)for a,b in zip(x,y)]में map(p,x,y)। आप अभी भी 3 में ऐसा कर सकते हैं, लेकिन आपको इसमें कॉल जोड़ना होगा list। मुझे लगता है कि आप लिन के सुझाव को भी सुधार सकते हैं z>=[]। असंबंधित, आपको typeएक स्थान बचाने के लिए तुलना क्रम को स्वैप करने में भी सक्षम होना चाहिए ।

— FryAmTheEggman

इर, मेरा मतलब था or`z`>'[', लेकिन मैं अपनी टिप्पणी अब नहीं बदल सकता। लेकिन वास्तव में, z>[]और भी छोटा है ( ==मामला पहले से ही संभाल रखा है)!

— लिन

@FryAmTheEggman मैप तब काम नहीं करता जब सूचियाँ विभिन्न आकारों की होती हैं; ज़िप सही ढंग से काट दिया गया। मैं

— ब्लू

3

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

d=lambda t:t>{}and-~max(map(d,t+[0]))
s=lambda x,y:s(y,x)if d(y)<d(x)else map(s,(x,[x]*len(y))[d(x)<d(y)],y)if d(y)else(x or 0)+(y or 0)

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

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

पायथन 2 में, सभी पूर्णांक सभी शब्दकोशों से कम हैं, लेकिन सभी सूचियां अधिक हैं। d पुनरावर्ती पूर्णांक के लिए 0 या उसके तत्वों और 0 की गहराई की अधिकतम वृद्धि के द्वारा टी की गहराई की गणना करता है । खाली सूची में विशेष आवरण से बचा जाता है।t+[0]

s पुनरावर्ती x और y के जेली योग की गणना करता है ।

यदि y की गहराई x से अधिक है , तो बदली हुई दलीलों के साथ ss(y,x) कॉल करता है, यह सुनिश्चित करता है कि d (x) y d (y) ।

यदि y में सकारात्मक गहराई है, map(s,(x,[x]*len(y))[d(x)<d(y)],y)तो निम्न कार्य करता है।

यदि एक्स के और y के गहराई से मेल खाते हैं, वह निष्पादित map(s,x,y), मानचित्रण रों के सभी तत्वों से अधिक एक्स और के इसी तत्व y ।

विभिन्न लंबाई की सूचियों के मामले में, नक्शा छोटी सूची में गायब तत्वों के लिए बाएं या दाएं तर्क के रूप में कोई भी पारित नहीं करेगा ।
यदि एक्स के गहराई से कम है y के, यह कार्यान्वित map(s,[x]*len(y),y), मानचित्रण रों (एक्स, ·) से अधिक y ।

यदि y (और, इसलिए, x ) में गहराई 0 है , तो (x or 0)+(y or 0)झूठा तर्क ( कोई नहीं या 0 ) को शून्य से बदल देता है और परिणामी पूर्णांक का योग लौटाता है।

— डेनिस
स्रोत

1

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

f=(a,b,g=a=>a.map?1+Math.max(0,...a.map(g)):0)=>g(a)<g(b)?f(b,a):g(b)<g(a)?a.map(e=>f(e,b)):g(a)?a.length<b.length?f(b,a):a.map((e,i)=>f(e,b[i]||0)):a+b
;t=(x,y,z)=>o.textContent+=`
${JSON.stringify(x)}
${JSON.stringify(y)}
${JSON.stringify(z)}
${JSON.stringify(f(x,y))}
`;`
0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]`.slice(1).split`
`.map(l=>t(...l.split(/ [+=] /).map(a=>JSON.parse(a))));

<pre id=o></pre>

स्निपेट का विस्तार करें

— नील
स्रोत

1

रूबी 2.3, 143 145 148 149 बाइट्स

रूबी के पास ये सब कुछ है कि zipअलग-अलग लंबाई के एरे और mapमल्टी-तर्क कार्यों के साथ काम करता है, जिससे यह गोल्फ के लिए बहुत मजेदार है।

f=->x,y{d=->a{-~(a.map(&d).max||0)rescue 0}
d[x]<d[y]?y.map{|e|f[x,e]}:d[x]>d[y]?x.map{|e|f[e,y]}:d[x]<1?x+(y||0):[*x.zip(y).map(&f),*y[x.size..-1]]}

— मान स्याही
स्रोत

यह बहुत दिलचस्प है - मैंने इस फ़ंक्शन के लिए पहले कभी भी उस त्रुटि को नहीं देखा है। मैंने अभी भी अन्य बगों के कारण कुछ चीजों को तैयार किया है, लेकिन इसके अलावा यह मेरे लिए काम करता है (लेकिन अभी भी आइडोन पर विफल रहता है)। मुझे लगता है कि यह इसलिए है क्योंकि आइडोन 2.1 चलाता है और मेरे पास 2.3 है, इसलिए शायद 2.1 mapएक दो-आर्ग फ़ंक्शन पर उस तरह से कार्य नहीं कर सकता है जैसा मैंने इसे अंत में स्थापित किया था। यहां 2.1 के लिए एक संस्करण संपादित किया गया है जो काम करता है जो काम mapके अंत में कॉल को ट्विक करता है । ideone.com/q1jqTA

— वैल्यू इंक

1

जूलिया, 113 बाइट्स

~=endof;!t=0t!=0&&1+maximum(!,[t;0])
x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

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

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

~=endof

एंडोफ़ के लिए एक 1-बाइट उपनाम बनाता है , जो एक सरणी की लंबाई लौटाता है।

!t=0t!=0&&1+maximum(!,[t;0])

एक गहराई से कार्य को परिभाषित करता है। टी की गहराई शून्य है अगर और केवल अगर 0t == 0 । यदि नहीं, तो टी एक सरणी है, और इसकी गहराई की गणना इसके तत्वों और 0 की गहराई की अधिकतम वृद्धि के रूप में की जाती है । सरणी t पर 0[t;0] जोड़ता है , इस प्रकार खाली सरणी को विशेष-केस करने की आवश्यकता से बचा जाता है।

जूलिया की निर्मित राशि + पहले से ही जेली के योग की तरह व्यवहार करती है यदि या तो (या दोनों) इसके तर्क एक पूर्णांक हैं। हालांकि, दो सरणियों ( + ) के योग के लिए समान आकार के सरणियों की आवश्यकता होती है, और यहां तक कि वेक्टर की गई राशि ( । + ) के लिए आवश्यक सरणियों को एक सामान्य आकार में प्रसारित किया जा सकता है।

हम सरणियों की एक जोड़ी के लिए + को फिर से परिभाषित करते हैं

x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

यह पूर्णांक / पूर्णांक, सरणी / पूर्णांक या पूर्णांक / सरणी तर्क के लिए + की परिभाषा को प्रभावित नहीं करता है।

(!x,~x)>(!y,~y)लेक्सिकोग्राफिक रूप से एक्स और वाई दोनों की गहराई और लंबाई के जोड़े की तुलना करता है । यदि x की गहराई y के s से अधिक है , या यदि उनका गहराई मिलान और x है की लंबाई y से अधिक है , तो y+xपुनरावर्ती तर्कों के साथ + कॉल करता है।

अन्यथा, !x<!yयदि x की गहराई y से कम है , तो परीक्षण किया जाता है की । अगर ऐसा है, map(t->x+t,y)नक्शे x + · से अधिक y ।

यदि गहराई मेल खाती है, ~x<~yतो यदि y से x छोटा है , तो परीक्षण किया जाता है । यदि यह है, तो बाईं ओर के तर्क को 0 से अपग्रेड करने के बाद [x;0]+yपुन: कॉल + किया जाता है।

अंत में, अगर गहराई और लंबाई दोनों समान हैं, तो x के सभी तत्वों पर y + और y के संगत तत्वों के x.+yनक्शे ।

— डेनिस
स्रोत

जाम ऐसा नहीं है

पृष्ठभूमि

परिभाषाएं

कार्य

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

पायथ, 42 बाइट्स

एपीएल, 44 बाइट्स

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

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

व्याख्या

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

जावा, 802 794 754 746 बाइट्स

पायथन 2.7, 261 209 202 198 191 185 197 181 बाइट्स

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

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

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

रूबी 2.3, 143 145 148 149 बाइट्स

जूलिया, 113 बाइट्स

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