กำหนดรายการที่เรียงลำดับของสตริงตัวอักษรตัวพิมพ์เล็ก (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

ถ้าคุณชอบลองคิดว่ามันเป็นเหมือนรายชื่อไดเรกทอรีและคุณต้องเรียงลำดับชื่อในแต่ละไดเรกทอรี

ข้อปลีกย่อย

• รายการอาจเยื้องโดยจำนวนช่องว่างใด ๆ หากมีการย่อหน้าด้วยจำนวนช่องว่างเท่ากับรายการก่อนหน้ารายการนั้นจะอยู่ในลำดับชั้นการเรียงลำดับเดียวกับรายการก่อนหน้า ถ้ามันถูกเยื้องโดยช่องว่างมากขึ้นมันเป็นจุดเริ่มต้นของลำดับชั้นย่อยใหม่
• หากบรรทัดถูกเยื้องโดยช่องว่างน้อยกว่าบรรทัดด้านบนมันจะเชื่อมโยงไปยังกลุ่มย่อยที่อยู่ใกล้ที่สุดด้านบนด้วยช่องว่าง # หรือน้อยกว่าก่อนหน้านั้น (เช่นมะรุมในตัวอย่างด้านบนซึ่งลิงก์ไปยังกลุ่มวาซาบิด้านบนเพราะ วาซาบิเป็นรายการแรกที่อยู่เหนือไม่มีที่ว่างอีกกว่ามะรุม)
• คุณต้องรักษาระดับการเยื้องของแต่ละรายการอินพุตในเอาต์พุตของคุณ
• แท็บในเอาต์พุตไม่ได้รับอนุญาต
• บรรทัดแรกของอินพุตจะไม่ถูกเยื้อง
• โปรแกรมของคุณต้องจัดการกับสตริงตัวพิมพ์ใหญ่และตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว มันไม่จำเป็นต้องจัดการทั้งสองอย่าง

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่ใช้จำนวนไบต์น้อยที่สุดชนะ

Pyth , 23 ไบต์

jeMtSuaG+f</Td/HdeGHQ]Y

ลองที่นี่!

Python 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:]]

ลองออนไลน์!

ใช้เป็นรายการอินพุตของสตริง และแสดงรายการสตริงที่เรียงลำดับตามต้องการ

แนวคิดคือเปลี่ยนแต่ละองค์ประกอบให้เป็นรายการซึ่งมี "เส้นทางสัมบูรณ์" เป็นรายการ จากนั้นให้ Python จัดการการเรียงลำดับ เช่นถ้าอินพุตคือ:

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

จากนั้นผ่านทางreduce()เราจะแปลงเป็นรายการ:

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

ซึ่งได้รับการจัดเรียงเป็น:

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

จากนั้นเอาท์พุทองค์ประกอบสุดท้ายของแต่ละรายการใน list-of-list เพื่อรับ:

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

APL (Dyalog Unicode) , 31 ไบต์^SBCS

คำนำหน้าไม่ระบุชื่อแลมบ์ดารับและส่งคืนรายการสตริง

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

ลองออนไลน์!

{… } "dfn"; ⍵คือการโต้แย้ง

 ⍵[... ทำ] ดัชนีอาร์กิวเมนต์ด้วยดัชนีต่อไปนี้:

  ' '(… )¨⍵ ใช้ฟังก์ชัน tacit ต่อไปนี้กับแต่ละสตริงด้วยช่องว่างเป็นอาร์กิวเมนต์ด้านซ้าย:

   , เชื่อมช่องว่างกับสตริง

   ⊣= รายการบูลีนระบุตำแหน่งที่ว่างเท่ากับอักขระแต่ละตัวนั้น

   ,⊂⍨ ใช้สิ่งนั้นเพื่อแบ่งพาร์ติชัน (เริ่มต้นส่วนที่จริง) การต่อกันของช่องว่างและสตริง

  ↑ รายการผสมของรายการของสตริงลงในเมทริกซ์ของสตริง

  {… }⍀ การลดการสะสมในแนวดิ่งโดย "dfn"; ⍺และ⍵อยู่บนและล่าง args:

   ≢⍵ ความยาวของสตริงที่ต่ำกว่า

   1= นั่นเท่ากับ 1 หรือไม่? (เช่นไม่มีอะไรนอกจากมีที่ว่างเดียว)

   :⍺ ถ้าเป็นเช่นนั้นกลับอาร์กิวเมนต์บน

   ⋄⍵ มิฉะนั้นส่งคืนอาร์กิวเมนต์ที่ต่ำกว่า

  ⍋ เพิ่มเกรด (ค้นหาดัชนีที่จะจัดเรียง)

เรติน่า 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+ 
 

ลบคำที่แทรกทั้งหมด

Perl 6 , 120 83 81 63 54 37 47 42 ไบต์

-5 ไบต์ขอบคุณ nwellnhof

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

ลองออนไลน์!

นี้จะใช้วิธีการ Chas ของบราวน์ บล็อกโค้ดแบบไม่ระบุชื่อที่รับรายการบรรทัดและส่งคืนรายการบรรทัด

คำอธิบาย:

{                                        }  # 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

ทำความสะอาด , 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]]ซึ่งแยกสายเข้า tuples ในรูปแบบที่มีการเรียงซ้ำโดยฟังก์ชั่นผู้ช่วย(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

JavaScript (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])

ลองออนไลน์!

วิธีการคล้ายกับคำตอบ Python ของ Chas Brown แต่ใช้นิพจน์ทั่วไปแทน

คำอธิบาย

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
)                                   //

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

Perl 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]}

Ungolfed (เรียงลำดับ):

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]) น่าเสียดายที่เราต้องประกาศตัวแปรจำนวนหนึ่งที่ใช้ในการเรียกซ้ำไม่อย่างนั้นพวกมันจะอยู่ในระดับโลกโดยปริยายและการเรียกซ้ำจะไม่ทำงานอย่างถูกต้อง