月曜日の夕方の簡単なチャレンジ（まあ、または世界の他の半分の火曜日の朝...）

入力として、正の整数のネストされた潜在的に不規則な配列が与えられます：

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

あなたの仕事は、その深さを決定することです。これは、リスト内の整数の最大の入れ子の深さです。この場合、の深さは11で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）すべてのレベルのすべてのリストを1つの要素のみで構成し、b）すべての非リスト構造文字を削除する効果があります。
• ステージ2-残りカウント{。これにより、最も深いレベルのネストが可能になります。

オンラインでお試しください。

それが長すぎる場合、前の答えは次のとおりでした。

網膜、13

リストは中括弧で囲まれていると仮定します{}。

+ `[^} {] |} {

{

オンラインでお試しください。

Python 2、33バイト

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

数値の深さは0で、リストの深さはその要素の最大深さより1大きいと言うことで、深さを再帰的に定義します。数値とリストは、空の辞書と比較することでチェックされます{}。この辞書は、Python 2の組み込み型の任意の順序付けで、数値より上でリストの下にあります。

Pyth- 11 10 7バイト

@Dennisのおかげで1バイト節約

@Thomas Kwaのおかげで4バイト節約

eU.usNQ

こちらからオンラインでお試しください。

変更を停止するまで配列の合計を続けます。これは、その数を意味し、これを累積的に実行してすべての中間結果を保存し、リストと同じ長さのurangeを作成し、最後の要素を取得して長さを取得します。

Haskell、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を減算し[、それ以外の場合は値を保持します。scanrすべての中間結果を保持するため、maximum作業を行うことができます。

JavaScript（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では、このタイプの配列に対して中括弧が使用されます。とにかく、入力が取得され、文字列として処理されるため、角かっこを同様に使用して、コード内の2文字を変更できます。

オンラインでお試しください！

          % 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、我々は、乗算0とによるもの、我々は知っている場合、結果はスカラ0であるか否かをチェック我々は、各要素に関数を適用するように、配列され、最大値を取り、1を加えます。

デニスのおかげで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.

更新

この答えを書いている間、リストの深さをそのアイテムの深さの増分の最小値として計算したため、Jellyは不規則なリストに対してかなり奇妙に振る舞うことに気付きました。

これは最新バージョンで対処されているため、次のコード（6バイト）が機能するようになりました。

¬SSпL

これは、配列の行を連結するのではなく、合計します。

Mathematica、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バイトを節約しました
• 文字列の比較を簡素化し、[および]
• $iintにキャストしないことでバイトを保存しました。文字列オフセットは暗黙的にintにキャストされます
• 序数の代わりに結合比較演算子を使用して3バイトを保存しました

C、98 69バイト

ありがとう@DigitalTrauma 29バイトオフ!!

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

Pythonの3、42の 39バイト

Sp3000のおかげで-3バイト

これは本質的にxnorのPython 2ソリューションの移植です：

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

残念ながら、エラー[] > {}が返されるunorderable typesため、xnorの特定の巧妙なトリックは使用できません。その代わりに、-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 []

同じ長さですが、ratherいハックの領域では、

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

Sed、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バイト

編集：@Martin Ender♦すばらしい-1トリックから1バイト節約してくれてありがとう！

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

オンラインで試してテストケースを確認してください！

以下の画像は変更されていませんが、フローは基本的に同じです。また-1、入力が配列でない場合（つまり、なし[]）に返されることに注意してください。

私は六角形の中に多くのノーオペレーションを持っています...私はそれが間違いなくもっとゴルフされることができると思います。

説明

簡単に言うと、-1に遭遇する[と追加され1、に遭遇すると追加されます]。最後に、最大値を出力します。

テストケース5に沿って実行して、文字列に沿って実行するときの動作を確認します[1, [[3]], [5, 6], [[[[8]]]], 1]。

最初から始まり、Wコーナーで入力を受け取ります。

ヌル文字\0やEOLではなく入力がまだあるため、先頭に折り返されて深紅色のパスを開始します。

そこからかわいいまで何が起こるかは><次のとおりです。

,読み出し[バッファに、そして{およびZ定数Zが90であると設定'差分に移動して-差を算出します。以下の場合[と]の違いになります1と3、それぞれ。数字、スペース、およびコンマの場合、負になります。

それ(から、-1and を取得して1応答するために[、2回（深紅のパスの終わりに1回、緑色のパスにラップした後の最初に1回）実行します]。ここで、の名前をに変更DiffしValueます。この値を深さに追加します。（以前Z&は正しい隣人を確実にコピーしていました）。次にlastMin - Depth、メモリエッジで数値を計算して取得しましたminLR。

次に&（緑のパスの最後に）適用します。minLR数値が<= 0の場合、左の値（つまりlastMin - Depth <= 0 => lastMin <= Depth）をコピーします。それ以外の場合は、右の値を取ります。

私たちは、水平方向の青のパスにラップし、私たちは見Z&再びそのコピーminLR。次に"&、計算された最小値のコピーを作成しました。括弧はバランスが取れていると想定されるため、minは<= 0でなければなりません。ラップした後、青いパスが左に移動してを押すと(、コピー1が実際の最小値より小さくなります。を再利用して-、もう1つの1回限りのコピーをBufferの隣接として作成しました。

注：というcopy名前に変更されます1-off

ときに青いパスのヒット\と素敵だ"と<キャッチそれをバックメインループへ。

ときにループのヒット1、,または入力として、あるいは他の番号：

Diffは負になり、次の入力のためにメインループに反映されます。

すべてがメインループを通過すると、バッファーを作成するEOLに到達-1し、最終的に下端に移動します。

'MPをに移動し、1-off copyそれを)増分します。~否定を使用すると、正しい最大深度値が得られます。!

そして物語はで終わり@ます。

私は物事を少し複雑にする必要があると思います。インクリメントとネゲートを行わずに「戻る」と「印刷」するだけであれば、完全なHexagonを使用せずに2バイトを節約できます。

グレートおかげTimwiための密教IDEとHexagony Colorer！

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

Perl 5、34バイト

32、プラス2 -p

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

Digital TraumaのRetinaアンサーから盗まれた…これは26％短いです。:-)

または、同様に：

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

ルビー、51文字

（のための改善提案としてスタートしましたドアノブのRubyの答えが、異なっ終わった。だから私は別の答えとして、それを掲載した。深カウントアイデア（のための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

Perl 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は、入力文字列の文字ごとに1行を作成します。

SUBSTRは、行番号に対応する文字を分離します。

DECODEは、各「[」を1に、各「]」を-1に、他のすべての文字を0に変換します。

分析SUMは、現在の行を含む、前の行の1、-1、0を合計します。

MAXの合計は深さです。

Java 8、95

これはaのラムダ式ですToIntFunction<String>。入力はString、OPの例の形式ではaと見なされます。

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。