각 문자열 앞에 0 개 이상의 공백 () 문자가 오는 동일한 대소 문자 문자열 (az XOR AZ)의 정렬 된 목록이 제공되면 동일한 목록을 출력하지만 각 들여 쓰기 수준에서 문자열이 정렬됩니다. 다른 부모의 들여 쓰기 깊이는 정렬을 위해 별개의 목록으로 계산됩니다.

예

입력이 다음과 같은 경우 :

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

원하는 경우 디렉토리 목록처럼 생각하고 각 디렉토리 내에서 이름을 정렬해야합니다.

사소한 점

• 항목은 여러 개의 공백으로 들여 쓸 수 있습니다. 이전 항목과 동일한 수의 공백으로 들여 쓰기되면 이전 항목과 동일한 정렬 계층 구조에 속합니다. 더 많은 공간이 들여 쓰기되면 새로운 하위 계층의 시작입니다.
• 줄이 더 적게 들여 쓰기되면 그 위의 줄보다 공간 위의 와사비 그룹으로 연결되는 위의 예에서 와사비와 같이 같은 # 또는 더 적은 공간으로 그 위의 가장 가까운 하위 그룹으로 연결됩니다. 와사비는 양 고추 냉이보다 더 많은 공간을 갖지 않는 첫 번째 품목입니다
• 출력에서 각 입력 항목의 들여 쓰기 레벨을 유지해야합니다.
• 출력의 탭이 허용되지 않습니다
• 입력의 첫 줄은 들여 쓰기되지 않습니다
• 프로그램은 대문자와 소문자 문자열 중 하나 이상을 처리해야합니다. 둘 다 처리 할 필요는 없습니다.

채점

이것은 code-golf 이므로 가장 적은 바이트를 사용하는 답이 이깁니다.

Pyth , 23 바이트

jeMtSuaG+f</Td/HdeGHQ]Y

여기 사용해보십시오!

파이썬 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',
]

APL (Dyalog Unicode) , 31 바이트 ^SBCS

익명 접두어 람다는 문자열 목록을 가져 와서 반환합니다.

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

온라인으로 사용해보십시오!

{… } "dfn"; ⍵논쟁이다

 ⍵[… ] 다음 지수로 인수를 색인화하십시오.

  ' '(… )¨⍵ 왼쪽 인수로 공백이있는 각 문자열에 다음 암묵적 함수를 적용하십시오.

   , 공백을 문자열로 연결

   ⊣= 공백이 각 문자와 동일한 위치를 나타내는 부울 목록

   ,⊂⍨ 이것을 사용하여 공간과 문자열의 연결을 분할 (참인 부분부터 시작)

  ↑ 문자열 목록을 문자열 행렬로 혼합

  {… }⍀ 이 "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. 시행 착오를 통해이 정규 표현식을 발견 했으므로 에지 사례가있을 수 있습니다.

O$`
$L$&

이제 대소 문자를 구분하지 않고 줄을 정렬 할 수 있습니다.

\S+ 
 

삽입 된 모든 단어를 삭제하십시오.

펄 6 , 120 83 81 63 54 37 47 42 바이트

nwellnhof 덕분에 -5 바이트

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

온라인으로 사용해보십시오!

이것은 Chas Brown의 방법을 사용 합니다. 줄 목록을 가져와 줄 목록을 반환하는 익명 코드 블록입니다.

설명:

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

클린 , 112101 바이트

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

자바 스크립트 (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])

온라인으로 사용해보십시오!

Chas Brown의 Python 답변과 비슷한 접근법이지만 정규 표현식을 대신 사용합니다.

설명

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

펄 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])을 가져 와서 들여 쓰기 수준을 확인합니다 . 불행히도 실제로 재귀에 사용되는 소수의 변수 를 선언 해야합니다. 그렇지 않으면 암시 적으로 전역 적이며 재귀가 올바르게 작동하지 않습니다.