एक नेस्टेड सूची को क्रमबद्ध करें

Question

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो एक नेस्टेड सूची को सॉर्ट करता है। यहां नेस्टेड सूची को छाँटने के नियम दिए गए हैं:

आइए इस सूची को एक उदाहरण के रूप में लेते हैं:

((5, 2), 2, 7, (2, 1, (3, 4)), 9)

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

तो, गहराई 1 के सभी तत्वों की प्राथमिकताएं हैं:

 (  7 )  2  7  (    3       )  9
((5, 2), 2, 7, (2, 1, (3, 4)), 9)

प्रत्येक तत्व को प्राथमिकता से क्रमबद्ध करें। यदि कोई टाई है, तो आपको मूल सूची के समान क्रम रखना होगा।

 2  (     3      )  (  7 )  7  9
(2, (2, 1, (3, 4)), (5, 2), 7, 9) 

हर सबलिस्ट के लिए दोहराएँ। तो इस सबलिस्ट पर

(2, 1, (3, 4))

हमारी प्राथमिकताएं ऐसी दिखती हैं:

 2  1  (  7  )
(2, 1, (3, 4))

तो क्रमबद्ध, ऐसा लगता है:

(1, 2, (3, 4))

(3, 4)पहले से ही हल है, इसलिए हम कर रहे हैं। (5, 2)जिसके लिए परिणाम दोहराएं (2, 5)और हम कर रहे हैं! हमारी अंतिम सूची है:

(2, (1, 2, (3, 4)), (2, 5), 7, 9) 

नियम:

• अत्यधिक संदिग्ध, लेकिन सिर्फ मामले में गणितज्ञ के पास इसके लिए कुछ है, कोई भी नेस्टेड सूची सॉर्टिंग बिल्डरों की अनुमति नहीं है। नियमित छंटाई कार्यों की अनुमति है।

• I / O किसी भी उचित प्रारूप में हो सकता है।

• हर सबलिस्ट में कम से कम एक नंबर या सूची होगी। इसके अलावा, सब्लिस्ट्स को कई स्तरों तक नेस्टेड किया जा सकता है। उदाहरण के लिए, में , क्योंकि यह उस में केवल उप-सूचियों है, 0 से प्राथमिकता है। (1, 2, (((3))))(((3)))

• अमान्य सूचियाँ (बेजोड़ कोष्ठक, गैर-संख्याएँ, गलत ब्रैकेट प्रकार, ऋणात्मक संख्याएँ, आदि) अपरिभाषित व्यवहार का परिणाम हैं।

टेस्ट I / O:

(1, 2, 3) ---> (1, 2, 3)

(1, 2, 6, 3, 9, 8) ---> (1, 2, 3, 6, 8, 9)

(4, 3, (2), (1)) ---> ((1), (2), 3, 4)

(4, 3, (2), ((1))) ---> (((1)), (2), 3, 4)

(5, (1, 2, (9, 8))) ---> ((1, 2, (8, 9)), 5)

(3, (1, 2), (2, 1)) ---> (3, (1, 2), (1, 2))

(3, (1, 2, (99)), (2, 1, (34))) ---> (3, (1, 2, (99)), (1, 2, (34)))

(7, 2, (1, (9, 12)), (4, 3, 2, (1, 2))) ---> ((1, (9, 12)), 2, 7, (2, 3, (1, 2), 4))

बाइट्स जीत में सबसे छोटा जवाब।

Comments

क्या हम मान सकते हैं कि संख्या पूर्णांक हैं?

— isaacg

@ आइसाकग हां, आप कर सकते हैं।

— DJMcMayhem

Answer 1

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

fFSµ€Ụị߀µ¹<?

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

fFSµ€Ụị߀µ¹<?  Main link. Input: A (list)

   µ€          Apply the chain to the left to each item B in A.
 F             Flatten B.
f              Filter; intersect B with flattened B, yielding a list.
               This returns the numbers in B if B is a list, [B] if B is a number.
  S            Compute the sum of the resulting list.
     Ụ         Sort the indices of A according to the computed sums.
       ߀      Recursively apply the main link to each B in A.
      ị        Retrieve the items of the list (right) at those indices (left).
         µ     Convert the preceding chain into a single link.
            ?  If:
           <     A compared with itself is truthy:
                   Execute the link to the left.
          ¹      Else, apply the identity function to A.

तुलना ( <) खुद के साथ एक संख्या 0 (झूठा) देती है, लेकिन गैर-खाली सूची की तुलना अपने आप से 0 's (सत्य) की <सूची प्राप्त करती है , इसलिए इसका उपयोग सूचियों से संख्याओं को अलग करने के लिए किया जा सकता है।

Comments

0 गलत है, लेकिन 0 का एक बॉक्स ट्रू है, लेकिन एक खाली बॉक्स गलत है। दिलचस्प है कि पायथन कैसे काम करता है। : पी

— बिल्ली

25 बाइट्स (जब UTF-8 में एन्कोडेड) लगता है।

— रॉटस्टर

@ रॉटर्स जो सही के बारे में लगता है। हालांकि, जेली कस्टम कोड पेज का उपयोग करती है जो सभी 256 वर्णों को कूटबद्ध करता है जो इसे एकल बाइट्स के रूप में समझता है।

— डेनिस

Answer 2

अजगर 2, 114 101 78 73 62 बाइट्स

k=lambda t:t*(t<[])or t.sort(key=k)or sum(z for z in t if[]>z)

मुझे पता था कि सूचियों को फ़िल्टर करने का एक बेहतर तरीका है।

एक अजगर सूची (और इसके उप-कलाकारों) को अंदर जगह देता है।

https://eval.in/540457 धन्यवाद @tac मुझे यह बताने के लिए कि इन-प्लेस समाधान स्वीकार्य हैं, और आगे के अनुकूलन के लिए @xnor + @feersum!

Comments

कुछ और अनुकूलन k=lambda t:t*(t<[])or sum(z for z in t if[t.sort(key=k)]>z):।

— xnor

@xnor मुझे लगता है कि समाधान काफी सही नहीं है: eval.in/540447 । इस उदाहरण के लिए, हम पहले सबलिस्ट में वापस आते हैं और zउसमें से प्रारंभिक हड़प लेते हैं। 5. फिर सशर्त में, हम उस सूची को सॉर्ट करते हैं जिसे हम ()! 10. की राशि के लिए अग्रणी। हम फिर इन कुंजियों के साथ बाहरी सूची को सॉर्ट करते हैं और [6, [1, 5]] प्राप्त करते हैं, जो कि "यदि कोई टाई है, तो यह गलत है, आपको मूल सूची के समान क्रम रखना होगा। " दिलचस्प बात यह है कि हम sortदोनों सूचियों पर दो बार कॉल करते हैं, इसलिए यह केवल समान कुंजी पर होता है: यदि सबलिस्ट कम होता तो यह वापस आ जाता।

— Orez

अच्छी पकड़। यह हास्यास्पद है कि अब जारी सूची के साथ पुनरावृत्ति जारी है। मुझे लगता है कि वहाँ अभी भी एक छोटा रास्ता होना चाहिए के Noneउत्पादन में छड़ी t.sort(key=k), लेकिन मैं यह नहीं देख रहा हूँ।

— xnor

Falseके प्रयोजनों के लिए 0 है +और विस्तार से, sum। यद्यपि यह नहीं सोचता कि यह बाइट्स को कैसे बचाता है।

— कैलक्यूलेटरफेलीन

@CatsAreFluffy list.sortरिटर्न None, नहीं False।

— डेनिस

Answer 3

लुआ, 172 बाइट्स

function p(a)if type(a)~="table"then return a end s(a)local t=0 for i,v in next,a do t=t+p(v)end return t end
function s(t)table.sort(t,function(a,b)return p(a)<p(b)end)end

फ़ंक्शन sनियमों के अनुसार एक Lua तालिका (एक डेटा संरचना जो Lua में अन्य चीजों के बीच एक सूची के रूप में कार्य करता है) की जगह लेती है।

Comments

मैं प्यार करता हूँ कि कैसे type(a)एक स्ट्रिंग लौटाता है

— बिल्ली

अंत में लुआ का उपयोग कर एक उत्तर।

— लीक नून

Answer 4

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

#0/@SortBy[#,Tr@Cases[#,_Integer,{0,1}]&]~Check~#&

सरल पुनरावर्ती विधि जो उपयोग करती है SortBy। संदेशों को अनदेखा करें।

Answer 5

हास्केल, 160 151 135 बाइट्स

import Data.List
data T=N Int|T[T]deriving Show
p(N x)=x
p(T t)=sum$[x|N x<-t]
f(N x)=N x
f(T t)=T$sortBy((.p).compare.p)$map f$t

पहली समस्या नेस्टेड सूची है। हास्केल के लिए आवश्यक है कि किसी सूची के सभी तत्वों में एक ही प्रकार हो; विशेष रूप से, एक पूर्णांक और पूर्णांकों की सूची एक ही प्रकार नहीं हैं। दूसरे शब्दों में, एक चर-नेस्टेड सूची एक सूची नहीं है, यह एक गुलाब का पेड़ है!

तो पहले, हमें गुलाब के पेड़ों के लिए एक डेटा प्रकार को परिभाषित करना होगा:

data T = N Int | T [T]

(सख्ती से, deriving Showकेवल तभी आवश्यक है जब आप परिणाम देखना चाहते हैं । लेकिन यह एक तकनीकी है।) इस परिभाषा के साथ, हम एक सूची लिख सकते हैं जैसे (1, 2, (3, 4))कि

T [N 1, N 2, T [N 3, N 4]]

जो काफी कम पठनीय है। जो कुछ भी लेकिन; यह एक तुच्छ, यांत्रिक अनुवाद है। हर संख्या को उपसर्ग के साथ Nऔर हर उपसर्ग के साथ उपसर्ग करें T।

अब हमें प्राथमिकताओं की गणना करने की आवश्यकता है। यह आसान होगा यदि एक सबट्री की प्राथमिकता सरल थी जिसमें सभी तत्व शामिल थे। यह एक तुच्छ पुनरावर्ती लूप होगा। लेकिन चूंकि यह नहीं है, हमें दो कार्यों को परिभाषित करने की आवश्यकता है : एक जो पुनरावृत्ति करता है, और एक जो नहीं करता है।

p (N x) = x
p (T t) = sum $ map q t

q (N x) = x
q _     = 0

यदि हम सभी सबमिशन को जोड़ते, तो qबड़ी संख्या में पात्रों को सहेजने की आवश्यकता नहीं होती। ओह अच्छा!

संपादित करें: वास्तव में, कई टिप्पणीकार बताते हैं कि आप qएक सूची समझ का उपयोग करने से बच सकते हैं [ x | N x <- t]:। अच्छी कॉल, दोस्तों!

(वास्तव में, pया तो अस्तित्व की आवश्यकता नहीं होगी; हम संकलक ऑटो-जेनरेट कर सकते हैं Ordहमारे लिए मुट्ठी भर पात्रों में, और यह डिफ़ॉल्ट कार्यान्वयन कल्पना से मेल खाएगा।)

अंत में, हमें सभी उप-पेड़ों पर पुनरावर्ती और उन्हें सॉर्ट करने की आवश्यकता है:

f (N x) = N x
f (T t) = T $ sortBy (\ x y -> compare (p x) (p y)) $ map f $ t

यही है, fएक पेड़ को पुनरावर्ती रूप से सभी तत्वों ( map f) पर लागू करके , और फिर sortByशीर्ष स्तर को सॉर्ट करने के लिए फ़ंक्शन को कॉल करके सॉर्ट करें। पहली पंक्ति कहती है कि संख्या को क्रमबद्ध करने से कुछ नहीं होता है, और पुनरावृत्ति को समाप्त करना आवश्यक है।

Comments

sortBy (\ x y -> compare (p x) (p y))बस है sortOn p। में नक्शे के इन्फ़िक्स संस्करण का उपयोग करें p: sum$q<$>t।

— नमि

@ निम्मी को कहाँ sortOnपरिभाषित किया गया है? मैं हमेशा जानना चाहता था है ...

— MathematicalOrchid

डेटा । 4.8.0.0 के बाद से ।

— नमि

आप अभी भी सूची बोध चाल के साथ कुछ 16 बाइट्स दाढ़ी कर सकते हैं, p(T t)=sum[x|N x<-t]और data T=N Int|T[T]deriving Show। :)

— Ness

क्या आपने अपनी गिनती में प्रत्येक न्यूलाइन के लिए 2 बाइट्स शामिल किए हैं? मुझे लगता है कि हमें उन्हें एकल के रूप में गिनने की अनुमति है । इसके अलावा, इसमें कोई आवश्यकता नहीं $है sum$[x|N x<-t]। तो, 135-5-1 = 129। :)

— विल नेस

Answer 6

सीएलआईएसपी, 380 बाइट्स

(defun q(L)(if(null L)L(append(append(q(car(s(cdr L)(car L))))(list(car L)))(q(cadr(s(cdr L)(car L))))))))(defun s(L E)(if(not(atom(car L)))(setq L(cons(q(car L))(cdr L))))(cond((null L)'(nil nil))((<(v(car L))E)(list(cons(car L)(car(s(cdr L)E)))(cadr(s(cdr L)E))))(T(list(car(s(cdr L)E))(cons(car L)(cadr(s(cdr L)E)))))))(defun v(L)(if(atom L)L(apply'+(remove-if-not #'atom L))))

फ़ंक्शन q को किसी सूची के साथ कॉल करें।

मैं एक लिस्प नोब हूँ, कृपया मुझे मत मारो ^ ^

Comments

हाहा, मैं उम्मीद कर रहा था कि कोई इसे लिस्प में करेगा!

— DJMcMayhem

Answer 7

अजगर, 15 बाइट्स

L?sIbbossI#NyMb

परीक्षण सूट

एक पुनरावर्ती कार्य, जो निम्नानुसार कार्य करता है:

L?sIbbossI#NyMb
L                  define y(b):
 ?sIb              If b is an integer:          (invariant under the s function)
     b             Return it.
            yMb    Else, apply y recursively to all of the elements of b,
      o            Then sort b by
        sI#N       For each element, the elements of that list that are integers.
                   This is luckily a nop on integers.
       s           Summed.

Answer 8

जावा, 219 बाइट्स

import java.util.*;List f(List l){l.sort(Comparator.comparing(o->{if(o instanceof Integer)return(Integer)o;f((List)o);return((List) o).stream().filter(i->i instanceof Integer).mapToInt(i->(Integer)i).sum();}));return l;}

लाइन ब्रेक के साथ:

import java.util.*;
List f(List l){
    l.sort(Comparator.comparing(o -> {
        if (o instanceof Integer)
            return (Integer) o;
        f((List) o);
        return ((List) o).stream().filter(i -> i instanceof Integer).mapToInt(i -> (Integer) i).sum();
    }));
    return l;
}

वहाँ कास्टिंग की एक बहुत कुछ है जो वास्तव में बाइट गिनती तक जा रहा है। : पी

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

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

Comments

यहाँ 154 बाइट्स में एक ही तकनीक हैint f(List l){l.sort(Comparator.comparing(o->o instanceof Integer?(int)o:f((List)o)));return l.stream().mapToInt(o->o instanceof Integer?(int)o:0).sum();}

— एंड्रियास

मुझे लगता है कि निचोड़ने के लिए और भी बहुत कुछ है।

— एंड्रियास

लेकिन कुछ मुद्दे हैं: आप स्पष्ट रूप Objectसे intउस तरह से परिवर्तित नहीं कर सकते हैं , और चुनौती के लिए आवश्यक है कि एक सूची आउटपुट है।

— टीएनटी

आप वास्तव में इंटेगर के बजाय सूची की जांच करने के लिए इंस्टॉफ़ बदलकर 1 बाइट बचाते हैं। पूर्णांक 7 बाइट्स w / o घुंघराले ब्रेसिज़ है, लेकिन सूची इसके साथ 6 बाइट्स है।

— ब्लू

@TNT आप एक वस्तु को जावा 1.7 या उससे अधिक में एक आदिम कास्ट कर सकते हैं। बेशक अगर ऑब्जेक्ट अशक्त है तो आपको एक झपकी आ जाएगी। मुझे सूची में जगह छाँटने में कोई समस्या नहीं दिखती, चुनौती सीधे मुद्दे पर बात करने की नहीं लगती।

— एंड्रियास

Answer 9

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

f=a=>a.map?a.map(f).sort((a,b)=>p(a)-p(b),p=a=>a.map?a.map(a=>t+=a.map?0:a,t=0)|t:a):a

वह सब सरणी जाँच :-(

Comments

map.map.map.map.map.map.map.map.map

— कैट