Đưa ra một danh sách có thứ tự các chuỗi ký tự cùng trường hợp (az XOR AZ) trong đó mỗi chuỗi có trước 0 hoặc nhiều ký tự khoảng trắng (), xuất ra cùng một danh sách nhưng với các chuỗi được sắp xếp ở mỗi cấp độ thụt. Độ sâu thụt dưới các bậc cha mẹ khác nhau được tính là danh sách riêng biệt cho mục đích sắp xếp.

Thí dụ

Nếu đầu vào của bạn là:

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

đầu ra của bạn phải là

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

Nếu bạn thích, hãy nghĩ về nó giống như một danh sách thư mục và bạn cần sắp xếp tên trong mỗi thư mục.

Minutiae

• Một mục có thể được thụt lề bởi bất kỳ số lượng không gian. Nếu nó được thụt vào bởi cùng một số khoảng trắng với mục trước thì nó thuộc cùng phân cấp sắp xếp như mục trước. Nếu nó được thụt lề bởi nhiều không gian hơn thì đó là sự khởi đầu của một hệ thống phân cấp mới.
• Nếu một dòng được thụt vào bởi ít khoảng trắng hơn dòng trên nó, nó sẽ liên kết với nhóm phụ gần nhất bên trên nó với cùng # hoặc ít khoảng trắng trước nó (như horseradish trong ví dụ trên, liên kết với nhóm wasabi phía trên nó bởi vì wasabi là mục đầu tiên ở trên nó không có nhiều không gian hơn cải ngựa)
• Bạn phải duy trì mức thụt lề của từng mục đầu vào trong đầu ra của bạn
• Các tab trong đầu ra không được phép
• Dòng đầu tiên của đầu vào sẽ không bao giờ được thụt lề
• Chương trình của bạn phải xử lý ít nhất một chuỗi chữ hoa và chữ thường; nó không phải xử lý cả hai.

Chấm điểm

Đây là một môn đánh gôn , vì vậy câu trả lời sử dụng ít byte nhất sẽ thắng.

Bình thường , 23 byte

jeMtSuaG+f</Td/HdeGHQ]Y

Hãy thử nó ở đây!

Python 2 , 117 byte

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

Hãy thử trực tuyến!

Đưa vào như một danh sách các chuỗi; và đưa ra một danh sách các chuỗi, được sắp xếp theo yêu cầu.

Ý tưởng là biến mỗi phần tử thành một danh sách chứa "đường dẫn tuyệt đối" làm danh sách; và sau đó để Python xử lý việc sắp xếp. Ví dụ: nếu đầu vào là:

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

Sau đó, thông qua reduce(), chúng tôi chuyển đổi thành một danh sách các danh sách:

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

được sắp xếp là:

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

và sau đó xuất phần tử cuối cùng của mỗi danh sách trong danh sách danh sách cần lấy:

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

APL (Dyalog Unicode) , 31 byte ^SBCS

Tiền tố nặc danh lambda, lấy và trả về danh sách các chuỗi.

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

Hãy thử trực tuyến!

{... } "DFN"; ⍵là đối số

 ⍵[... ] chỉ số tranh cãi với các chỉ số sau:

  ' '(... )¨⍵ áp dụng các chức năng ngầm sau đây để mỗi chuỗi với không gian như là đối số bên trái:

   , nối không gian vào chuỗi

   ⊣= Danh sách Boolean cho biết vị trí không gian bằng với mỗi ký tự

   ,⊂⍨ sử dụng điều đó để phân vùng (bắt đầu phần đúng) kết hợp không gian và chuỗi

  ↑ trộn danh sách các chuỗi thành ma trận của chuỗi

  {... }⍀ giảm tích lũy dọc của thành viên này "DFN"; ⍺và ⍵là đối số trên và dưới:

   ≢⍵ độ dài của chuỗi dưới

   1= có bằng 1 không? (tức là không có gì ngoài không gian duy nhất ở đó?)

   :⍺ nếu vậy, trả về đối số trên

   ⋄⍵ khác, trả về đối số thấp hơn

  ⍋ lên lớp (tìm chỉ số sẽ sắp xếp đó)

Võng mạc , 47 byte

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

Hãy thử trực tuyến! Lưu ý: Một số dòng có dấu cách. Giải trình:

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

Bước đầu tiên là chèn từng từ vào các dòng sau ở cùng một vết lõm. Ví dụ, với các dòng aisle, wasabivà elfcác dòng kết quả là aisle, aisle wasabivà aisle wasabi elf. Tôi đã phát hiện ra regex này bằng cách dùng thử và lỗi vì vậy có thể có các trường hợp cạnh với nó.

O$`
$L$&

Bây giờ chúng ta có thể sắp xếp các dòng không phân biệt chữ hoa chữ thường.

\S+ 
 

Xóa tất cả các từ được chèn.

Perl 6 , 120 83 81 63 54 37 47 42 byte

-5 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Điều này sử dụng phương pháp của Chas Brown . Một khối mã ẩn danh nhận danh sách các dòng và trả về danh sách các dòng.

Giải trình:

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

Sạch , 112 101 byte

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

f o$

Hãy thử trực tuyến!

Hàm ẩn danh :: [[Char]] -> [[Char]]bao bọc $ :: [[Char]] -> [[[Char]]]thành định dạng đầu ra đúng. $nhóm các chuỗi thành "nhiều khoảng trống hơn" và "mọi thứ khác sau đó", đệ quy qua từng nhóm và sắp xếp khi chúng liền kề nhau. Ở mỗi bước, danh sách được sắp xếp trông như sau:

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

Sạch sẽ , 127 byte

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=[]

Hãy thử trực tuyến!

Xác định hàm $ :: [[Char]] -> [[Char]]phân tách các chuỗi thành các bộ dữ liệu ở dạng (spaces, letters)được sắp xếp đệ quy theo hàm trợ giúp ? :: [([Char],[Char])] -> [[([Char],[Char])]].

Giải thích:

$ 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 byte

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

Hãy thử trực tuyến!

Cách tiếp cận tương tự với câu trả lời Python của Chas Brown, nhưng sử dụng các biểu thức thông thường thay thế.

Giải trình

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 byte

Dung dịch:

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

Thí dụ:

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"

Giả định:

a. Rằng mỗi hệ thống phân cấp sẽ bắt đầu với mức thấp nhất, tức là bạn sẽ không nhận được:

bdellium
      fox
    hound
    alien

Giải trình:

{,/(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 byte

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 (loại):

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

Đó là một thực hiện đệ quy khá đơn giản. Chúng tôi kiểm tra mức độ thụt đầu dòng bằng cách tìm kiếm ký tự không phải không gian đầu tiên ( /\S/) và nhận chỉ mục của nó ( $-[0]). Thật không may, chúng tôi thực sự phải khai báo một số biến được sử dụng trong đệ quy, nếu không chúng sẽ hoàn toàn toàn cầu và đệ quy sẽ không hoạt động chính xác.