입력

배열 또는 양의 연속적인 오름차순 정수를 포함 할 수있는 배열입니다. 배열은 그 안에 여러 배열을 가질 수 있습니다. 배열이 비어 있지 않습니다.

산출

이 배열은 단순화되었습니다

배열을 단순화하는 방법

[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]예제로 배열을 사용합니다 .

먼저 값이 얼마나 깊이 중첩되어 있는지 확인합니다. 깊이와 깊이는 다음과 같습니다.

0  1
1  2 3 9
2  4 7
3  5 6
5  8

원래 배열에서 숫자를 가져 와서 얼마나 깊이 중첩되는지 그룹화 한 다음 요소의 원래 깊이 깊이에 그룹을 중첩하여 출력 배열을 구성합니다. 숫자를 오름차순과 오름차순으로 정렬하십시오.

우리의 결과는 [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]

예

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

젤리 , 8 바이트

fFṄḟ@;/ß

출력은 한 줄에 한 수준이며 요소가없는 수준에 대해서는 빈 줄이 있습니다. 온라인으로 사용해보십시오!

작동 원리

fFṄḟ@;/ß  Main link. Argument: A (array)

 F        Flat; yield all integers (at any level) in A.
f         Filter; intersect A with the integers, yielding those at level 0.
  Ṅ       Print the filtered array and a linefeed. Yields the filtered array.
     ;/   Reduce by concatenation.
          This decreases the levels of all integers at positive levels by 1.
   ḟ@     Swapped filter-false; remove the integers at level 0 in A from the array
          with decreased levels.
       ß  Recursively call the main link on the result.
          The program stops once A is empty, since ;/ will result in an error.

자바 스크립트 (ES6) 139 109 바이트

f=(a,v=b=>a.filter(a=>b^!a[0]))=>a[0]?v().concat((a=f([].concat(...v(1))),b=v())[0]?[b]:[],v(1).map(a=>[a])):[]

예제 입력을 사용하여 설명 : v배열 (매개 변수 사용 1) 또는 값 ( 매개 변수 없음 ) 을 리턴하는 헬퍼 메소드입니다 . a = [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]비어 있지 않은로 시작 합니다. 우리는 배열을 필터링하여을 제공 [1]합니다. 그런 다음 함께 연결된 배열을 재귀 적으로 호출 [2, 3, [4], [[5, 6], 7, [[[8]]]], 9]합니다. 결과는 [2, 3, 9, [4, 7], [[5, 6]], [[[[8]]]]]입니다. 배열을 다시 필터링하여 출력의 두 번째 항을 제공 [2, 3, 9]하지만 빈 배열을 여기에 삽입하지 않도록주의해야합니다. 배열 [4, 7], [[5, 6]], [[[[8]]]]내부의 배열 을 감싸서 출력에 추가하여 결과를 유지 [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]합니다.

05AB1E , 27 26 25 21 바이트

D˜gFvyydi„ÿ ?}}¶?.gG«

온라인으로 사용해보십시오! ( .g아직 TIO에없는 것처럼 약간 수정 됨 )

설명

D˜gF                    # flattened input length times do
    vy                  # for each y current level of list
      ydi„ÿ ?}          # if y is a digit, print with space
              }         # end v-loop
               ¶?       # print newline
                 .g     # calculate length of stack (this should be .g but I can't test)
                   G«   # length stack times, concatenate items on stack

주요 전략은 중첩 배열의 각 가능한 수준을 반복하고 한 행에 숫자를 인쇄하는 반면, 숫자가 아닌 목록 (목록)은 중첩되지 않은 수준으로 유지하는 것입니다.

펄, 52 바이트

재귀 서브 루틴 (Perl 답변에 특이한 것이 있습니다 ..)

sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}

그것을 그렇게 부르십시오 :

$ perl -E 'sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}f(1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9])'
1
2 3 9
4 7
5 6

8

출력의 각 라인은 어레이의 깊이 레벨에 해당합니다 (따라서 위 예제에서 빈 라인).

입력을 Perl 배열로 변환하기 위해 add -n플래그와 eval( @{ }입력을 arrayref가 아닌 배열로 변환하기 위해) add 플래그와 전체 프로그램으로 바꿀 수 있습니다 .

perl -nE 'sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}f(@{+eval})' <<< "[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]"

내 이전 접근법은 약간 길었지만 (65 바이트) 여전히 흥미 롭기 때문에 여기에 두겠습니다.

perl -nE '/\d/?push@{$;[$d-1]},$_:/]/?$d--:$d++for/\[|]|\d+/g;say"@$_"for@' <<< "[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]"

자바 스크립트 (ES6) 121 144 152

편집 많은 수정, 1 바이트 절약 thx Patrick Roberts, 그리고 21 개 더 코드 검토

입력 및 출력의 배열에서 작동하는 재귀 함수. 깊이 1의 요소를 출력 배열의 단일 요소로 요구하는 것을 좋아하지 않습니다 (더 큰 레벨은 하나의 요소로 그룹화 됨) [l1,l1, [l2...], [[l3...]] ]. 이것이 더 직접적이지만 :[ [l1...], [[l2...]], [[[l3...]]] ]

f=(l,d=0,r=[])=>l.map(v=>v[0]?f(v,d+1,r):r[d]=[...r[d]||[],v])
r.reduce((r,v,d)=>d?[...r,(n=d=>d-->1?[n(d)]:v)(d)]:v,[])

가독성을 위해 줄 바꿈이 추가되었습니다.

몇 가지 참고 사항 : 2 번째 줄은 각 재귀 호출마다 반복해서 평가되지만 재귀 끝의 마지막 반복 만 유용합니다. 2 행에서
특수 처리 d==0는 레벨 1 요소에 대한 이상을 처리합니다. 재귀 함수는 출력에 중첩 배열 처리
n

테스트

f=(l,d=0,r=[])=>l.map(v=>v[0]?f(v,d+1,r):r[d]=[...r[d]||[],v])
&&r.reduce((r,v,d)=>d?[...r,(n=d=>d-->1?[n(d)]:v)(d)]:v,[])

console.log=x=>O.textContent+=x+'\n'

test=[
 [ 
   [1, [2,3], 4], /* -> */ [1, 4, [2,3]]
 ]
,[
   [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]], 
   // ->
   [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]
 ]
,[
  [[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]],
  // ->
  [4, [2, 5], [[1, 3, 6]], [[[7]]], [[[[8, 9]]]], [[[[[[10]]]]]]] 
 ]
,[  
  [1], /* -> */ [1]
 ]
,[  
  [1, [2], [[3]], [[[4]]], [[[[5]]]]],
  // ->
  [1, [2], [[3]], [[[4]]], [[[[5]]]]]
 ]
,[  
  [1, [[[[2], 3]]], [[4]]],
  [1, [[4]], [[[3]]], [[[[2]]]]]
]]

test.forEach(t=>{
  var i=t[0], k=t[1], r=f(i),
      si=JSON.stringify(i),
      sr=JSON.stringify(r),
      sk=JSON.stringify(k)
  
  console.log((sr==sk?'OK ':'KO ')+si + " => " + sr)
})

<pre id=O></pre>

자바 스크립트 (ES6) 168 바이트

f=a=>(s=[],b=-1,k=0,a.replace(/\d+|\[|\]/g,a=>a=='['?b++:a==']'?b--:(s[b]=s[b]||[]).push(a)),'['+s.map((a,b)=>k=a&&(k?',':'')+'['.repeat(b)+a+']'.repeat(b)).join``+']')

데모

PHP, 145 바이트

<?function c($r){$n=[];foreach($r as$k=>$v)if(is_array($v)){$n=array_merge($n,$v);unset($r[$k]);}if($n)$r[]=c($n);return$r;}print_r(c($_GET[a]));

고장

function c($r){
  #usort($r,function($x,$y){return is_array($x)<=>is_array($y)?:$x<=>$y;}); 
#no need to sort and a simple sort($r); do it sort array after scalar
  $n=[];
  foreach($r as$k=>$v)if(is_array($v)){$n=array_merge($n,$v);unset($r[$k]);} # put arrays on the same depth together
  if($n)$r[]=c($n); # recursive if an array exists
  return$r; #return changes
}
print_r(c($_GET[a])); #Output and Input

Pyth, 19 16 바이트

W=Qsf!&sITp+TdQk

온라인으로 사용해보십시오. 테스트 스위트.

선행 공간에 유의하십시오. Perl 답변과 같은 행의 레벨을 출력합니다.

설명

• 내재 입력 Q.
• filter 항목 T의 Q에 :
  • s음이 I켜져 있는지 확인하십시오 T.
  • 그것이 경우 (이 숫자였다) pRINT T플러스 공간 +... d.
  • 배열이 아닌 경우 보관하십시오.
• s음. 그러면 각 항목에서 배열 레이어가 제거됩니다. 아무것도 남지 않으면 수확량0 .
• =결과 할당Q .
• W결과가 비어 있지 않으면 빈 문자열 k과 줄 바꿈을 인쇄하십시오 .

하스켈 124 123 바이트

data L=I Int|R[L]
d#R l=((d+1)#)=<<l
d#i=[(d::Int,i)]
[]!_=[]
l!1=l
l!d=[R$l!(d-1)]
h l=R$do d<-[1..];[i|(e,i)<-0#l,d==e]!d

Haskell은 기본적으로 혼합 목록 (정수 및 정수 목록)을 지원하지 않으므로 사용자 정의 목록 유형을 정의합니다 L. 사용 예 :

*Main> h (R[I 1, R[I 2, I 3], R[ R[I 4]], R[ R[ R[I 5, I 6], I 7, R[R[R[I 8]]]], I 9]])
R [I 1,R [I 2,I 3,I 9],R [R [I 4,I 7]],R [R [R [I 5,I 6]]],R [R [R [R [R [I 8]]]]]]

참고 : 모든 양의 정수 (32 또는 64 비트)를 반복하여 깊은 중첩 수준을 찾기 때문에 실행하는 데 시간이 걸립니다. 또한 : 사용자 정의 목록 유형은 기본적으로 인쇄 할 수 없으므로 위의 예와 같이 결과를 보려면 선언 에 추가 deriving Show해야합니다 data(->data L=I Int|R[L] deriving Show ). 함수에서 L 목록을 반환 할 필요가 없으므로 바이트 수를 계산하지 않습니다.

작동 방식 :

data L=I Int|R[L]               -- custom list type L, which is either an Int
                                -- (-> I Int) or a list of some L (-> R [L]) 

d#R l=((d+1)#)=<<l              -- # makes a list of (depth, I-number) pairs from
d#i=[(d::Int,i)]                -- a given L-list, e.g.
                                -- 0 # (R[I 1,R[I 2,I 3],I 4]) -> [(1,I 4),(2,I 2),(2,I 3),(1,I 4)]
                                -- the type annotation ::Int makes sure that all
                                -- depths are bounded. Without it, Haskell
                                -- would use arbitrary large numbers of type
                                -- ::Integer and the program won't finish

[]!_=[]                         -- ! wraps a list of Is with (d-1) additional
l!1=l                           --  R constructors
l!d=[R$l!(d-1)]

h l=                            -- main function, takes a L-list
      do d<-[1..]               -- for each nest level d make
        [i|(e,i)<-0#l,d==e]     -- a list of all I where the depth is d
                           !!d  -- and wrap it again with d-1 Rs         
     R$                         -- wrap with a final R

@BlackCap 편집 >>=은 do표기법 으로 전환하여 바이트를 저장했습니다 . 감사!

자바 스크립트 (ES6), 127 (137) 134 바이트

배열을 입력으로 받아서 문자열을 반환합니다.

f=(a,l=[],d=0,o='')=>`[${a.map(x=>x[0]?f(x,l,d+1,o+'['):l[d]=(l[d]?l[d]+',':o)+x),l.map((s,d)=>x+s+']'.repeat(d,x=','),x='').join``}]`

테스트 사례

f=(a,l=[],d=0,o='')=>`[${a.map(x=>x[0]?f(x,l,d+1,o+'['):l[d]=(l[d]?l[d]+',':o)+x),l.map((s,d)=>x+s+']'.repeat(d,x=','),x='').join``}]`

console.log(f([1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]));
console.log(f([[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]]));
console.log(f([1]));
console.log(f([1, [2], [[3]], [[[4]]], [[[[5]]]]]));
console.log(f([1, [[[[2], 3]]], [[4]]]));