घोंसला छोड़कर

Question

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

आप मान सकते हैं कि पूर्णांक सभी (समावेशी) श्रेणी में हैं [-100, 100]। सूचियों के लिए कोई अधिकतम लंबाई या घोंसले की गहराई नहीं है। इनपुट में कोई खाली सूची नहीं होगी - प्रत्येक घोंसले के स्तर में कम से कम एक पूर्णांक या सूची होगी।

इनपुट और आउटपुट आपकी भाषा की मूल सूची / सरणी / enumerable / iterable / etc में होना चाहिए। यदि आपकी भाषा में अनुक्रम प्रकार का अभाव है, तो प्रारूप, या किसी भी उचित, अस्पष्ट प्रारूप में।

उदाहरण

[1, 2, [3, [4, 5], 6, [7, [8], 9]]] => [[1, 2], [3, 6], [4, 5, 7, 9], [8]]

[3, 1, [12, [14, [18], 2], 1], [[4]], 5] => [[3, 1, 5], [12, 1], [14, 2, 4], [18]]

[2, 1, [[5]], 6] => [[2, 1, 6], [5]]

[[54, [43, 76, [[[-19]]]], 20], 12] => [[12], [54, 20], [43, 76], [-19]]

[[[50]], [[50]]] => [[50, 50]]

Answer 1

अजगर, १,

 us-GeaYsI#GQ)S#Y

अग्रणी स्थान महत्वपूर्ण है। यह इस सूची को फ़िल्टर करता है कि क्या मान अपरिवर्तित हैंs फ़ंक्शन , फिर इन मानों को सूची से निकालकर एक स्तर पर समतल कर देता है। मानों को भी संग्रहीत किया जाता है Yऔर जब हम प्रिंट करते हैं तो हम खाली मानों को फ़िल्टर करके हटा देते हैं यदि सूची का क्रमबद्ध मूल्य सत्य है।

परीक्षण सूट

वैकल्पिक रूप से, एक संदिग्ध उत्पादन प्रारूप के साथ एक 15 बाइट उत्तर:

 us-GpWJsI#GJQ)

परीक्षण सूट

विस्तार:

 us-GeaYsI#GQ)S#Y     ##   Q = eval(input)
 u          Q)        ##   reduce to fixed point, starting with G = Q
        sI#G          ##   get the values that are not lists from G
                      ##   this works because s<int> = <int> but s<list> = flatter list
      aY              ##   append the list of these values to Y
     e                ##   flatten the list
   -G                 ##   remove the values in the list from G
              S#Y     ##   remove empty lists from Y

Answer 2

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

_{एलेफाल्फा के कारण -2 बाइट्स ।}

_{CatsAreFluffy के कारण -2 बाइट्स ।}

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}/.{}->Nothing&

दरअसल खाली स्तरों को हटाता है।

Comments

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}~DeleteCases~{}&

— एलेफ़लफा

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}/.{}->Nothing&, 2 बाइट्स छोटी

— कैलक्यूलेटर

Answer 3

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

f=lambda l:l and zip(*[[x]for x in l if[]>x])+f(sum([x for x in l if[]<x],[]))

Answer 4

रेटिना ,, ९

मुझे पता है कि रेटिना विशेषज्ञ इसे और अधिक गोल्फ देंगे, लेकिन यहां एक शुरुआत है:

{([^{}]+)}(,?)([^{}]*)
$3$2<$1>
)`[>}],?[<{]
,
(\d),+[<{]+
$1},{
<+
{
,*[>}]+
}

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

Answer 5

मैथेमेटिका 55 64 62 बाइट्स

#~Select~AtomQ/.{}->Nothing&/@Table[Level[#,{k}],{k,Depth@#}]&

---

%&[{1, 2, {3, {4, 5}, 6, {7, {8}, 9}}}]

{{1, 2}, {3, 6}, {4, 5, 7, 9}, {8}}

Answer 6

जावास्क्रिप्ट, 112 80 बाइट्स

F=(a,b=[],c=0)=>a.map(d=>d!==+d?F(d,b,c+1):b[c]=[...b[c]||[],d])&&b.filter(d=>d)

32 बाइट्स से दाढ़ी बनाने में मदद करने के लिए धन्यवाद नील।

Comments

यहाँ गोल्फ के लिए बहुत सारे अवसर। कुछ आसान को दूर करने के लिए कर रहे हैं!=nullnull वैसे भी जैसे झूठा हो। यह b=भी अनावश्यक है। हटाया होने कि तुम तो ले जा सकते हैं .filter(a=>x)करने के लिए &&bजो तब जो आप कर सकते हैं तो इनलाइन भीतरी फ़ंक्शन की कॉल करने के लिए बाहरी समारोह कम कर देता है। मैं इसके साथ रह गया हूँ f=(a,b=[],c=0)=>a.map(d=>d[0]?f(d,b,c+1):b[c]=[...b[c]||[],d])&&b.filter(d=>d):।

— नील

@Neil d[0]?मूल्यांकन करेगा falseयदि यह बराबर था 0, जो सीमा के भीतर है[-100,100] । और ऐसा ही होगाd=>d

— पैट्रिक रॉबर्ट्स

@ नील ने इसे एक भीड़ में फेंक दिया, इसलिए मुझे पता था कि इसे सिकोड़ने के अन्य अवसर थे, लेकिन यह तब भी बेहतर है जब मैं कर सकता था। धन्यवाद! ओह, और पैट्रिक उस कारण के लिए आवश्यक होने जा रहे शून्य चेक पर सही है। मैं d===+dहालांकि के साथ चला गया , क्योंकि यह अशक्त जाँच पर 2 बाइट बचाता है।

— Mwr247

@ डेंड्रोबियम जो पिछले केस (या किसी भी मामले को [...,[[...]]]) को ठीक से हैंडल नहीं करेगा

— Mwr247

@PatrickRoberts d=>dठीक है क्योंकि dउस बिंदु पर हमेशा एक सरणी या अशक्त है, लेकिन एक उचित बिंदु के बारे में है d[0], हालांकि हमेशा ऐसा होता है d.mapजो एक सरणी के लिए सत्य होगा लेकिन एक संख्या के लिए मिथ्या होगा।

— नील

Answer 7

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

fFW®;©ṛ¹ḟF;/µŒḊ’$¡W®Tị¤;

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

यदि न्यूलाइन-सेपरेटेड सूचियों की अनुमति दी गई थी, तो इसे 14 बाइट्स तक सीमित किया जा सकता है ।

fFṄ¹¹?ḟ@¹;/µ¹¿

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

Answer 8

अजगर, 108 99 बाइट्स

यह मेरे लिए थोड़ा लंबा लगता है, लेकिन मैं एक-लाइनर को छोटा नहीं बना सकता, और अगर मैं orइसके बजाय का उपयोग करने की कोशिश करता हूंif परिणामों में खाली सूची मिलती है।

def f(L):
    o=[];i=[];j=[]
    for x in L:[i,j][[]<x]+=[x]
    if i:o+=[i]
    if j:o+=f(sum(j,[]))
    return o

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

संपादित करें: सहेजे गए 9 बाइट्स ढेर अतिप्रवाह के लिए धन्यवाद

Comments

आपको अपने इंडेंट को सिंगल स्पेस में बदलना चाहिए, इसलिए वे कोड ब्लॉक में ठीक से रेंडर करते हैं। आप उन filter(None,o)खाली सूचियों को निकालने के लिए भी उपयोग कर सकते हैं जो सबसे बाहरी घोंसले के स्तर पर हैं o।

— Mego

मैं टैब के साथ अपना कोड देखना पसंद करता हूं। रिक्त स्थान बुराई है।

— mbomb007

एसई मार्काडाउन टैब को 4 स्थानों में परिवर्तित करता है, इसलिए इनका फिर भी कोई बचाव नहीं होता है :) मार्कडाउन में एकल स्थान का उपयोग करने से कोड ब्लॉक की बाइट गिनती वास्तव में कोड की बाइट गणना से मेल खाती है।

— Mego

यदि आप इसे संपादित करना चाहते हैं, तो मेरे कोड में ही टैब हैं। यह अंदर है कि मायने रखता है। ;)

— mbomb007

Answer 9

पायथन 3, 109 बाइट्स

हमेशा की तरह, बेवकूफ पायथन 2 में ints और lists की तुलना करने का मतलब है कि पायथन 3 पीछे से आता है। ओह अच्छा...

def d(s):
 o=[]
 while s:
  l,*n=[],
  for i in s:
   try:n+=i
   except:l+=[i]
  if l:o+=[l]
  s=n
 return o

Answer 10

पर्ल, 63 बाइट्स

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}

इनपुट @i, उत्पादन में उत्पादन की उम्मीद है@o । (मुझे आशा है कि यह स्वीकार्य है)।

उदाहरण:

@i=[[54, [43, 76, [[[-19]]]], 20], 12];                              # input

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}      # the snippet

use Data::Dumper;                                                    # print output
$Data::Dumper::Indent=0;  # keep everything on one line
$Data::Dumper::Terse=1;   # don't print $VAR =
print Dumper(\@o);

आउटपुट:

[[12],[54,20],[43,76],[-19]]

Answer 11

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

(116 seq, और इनपुट के रूप में सूचियों, एक मामूली संशोधन)

(defn f([v](vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

बेहतर इरादा:

(defn f([v]  (vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))
       ([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

जब दो तर्कों (मौजूदा स्तर और एक संग्रह) के साथ बुलाया जाता है, तो यह या तो एक-तत्व अनियंत्रित-मानचित्र बनाता है {level: value}, या कॉल करता हैf अनियंत्रित यदि कोई गैर-संख्या (संभवतः एक संग्रह) देखा जाए तो पुनरावर्ती है।

इन मिनी-मैप्स को तब एकल में विलय कर दिया जाता है sorted-mapऔर कुंजी टकराव को concatकार्य द्वारा नियंत्रित किया जाता है ।valsमानचित्र के मूल्यों को पहले स्तर से अंतिम तक लौटाता है।

यदि कोई संख्या अपने स्तर पर एकमात्र है तो वह एक ही रहती है vec, दूसरों को सूचियों में बदल दिया जाता है concat।

(f [[54, [43, 76, [[[-19]]]], 20], 12])
([12] (54 20) (43 76) [-19])

अगर listइसके बजाय इनपुट थाvec तो number?बदला जा सकता है seq?, विषम वेक्टर नहीं है, seq?लेकिन यह है sequential?। लेकिन मैं उस संस्करण को लागू करने के लिए बहुत आलसी हूं, उदाहरणों को फिर से करना आदि।

Answer 12

रैकेट 259 बाइट्स

(let((ol'())(m 0))(let p((l l)(n 0))(cond[(empty? l)][(list?(car l))(set! m(+ 1 n))
(p(car l)(+ 1 n))(p(cdr l)n)][(set! ol(cons(list n(car l))ol))(p(cdr l)n )]))
(for/list((i(+ 1 m)))(flatten(map(λ(x)(cdr x))(filter(λ(x)(= i(list-ref x 0)))(reverse ol))))))

Ungolfed:

(define (f l)
  (define ol '())
  (define maxn 0)
  (let loop ((l l)              ; in this loop each item is added with its level
             (n 0))
    (cond
      [(empty? l)]
      [(list? (first l))
       (set! maxn (add1 n))
       (loop (first l) (add1 n))
       (loop (rest l) n)]
      [else
       (set! ol (cons (list n (first l)) ol))
       (loop (rest l) n )]))

  ; now ol is '((0 1) (0 2) (1 3) (2 4) (2 5) (1 6) (2 7) (3 8) (2 9)) 

  (for/list ((i (add1 maxn)))   ; here similar levels are combined
    (flatten
     (map (λ (x) (rest x))      ; level numbers are removed
          (filter (λ (x) (= i(list-ref x 0)))
                  (reverse ol))))))

परिक्षण:

(f '[1 2 [3 [4 5] 6 [7 [8] 9]]])

आउटपुट:

'((1 2) (3 6) (4 5 7 9) (8))

Answer 13

MATL , 37 बाइट्स

j']['!=dYsXKu"GK@=)'[\[\],]'32YXUn?1M

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

वर्तमान रिलीज़ के साथ काम करता है (13.0.0)भाषा / संकलक की के ।

यह आउटपुट को अंतरिक्ष-पृथक मानों की रेखाओं के रूप में उत्पन्न करता है, जहां प्रत्येक पंक्ति समान घोंसले के स्तर से मेल खाती है, और अलग-अलग घोंसले के स्तर को नए सिरे से अलग किया जाता है।

j            % read input as string (row array of chars)
']['!        % 2x1 array containing ']'  and '['
=            % test for equality, all combinations
d            % row array obtained as first row minus second row
Ys           % cumulative sum. Each number is a nesting level
XK           % copy to clibdoard K
u            % unique values: all existing nesting levels
"            % for each nesting level
  G          %   push input
  K          %   push array that indicates nesting level of each input character
  @          %   push level corresponding to this iteration
  =          %   true for characters corresponding to that nesting level
  )          %   pick those characters
  '[\[\],]'  %   characters to be replaced
  32         %   space
  YX         %   regexp replacement
  U          %   only numbers and spaces remain: convert string to array of numbers
  n?         %   if non-empty
    1M       %     push that array of numbers again
             %   end if implicitly
             % end for each implicitly