월요일 저녁 (세계의 다른 반쪽에서 화요일 또는 화요일 아침)에 대한 간단한 도전 ...

양의 정수로 중첩되고 비정형 배열이 입력으로 제공됩니다.

[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]

당신의 임무는 깊이를 결정하는 것인데, 이것은 목록에서 정수의 가장 큰 중첩 깊이입니다. 이 경우의 깊이 11IS 6최대 규모이다.

어떤 배열도 비어 있지 않다고 가정 할 수 있습니다.

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받고 STDOUT (또는 가장 가까운 대안), 함수 리턴 값 또는 함수 (out) 매개 변수를 통해 결과를 출력하는 프로그램 또는 함수를 작성할 수 있습니다.

실제 정보가 전처리되지 않는 한 사각형이 아닌 배열 (깊이가 다른 중첩 배열 포함)을 지원하는 편리한 목록 또는 문자열 형식으로 입력 할 수 있습니다.

배열의 모양과 관련된 내장 기능을 사용해서는 안됩니다 (이 문제를 해결하고 중첩 배열의 크기를 얻는 내장 기능 포함). 이것의 유일한 예외는 배열의 길이를 얻는 것입니다.

표준 코드 골프 규칙이 적용됩니다.

테스트 사례

[1]                                                               -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7

K, 4 바이트

#,/\

K에서는 ,/목록의 모든 요소를 ​​결합합니다. 공통 관용구 ,//는 임의의 중첩 목록을 완전히 평평하게하여 고정 소수점까지 반복합니다. ,/\비슷한 방식으로 고정 소수점까지 반복하지만 중간 결과 목록을 수집합니다. 고정 점 ( #) 에 도달하기 전에 방문한 중간 결과 수를 세면 원하는 중첩, 최대 중첩 깊이를 얻을 수 있습니다.

"고정 점 스캔을 통한 결합 수".

실제로 :

 (#,/\)'(,1
        1 2 3
        ,1 2 3
        (3;(3;,3;3);3)
        ,((,1;2);(3;,4)))
1 1 2 3 4

망막 , 10

• @ ӍѲꝆΛҐӍΛПҒЦꝆ 덕분에 1 바이트 절약
• @ MartinBüttner 덕분에 14 바이트 추가 절약

+`\ w |} {

{

여기서 입력 형식은 약간 구성되어 있습니다. _문자는 목록 구분 기호로 사용되므로 입력은 다음과 같습니다.{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• 1 단계- }{다른 모든 \w문자를 반복적으로 제거 합니다. 이는 a) 모든 수준의 모든 목록을 하나의 요소로만 구성하고 b) 목록이 아닌 구조적 문자를 모두 제거하는 효과가 있습니다.
• 2 단계 남은 횟수 {. 이것은 가장 깊은 수준의 중첩을 제공합니다.

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

너무 늘어 나면 이전 답변은 다음과 같습니다.

망막 , 13

목록이 중괄호 안에 있다고 가정합니다 {}.

+`[^} {] |} {

{

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

파이썬 2, 33 바이트

f=lambda l:l>{}and-~max(map(f,l))

숫자의 깊이가 0이고 목록의 깊이가 요소의 최대 깊이보다 하나 이상이라고 말함으로써 깊이를 반복적으로 정의합니다. 숫자 대 목록은 빈 사전과 비교하여 확인합니다. 빈 사전 {}은 숫자보다 높지만 파이썬 2의 내장 유형의 임의 순서는 목록 아래입니다.

Pyth- 11 10 7 바이트

@Dennis 덕분에 1 바이트 절약

@Thomas Kwa 덕분에 4 바이트 절약

eU.usNQ

여기에서 온라인으로 사용해보십시오 .

배열이 변경을 멈출 때까지 계속 합산합니다. 이는 숫자를 의미하며, 모든 중간 결과를 저장하기 위해 누적 적으로 수행하고 목록과 동일한 길이의 urange를 만들고 마지막 요소를 가져와 길이를 얻습니다.

하스켈, 43 바이트

'['#x=x-1
']'#x=x+1
_#x=x
maximum.scanr(#)0

사용 예 : maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"-> 5.

Haskell에는 혼합 목록 (과 Integer혼합 List of Integer)이 없으므로 일부 목록 감지 기능을 이용할 수 없으므로 문자열을 구문 분석해야합니다.

오른쪽에서 시작하여 0매 ]1마다 1을 더하고 매 1마다 1을 빼고 [그렇지 않으면 값을 유지하십시오. scanr모든 중간 결과를 유지하므로 maximum효과가 있습니다.

자바 스크립트 (ES6), 35 바이트

f=a=>a[0]?Math.max(...a.map(f))+1:0

설명

배열의 최대 깊이를 반환하거나 0숫자를 전달한 경우 재귀 함수입니다 .

var solution =

f=a=>
  a[0]?                   // if a is an array
    Math.max(...a.map(f)) // return the maximum depth of each element in the array
    +1                    // add 1 to increase the depth
  :0                      // if a is a number, return 0

// Test cases
result.textContent =
`[1]                                                              -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7`
.split`\n`.map(t=>(c=t.split`->`.map(p=>p.trim()),c[0]+" == "+c[1]+": "+(solution(eval(c[0]))==c[1]?"Passed":"Failed"))).join`\n`

<input type="text" id="input" value="[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]" />
<button onclick="result.textContent=solution(eval(input.value))">Go</button>
<pre id="result"></pre>

MATL , 11 14 15 바이트

'}{'!=dYsX>

MATL에서는이 유형의 배열에 중괄호가 사용됩니다. 어쨌든 입력은 문자열로 처리되어 처리되므로 코드에서 두 문자를 수정하여 대괄호를 동일하게 사용할 수 있습니다.

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

          % implicitly take input as a string (row array of chars)
'}{'!     % 2x1 (column) char array with the two curly brace symbols
=         % 2-row array. First / second row contains 1 where '}' / '{' is found
d         % second row minus first row
Ys        % cumulative sum of the array
X>        % maximum of the array
          % implicitly display result

옥타브, 29 바이트

@(a)max(cumsum(92-(a(a>90))))

맵 [1과 ]-1 후 누적 합계의 최대 걸린다.

입력은 형식의 문자열입니다

S6 = '[1, [[3]], [5, 6], [[[[8]]]], 1]';

ideone에서 샘플 실행 .

줄리아, 55 26 바이트

f(a)=0a!=0&&maximum(f,a)+1

이것은 유형의 내용을 가진 1 차원 배열을 받아들이고 Any정수를 리턴하는 재귀 함수입니다 . 배열을 함수에 전달할 때 모든 대괄호 앞에 Any, 즉을 붙이십시오 f(Any[1,Any[2,3]]).

접근 방식은 매우 간단합니다. 입력 a의 경우 a 에 0 을 곱하고 결과가 스칼라 0인지 확인합니다. 그렇지 않은 경우 a 가 배열 임을 알고 있으므로 a의 각 요소에 함수를 적용 하고 최대 값을 취하고 1을 더합니다.

Dennis 덕분에 29 바이트를 절약했습니다!

루비, 53 바이트

i=0;p gets.chars.map{|c|i+=('] ['.index(c)||1)-1}.max

STDIN에서 입력하고 STDOUT으로 출력합니다.

i=0;                 initialize counter variable
p                    output to STDOUT...
gets                 get line of input
.chars               enumerator of each character in the input
.map{|c|             map each character to...
i+=                  increment i (and return the new value) by...
('] ['.index(c)||1)  returns 0 for ], 2 for [, 1 for anything else
-1                   now it's -1 for ], 1 for [, 0 for anything else
                     therefore: increment i on increase in nesting, decrement i
                       on decrease, do nothing otherwise
}.max                find the highest nesting level that we've seen

젤리, 10 7 바이트

¬;/SпL

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

¬;/SпL  Main link. Input: A (list)

¬        Negate all integers in A. This replaces them with zeroes.
    п   Cumulative while loop.
   S       Condition: Compute the sum of all lists in A.
                      If the sum is an integer, it will be zero (hence falsy).
 ;/        Body:      Concatenate all lists in A.
      L  Count the number of iterations.

최신 정보

이 답변을 쓰는 ​​동안 나는 젤리가 비정형 목록에 대해 다소 이상하게 행동한다는 것을 알았습니다. 왜냐하면 목록의 깊이를 증분으로 계산했기 때문입니다. 의 깊이는 항목의 최소 입니다.

이 문제는 최신 버전에서 해결되었으므로 다음 코드 ( 6 바이트 )가 작동합니다.

¬SSпL

배열의 행을 연결하지 않고 합합니다.

매스 매 티카, 18 바이트

Max@#+1&//@(0#-1)&

Mathematica, 27 20 바이트

Max[#0/@#]+1&[0#]-1&

간단한 재귀 함수.

PHP, 61 바이트

function d($a){return is_array($a)?1+max(array_map(d,$a)):0;}

각 요소를 깊이로 대체하기 위해 자체를 맵핑 함수로 사용하는 재귀 함수.

PHP, 84 72 64 63 60 바이트

참고 : 결합 된 비교 연산자에는 PHP 7이 필요합니다. IBM-850 인코딩도 사용

for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;

다음과 같이 실행하십시오.

php -r 'for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;' "[1, [[3]], [5, 6], [[[[8]]]], 1]"

• 대신 문자열 표현의 중괄호를 세어 12 바이트를 절약했습니다.
• 문자열 비교를 단순화하고 경우에 문자의 순서 번호를 사용하여 8 바이트를 저장 [하고]
• 캐스팅하지 않고 바이트를 저장했습니다. $iint로 . 문자열 오프셋은 암시 적으로 int로 캐스트됩니다.
• 서수 대신 결합 비교 연산자를 사용하여 3 바이트 절약

C, 98 69 바이트

29 바이트 할인 @DigitalTrauma 합니다 !

r,m;f(char*s){for(r=m=0;*s;r-=*s++==93)r+=*s==91,m=r>m?r:m;return m;}

걸린다 문자열 입력으로하고 정수로 결과를 반환합니다.

http://ideone.com/IC23Bc의 라이브 예

파이썬 3, 42 39 바이트

Sp3000 덕분에 -3 바이트

이것은 본질적으로 xnor의 Python 2 솔루션 포트입니다 .

f=lambda l:"A"<str(l)and-~max(map(f,l))

불행히도, xnor의 특별한 영리한 트릭을 사용할 수 없도록 오류를 [] > {}반환합니다 unorderable types. 대신 -0123456789ASCII 값 A이보다 작습니다.보다 작 []으므로 문자열 비교가 작동합니다.

CJam (15 바이트)

q~{__e_-M*}h],(

온라인 데모

해부

q~      e# Read line and parse to array
{       e# Loop...
  _     e#   Leave a copy of the array on the stack to count it later
  _e_-  e#   Remove a flattened version of the array; this removes non-array elements from
        e#   the top-level array.
  M*    e#   Remove one level from each array directly in the top-level array
}h      e# ...until we get to an empty array
],(     e# Collect everything together, count and decrement to account for the extra []

길이는 같지만 추악한 해킹 영역에서는 더 길지만

q'[,-{:~_}h],2-

sed, 40 자

(39 자 코드 + 1 자 명령 행 옵션)

s/[^][]+//g
:;s/]\[//;t
s/]//g
s/\[/1/g

입력 : 문자열, 출력 : 단항

샘플 실행 :

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;s/]//g;s/\[/1/g' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111

시드, 33 자

(32 자 코드 + 1 자 명령 행 옵션)

출력에 후행 공백이 허용되는 경우.

s/[^][]+//g
:;s/]\[//;t
y/[]/1 /

입력 : 문자열, 출력 : 단항

샘플 실행 :

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;y/[]/1 /' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111      

헥사 고니 , 61 바이트

편집 : 놀라운 -1 트릭에서 1 바이트를 저장해 주셔서 감사합니다 @Martin Ender ♦!

|/'Z{>"-\..(.."/'&<'..{>-&,=+<$.{\$._{..><.Z=/...({=Z&"&@!-"

테스트 사례를 확인하려면 온라인으로 사용해보십시오!

아래 이미지는 수정되지 않았지만 흐름은 기본적으로 동일합니다. 또한 -1입력이 배열이 아닌 경우 (즉,[] ) .

육각형 내부에 많은 놈이 없습니다 ... 확실히 더 골프를 칠 수 있다고 생각합니다.

설명

간단히 말하면 -1a [와 만나면 추가 되고 a 와 1만나면 추가 됩니다 ]. 마지막으로 얻은 최대 값을 인쇄합니다.

테스트 케이스 5를 따라 실행하여 문자열을 따라 실행될 때의 동작을 살펴 보겠습니다 [1, [[3]], [5, 6], [[[[8]]]], 1].

처음부터 시작하여 W 코너에서 입력을받습니다.

여전히 널 문자 \0나 EOL이 아닌 입력이 있기 때문에 맨 위로 감싼 후 크림슨 경로를 시작합니다.

거기에서 귀여운 때까지 다음과 같은 일이 발생합니다 ><.

,판독 [버퍼 및 {및 Z(90)로 일정한 Z 설정 'DIFF로 이동하고 -그 차이를 계산한다. 의 경우 [와 ]차이가있을 것입니다 1및 3각각. 숫자와 공백 및 쉼표의 경우 음수가됩니다.

그런 다음 우리는 (두 번 실행합니다 (한 번 크림슨 경로 끝에서 한 번, 녹색 경로에서 줄 바꿈 후 시작에서 한 번).-1 과 1에 대한 RESP [와 ]. 여기에서 이름을 Diff로 변경합니다 Value. 이 값을 깊이에 추가하십시오. (나는 Z&그것이 올바른 이웃을 복사하는 데 사용 했다). 그런 다음 lastMin - Depth메모리 가장자리에서 숫자를 계산 하고 얻었습니다 minLR.

그런 다음 &(녹색 경로의 끝에서) 다음에 적용 minLR합니다. 숫자가 <= 0이면 왼쪽 값을 복사합니다.lastMin - Depth <= 0 => lastMin <= Depth 그렇지 않으면 올바른 값을 사용합니다.

가로 파란색 경로로 줄 바꿈 Z&하고 minLR. 그런 다음 우리"& 계산 된 최소값의 사본을 작성했습니다. 대괄호는 균형이 잡힌 것으로 가정되므로 최소값은 <= 0이어야합니다. 줄 바꿈 후 파란색 경로가 왼쪽으로 이동 (하여 사본을 1실제 분보다 작게 만듭니다 . 을 재사용하여 -버퍼의 이웃으로 1 회성 사본을 하나 더 생성했습니다.

노트 : copy 로 이름이 변경됩니다1-off

때 경로 안타 파란색 \과 좋은있어 "와< 어획량을 다시 메인 루프로.

때 루프 히트 1, ,또는 입력으로 또는 다른 번호 :

Diff는 음이되고 다음 입력을 위해 메인 루프에 다시 반영됩니다.

모든 것이 메인 루프를 통과하면 버퍼를 만드는 EOL에 도달 -1하고 결국 맨 아래 가장자리로 이동합니다.

' MP를 1-off copy 시키고 )증가시킵니다. ~부정하면 정확한 최대 깊이 값을 얻습니다.!

그리고 이야기는로 끝납니다 @.

좀 복잡해 져야 할 것 같아요. 증분과 부정없이 "뒤로 이동"과 "인쇄"만해야한다면, 완전한 육각형을 사용하지 않고 2 바이트를 잘 절약했을 것입니다.

Esoteric IDE 와 Hexagony Colorer를 위한 Timwi 에게 감사드립니다 !

brainfuck, 48 바이트

,[<++[>-<------]>++[+[<]>>[-]]+<,]-[<[>+<-]>>]<.

형식화 :

,
[
  <++[>-<------]>++
  [
    not close paren
    +
    [
      not open paren
      <
    ]
    >>[-]
  ]
  +<,
]
-[<[>+<-]>>]
<.

같은 형식의 입력을 받아서 바이트 값을(1, ((3)), (5, 6), ((((8)))), 1) 출력 합니다 .

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

메모리 위치별로 깊이를 저장하고 포인터를 오른쪽 (및 왼쪽으로 이동 )하고 다른 문자는 무시합니다. 방문한 셀에는 1플래그 가 표시 되므로 기본 루프의 끝에 depth + 1현재 셀의 오른쪽에 플래그 가 있습니다 . 그런 다음 최종 결과를 인쇄하기 위해 추가됩니다.

다른 접근 방식을 사용하는 이전 69 바이트 솔루션 :

,
[
  >>++[<<->>------]<-<++
  [
    not close paren
    >++<+
    [
      not open paren
      >-<[-]
    ]
  ]
  <
  [
    [>+>]
    <[<-<]
    >
  ]
  >>[<+> >+<-]
  ,
]
<.

이 버전에서는 깊이와 최대 깊이가 셀에 명시 적으로 저장됩니다.

Pyth, 15 13 바이트

@Maltysen에 의해 -2 바이트

eSm-F/Ld`Y._z

누적 계수의 차이 계산 [과 ], 최대 걸린다. Y는 빈 배열이며 문자열 표현 ( `)은 편리합니다 [].

여기에서 시도 하십시오 .

CJam, 19 22 23 바이트

0l{_91=\93=-+_}%:e>

내 MATL 답변과 비슷한 아이디어.

3 바이트를 제거해 준 Peter Taylor에게 감사합니다

여기 사용해보십시오

0                            push a 0
l                            read line as string
{            }%              map this block on the string
  _91=\93=-                  1 if it's an opening bracket, -1 if closing
           +_                cumulative sum
               :e>           fold maximum function

펄 5, 34 바이트

32 개 더하기 -p

{s&]\[|[^][]&&g&&redo}$_=@a=/]/g

Digital Trauma 의 Retina 답변 에서 도난당했습니다 . 이보다 26 % 짧습니다.:-)

또는 똑같이 :

{s&]\[|[^][]&&g&&redo}$_=y///c/2

루비, 51 자

(대한 개선 제안으로 시작 손잡이 의 루비 대답 하지만 다르게했다. 그래서 별도의 답변으로 그것을 기록했다. 깊이 계산 아이디어 (대한 Upvotes ?\\<=>$&에서 하강 '] ['.index(c)) 원래의 대답에 가야한다.)

m=i=0
gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max}
p m

입력 : 문자열, 출력 : 숫자.

샘플 실행 :

bash-4.3$ ruby -e 'm=i=0;gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max};p m' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
6

펄 6, 53 바이트

폐쇄 :

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}

인수가 필요합니다. 예 :

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}("[[[3]][2]]")
3

설명:

{ my ($m,$d);                 # start closure, declare variables    

  /                           # start regex match

   [                          # start (non-capturing) group

     \[ {$d++;$m=max $m,$d} | # match [ and track depth; OR

     \] {$d--}              | # match ] and track depth; OR

     .                        # match one character

   ]*                         # repeat group

  /;                          # end regex

  $m                          # return max depth
}

Minkolang 0.15 , 31 29 24 바이트

Luis Mendo의 CJam 답변에서 영감을 받아 알고리즘을 점검 하고 5 바이트를 절약했습니다!

od5&j$ZN.d"["=$r"]"=~++d

여기 사용해보십시오!

설명

기본적으로이 코드는 실행 총계를 각각 +1 [과 -1로 ]유지하여 도달 한 최대 값을 추적하여 끝에 최대 값을 출력합니다. 루핑은 Minkolang 코드 박스의 환상적 특성에 의해 처리됩니다.

od           Take character from input and duplicate it (0 if input is empty)
  5&         Pop top of stack and skip the following five spaces if 0
    j$Z      Push the maximum value of the stack
       N.    Output as number and stop.

  d                  Duplicate top of stack for character tests
   "["=              +1 if the character is [
       $r            Swap top two items of stack
         "]"=~       -1 if the character is ]
              ++     Add twice
                d    Duplicate top of stack for the running total

루비, 41 자

f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}

매개 변수 : 배열, 리턴 : 숫자

샘플 실행 :

2.1.5 :001 > f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}
 => #<Proc:0x0000000214d258@(irb):1 (lambda)> 

2.1.5 :002 > f[[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]]
 => 6 

Oracle SQL 11.2, 133 바이트

SELECT MAX(d)FROM(SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL)d FROM DUAL CONNECT BY LEVEL<=LENGTH(:1));

언 골프

SELECT MAX(d)
FROM   (
         SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL) d 
         FROM   DUAL 
         CONNECT BY LEVEL<=LENGTH(:1)
       );

CONNECT BY는 입력 문자열에서 문자 당 하나의 행을 작성합니다.

SUBSTR은 행 번호에 해당하는 문자를 분리합니다.

DECODE는 각 '['를 1로, 각 ']'를 -1로, 다른 모든 문자를 0으로 변환합니다.

분석 SUM은 현재 행을 포함하여 이전 행의 각 1, -1 및 0을 합합니다.

MAX 합계는 깊이입니다.

자바 8, 95

이것은에 대한 람다 식입니다 ToIntFunction<String>. 입력은 StringOP의 예제 형식으로 사용됩니다.

s->{int d=e=-1;for(String t:s.split("[")){d=++e>d?e:d;e-=t.split("]",-1).length()-1;}return d;}

상당히 간단합니다. [구분 기호로 문자열을 분할하십시오 . 각각에 대해 카운터 e를 늘리고 카운터 와 비교 d하여 더 큰 값 을 유지하십시오 d. 그런 다음 ]이번에는 구분자로 사용하여 현재 반복 문자열을 분할하고에서 추가 분할 수를 뺍니다 e.