इंडेंटेशन आधारित सॉर्ट

Question

समान-केस लेटर स्ट्रिंग्स (az XOR AZ) की एक ऑर्डर की गई सूची को देखते हुए, जहां प्रत्येक स्ट्रिंग को 0 या अधिक स्थान () वर्णों से पहले लिया गया है, उसी सूची को आउटपुट करता है, लेकिन प्रत्येक स्तर पर इंडेंटेशन में छंटे हुए स्ट्रिंग्स के साथ। अलग-अलग माता-पिता के तहत इंडेंटेशन की गहराई छंटाई के प्रयोजनों के लिए अलग-अलग सूचियों के रूप में गिना जाता है।

उदाहरण

यदि आपका इनपुट है:

bdellium
  fox
  hound
  alien
aisle
  wasabi
    elf
    alien
  horseradish
    xeno
irk
wren
tsunami
djinn
      zebra

आपका आउटपुट होना चाहिए

aisle
  horseradish
    xeno
  wasabi
    alien
    elf
bdellium
  alien
  fox
  hound
djinn
      zebra
irk
tsunami
wren

यदि आप इसे पसंद करते हैं, तो इसे एक निर्देशिका लिस्टिंग की तरह सोचें, और आपको प्रत्येक निर्देशिका के नामों को क्रमबद्ध करना होगा।

ज़रा सी बात

• एक आइटम किसी भी स्थान से प्रेरित हो सकता है। यदि यह पिछले आइटम के समान रिक्त स्थान के समान है, तो यह पिछले आइटम के समान ही पदानुक्रम में है। यदि यह अधिक रिक्त स्थान से प्रेरित है तो यह एक नए उप-पदानुक्रम की शुरुआत है।
• यदि कोई रेखा इसके ऊपर की रेखा से कम रिक्त स्थान से प्रेरित है , तो यह ऊपर दिए गए निकटतम # या उससे पहले के रिक्त स्थान के साथ लिंक करती है (जैसा कि उपरोक्त उदाहरण में हॉर्सरैडिश की तरह है, जो इसके ऊपर वसाबी समूह पर लिंक करता है) वसाबी इसके बाद का पहला आइटम है जिसमें हॉर्सरैडिश से अधिक स्थान नहीं है)
• आपको अपने आउटपुट में प्रत्येक इनपुट आइटम के इंडेंटिंग स्तर को संरक्षित करना होगा
• आउटपुट में टैब अस्वीकृत हैं
• इनपुट की पहली पंक्ति कभी भी इंडेंट नहीं की जाएगी
• आपके प्रोग्राम को कम से कम ऑल-अपरकेस और ऑल-लोअरकेस स्ट्रिंग्स को संभालना चाहिए; यह दोनों को संभालने की जरूरत नहीं है।

स्कोरिंग

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

Comments

अच्छी चुनौती!

— एडम

अगली बार, Btw, मुख्य साइट पर पोस्ट करने से पहले एक चुनौती के साथ मुद्दों को बाहर करने के लिए सैंडबॉक्स का उपयोग करने पर विचार करें ।

— अदम

@ Adám नहीं, पुनरावर्ती स्ट्रिंग पार्सिंग तर्क की आवश्यकता है यही कारण है कि मैंने यह संकेत लिखा है।

— Techrocket9

यदि इनपुट है ['a','..b', '.c', '..d'], तो आउटपुट क्या होना चाहिए? ['a','..b', '.c', '..d']या ['a','.c','..b', '..d']कोई और बात? (मैं '.'दृश्य स्पष्टता के लिए जगह के बजाय उपयोग कर रहा हूं )।

— चास ब्राउन

@streetster स्ट्रिंग्स (az XOR AZ)

— Adám

Answer 1

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

jeMtSuaG+f</Td/HdeGHQ]Y

यहाँ यह कोशिश करो!

Answer 2

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

lambda S:[s[-1]for s in sorted(reduce(lambda t,s:t+[[v for v in t[-1]if v.count(' ')<s.count(' ')]+[s]],S,[[]]))[1:]]

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

इनपुट के रूप में तार की एक सूची लेता है; और आवश्यकता के अनुसार क्रमबद्ध तार की एक सूची तैयार करता है।

विचार प्रत्येक तत्व को एक सूची में बदलना है जिसमें सूची के रूप में "पूर्ण पथ" शामिल है; और फिर अजगर को छँटाई करने दें। जैसे यदि इनपुट है:

[
 'a',
 ' c',
 '  d',
 ' b'
]

तब के माध्यम से reduce(), हम सूचियों की एक सूची में परिवर्तित करते हैं:

[
 ['a'],
 ['a',' c'],
 ['a',' c', '  d'],
 ['a',' b']
]

जो निम्नानुसार क्रमबद्ध हो जाता है:

[
 ['a'],
 ['a',' b']
 ['a',' c'],
 ['a',' c', '  d'],
]

और फिर सूची में से प्रत्येक सूची के अंतिम तत्व को प्राप्त करने के लिए सूची:

[
 'a',
 ' b'
 ' c',
 '  d',
]

Comments

वाह समाधान मैं पोस्ट करने वाला था 183 बाइट्स ... मैं

— डॉन थाउजेंड

@ ऋषभ मेहता: मेरी पहली कोशिश लगभग 205 बाइट्स की थी ... फिर दूर हैक! :)

— चास ब्राउन

Answer 3

एपीएल (Dyalog यूनिकोड) , 31 बाइट्स ^SBCS

अनाम उपसर्ग लंबोदर, स्ट्रिंग्स की सूची लेता और वापस करता है।

{⍵[⍋{1=≢⍵:⍺⋄⍵}⍀↑' '(,⊂⍨⊣=,)¨⍵]}

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

{... } "dfn"; ⍵तर्क है

 ⍵[… ] निम्न सूचकांकों के साथ तर्क को अनुक्रमित करें:

  ' '(… )¨⍵ बाएं तर्क के रूप में अंतरिक्ष के साथ प्रत्येक स्ट्रिंग में निम्नलिखित टैकट फ़ंक्शन लागू करें:

   , स्ट्रिंग के लिए स्थान घेरना

   ⊣= बूलियन सूची इंगित करती है कि अंतरिक्ष प्रत्येक वर्ण के बराबर कहां है

   ,⊂⍨ विभाजन और भाग (जहां सत्य है) को शुरू करने के लिए स्पेस और स्ट्रिंग का उपयोग करें

  ↑ तार की मैट्रिक्स में तारों की सूची की मिक्स सूची

  {... }⍀ इस "dfn" द्वारा लंबवत संचयी कमी; ⍺और ⍵ऊपरी और निचले हिस्से हैं:

   ≢⍵ निचली स्ट्रिंग की लंबाई

   1= 1 के बराबर है? (यानी वहां पर सिंगल स्पेस के अलावा कुछ नहीं है?)

   :⍺ यदि ऐसा है, तो ऊपरी तर्क वापस करें

   ⋄⍵ और, निम्न तर्क लौटाएं

  ⍋ ग्रेड अप (उन सूचकांकों को खोजें जो इसे क्रमबद्ध करेंगे)

Answer 4

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

+-1m`(?<=^\2(\S+).*?¶( *)) 
$1 
O$`
$L$&
\S+ 
 

इसे ऑनलाइन आज़माएं! नोट: कई लाइनों में अनुगामी स्थान हैं। स्पष्टीकरण:

+-1m`(?<=^\2(\S+).*?¶( *)) 
$1 

पहला कदम एक ही इंडेंटेशन में प्रत्येक शब्द को निम्नलिखित पंक्तियों में सम्मिलित करना है। उदाहरण के लिए, लाइनों के साथ aisle, wasabiऔर elfपरिणामी लाइनें हैं aisle, aisle wasabiऔर aisle wasabi elf। मैंने इस regex को परीक्षण और त्रुटि के द्वारा खोजा ताकि इसके साथ किनारे के मामले हो सकते हैं।

O$`
$L$&

अब हम केस केस को असंवेदनशील तरीके से सॉर्ट कर सकते हैं।

\S+ 
 

सम्मिलित सभी शब्दों को हटा दें।

Answer 5

पर्ल 6 , 120 83 81 63 54 37 47 42 बाइट्स

-5 बाइट्स nwellnhof के लिए धन्यवाद

{my@a;.sort:{@a[+.comb(' ')..*+1]=$_;~@a}}

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

यह चास ब्राउन की विधि का उपयोग करता है । एक अनाम कोड ब्लॉक जो लाइनों की एक सूची लेता है और लाइनों की एक सूची देता है।

स्पष्टीकरण:

{                                        }  # Anonymous code block
 my@a;  # Declare a local list
      .sort # Sort the given list of lines
           :{                           }  # By converting each line to:
             @a[+.comb(' ')..*+1]=$_;      # Set the element at that indentation level onwards to that line
                                     ~@a   # And return the list coerced to a string

Comments

@nwellnhof यह इंगित करने के लिए धन्यवाद। मुझे लगता है कि मैंने इसे नवीनतम संस्करण में तय किया है

— जो किंग

@nwellnhof आह अच्छी तरह से, यह पिछले चलना में छोटा था। बाइट्स के लिए धन्यवाद, लेकिन मुझे इसे थोड़ा बदलना पड़ा

— जो किंग

अरे हाँ। वास्तव में, {my@a;.sort:{@a[+.comb(' ')...*>@a]=$_;~@a}}उच्च इंडेंटेशन स्तरों का समर्थन करने के लिए कुछ आवश्यक है।

— nwellnhof

Answer 6

क्लीन , 112 101 बाइट्स

import StdEnv
f=flatten
?e=[0\\' '<-e]
$[h:t]#(a,b)=span(\u= ?u> ?h)t
=sort[[h:f($a)]: $b]
$e=[]

f o$

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

अनाम फ़ंक्शन :: [[Char]] -> [[Char]]जो $ :: [[Char]] -> [[[Char]]]सही आउटपुट स्वरूप में लपेटता है । $समूहों को "से अधिक रिक्त स्थान" और "बाद में सब कुछ" में समूहित करता है, प्रत्येक समूह पर पुनरावृत्ति करता है और जब वे समीप होते हैं तो क्रमबद्ध होते हैं। प्रत्येक चरण में, सूची को क्रमबद्ध किया जा रहा है जैसे:

[[head-of-group-1,child-1,child-2..],[head-of-group-2,child-1,child-2..]..]

क्लीन , 127 बाइट्स

import StdEnv
$l=[x++y\\z<- ?(map(span((>)'!'))l),(x,y)<-z]
?[h:t]#(a,b)=span(\(u,_)=u>fst h)t
=sort[[h:flatten(?a)]: ?b]
?e=[]

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

फ़ंक्शन को परिभाषित करता है $ :: [[Char]] -> [[Char]]जो स्ट्रिंग्स को रूप में ट्यूपल्स में अलग करता है जो (spaces, letters)हेल्पर फ़ंक्शन द्वारा पुनरावर्ती रूप से सॉर्ट किए जाते हैं ? :: [([Char],[Char])] -> [[([Char],[Char])]]।

व्याख्या की:

$ list                                  // the function $ of the list
    = [                                 // is
        spaces ++ letters               // the spaces joined with the letters
        \\ sublist <- ? (               // from each sublist in the application of ? to
            map (                       // the application of
                span ((>)'!')           // a function separating spaces and letters
            ) list                      // to every element in the list
        )
        , (spaces, letters) <- sublist  // the spaces and letters from the sublist
    ]

? [head: tail]                              // in the function ? of the head and tail of the input
    # (group, others)                       // let the current group and the others equal
        = span (                            // the result of separating until ... is false
            \(u, _) = u >                   // only elements where there are more spaces
                          fst head          // than in the head of the input
        ) tail                              // the tail of the input
    = sort [
        [head                               // prepend the head of the input to
             : flatten (?group)             // the flat application of ? to the first group
                               ]            // and prepend this to
                                : ?others   // the application of ? to the other group(s)
    ]

? empty = [] // match the empty list

Answer 7

जावास्क्रिप्ट (Node.js) , 114 100 92 88 बाइट्स

x=>x.map(y=>a=a.split(/ */.exec(y)[0]||a)[0]+y,a="_").sort().map(x=>/ *\w+$/.exec(x)[0])

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

चास ब्राउन के पायथन उत्तर के समान दृष्टिकोण, लेकिन इसके बजाय नियमित अभिव्यक्ति का उपयोग करना।

व्याख्या

x => x.map(                         // 
 y => a = a.split(                  // Renders the indentation paths
  / */.exec(y)[0]                   //  Checks the indentation level
  || a                              //  If this is the top level, go to root
 )[0] + y,                          //  Appends the child to the parent
 a = "_"                            // At first the cursor is at the root
)                                   // 
.sort()                             // Sorts the indentation paths
.map(                               // 
 x => / *\w+$/.exec(x)[0]           // Extracts only the last level of the path
)                                   //

Answer 8

K4 , 51 बाइट्स

समाधान:

{,/(1#'r),'.z.s@'1_'r:(w_x)@<x@w:&s=&/s:+/'" "=/:x}

उदाहरण:

q)k){,/(1#'r),'.z.s@'1_'r:(w_x)@<x@w:&s=&/s:+/'" "=/:x}("bdellium";"  fox";"  hound";"  alien";"aisle";"  wasabi";"    elf";"    alien";"  horseradish";"    xeno";"irk";"wren";"tsunami";"djinn";"      zebra")
"aisle"
"  horseradish"
"    xeno"
"  wasabi"
"    alien"
"    elf"
"bdellium"
"  alien"
"  fox"
"  hound"
"djinn"
"      zebra"
"irk"
"tsunami"
"wren"

मान्यताओं:

ए। प्रत्येक पदानुक्रम न्यूनतम स्तर के साथ शुरू होगा, अर्थात आपको नहीं मिलेगा:

bdellium
      fox
    hound
    alien

स्पष्टीकरण:

{,/(1#'r),'.z.s@'1_'r:(w_x)@<x@w:&s=&/s:+/'" "=/:x} / the solution
{                                                 } / lambda function, implicit x
                                           " "=/:x  / " " equal to each right (/:) x
                                        +/'         / sum up each
                                      s:            / save as s
                                    &/              / find the minimum (ie highest level)
                                  s=                / is s equal to the minimum?
                                 &                  / indices where true 
                               w:                   / save as w
                             x@                     / index into x at these indices
                            <                       / return indices to sort ascending
                           @                        / index into
                      (   )                         / do this together
                       w_x                          / cut x at indices w
                    r:                              / save as r
                 1_'                                / drop first from each r
            .z.s@                                   / apply recurse (.z.s)
          ,'                                        / join each both
    (    )                                          / do this together
     1#'r                                           / take first from each r
  ,/                                                / flatten

Answer 9

पर्ल 5, 166 बाइट्स

sub f{my$p=shift;my@r;while(@i){$i[0]=~/\S/;$c=$-[0];if($p<$c){$r[-1].=$_ for f($c)}elsif($p>$c){last}else{push@r,shift@i}}sort@r}push@i,$_ while<>;print sort@{[f 0]}

अघोषित (प्रकार):

sub f {
    my $p = shift;
    my @r;
    while(@i) {
        $i[0] =~ /\S/;
        $c = $-[0];
        if($p < $c) {
            $r[-1] .= $_ for f($c)
        } elsif ($p > $c) {
            last
        } else {
            push @r, shift @i
        }
    }
    sort @r
}

push @i, $_ while <>;
print sort@{[f 0]}

यह एक बहुत सरल पुनरावर्ती कार्यान्वयन है। हम पहले गैर-अंतरिक्ष चरित्र ( /\S/) की खोज करके और इसके सूचकांक ( $-[0]) प्राप्त करके इंडेंटेशन स्तर की जांच करते हैं । दुर्भाग्यवश, हमें वास्तव में मुट्ठी भर वैरिएबल्स की घोषणा करनी है जो रिकर्सन में उपयोग किए जाते हैं, या फिर वे अंतर्निहित रूप से वैश्विक होंगे और रिकर्सन ठीक से काम नहीं करेगा।