ความท้าทายที่ง่ายสำหรับตอนเย็นวันจันทร์ของคุณ (ดีหรือเช้าวันอังคารในอีกครึ่งหนึ่งของโลก ... )

คุณได้รับการป้อนข้อมูลเป็นจำนวนเต็มจำนวนเต็มบวกที่ซ้อนกันซึ่งอาจทำให้ขาดดุล:

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

งานของคุณคือการกำหนดความลึกซึ่งเป็นความลึกการซ้อนที่ยิ่งใหญ่ที่สุดของจำนวนเต็มใด ๆ ในรายการ ในกรณีนี้ความลึกของ11คือ6ซึ่งใหญ่ที่สุด

คุณอาจสมมติว่าไม่มีอาร์เรย์ใดว่างเปล่า

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่น, รับอินพุตผ่าน STDIN (หรือทางเลือกที่ใกล้เคียงที่สุด), อาร์กิวเมนต์บรรทัดคำสั่งหรืออาร์กิวเมนต์ของฟังก์ชันและส่งผลลัพธ์ผ่าน STDOUT (หรือทางเลือกที่ใกล้เคียงที่สุด), ค่าส่งคืนของฟังก์ชันหรือพารามิเตอร์

อินพุตอาจถูกนำมาใช้ในรายการที่สะดวกหรือรูปแบบสตริงที่สนับสนุนอาร์เรย์ที่ไม่ใช่สี่เหลี่ยม (มีอาร์เรย์ซ้อนกันที่มีระดับความลึกต่างกัน) ตราบใดที่ข้อมูลจริงไม่ได้ถูกประมวลผลล่วงหน้า

คุณต้องไม่ใช้บิวด์อินที่เกี่ยวข้องกับรูปร่างของอาร์เรย์ (รวมถึงบิวด์อินที่แก้ปัญหานี้ซึ่งจะทำให้คุณได้มิติของอาร์เรย์ที่ซ้อนกัน) ข้อยกเว้นเพียงอย่างเดียวคือการได้รับความยาวของอาร์เรย์

ใช้กฎมาตรฐานของกอล์ฟ

กรณีทดสอบ

[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 ไบต์ขอบคุณ @ @ПӍѲꝆΛҐӍΛ
• บันทึก 14 ไบต์พิเศษด้วย @ MartinBüttner

+ `w \ |} {

{

ที่นี่รูปแบบการป้อนข้อมูลเป็นบิตที่วางแผนไว้ - _อักขระถูกใช้สำหรับตัวคั่นรายการดังนั้นอินพุตจะมีลักษณะเช่นนี้{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• ขั้นตอนที่ 1 - ลบซ้ำ ๆ}{และ\wตัวละครอื่น ๆ ทั้งหมด สิ่งนี้มีผลต่อการก) การทำรายการทั้งหมดในทุกระดับประกอบด้วยเพียงองค์ประกอบเดียวและข) การลบอักขระที่ไม่อยู่ในรายการทั้งหมด
• ขั้นที่ 2 - {การนับจำนวนที่เหลืออยู่ สิ่งนี้ทำให้การทำรังในระดับที่ลึกที่สุด

ลองออนไลน์

หากยืดออกมากเกินไปคำตอบก่อนหน้าคือ:

เรติน่า 13

{}ถือว่ารายชื่อที่มีอยู่ในวงเล็บปีกกา

+ `[^} {] |} {

{

ลองมันออนไลน์

Python 2, 33 ไบต์

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

กำหนดความลึกแบบวนซ้ำโดยบอกความลึกของตัวเลขคือ 0 และความลึกของรายการนั้นมากกว่าความลึกสูงสุดขององค์ประกอบ รายการ Number vs ถูกตรวจสอบโดยเปรียบเทียบกับพจนานุกรมว่างเปล่า{}ซึ่งอยู่เหนือตัวเลข แต่อยู่ด้านล่างรายการของการเรียงลำดับในตัวของ Python 2 โดยพลการ

Pyth - 11 10 7 ไบต์

บันทึก 1 ไบต์ด้วย @Dennis

บันทึกได้ 4 ไบต์ด้วย @Thomas Kwa

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 สำหรับอาร์เรย์ประเภทนี้ อย่างไรก็ตามข้อมูลจะถูกนำเข้าและประมวลผลเป็นสตริงดังนั้นสามารถใช้วงเล็บเหลี่ยมอย่างเท่าเทียมกันโดยปรับเปลี่ยนอักขระสองตัวในรหัส

ลองออนไลน์!

          % 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

Julia, 55 26 ไบต์

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

นี่เป็นฟังก์ชั่นวนซ้ำที่ยอมรับอาร์เรย์หนึ่งมิติที่มีเนื้อหาประเภทAnyและส่งกลับจำนวนเต็ม เมื่อผ่านอาร์เรย์เพื่อฟังก์ชั่นคำนำหน้าทั้งหมดที่มีวงเล็บคือAnyf(Any[1,Any[2,3]])

วิธีการนั้นค่อนข้างง่าย สำหรับการป้อนข้อมูลเราคูณโดย 0 และตรวจสอบว่าผลที่ได้คือเกลา 0. ถ้าไม่ได้เรารู้ว่าเป็นอาร์เรย์เพื่อให้เราใช้ฟังก์ชั่นให้กับองค์ประกอบของแต่ละใช้สูงสุดและเพิ่ม 1

บันทึก 29 ไบต์ขอบคุณ Dennis!

Ruby, 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

สิ่งนี้จะสรุปจำนวนแถวของอาร์เรย์แทนการต่อข้อมูลเข้าด้วยกัน

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 ไบต์โดยนับการจัดฟันของการแทนค่าสตริงแทน
• บันทึก 8 ไบต์โดยทำให้การเปรียบเทียบสตริงง่ายขึ้นและใช้เลขลำดับของถ่านในกรณีของ[และ]
• บันทึก byte โดยไม่ส่ง$iไปยัง int การชดเชยสตริงจะถูกส่งไปยัง 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

Python 3, 42 39 ไบต์

-3 ไบต์ขอบคุณ Sp3000

นี่คือพอร์ตของโซลูชัน Python 2ของxnor :

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

น่าเสียดายที่[] > {}ส่งคืนunorderable typesข้อผิดพลาดดังนั้นจึงไม่สามารถใช้เคล็ดลับที่ชาญฉลาดของ xnor ได้ ในสถานที่นั้น-0123456789มีค่า ASCII ต่ำกว่า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-

ไม่เกิน 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      

Hexagony , 61 ไบต์

แก้ไข : ขอบคุณ @Martin Ender ♦สำหรับการบันทึกฉัน 1 ไบต์จากเคล็ดลับ -1 ที่ยอดเยี่ยม!

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

ลองออนไลน์เพื่อตรวจสอบกรณีทดสอบ!

ภาพด้านล่างนี้ไม่ได้ถูกดัดแปลง แต่การไหลนั้นเหมือนกัน โปรดทราบด้วยว่าสิ่งนี้จะส่งคืน-1หากอินพุตไม่ใช่อาร์เรย์ (เช่นไม่มี[])

ฉันไม่มีตัวเลือกมากมายใน Hexagon ... ฉันคิดว่ามันสามารถเล่นกอล์ฟได้มากขึ้นอย่างแน่นอน

คำอธิบาย

ในช่วงสั้น ๆ จะเพิ่ม-1เมื่อพบ[และเพิ่มเมื่อพบ1 ]ในที่สุดมันก็พิมพ์ค่าสูงสุดที่ได้รับ

ลองวิ่งไปตามกรณีทดสอบ 5 เพื่อดูพฤติกรรมของมันเมื่อมันวิ่งไปตามสายอักขระ[1, [[3]], [5, 6], [[[[8]]]], 1]:

มันเริ่มต้นที่จุดเริ่มต้นและรับอินพุตที่มุม W:

เนื่องจากยังมีอินพุตอยู่ (ไม่ใช่อักขระ null \0หรือ EOL) จึงตัดไปด้านบนและเริ่มต้นเส้นทางสีแดงเข้ม

นี่คือสิ่งที่เกิดขึ้นเมื่อจากที่นั่นจนถึงน่ารัก><:

,อ่าน[ในบัฟเฟอร์{และZตั้งค่า Z คงที่เป็น 90 'เลื่อนไปที่ Diff และ-คำนวณความแตกต่าง สำหรับ[และ]ความแตกต่างจะเป็น1และ3ตามลำดับ สำหรับตัวเลขและช่องว่างและเครื่องหมายจุลภาคมันจะเป็นค่าลบ

จากนั้นเราจะดำเนินการ(สองครั้ง (ครั้งเดียวในตอนท้ายของเส้นทางสีแดงเข้มคนหนึ่งที่เริ่มต้นหลังจากที่การตัดเส้นทางสีเขียว) ที่จะได้รับ-1และ1รับผิดชอบสำหรับการและ[ ]ที่นี่เราเปลี่ยนการตั้งชื่อให้กับDiff Valueเพิ่มค่านี้เป็นความลึก (ฉันใช้Z&เพื่อให้แน่ใจว่ามันคัดลอกเพื่อนบ้านที่ถูกต้อง) จากนั้นเราจะคำนวณและได้รับหมายเลขบนขอบหน่วยความจำlastMin - DepthminLR

จากนั้นเราจะนำไปใช้&(ที่จุดสิ้นสุดของเส้นทางสีเขียว) กับminLR: หากตัวเลขคือ <= 0 จะเป็นการคัดลอกค่าที่เหลือ (เช่นlastMin - Depth <= 0 => lastMin <= Depth) มิฉะนั้นจะใช้ค่าที่ถูกต้อง

เราตัดไปยังเส้นทางสีฟ้าแนวนอนและที่เราเห็นอีกครั้งซึ่งสำเนาZ& minLRจากนั้นเรา"&และทำสำเนาของการคำนวณขั้นต่ำ วงเล็บจะถือว่ามีความสมดุลดังนั้น min จะต้องเป็น <= 0 หลังจากห่อแล้วเส้นทางสีฟ้าก็จะไปทางซ้ายและถูกยิง(ทำให้การคัดลอก1น้อยกว่านาทีจริง การนำ-เราได้สร้างอีกหนึ่ง 1 ออกสำเนาเป็นเพื่อนบ้านของบัฟเฟอร์:

หมายเหตุ: copyถูกเปลี่ยนชื่อเป็น1-off

เมื่อเส้นทางสีน้ำเงินกระทบ\และมีความสุข"และ<จับมันกลับไปที่วงหลัก

เมื่อฮิตวง1, ,หรือหรือตัวเลขอื่น ๆ เช่นการป้อนข้อมูล:

ดิฟจะกลายเป็นลบและมันจะสะท้อนกลับไปที่ลูปหลักสำหรับอินพุตถัดไป

เมื่อทุกอย่างผ่านลูปหลักเราจะไปถึง EOL ซึ่งจะทำให้บัฟเฟอร์-1และในที่สุดก็ไปที่ขอบด้านล่าง:

'ย้าย MP ไปที่1-off copyและ)เพิ่มขึ้นและด้วยการ~ปฏิเสธจะได้รับค่าความลึกสูงสุดที่ถูกต้องซึ่งพิมพ์ด้วย!

@และเรื่องนี้จบลงด้วย

ฉันคิดว่าฉันต้องมีสิ่งที่ซับซ้อนเกินกว่าเล็กน้อย หากฉันต้อง "ย้อนกลับ" และ "พิมพ์" โดยไม่เพิ่มและปฏิเสธเท่านั้นฉันจะได้รับการบันทึก 2 ไบต์โดยไม่ต้องใช้ Hexagon แบบเต็ม

ขอบคุณที่ดีในการ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 ไบต์

-2 ไบต์โดย @Maltysen

eSm-F/Ld`Y._z

นับความแตกต่างระหว่างการนับสะสมของ[และ], และใช้เวลาสูงสุด Yคืออาร์เรย์ที่ว่างเปล่าและการเป็นตัวแทนสตริง ( `) []เป็นสิ่งอำนวยความสะดวก

ลองมันนี่

CJam, 19 22 23ไบต์

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

แนวคิดที่คล้ายกับคำตอบ MATL ของฉัน

ขอบคุณ Peter Taylor ที่ลบ 3 ไบต์

ลองที่นี่

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, บวกสองสำหรับ -p

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

ขโมยมาจากดิจิตอลบาดเจ็บ 's คำตอบ Retina ... ซึ่งเป็น 26% สั้นกว่านี้:-)

หรือเท่าเทียมกัน:

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

Ruby, 51 ตัวอักษร

(เริ่มต้นเป็นข้อเสนอแนะการปรับปรุงสำหรับคำตอบ RubyของDoorknobแต่จบลงแตกต่างกันดังนั้นฉันโพสต์มันเป็นคำตอบที่แยกต่างหาก 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 ไบต์

ปรับปรุงอัลกอริทึมของฉันโดยรับแรงบันดาลใจจากคำตอบ CJam ของ Luis Mendoและบันทึกไว้ 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

Ruby, 41 ตัวอักษร

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

พารามิเตอร์: array, return: number

วิ่งตัวอย่าง:

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

ผลรวมการวิเคราะห์ผลรวม 1, 1 และ 0 จากแถวก่อนหน้ารวมทั้งแถวปัจจุบัน

จำนวน MAX เป็นความลึก

Java 8, 95

ToIntFunction<String>นี่คือการแสดงออกแลมบ์ดาหา อินพุตถูกใช้เป็น a Stringในรูปแบบตัวอย่างของ OP

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