_{नोट: यह सरणी-हेरफेर चुनौतियों की एक श्रृंखला में # 2 है । पिछली चुनौती के लिए, यहां क्लिक करें ।}

नेस्टेड सूची को अलग करना

नेस्टेड सूची में मानों को अलग करने के लिए, इसे समतल करें, और फिर प्रत्येक मान को लपेटें ताकि यह पहले की तरह ही नेस्टेड गहराई पर हो।

यह कहना है, यह सूची:

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

बन जाएगा:

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

चुनौती

आपका कार्य एक प्रोग्राम लिखना है जो सकारात्मक पूर्णांकों (आपकी भाषा की सीमाओं के भीतर) की किसी भी नेस्टेड सूची को लेता है और इस पृथक्करण ऑपरेशन को करता है।

आप एक फ़ंक्शन सबमिट कर सकते हैं जो सूची को एक तर्क के रूप में लेता है, या एक पूर्ण कार्यक्रम जो I / O करता है।

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

_{* मानक गोल्फिंग खामियों पर रोक लगाई जाती है। तुम्हें ड्रिल पता है।}

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

इनपुट सूची में केवल आपकी भाषा के मानक पूर्णांक आकार में पूर्णांक होंगे। भाषाओं की बाधाओं से उन्हें प्रतिस्पर्धा से रोकने के लिए, मूल्यों को 10 से अधिक की गहराई पर घोंसला नहीं बनाया जाएगा।

आप मान सकते हैं कि इनपुट में खाली उप-सूची [[5, []]]नहीं होगी : उदाहरण के लिए - नहीं दी जाएगी। हालांकि, मुख्य सूची खाली हो सकती है।

[]            ->  []

[[1, 2]]      ->  [[1], [2]]
[3, [4, 5]]   ->  [3, [4], [5]]
[3, [3, [3]]] ->  [3, [3], [[3]]]
[[6, [[7]]]]  ->  [[6], [[[7]]]]
[[5, 10], 11] ->  [[5], [10], 11]

अगर मैंने एक कोने के मामले को याद किया है तो एक टिप्पणी छोड़ने में संकोच न करें।

उदाहरण

मैंने एक त्वरित (ungolfed) पायथन 3 समाधान को एक उदाहरण के रूप में एक साथ फेंक दिया - आप इसे repl.it पर परीक्षण कर सकते हैं ।

code-golf array-manipulation integer

— FlipTack
स्रोत

स्ट्रिंग आधारित उत्तरों के लिए एकल अंकों की संख्या के साथ एक टेस्टकेस जोड़ें।

— orlp

@orlp अच्छा विचार है।

— फ्लिपकैक

2

क्या हम एक निश्चित अधिकतम गहराई मान सकते हैं? कहो, 16?

— orlp

@orlp मैं हां कहने जा रहा हूं, अधिकतम नेस्टेड डेप्थ 10 होगी, क्योंकि मैं आपकी एल्गोरिथ्म और आपकी भाषा की बाधाओं की तुलना में विधि निष्पादन में अधिक रुचि रखता हूं। अब थ्रेड अपडेट करेंगे।

— फ्लिपकैक

क्या मैं एक स्ट्रिंग के रूप में आउटपुट कर सकता हूं?

— रोहन झुनझुनवाला

4

ब्रेकीलॉग , 16 बाइट्स

:{##:0&:ga|g}ac|

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

व्याख्या

Example input: [1:[2:3]]

:{          }a     Apply the predicate below to each element of the list: [[1]:[[2]:[3]]]
              c    Concatenate: Output = [1:[2]:[3]]
               |   Or: Input = Output = []

  ##                 Input is a list: e.g. Input = [2:3]
    :0&              Call recursively the main predicate with this input: [2:3]
       :ga           Group each element in a list: Output = [[2]:[3]]
          |          Or (not a list): e.g. Input = 1
           g         Group into a list: Output = [1]

— Fatalize
स्रोत

ZTIO पर तर्क क्या करता है ? इसके बिना यह सच / गलत के साथ आउटपुट करने लगता है, जिससे यह प्रतीत होता Zहै कि बाइट गिनती में आवश्यक है।

— 19

@FlipTack ब्रेकीलॉग को Zबताता है कि आउटपुट तर्क एक चर है। यह वह चर है जो परिणामी आउटपुट के साथ एकीकृत हो जाता है। जब आप इसे हटाते हैं, तो यह बताता है कि ब्रैकलॉग आउटपुट एक अनाम चर है, और इसके बजाय यह प्रिंट करेगा कि मुख्य विधेय सफल होता है या विफल। यह Prolog के समान है जहां परिणाम एक चर में "पुट" होता है।

— घातक

ठीक है :) अच्छा जवाब!

— 9

19

गणितज्ञ, २४ २१ बाइट्स

##&@@List/@#0/@#&/@#&

या इनमें से एक:

##&@@List/@#&/@#0/@#&
##&@@List@*#0/@#&/@#&
##&@@List/@#&@*#0/@#&

व्याख्या

इसका कारण इतना छोटा है कि यह मूल रूप से एक पुनरावृत्ति है जिसमें एक स्पष्ट आधार मामले की आवश्यकता नहीं है।

यहां बहुत अधिक मात्रा में चीनी है, तो चलिए इसे ungolfing द्वारा शुरू करते हैं। &इसके बचे एक अनाम फ़ंक्शन को दर्शाता है, जिसके तर्क के रूप में लिखा गया है #। इस फ़ंक्शन के अंदर फ़ंक्शन को #0संदर्भित करता है, जो किसी को अनाम पुनरावर्ती कार्यों को लिखने की अनुमति देता है। लेकिन आइए आंतरिक कार्य को एक नाम देकर और इसे बाहर खींचकर शुरू करें:

f[x_] := ##& @@ List /@ f /@ x
f /@ # &

अन्य महत्वपूर्ण वाक्यगत शर्करा है, f/@xजो कम है Map[f, x]अर्थात यह fतत्व के प्रत्येक तत्व को बुलाता है x। कारण f[x_] := ... f /@ xअनंत पुनरावृत्ति का कारण नहीं है कि एक परमाणु पर कुछ मैपिंग वास्तव में फ़ंक्शन को बुलाए बिना परमाणु को अपरिवर्तित छोड़ देता है। इसलिए, हमें आधार मामले (वर्तमान तत्व एक पूर्णांक) को स्पष्ट रूप से जांचने की आवश्यकता नहीं है।

तो फ़ंक्शन fपहले नीचे की सबसे गहरी सूची में पुनरावृत्ति करता है x, जिस बिंदु पर f/@एक नो-ऑप बन जाता है। तब हम ##& @@ List /@उस पर उपयोग कहते हैं । Listसूची में मैपिंग बस प्रत्येक तत्व को एक अलग सूची में लपेटता है, इसलिए {1, 2, 3}बन जाता है{{1}, {2}, {3}} । फिर हम उस पर लागू होते ##& हैं, जिसका अर्थ है कि सिर (यानी बाहरी सूची) द्वारा प्रतिस्थापित किया जाता है ##&, इसलिए यह बदल जाता है ##&[{1}, {2}, {3}]। लेकिन ##&बस रिटर्न यह एक के रूप में तर्क हैSequence (जिसे आप एक अलिखित सूची के रूप में सोच सकते हैं, या अन्य भाषाओं में "स्पैट" ऑपरेटर की तरह)।

तो ##& @@ List /@एक सूची {1, 2, 3}में बदल जाता है {1}, {2}, {3}(इस तरह का, कि आखिरी चीज वास्तव में सिर में लिपटी हैSequence , लेकिन जैसे ही हम मूल्य का उपयोग करते हैं, गायब हो जाता है)।

यह सवाल छोड़ देता fहै कि चुनौती का हल पहले से ही क्यों नहीं है। समस्या यह है कि सबसे बाहरी सूची को अलग तरीके से व्यवहार किया जाना चाहिए। यदि हमारे पास इनपुट है {{1, 2}, {3, 4}}तो हम चाहते हैं {{1}, {2}, {3}, {4}}और नहीं {{1}}, {{2}}, {{3}}, {{4}} । मेरे मूल समाधान ने अंतिम परिणाम को तर्कों की एक सूची के रूप में पारित करके इसे निर्धारित किया, Joinजो बाहरी स्तर की सूचियों को पुनर्स्थापित करेगा, लेकिन यह सिर्फ आउटपुट पर एक नक्शे में f खुद का उपयोग करके बाहरी स्तर को छोड़ देता है । इसलियेf केवल सबसे बाहरी सूची के व्यक्तिगत तत्वों पर लागू होता है और कभी भी उस सूची को छूने के लिए नहीं मिलता है।

अन्य तीन समाधानों के लिए, पहले वाला केवल बाहर की पुनरावृत्ति को लागू fकरता है और साथ ही साथ काम करता है। अन्य दो समाधान Mapपहले दो कार्यों की रचना करके और फिर परिणाम को केवल एक बार मैप करके दोहराए जाने वाले ऑपरेशन से बचते हैं ।

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

8

जे , 19 18 बाइट्स

(<@]/@,~>)S:0 1{::

यह एक अनाम क्रिया है जो बॉक्सिंग सरणियों को लेती है और लौटाती है, जो कि नेस्टेड सरणियों का J (बल्कि बोझिल) संस्करण हैं। देखें कि यह सभी परीक्षण मामलों को पास करता है।

व्याख्या

यह कुछ हद तक विदेशी संचालन {::( मानचित्र ) और S:( प्रसार ) का उपयोग करता है , जो बॉक्सिंग सरणियों पर काम करते हैं। {::प्रत्येक पत्ती को उस पत्ती के बॉक्स वाले रास्ते से बदल देता है। S:दी गई घोंसले की गहराई के लिए एक दिए गए क्रिया को लागू करता है, फिर परिणामों को एक सरणी में विभाजित करता है।

(<@]/@,~>)S:0 1{::  Input is y.
(        )          Let's look at this verb first.
        >           Open the right argument,
      ,~            append the left argument to it,
    /               then reduce by
 <@]                boxing. This puts the left argument into as many nested boxes
                    as the right argument is long.
                    This verb is applied to y
               {::  and its map
            0 1     at levels 0 and 1.
                    This means that each leaf of y is paired with its path,
                    whose length happens to be the nesting depth of y,
                    and the auxiliary verb is applied to them.
          S:        The results are spread into an array.

— Zgarb
स्रोत

3

आर, 199 बाइट्स

function(l){y=unlist(l);f=function(x,d=0){lapply(x,function(y){if(class(y)=='list'){f(y,d=d+1)}else{d}})};d=unlist(f(l));lapply(1:length(d),function(w){q=y[w];if(d[w]){for(i in 1:d[w])q=list(q)};q})}

यह प्रश्न HARD था। आर की सूचियां थोड़ी अजीब हैं और यह सब्लिस्ट के सभी तत्वों पर लूप करने के लिए बिल्कुल सरल नहीं है। उस सूची की गहराई का निर्धारण करना भी सरल नहीं है। फिर चुनौती अलग किए गए सभी तत्वों के साथ सूची को फिर से बनाने की बन जाती है, इसलिए हमें एक निश्चित गहराई की सूची को अनुकूल रूप से बनाने के लिए एक रास्ता भी चाहिए।

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

  f=function(x,d=0){
    lapply(x,function(y){
      if(class(y)=='list'){
        f(y,d=d+1)
      } else {
        d
      }})
  }

जब हमारे पास वेक्टर की हर प्रविष्टि की गहराई unlist(l)होती है d, तो हम संग्रहीत करते हैं , तो हम lapplyनिम्नलिखित सूची के साथ एक सूची बनाते हैं और इसे भरते हैं:

  lapply(1:length(d),function(w){
    q=y[w]
    if(d[w]){
      for(i in 1:d[w]){
        q=list(q)
      }
    }
    q
  })

इस लागू कॉल में, हम qसूची में प्रवेश के मूल्य के साथ एक वस्तु बनाते हैं , इसकी गहराई की जांच करें और देखें कि क्या यह नॉनजरो है। यदि यह शून्य है, तो हम इसे संख्यात्मक मान के रूप में छोड़ सकते हैं। यदि यह गैर-शून्य है, तो हमें सूचियों की उस राशि में इसे घोंसला बनाना होगा। इसलिए हम dबार - बार लूप कॉल करते हैं और बार-बार कॉल करते हैं q=list(q)।

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

उचित रिक्ति और इस तरह के साथ पूरा कार्यक्रम:

function(our.list){
  values <- unlist(our.list)
  f <- function(part.list, depth = 0){
    lapply(part.list, function(y){
      if(class(y)=='list'){
        f(y, depth <- depth + 1)
      } else {
        return(depth)
      }})
  }
  depths <- unlist(f(our.list))
  new.list <- lapply(1:length(depths), function(w){
    q <- values[w]
    if(depths[w] != 0){
      for(i in 1:depths[w]){
        q <- list(q)
      }
    }
    return(q)
  })
  return(new.list)
}

— JAD
स्रोत

एक अच्छी बात है, यह वह तरीका है जिसका मैंने परीक्षण मामलों के लिए अपने शुरुआती पायथन समाधान के साथ प्रयोग किया :) :)

— FlipTack

is.list(y)के बजाय class(y)=='list'? यह सत्यापित नहीं कर सकता कि वास्तव में काम करेगा।

— Giuseppe

180 बाइट्स

— Giuseppe

3

रेटिना , 34 बाइट्स

+`(.(?>()\[|(?<-2>)]|.)+)\2,
$1],[

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

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

कैसे (?<-2>)काम करता है ?

— कृति लिथोस

@KritiiLithos यह एक संतुलन समूह है । यह कैप्चर स्टैक 2 से आता है जो मुझे वर्तमान घोंसले के शिकार गहराई का ट्रैक रखने देता है।

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

2

सी (जीसीसी), 147 बाइट्स

d=0,l,i;
P(n,c){for(;n--;)putchar(c);}
main(c){for(;~(c=getchar());l=i)i=isdigit(c),P((l<i)*d,91),P(i,c),P((l>i)*d,93),P(l>i,32),d+=(92-c)*(c>90);}

उदाहरण इनपुट:

1 [23 3] [40 4 [5 2] 1]

उदाहरण आउटपुट:

1 [23] [3] [40] [4] [[5]] [[2]] [1]

— orlp
स्रोत

2

स्टैक्ड , नॉनकंपेटिंग, 25 बाइट्स

{e d:e$wrap d 1-*}cellmap

यह एक फ़ंक्शन है जिसमें यह स्टैक के शीर्ष सदस्य को संशोधित करता है। आप एक वास्तविक समारोह चाहते हैं, बस जोड़ने [और ]शुरुआत और अंत करने के लिए। यहाँ यह कोशिश करो!

यहाँ एक पठनीय संस्करण है:

{ arr :
  arr { ele depth :
    ele   $wrap depth 1- * (* execute wrap n times, according to the depth *)
  } cellmap (* apply to each cell, then collect the results in an array *)
} @:a2
(1 (2 3) (4 4 (5 2) 1)) a2 out

परीक्षण का मामला:

(1 (2 3) (4 4 (5 2) 1))    (* arg on TOS *)
{e d:e$wrap d 1-*}cellmap
out                        (* display TOS *)

उत्पादन के बिना newlines:

(1 (2) (3) (4) (4) ((5)) ((2)) (1))

— कोनोर ओ ब्रायन
स्रोत

क्या *कोड ब्लॉक करने का तर्क है?

— डाउनगेट

@Downgoat इस मामले में यह तर्क d-1समय को लपेटता है । $funcएक फ़ंक्शन है जिसमें हेरफेर किया जा सकता है।

— कॉनर ओ'ब्रायन

2

PHP, 101 94 बाइट्स

@ ब्रीथोफ़ के लिए 1 बाइट के धन्यवाद से बचा, इससे प्रेरित एक और 6 को बचाया।

function s($a){foreach($a as$b)if($b[0])foreach(s($b)as$c)$r[]=[$c];else$r[]=$b;return$r?:[];}

पुनरावर्ती कार्य, बहुत सीधे आगे

टूट - फूट

function s($a)
{
    foreach($a as$b)                // loop through array
        if($b[0])                       // if element is array
            foreach(s($b)as$c)$r[]=[$c];    // append separated elements to result
        else$r[]=$b;                    // else append element to result
    return$r?:[];                   // return result, empty array for empty input
}

— टाइटस
स्रोत

परिणाम आरंभ में कहां मिलता है?

— नील

@ नील: पीएचपी को स्पष्ट आरंभीकरण की आवश्यकता नहीं है। या तो $rलूप में तत्व मिलते हैं या फ़ंक्शन एक खाली सरणी देता है। यह नोटिस प्राप्त कर सकता है, लेकिन वे डिफ़ॉल्ट कॉन्फिगर के साथ मुद्रित नहीं हैं।

— टाइटस

इसका मतलब यह नहीं है कि आप केवल एक बार ही कॉल कर पाएंगे?

— नील

1

आप पागल हो सकते हैं !cos():। हर सरणी और एक फ्लोट के लिए cos()रिटर्न null! = 0 हर पॉज़िटिव पूर्णांक के लिए। मेरा मतलब है ... जो चेतावनी के लिए परवाह है?

— क्रिस्टोफ

1

@Christoph: चेतावनियाँ छपी हैं, नोटिस नहीं हैं (thje default config में)। लेकिन यह एक महान विचार है! पर is_int: स्थिति को उलटने से कुछ भी नहीं बचता; मुझे elseऔर के बीच की जगह चाहिए foreach। लेकिन: $b[0]पूर्णांक के लिए है NULL।

— टाइटस

2

अजगर 2, 122 106 बाइट्स

बहुत भयानक स्कोर, बस एक सीधा कार्यान्वयन।

16 बाइट बचाने में मदद करने के लिए @Zachary टी का धन्यवाद!

def x(l,a=[],d=0):
 n=lambda b:b and[n(b-1)]or l
 if'['in`l`:[x(e,a,d+1)for e in l];return a
 else:a+=n(d)

xचलाने के लिए एक तर्क के साथ कॉल करें । किसी कारण से इसे केवल एक बार चलाया जा सकता है।

— नीला
स्रोत

तुम बदल सकते हो a+=[n(l,d)] करने के लिए a+=n(l,d),(ध्यान दें अनुगामी अल्पविराम)

— FlipTack

क्या आपको भी असाइन करने की आवश्यकता है t ?

— जकार्इ

क्या यह कार्य तब होता है जब आप इसे एक से अधिक बार कहते हैं?

— जकार्इ

आप nफ़ंक्शन पर जा सकते हैं और पहला तर्क हटा सकते हैं क्योंकि यह हमेशा रहने वाला है l।

— जकार्इ

repl.it/EwPz

— Zacharý

2

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 53 बाइट्स

f=a=>[for(e of a)for(d of e.map?f(e):[e])e.map?[d]:d]

अब तक मेरे पास सबसे अच्छे ईएस 6 उत्तर 76 बाइट्स हैं:

f=(a,r=[],d=0)=>a.map(e=>e.map?f(e,r,d+1):r.push((n=d=>d?[n(d-1)]:e)(d)))&&r

— नील
स्रोत

2

दोनों कोड ब्लॉक में, मुझे लगता है कि आपने अग्रणी को छोड़ दिया है f=।

— कॉनर ओ'ब्रायन

@ कोनोरो ब्रायन फिर भी ...

— नील

1

पायथ - 29 बाइट्स

.b]FYt-F/LN`[)PsM._:`Q"\d"3.n

परीक्षण सूट ।

— Maltysen
स्रोत

1

पर्ल 6 , 60 47 बाइट्स

sub f{[$_~~List??|([$_] for .&f)!!$_ for |$^a]}

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

स्पष्टीकरण:

[... for |$^a]: इनपुट सरणी पर Iterate करें, और उससे एक नई सरणी बनाएँ।
$_ ~~ List ?? ... !! ...: प्रत्येक तत्व के लिए, जांचें कि क्या यह एक सरणी है।
|([$_] for .&f): यदि तत्व एक सरणी है, तो पुनरावर्ती रूप से फ़ंक्शन को लागू करें, उस पुनरावर्ती कॉल से लौटे नए सरणी के तत्वों पर पुनरावृति करें, प्रत्येक तत्व को अपने स्वयं के सरणी में लपेटें, और उन्हें बाहरी सूची में खिसकाएं।
$_: यदि तत्व एक सरणी नहीं है, तो इसे इस रूप में पास करें।

— SMLS
स्रोत

1

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

data L=N Int|C[L] 
d#C l=((C .pure.d)#)=<<l
d#n=[d n]
f(C l)=C$(id#)=<<l

फिर से मुझे अपनी सूची प्रकार को परिभाषित करना होगा, क्योंकि हास्केल की मूल सूची में मनमाने ढंग से घोंसले नहीं हो सकते। यह नया प्रकार Lएक फ़ंक्शन से वापस किया जा सकता है लेकिन डिफ़ॉल्ट रूप से मुद्रित नहीं किया जाता है, इसलिए परिणाम देखने के लिए मैं इसके showलिए एक उदाहरण परिभाषित करता हूं L:

instance Show L where
  show (N n)=show n
  show (C l)=show l

अब हम REPL में कुछ परीक्षण कर सकते हैं:

*Main> f $ C[N 1, C[N 2, N 3], C[N 4, N 4, C[N 5, N 2], N 1]]
[1,[2],[3],[4],[4],[[5]],[[2]],[1]]

*Main> f $ C[C[N 6, C[C[N 7]]]]
[[6],[[[7]]]]

यह कैसे काम करता है: एक साधारण पुनरावर्तन जो Cनिर्माण के कार्य के रूप में घोंसले के शिकार स्तर को पार करता है । हम पहचान समारोह के साथ शुरू करते हैं idऔर जब भी कोई सूची (-> पैटर्न मैच d#C l=) होती है, तो हम सूची के सभी तत्वों के पुनरावर्ती कॉल में C(-> C .pure.d) की एक और परत जोड़ते हैं #। यदि हम एक संख्या का सामना करते हैं, तो हम केवल संख्या पर नेस्टिंग-स्तर-फ़ंक्शन लागू करते हैं d।

— nimi
स्रोत

0

APL (Dyalog) , 44 बाइट्स *

बेनामी tacit उपसर्ग समारोह। नेस्टेड एपीएल सूची को तर्क के रूप में लेता है और एक नेस्टेड एपीएल सरणी देता है।

∊{⊃⊂⍣⍵,⍺}¨{⊃¨(j∊⎕D)⊆+\-⌿'[]'∘.=j←⎕JSON⍵}

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

{... } निम्नलिखित स्पष्ट फ़ंक्शन को लागू करें जहां तर्क द्वारा दर्शाया गया है ⍵:

⎕JSON⍵ JSON के तर्क को परिवर्तित करें

j← सग्रह करना j

'[]'∘.= तालिका जहां jखुले (शीर्ष पंक्ति) और करीब (नीचे पंक्ति) कोष्ठक के बराबर होती है

-⌿ शीर्ष पंक्ति शून्य से नीचे की पंक्ति (ऊर्ध्वाधर अंतर में कमी)

+\ संचयी योग (यह प्रत्येक वर्ण के लिए घोंसले का स्तर देता है)

(... )⊆ विभाजन, एक नए विभाजन की शुरुआत जब भी एक 1 में 1 से पहले नहीं होती है ...

j∊⎕D जहां का प्रत्येक चरित्र डी igits jके सेट का एक सदस्य है

⊃¨ प्रत्येक का पहला चुनें (यह बहु-अंक संख्या प्रति घोंसले का स्तर देता है)

∊{... }¨ प्रत्येक नेस्टिंग स्तर (के लिए निम्न समारोह लागू ⍵,) से इसी तत्व का उपयोग ε nlisted (चपटा) बाईं तर्क के रूप में तर्क ( ⍺):

,⍺ संख्या को बढ़ाएँ (सूचीबद्ध करें) (क्योंकि स्केलर संलग्न नहीं किए जा सकते)

⊂⍣⍵ घेरना ⍵बार

⊃ खुलासा (क्योंकि अंतरतम सूची अपने आप में एक संलग्नक है)

^{* साथ Dyalog क्लासिक का उपयोग करना ⎕ML←3(कई सिस्टम पर डिफ़ॉल्ट), प्रतिस्थापन ⊂के लिए ⊆और ↑के लिए ⊃। Tio!}

— एडम
स्रोत

चुनौतियाँ # 2 का एक सरणी: एक नेस्टेड सरणी को अलग करें

नेस्टेड सूची को अलग करना

चुनौती

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

उदाहरण

ब्रेकीलॉग , 16 बाइट्स

व्याख्या

गणितज्ञ, २४ २१ बाइट्स

व्याख्या

जे , 19 18 बाइट्स

व्याख्या

आर, 199 बाइट्स

उचित रिक्ति और इस तरह के साथ पूरा कार्यक्रम:

रेटिना , 34 बाइट्स

सी (जीसीसी), 147 बाइट्स

स्टैक्ड , नॉनकंपेटिंग, 25 बाइट्स

PHP, 101 94 बाइट्स

अजगर 2, 122 106 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 53 बाइट्स

पायथ - 29 बाइट्स

पर्ल 6 , 60 47 बाइट्स

स्पष्टीकरण:

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

APL (Dyalog) , 44 बाइट्स *