Tantangan sederhana untuk Senin malam Anda (yah, atau Selasa pagi di belahan dunia lain ...)

Anda diberi input array bertumpuk, bilangan bulat positif yang berpotensi acak-acakan:

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

Tugas Anda adalah menentukan kedalamannya, yang merupakan kedalaman bersarang terbesar dari semua bilangan bulat dalam daftar. Dalam hal ini, kedalaman 11adalah 6, mana yang terbesar.

Anda dapat mengasumsikan bahwa tidak ada array yang kosong.

Anda dapat menulis sebuah program atau fungsi, mengambil input melalui STDIN (atau alternatif terdekat), argumen baris perintah atau argumen fungsi dan mengeluarkan hasilnya melalui STDOUT (atau alternatif terdekat), nilai pengembalian fungsi atau parameter function (out).

Input dapat diambil dalam format string atau daftar yang nyaman yang mendukung array non-persegi panjang (dengan array bersarang dari kedalaman berbeda), selama informasi aktual tidak diproses sebelumnya.

Anda tidak boleh menggunakan built-in yang terkait dengan bentuk array (termasuk built-in yang menyelesaikan tantangan ini, yang memberi Anda dimensi array bersarang). Satu-satunya pengecualian untuk ini adalah mendapatkan panjang array.

Aturan standar kode-golf berlaku.

Uji Kasus

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

#,/\

Di K, ,/akan bergabung dengan semua elemen daftar. Ungkapan umum ,//beralih ke titik tetap, meratakan daftar bersarang semena-mena sepenuhnya. ,/\akan beralih ke titik yang tetap dengan cara yang sama, tetapi mengumpulkan daftar hasil antara. Dengan menghitung berapa banyak hasil antara yang kami kunjungi sebelum mencapai titik tetap ( #), kami mendapatkan jawaban yang kami inginkan: kedalaman bersarang maksimum.

"Hitungan gabungan pemindaian titik tetap".

Dalam aksi:

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

Retina , 10

• Disimpan 1 byte berkat @ ӍѲꝆΛҐӍΛПҒЦꝆ
• Disimpan 14 byte tambahan berkat @ MartinBüttner

+ `\ w |} {

{

Di sini format input agak dibuat-buat - _karakter digunakan untuk pemisah daftar, sehingga input akan terlihat seperti ini{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Tahap 1 - berulang kali menghapus }{dan semua \wkarakter lainnya . Ini memiliki efek a) membuat semua daftar di semua tingkatan hanya terdiri dari satu elemen dan b) menghapus semua karakter non-daftar-struktural.
• Tahap 2 - hitungan tersisa {. Ini memberikan tingkat bersarang yang paling dalam.

Cobalah online.

Jika itu terlalu banyak, maka jawaban sebelumnya adalah:

Retina , 13

Asumsi daftar terkandung dalam kurung kurawal {}.

+ `[^} {] |} {

{

Cobalah online .

Python 2, 33 byte

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

Secara rekursif mendefinisikan kedalaman dengan mengatakan kedalaman angka adalah 0, dan kedalaman daftar adalah satu lebih dari kedalaman maksimum elemen-elemennya. Angka vs daftar diperiksa dengan membandingkan ke kamus kosong {}, yang jatuh di atas angka tetapi di bawah daftar pada pemesanan sewenang-wenang Python 2 untuk tipe bawaan.

Pyth - 11 10 7 byte

1 byte disimpan berkat @Dennis

4 byte disimpan berkat @Thomas Kwa

eU.usNQ

Cobalah online di sini .

Terus menjumlahkan array sampai berhenti berubah, yang berarti hanya angka, apakah ini secara kumulatif untuk menyimpan semua hasil antara dan mendapatkan panjang dengan membuat urange dengan panjang yang sama dengan daftar dan mengambil elemen terakhir.

Haskell, 43 byte

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

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

Haskell tidak memiliki daftar campuran (Integer campur dengan List of Integer), jadi saya tidak dapat mengeksploitasi beberapa fungsi deteksi daftar dan saya harus menguraikan string.

Saya mulai dari kanan dengan 0dan menambahkan 1 untuk setiap ], kurangi 1 untuk setiap [dan pertahankan nilai sebaliknya. scanrmenyimpan semua hasil antara, jadi maximumbisa lakukan itu berfungsi.

JavaScript (ES6), 35 byte

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

Penjelasan

Fungsi rekursif yang mengembalikan kedalaman maksimum array, atau 0jika melewati angka.

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 byte

'}{'!=dYsX>

Kurung kurawal digunakan dalam MATL untuk jenis array ini. Bagaimanapun, input diambil dan diproses sebagai string, sehingga tanda kurung sama-sama dapat digunakan, memodifikasi dua karakter dalam kode.

Cobalah online!

          % 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

Oktaf, 29 byte

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

Peta [ke 1 dan] -1, lalu ambil jumlah kumulatif maksimum.

Input adalah string dari formulir

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

Sampel dijalankan pada ideone .

Julia, 55 26 byte

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

Ini adalah fungsi rekursif yang menerima array satu dimensi dengan konten tipe Anydan mengembalikan integer. Saat mengirimkan array ke fungsi, awali semua tanda kurung Any, yaitu f(Any[1,Any[2,3]]).

Pendekatannya cukup sederhana. Untuk input a , kita kalikan a dengan 0 dan periksa apakah hasilnya skalar 0. Jika tidak, kita tahu bahwa a adalah array, jadi kita menerapkan fungsi ke setiap elemen a , ambil maksimum dan tambahkan 1.

Disimpan 29 byte berkat Dennis!

Ruby, 53 byte

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

Input dari STDIN, output ke 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

Jelly, 10 7 byte

¬;/SпL

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

¬;/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.

Memperbarui

Saat menulis jawaban ini, saya perhatikan bahwa Jelly bertingkah agak aneh untuk daftar acak-acakan, karena saya menghitung kedalaman daftar sebagai yang bertambah minimum yang kedalaman barang yang .

Ini telah diatasi dalam versi terbaru, sehingga kode berikut ( 6 byte ) akan berfungsi sekarang.

¬SSпL

Ini menjumlahkan deretan array alih-alih menggabungkannya.

Mathematica, 18 byte

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

Mathematica, 27 20 byte

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

Fungsi rekursif sederhana.

PHP, 61 byte

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

fungsi rekursif yang menggunakan dirinya sebagai fungsi pemetaan untuk mengganti setiap elemen dengan kedalamannya.

PHP, 84 72 64 63 60 byte

Catatan: membutuhkan PHP 7 untuk operator perbandingan gabungan. Juga menggunakan pengkodean IBM-850

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

Jalankan seperti ini:

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

• Menyimpan 12 byte hanya dengan menghitung kawat gigi dari representasi string
• Disimpan 8 byte dengan menyederhanakan perbandingan string dan menggunakan nomor urut char dalam kasus [dan]
• Disimpan satu byte dengan tidak melakukan casting $i ke int. Offset string dilemparkan ke int secara implisit
• Disimpan 3 byte dengan menggunakan operator perbandingan gabungan, bukan nomor urut

C, 98 69 byte

Off 29 byte terima kasih @DigitalTrauma !!

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

Mengambil string sebagai input dan mengembalikan hasilnya sebagai integer.

Contoh langsung di: http://ideone.com/IC23Bc

Python 3, 42 39 byte

-3 byte terima kasih kepada Sp3000

Ini pada dasarnya adalah port dari solusi Python 2 xnor :

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

Sayangnya, [] > {}mengembalikan unorderable typeskesalahan, sehingga trik pintar xnor tertentu tidak dapat digunakan. Sebagai gantinya, -0123456789lebih rendah dalam nilai ASCII daripada A, yang lebih rendah dari [], karenanya perbandingan string berfungsi.

CJam (15 byte)

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

Demo online

Pembedahan

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

Untuk panjang yang sama tetapi lebih banyak di wilayah hack jelek,

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

Sed, 40 karakter

(39 karakter kode + 1 opsi baris perintah karakter.)

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

Input: string, output: nomor unary.

Contoh dijalankan:

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 karakter

(32 karakter kode + 1 opsi opsi perintah karakter.)

Jika spasi tambahan diizinkan dalam output.

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

Input: string, output: nomor unary.

Contoh dijalankan:

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      

Hexagony , 61 byte

Sunting : Terima kasih @Martin Ender ♦ karena telah menyelamatkan saya 1 byte dari trik -1 yang luar biasa!

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

Cobalah online untuk memverifikasi kasus uji!

Gambar di bawah ini tidak dimodifikasi tetapi alirannya pada dasarnya sama. Perhatikan juga bahwa ini akan kembali -1jika input bukan array (yaitu tanpa []).

Saya punya banyak no-op di dalam Hexagon ... Saya kira itu pasti bisa golf lebih.

Penjelasan

Secara singkat, ia menambahkan -1ketika bertemu [dan menambahkan 1ketika bertemu a ]. Akhirnya mencetak max yang didapatnya.

Mari kita jalankan sepanjang Test Case 5 untuk melihat perilakunya ketika ia berjalan di sepanjang String [1, [[3]], [5, 6], [[[[8]]]], 1]:

Itu dimulai dari awal dan mengambil inputnya di sudut W:

Karena masih ada input (bukan karakter nol \0 atau EOL), ia membungkus ke atas dan memulai jalur merah.

Inilah yang terjadi ketika dari sana sampai lucu ><:

,membaca [ke Buffer, dan {dan Zmenetapkan konstanta Z menjadi 90. 'pindah ke Diff dan -menghitung perbedaannya. Untuk [dan ]perbedaannya akan 1dan 3masing - masing. Untuk angka, spasi, dan koma, hasilnya negatif.

Kemudian kita jalankan (dua kali (sekali di ujung jalur merah, satu di awal setelah membungkus di jalur hijau) untuk mendapatkan -1dan 1menghormati [dan ]. Di sini kita mengubah penamaan Diffmenjadi Value. Tambahkan Nilai ini ke Kedalaman. (Saya dulu Z&memastikan bahwa itu menyalin tetangga yang tepat). Lalu kami menghitung lastMin - Depthdan mendapat nomor di Memory edge minLR.

Kemudian kami menerapkan &(di ujung jalur hijau) ke minLR: Jika angkanya <= 0, ia menyalin nilai kiri (yaitulastMin - Depth <= 0 => lastMin <= Depth ), jika tidak maka akan mengambil nilai yang benar.

Kami membungkus ke jalur biru horisontal dan kami melihat Z&lagi yang menyalin minLR. Lalu kami "&dan membuat salinan dari min yang dihitung. Kurung diasumsikan seimbang, jadi min harus <= 0. Setelah membungkus, jalur biru ke kiri dan tekan (, membuat salinan 1kurang dari min sebenarnya. Menggunakan kembali -, kami membuat satu salinan 1-off lagi sebagai tetangga Buffer:

Catatan: copydiganti namanya menjadi1-off

Ketika jalur biru hits \dan mendapat bagus "dan< menangkapnya kembali ke loop utama.

Ketika loop menyentuh 1, ,atau atau nomor lain sebagai input:

Diff akan menjadi negatif dan dipantulkan kembali ke loop utama untuk input selanjutnya.

Ketika semuanya telah melalui loop utama, kita mencapai EOL yang membuat Buffer -1dan akhirnya menuju ke tepi bawah:

'memindahkan MP ke 1-off copydan )menaikkannya, dan dengan ~negasi itu mendapat nilai Kedalaman Max yang benar yang dicetak dengan!

Dan ceritanya berakhir dengan a @.

Saya kira saya pasti memiliki sedikit masalah rumit. Jika saya harus hanya "mundur" dan "mencetak" tanpa penambahan dan negasi, saya akan menghemat 2 byte tanpa menggunakan Hexagon penuh.

Terima kasih banyak kepada Timwi untuk IDE Esoterik dan Hexagony Colorer !

brainfuck, 48 byte

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

Diformat:

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

Mengambil input yang diformat seperti (1, ((3)), (5, 6), ((((8)))), 1)dan menghasilkan nilai byte .

Cobalah online.

Ini menyimpan kedalaman berdasarkan lokasi memori, menggerakkan pointer ke kanan (dan ke kiri untuk )dan mengabaikan karakter lain. Sel yang dikunjungi ditandai dengan 1bendera, sehingga pada akhir loop utama akan adadepth + 1 bendera di sebelah kanan sel saat ini. Ini kemudian ditambahkan untuk mencetak hasil akhir.

Solusi 69 byte sebelumnya menggunakan pendekatan yang berbeda:

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

Dalam versi ini, kedalaman dan kedalaman maks disimpan secara eksplisit dalam sel.

Pyth, 15 13 byte

-2 byte oleh @Maltysen

eSm-F/Ld`Y._z

Menghitung selisih antara jumlah kumulatif [dan ], dan mengambil maksimum.Yadalah array kosong, dan representasi stringnya ( `) dengan mudah [].

Coba di sini .

CJam, 19 22 23 byte

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

Ide serupa dengan jawaban MATL saya.

Terima kasih kepada Peter Taylor untuk menghapus 3 byte

Coba di sini

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 byte

32, ditambah dua untuk -p

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

Dicuri dari Digital Trauma 's Retina jawabannya ... yang merupakan 26% lebih pendek dari ini.:-)

Atau, sama:

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

Ruby, 51 karakter

(Dimulai sebagai perbaikan saran untuk Doorknob 's Ruby jawaban tapi berakhir berbeda. Jadi saya diposting sebagai jawaban yang terpisah. Upvotes untuk ide kedalaman penghitungan ( ?\\<=>$&, turun dari'] ['.index(c) ) harus pergi ke jawaban asli.)

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

Input: string, output: angka.

Contoh dijalankan:

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 byte

Penutupan:

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

Membutuhkan argumen, misalnya:

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

Penjelasan:

{ 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 byte

Merombak algoritma saya berdasarkan inspirasi oleh jawaban CJam Luis Mendo dan menyelamatkan 5 byte!

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

Coba di sini!

Penjelasan

Pada dasarnya, apa yang dilakukan kode ini adalah menjaga total berjalan dengan +1 untuk masing-masing [dan -1 untuk masing-masing ], melacak nilai maksimum yang dicapai, menghasilkan maksimum pada akhir. Looping ditangani oleh sifat toroidal dari kotak kode 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

Ruby, 41 karakter

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

Parameter: array, return: number.

Contoh dijalankan:

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 byte

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

Tidak bermain golf

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 membuat satu baris per karakter dalam string input.

SUBSTR mengisolasi karakter yang sesuai dengan nomor baris.

DECODE menerjemahkan setiap '[' ke 1, masing-masing ']' menjadi -1 dan setiap karakter lainnya menjadi 0.

SUM analitik menjumlahkan masing-masing 1, -1 dan 0 dari baris sebelumnya, termasuk baris saat ini;

Jumlah MAX adalah kedalaman.

Java 8, 95

Ini adalah ungkapan lambda untuk a ToIntFunction<String>. Input diambil sebagai Stringdalam format contoh OP.

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

cukup jujur. Pisahkan string menggunakan [sebagai pembatas. Untuk masing-masing, tambahkan penghitung edan bandingkan dengan penghitung d, pertahankan yang lebih besar d. Kemudian pisahkan string iterasi saat ini menggunakan ]sebagai pembatas saat ini dan kurangi jumlah pemisahan tambahan dari e.