평평하지 않은 정수 목록이 주어지면, 가장 작은 중첩 레벨부터 시작하여 왼쪽에서 오른쪽으로 읽을 때 입력 목록에서 원래 순서의 값으로 각 중첩 레벨의 정수를 포함하는 목록의 목록을 출력하십시오. 입력 목록에서 둘 이상의 목록이 동일한 중첩 수준에있는 경우 출력에서 ​​단일 목록으로 결합되어야합니다. 출력에는 빈 목록이 포함되지 않아야합니다. 목록 만 포함 된 중첩 수준은 완전히 건너 뛰어야합니다.

정수가 모두 (포함) 범위에 있다고 가정 할 수 있습니다 [-100, 100]. 목록의 최대 길이 또는 중첩 깊이는 없습니다. 입력에 빈 목록이 없습니다. 모든 중첩 수준에는 하나 이상의 정수 또는 목록이 포함됩니다.

입력 및 출력은 해당 언어의 기본 목록 / 배열 / 열거 가능 / iterable / 등에 있어야합니다. 형식 또는 언어에 시퀀스 유형이없는 경우 합리적이고 명확한 형식으로 표시하십시오.

예

[1, 2, [3, [4, 5], 6, [7, [8], 9]]] => [[1, 2], [3, 6], [4, 5, 7, 9], [8]]

[3, 1, [12, [14, [18], 2], 1], [[4]], 5] => [[3, 1, 5], [12, 1], [14, 2, 4], [18]]

[2, 1, [[5]], 6] => [[2, 1, 6], [5]]

[[54, [43, 76, [[[-19]]]], 20], 12] => [[12], [54, 20], [43, 76], [-19]]

[[[50]], [[50]]] => [[50, 50]]

피 이스, 17

 us-GeaYsI#GQ)S#Y

선행 공간이 중요합니다. s함수 에서 값이 변하지 않는지 여부에 대한 목록을 필터링 한 다음 목록에서 이러한 값을 제거하고 한 수준으로 평평하게합니다. 값도 저장되며 Y인쇄 할 때 목록의 정렬 된 값이 진실인지 필터링하여 빈 값을 제거합니다.

테스트 스위트

또는 모호한 출력 형식의 15 바이트 응답 :

 us-GpWJsI#GJQ)

테스트 스위트

확장:

 us-GeaYsI#GQ)S#Y     ##   Q = eval(input)
 u          Q)        ##   reduce to fixed point, starting with G = Q
        sI#G          ##   get the values that are not lists from G
                      ##   this works because s<int> = <int> but s<list> = flatter list
      aY              ##   append the list of these values to Y
     e                ##   flatten the list
   -G                 ##   remove the values in the list from G
              S#Y     ##   remove empty lists from Y

매스 매 티카, 56 54 52 바이트

_{Alephalpha 때문에 -2 바이트 .}

_{-2로 인해 바이트 CatsAreFluffy .}

Cases[#,_?AtomQ,{i}]~Table~{i,Depth@#}/.{}->Nothing&

실제로 빈 레벨을 삭제합니다.

파이썬 2, 78 바이트

f=lambda l:l and zip(*[[x]for x in l if[]>x])+f(sum([x for x in l if[]<x],[]))

망막 , 79

내가 알고 망막 전문가들은이 더 골프 것이다, 그러나 여기에서 시작이다 :

{([^{}]+)}(,?)([^{}]*)
$3$2<$1>
)`[>}],?[<{]
,
(\d),+[<{]+
$1},{
<+
{
,*[>}]+
}

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

Mathematica 55 64 62 바이트

#~Select~AtomQ/.{}->Nothing&/@Table[Level[#,{k}],{k,Depth@#}]&

%&[{1, 2, {3, {4, 5}, 6, {7, {8}, 9}}}]

{{1, 2}, {3, 6}, {4, 5, 7, 9}, {8}}

자바 스크립트, 112 80 바이트

F=(a,b=[],c=0)=>a.map(d=>d!==+d?F(d,b,c+1):b[c]=[...b[c]||[],d])&&b.filter(d=>d)

32 바이트를 줄여 주셔서 감사합니다.

젤리, 24 바이트

fFW®;©ṛ¹ḟF;/µŒḊ’$¡W®Tị¤;

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

줄 바꿈으로 구분 된 목록이 허용 된 경우 14 바이트 로 축소 할 수 있습니다 .

fFṄ¹¹?ḟ@¹;/µ¹¿

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

파이썬, 108 99 바이트

이것은 나에게 조금 긴 것 같지만 한 줄을 더 짧게 만들 수 없었고 or대신 대신 사용하려고 if하면 결과에 빈 목록이 표시됩니다.

def f(L):
    o=[];i=[];j=[]
    for x in L:[i,j][[]<x]+=[x]
    if i:o+=[i]
    if j:o+=f(sum(j,[]))
    return o

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

편집 : 스택 오버플로로 9 바이트 저장

파이썬 3, 109 바이트

ints와 lists를 비교하는 것과 같은 어리석은 Python 2 기능 은 Python 3이 뒤처진다는 것을 의미합니다. 오 잘 ...

def d(s):
 o=[]
 while s:
  l,*n=[],
  for i in s:
   try:n+=i
   except:l+=[i]
  if l:o+=[l]
  s=n
 return o

펄, 63 바이트

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}

에 입력이 예상되고 @i에 출력이 생성됩니다 @o. (이것이 허용되기를 바랍니다).

예:

@i=[[54, [43, 76, [[[-19]]]], 20], 12];                              # input

{$o[$x++]=[@t]if@t=grep{!ref}@i;(@i=map{@$_}grep{ref}@i)&&redo}      # the snippet

use Data::Dumper;                                                    # print output
$Data::Dumper::Indent=0;  # keep everything on one line
$Data::Dumper::Terse=1;   # don't print $VAR =
print Dumper(\@o);

산출:

[[12],[54,20],[43,76],[-19]]

클로저, 119 바이트

(seq? 및 목록으로 입력, 사소한 수정으로 116)

(defn f([v](vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

더 나은 의도 :

(defn f([v]  (vals(apply merge-with concat(sorted-map)(flatten(f 0 v)))))
       ([l v](map #(if(number? %){l[%]}(f(inc l)%))v)))

두 개의 인수 (현재 레벨과 컬렉션)로 {level: value}호출 f하면 같은 요소를 정렬되지 않은 하나의 맵 으로 만들거나 숫자가 아닌 (어쩌면 컬렉션)이 보이는 경우 재귀 적으로 호출합니다 .

그런 다음이 미니 맵을 단일로 병합 sorted-map하고 키 충돌을 concat기능별 로 처리 합니다. vals지도의 값을 첫 번째 수준에서 마지막 수준으로 반환합니다.

숫자가 해당 수준에서 유일한 숫자이면으로 남아 있고 vec다른 숫자는 로 목록으로 변환됩니다 concat.

(f [[54, [43, 76, [[[-19]]]], 20], 12])
([12] (54 20) (43 76) [-19])

입력이 있었다면 list대신 vec다음이 number?로 대체 될 수있는 seq?, 이상한 벡터 아니다 seq?그러나 그것은이다 sequential?. 그러나 나는 그 버전을 구현하고 예제를 다시 실행하는 것이 너무 게으르다.

라켓 259 바이트

(let((ol'())(m 0))(let p((l l)(n 0))(cond[(empty? l)][(list?(car l))(set! m(+ 1 n))
(p(car l)(+ 1 n))(p(cdr l)n)][(set! ol(cons(list n(car l))ol))(p(cdr l)n )]))
(for/list((i(+ 1 m)))(flatten(map(λ(x)(cdr x))(filter(λ(x)(= i(list-ref x 0)))(reverse ol))))))

언 골프 드 :

(define (f l)
  (define ol '())
  (define maxn 0)
  (let loop ((l l)              ; in this loop each item is added with its level
             (n 0))
    (cond
      [(empty? l)]
      [(list? (first l))
       (set! maxn (add1 n))
       (loop (first l) (add1 n))
       (loop (rest l) n)]
      [else
       (set! ol (cons (list n (first l)) ol))
       (loop (rest l) n )]))

  ; now ol is '((0 1) (0 2) (1 3) (2 4) (2 5) (1 6) (2 7) (3 8) (2 9)) 

  (for/list ((i (add1 maxn)))   ; here similar levels are combined
    (flatten
     (map (λ (x) (rest x))      ; level numbers are removed
          (filter (λ (x) (= i(list-ref x 0)))
                  (reverse ol))))))

테스트 :

(f '[1 2 [3 [4 5] 6 [7 [8] 9]]])

산출:

'((1 2) (3 6) (4 5 7 9) (8))

MATL , 37 바이트

j']['!=dYsXKu"GK@=)'[\[\],]'32YXUn?1M

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

함께 작동 현재 릴리스 (13.0.0) 언어 / 컴파일러.

이렇게하면 출력이 공백으로 구분 된 값의 라인으로 생성됩니다. 여기서 각 라인은 동일한 중첩 레벨에 해당하고 다른 중첩 레벨은 개행으로 구분됩니다.

j            % read input as string (row array of chars)
']['!        % 2x1 array containing ']'  and '['
=            % test for equality, all combinations
d            % row array obtained as first row minus second row
Ys           % cumulative sum. Each number is a nesting level
XK           % copy to clibdoard K
u            % unique values: all existing nesting levels
"            % for each nesting level
  G          %   push input
  K          %   push array that indicates nesting level of each input character
  @          %   push level corresponding to this iteration
  =          %   true for characters corresponding to that nesting level
  )          %   pick those characters
  '[\[\],]'  %   characters to be replaced
  32         %   space
  YX         %   regexp replacement
  U          %   only numbers and spaces remain: convert string to array of numbers
  n?         %   if non-empty
    1M       %     push that array of numbers again
             %   end if implicitly
             % end for each implicitly