Düz olmayan bir tamsayı listesi verildiğinde, her bir yuvalama düzeyindeki tam sayıları içeren, en az yuvalanmış düzeyden başlayarak, soldan sağa doğru okunduğunda giriş listesindeki orijinal sıradaki değerlerle değerleri içeren bir liste listesi verin. Giriş listesinde iki veya daha fazla liste aynı yuva düzeyinde ise, çıktıda tek bir listede birleştirilmelidir. Çıktı boş listeler içermemelidir - yalnızca listeleri içeren yuvalama seviyeleri tamamen atlanmalıdır.

Tam sayıların hepsinin (dahil) aralıkta olduğunu varsayabilirsiniz [-100, 100]. Listeler için maksimum uzunluk veya yuva derinliği yoktur. Girişte boş listeler olmayacak - her yerleştirme seviyesi en az bir tam sayı veya liste içerecektir.

Giriş ve çıkış, kendi dilinizde / array / enumerable / iterable / etc içerisinde olmalıdır. eğer dilinizde bir sıralama tipi yoksa, ya da herhangi bir makul, açık formatta.

Örnekler

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

Pyth, 17

 us-GeaYsI#GQ)S#Y

Baştaki alan önemlidir. Bu, sfonksiyondaki değerlerin değişmez olup olmadığına dair listeyi filtreler , ardından bu değerleri listeden kaldırır ve bir seviye düzleştirir. Değerler ayrıca depolanır Yve yazdırırken, listenin sıralanan değeri gerçeğe uygunsa filtreleyerek boş değerleri kaldırırız.

Test odası

Alternatif olarak, şüpheli bir çıktı biçiminde bir 15 baytlık cevap:

 us-GpWJsI#GJQ)

Test odası

Genişleme:

 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

Mathematica, 56 54 52 bayt

_{Halep'ten dolayı -2 bayt .}

_{CatsAreFluffy nedeniyle -2 bayt .}

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

Aslında boş seviyeleri siler.

Python 2,78 bayt

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

Retina , 79

ben biliyorum Retina uzmanları bu fazla golf olacak, ama burada da bir başlangıçtır:

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

Çevrimiçi deneyin.

Mathematica 55 64 62 bayt

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

JavaScript, 112 80 bayt

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

Neil'i 32 byte'lık tıraş için teşekkürler.

Jöle, 24 bayt

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

Çevrimiçi deneyin!

Eğer yeni satırlarla ayrılmış listeler izin verilirse, bu değer 14 bayta kadar düşürülebilir .

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

Çevrimiçi deneyin!

Python, 108 99 bayt

Bu benim için biraz uzun görünüyor, ancak tek bir gömlek daha kısa hale getiremedim ve oryerine kullanmayı denersem ifsonuçlarda boş listelerim olur.

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

Çevrimiçi deneyin

Düzenleme: Yığın Taşması sayesinde 9 bayt kaydedildi

Python 3, 109 bayt

Her zamanki gibi, aptal Python 2 ints ve lists'lerin karşılaştırılması gibi özellikler Python 3'ün ardında ortaya çıktığı anlamına geliyor. Oh iyi...

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

Perl, 63 bayt

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

Girdi bekleniyor @i, üretilen çıktı@o . (Umarım bu kabul edilebilir).

Örnek:

@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);

Çıktı:

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

Clojure, 119 bayt

(116 ile seq? Ve listeler halinde giriş, önemsiz bir değişiklik)

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

Daha iyi niyetli:

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

İki argümanla (mevcut seviye ve bir koleksiyon) {level: value}çağrıldığında, ya benzeri folmayan bir elemanlı bir harita oluşturur ya da sayı olmayan bir sayı (büyük olasılıkla bir koleksiyon) görülürse tekrarlı olarak çağırır.

Bu mini haritalar daha sonra tek bir birleştirilir sorted-mapve temel çarpışmalar concatişlev tarafından ele alınır .valsharitanın değerlerini ilk düzeyden sonuncuya döndürür.

Bir sayı düzeyinde tek sayıysa, o zaman a kalır vec, diğerleri tarafından listelere dönüştürülür concat.

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

Girdi bir olsaydı listyerine veco number?yerini olabilir seq?, garip bir şekilde vektör değil seq?ama öyle sequential?. Ancak, bu sürümü uygulamak için çok tembelim, örnekleri tekrar yapmalıyım.

Raket 259 bayt

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

Ungolfed:

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

Test yapmak:

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

Çıktı:

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

MATL , 37 bayt

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

Çevrimiçi deneyin!

Dilin / derleyicinin şu anki sürümü (13.0.0) ile çalışır .

Bu, çıktıyı, her bir çizginin aynı iç içe seviyeye karşılık geldiği ve farklı iç içe geçme düzeylerinin yeni çizgilerle ayrıldığı boşlukla ayrılmış değer çizgileri olarak üretir.

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