นี่เป็นหนึ่งในความท้าทายที่นำไปสู่วันเกิดของ Brain-Flak ค้นหาข้อมูลเพิ่มเติมได้ที่นี่

ท้าทาย

สำหรับความท้าทายครั้งนี้วัตถุประสงค์ของคุณจะได้รับการหาคู่แรกของการจับคู่วงเล็บในสตริงจับคู่ได้อย่างสมบูรณ์ของ()[]{}<>วงเล็บ ในการขอยืมคำจำกัดความของ DJMcMayhem สำหรับสตริงที่ตรงกันอย่างสมบูรณ์:

• สำหรับวัตถุประสงค์ของการท้าทายนี้เป็น "วงเล็บ" ใด ๆ ()[]{}<>ของตัวละครเหล่านี้:

• เครื่องหมายวงเล็บคู่หนึ่งถือว่าเป็น "จับคู่" หากวงเล็บเปิดและปิดอยู่ในลำดับที่ถูกต้องและไม่มีอักขระอยู่ภายในเช่น

  ()
  []{}
  

  หรือถ้าทุกองค์ประกอบย่อยภายในนั้นถูกจับคู่ด้วย

  [()()()()]
  {<[]>}
  (()())
  

  องค์ประกอบย่อยยังสามารถซ้อนกันหลายชั้นลึก

  [(){<><>[()]}<>()]
  <[{((()))}]>
  

• สตริงถือว่าเป็น "จับคู่อย่างสมบูรณ์" ถ้าเฉพาะในวงเล็บแต่ละคู่มีวงเล็บเปิดและปิดที่ถูกต้องในลำดับที่ถูกต้อง

อินพุต

ข้อมูลที่ป้อนจะประกอบด้วยสตริงที่ไม่ว่างเปล่าหรืออาร์เรย์ถ่านที่มีเฉพาะอักขระ()[]{}<>เท่านั้นและรับประกันว่าจะจับคู่อย่างสมบูรณ์ คุณสามารถป้อนข้อมูลในลักษณะที่สมเหตุสมผลใด ๆ ที่สอดคล้องกับค่าเริ่มต้นของi / o ของเรา

เอาท์พุต

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

กรณีทดสอบ

Input       0-indexed   1-indexed
()          1           2
(<>)        3           4
<[]{<>}>    7           8
{}{}{}{}    1           2
[[]<>[]]    7           8

นี่คือcode-golf , ไบต์ที่น้อยที่สุดชนะ!

V , 4 ไบต์

%Dø.

ลองออนไลน์!

สิ่งนี้แตกต่างจากคำตอบ V ส่วนใหญ่ใช้การจัดทำดัชนี 0 ฉันภูมิใจในคำตอบนี้อย่างมากและภาษาของฉันมาไกลแค่ไหน คำอธิบาย:

%       " Jump to the first bracket match
 D      " Delete everything under and after the cursor
  ø     " Count the number of times the following regex is matched:
   .    "   Any character

Brain-Flak , 685, 155, 151 , 137 bytes

(())({<{}({}()<(()()()())>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>
([{}()]{})(({})){{}({}[()])(<()>)}{}(<>)<>{{}<>{}({}<>)}{}(<>[]<>)>()}<>)

ลองออนไลน์!

136 -aไบต์ของรหัสบวกหนึ่งไบต์สำหรับ หนึ่งดัชนี

ไบต์ 530 ออกไป! นั่นอาจเป็นสนามกอล์ฟที่ใหญ่ที่สุดที่ฉันเคยทำมา

บันทึก 14 ไบต์ด้วย Riley!

นี่เป็นการละเมิดสูตรของวงเล็บเปิด / ปิด: ถ้าคุณใช้ค่า ASCII ให้เพิ่มขึ้นทีละหนึ่งและใช้โมดูโลของ 4 openers ( ({[<) จะได้รับเสมอ0หรือ1ในขณะที่ closers ( )}]>) จะได้รับ 2 หรือ 3 เสมอ

คำอธิบาย:

#Push 1
(())

#While true
({<

    #Pop stack height
    {}

    #Compute (TOS + 1) % 4
    ({}()<(()()()())>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

    #Decrement if positive
    (({})){{}({}[()])(<()>)}{}

    #Push 0 onto alternate
    (<>)

    #Toggle back
    <>

    #Pop two zeros from alternate if closer
    {{}<>{}({}<>)}{}

    #Push height of alternate stack
    (<>[]<>)

#Make each time through evaluate to 1
>()

#Endwhile
}

#Push the number of loops onto the offstack
<>)

05AB1E , 17 16 10 ไบต์

-1 ต้องขอบคุณ carusocomputing

-6 ขอบคุณ Adnan สำหรับความเข้าใจที่น่าทึ่งของเขาว่า "หลังจากเพิ่มขึ้นบิตสุดท้ายที่สองคือ 0 สำหรับวงเล็บเปิดและ 1 สำหรับวงเล็บปิด"

Ç>2&<.pO0k

ลองออนไลน์!

Ç          # Get input as ASCII values
 >         # Increment
  2&       # And with 2 (0 for open and 2 for close brackets)
    <      # decrement 
     .p    # prefixes
       O   # Sum
        0k # Print the index of the first 0

เป็นกลุ่ม 23 ไบต์

:se mps+=<:>
%DVr<C-a>C1<esc>@"

ลองออนไลน์!

ฉันเสียใจจริงๆกับคำตอบนี้ โซลูชันนี้สวยงามและสั้น แต่โดยค่าเริ่มต้น vim ไม่ได้พิจารณา<และ>จับคู่ดังนั้นฉันต้องใช้รหัสสำเร็จรูป 13 ไบต์ มิฉะนั้นจะเป็น 10 ไบต์

ฉันจะโพสต์คำตอบ V แต่นั่นจะสั้นกว่าเพียงหนึ่งไบต์เท่านั้นนั่นคือเปลี่ยนVrไปÒเนื่องจากVrเป็นคำสั่งทั่วไปของ vim-idiom

นี่คือ 1 การจัดทำดัชนี แต่อาจมีการปรับเปลี่ยนนิด ๆ จะเป็น 0 การจัดทำดัชนีโดยการเปลี่ยนไป10

:se mps+=<:>        " Stupid boilerplate that tells vim to consider `<` and `>` matched
%                   " Jump to the bracket that matches the bracket under the cursor
 D                  " Delete everything from here to the end of the line
  V                 " Visually select this whole line
   r<C-a>           " Replace each character in this selection with `<C-a>`
                    " This conveniently places the cursor on the first char also
         C          " Delete this whole line into register '"', and enter insert mode
          1<esc>    " Enter a '1' and escape to normal mode
                @"  " Run the text in register '"' as if typed. Since the `<C-a>` command
                    " Will increment the number currently under the cursor

เยลลี่ , 11 10 9 ไบต์

O’&2’+\i0

ลองออนไลน์!

คำอธิบาย

ความคิดที่นี่คือการหา "สูตรวิเศษ" ที่สามารถแยกความแตกต่างจากการปิดวงเล็บ ฉันเริ่มใช้O%7&2(เช่น "รับรหัส ASCII, modulo 7, bitwise-and 2") แต่แนะนำ @ETHproductions O’&2(ซึ่งแทนที่ modulo 7 ด้วยการลดลง); ทั้งคืน 0 สำหรับประเภทหนึ่งของวงเล็บและ 2 สำหรับอีกประเภทหนึ่ง การลบ 1 ( ’) จะทำให้ผลลัพธ์เหล่านี้เป็น -1 และ 1

+\ส่วนที่เหลือของรหัสเป็น +\สร้างผลรวมสะสม หากชุดของวงเล็บถูกจับคู่อย่างถูกต้องมันจะมีจำนวนเท่ากันของ -1s และ 1s นั่นคือผลรวมสะสมของมันจะเป็น 0 จากนั้นเราก็ต้องส่งกลับดัชนีของ 0 แรกในรายการผลลัพธ์; i0เราสามารถทำเช่นนั้นด้วย

เรติน่า26 26ไบต์

M!`^.(?<-1>([[({<])*.)*

ลองออนไลน์!

ผลลัพธ์เป็น 1-based

คำอธิบาย

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

M!`^.(?<-1>([[({<])*.)*

ค้นหา ( M) และผลตอบแทน ( !) การแข่งขันทั้งหมดของ ^.(?<-1>([[({<])*.)*regex regex นั้นข้ามอักขระตัวแรกของสตริงและจากนั้นใช้กลุ่มที่สมดุลเพื่อติดตามความลึกในการซ้อน ใด ๆ ของการ[({<เพิ่มความลึก (ติดตามโดยกลุ่ม1) และอักขระอื่น ๆ ลดความลึก (ตามหลักการ.อนุญาตให้ความลึกลดลงโดยการเปิดวงเล็บเช่นกัน แต่เนื่องจาก regex จับคู่กันอย่างตะกละตะกลาม backtracker จะไม่พยายามที่ ) เคล็ดลับแปลก ๆ คือ(?<-1>...)กลุ่มล้อมรอบ1ซึ่งทำงานได้เนื่องจากการ popping จากกลุ่มสมดุลเกิดขึ้นในตอนท้ายของกลุ่ม วิธีนี้ช่วยประหยัดสองไบต์เหนือวิธีมาตรฐานในแบบฟอร์ม((open)|(?<-2>close))*. การจับคู่จำเป็นต้องหยุดที่วงเล็บซึ่งปิดอันแรกเพราะเราข้ามมันไปดังนั้นมันจึงไม่ถูกนับในความลึกของสแต็ก

ความยาวของการจับคู่นี้คือดัชนีที่ใช้ 0 ของวงเล็บที่เรากำลังมองหา

เพียงนับจำนวนการแข่งขันที่ว่างเปล่าในสตริงนี้ regex ที่ว่างจะจับคู่มากกว่าหนึ่งครั้งในตัวอักขระเสมอดังนั้นนี่จะให้ดัชนีแบบ 1 ฐานของวงเล็บที่เราต้องการ

เรติน่า 24 ไบต์

.(([[({<])|(?<-2>.))*$

ลองออนไลน์!

นี้เป็นแรงบันดาลใจการแก้ปัญหามาร์ตินพลิก

คำอธิบาย

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

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

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

Perl 5 , 28 ไบต์

ที่บันทึกไว้ 6 ไบต์โดยใช้เพียงแค่.แทน[>})\]]จากมาร์ตินพลิกคำตอบ Retina

27 ไบต์ของรหัส + -pธง

/([<{([](?0)*.)+?/;$_=$+[0]

ลองออนไลน์!

Regex แบบเรียกซ้ำสิ่งประดิษฐ์ที่สวยงาม
regex จะค้นหาวงเล็บเปิด ( [<{([]) ตามด้วยการเรียกซ้ำ ( ?0) ตามด้วยวงเล็บปิด ( .) ทั้งหมดนี้ไม่โลภ ( +?) ดังนั้นมันตรงกับสั้นที่สุดเท่าที่เป็นไปได้จากจุดเริ่มต้น ดัชนีสิ้นสุดการแข่งขันคือคำตอบและเมื่อเกิดขึ้นก็สามารถพบ$+[0]ได้

JavaScript (ES6), 55 53 52 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @Adnan

f=([c,...s],i=1)=>(i-=-c.charCodeAt()&2)&&1+f(s,++i)

สำหรับวงเล็บเปิดทุกอันการใช้รหัส char 4 ให้ 0 หรือ 3; สำหรับวงเล็บปิดเราให้ 1 หรือ 2 ดังนั้นเราสามารถแยกแยะความแตกต่างระหว่างวงเล็บเปิดและปิดได้โดยการลบรหัส char ของวงเล็บปีกกา (ซึ่งพลิกบิตและลบ 1) และบิตที่มีนัยสำคัญน้อยที่สุดอันดับที่สอง; นั่นคือ, n&2.

C, 75 72 56 55 54 45 ไบต์

a;f(char*s){return(a-=(-*s++&2)-1)?1+f(s):0;}

เห็นมันทำงานแบบออนไลน์

หากคุณต้องการที่จะออก 1 การจัดทำดัชนีแทน 0 การจัดทำดัชนีแทนที่สุดท้ายกับ01

Python 2.7 + Numpy, 85 79 ไบต์

ความพยายามครั้งแรกของฉันที่การตีกอล์ฟ:

from numpy import*
lambda s:list(cumsum([(ord(x)+1&2)-1for x in s])).index(0)

Brain-Flak , 97 ไบต์ (96 สำหรับรหัส, 1 สำหรับการตั้งค่าสถานะ)

{}<>(())({<(<()>)<>({<({}[()])><>([{}]())<>}{})<>(<{}>())<>{({}[()])<>([{}])<>}{}<>({}{})>()}{})

วิ่งด้วย-aธง

ลองออนไลน์!

คำอธิบาย:

#Skip the first open bracket 
{}

#Place a 1 on stack B, representing the nesting depth
<>(())

#Start a loop, until the depth is 0
({<

 #Divide the ASCII code by 2, rounding up
 (<()>)<>({<({}[()])><>([{}]())<>}{})<>

 #Replace TOS B with a 1
 (<{}>())

 #Swap back to stack A
 <>

 #Negate the 1 on stack B n times (n = ASCII value+1/2)
 {({}[()])<>([{}])<>}{}

 #Swap back to stack B
 <>

 #Add the 1/-1 (depending on Open/close bracket) to the nesting depth accumulator
 ({}{})

 #Count loop cycles
 >()

#end loop, print result implicitly by pushing to the stack 
}{}) 

มันใช้งานได้โอเค

เรติน่า 34 ไบต์

^.
!
T`([{}])`<<<>
+T`p`!`<!*>
\G!

ลองออนไลน์!

ผลลัพธ์เป็นแบบอิง 0

คำอธิบาย

^.
!

!แทนที่ตัวอักษรตัวแรกด้วย นี่ทำให้วงเล็บที่เรากำลังมองหาที่จะไม่ตรงกัน

T`([{}])`<<<>

แปลงวงเล็บวงเล็บเหลี่ยมและวงเล็บปีกกาเป็นวงเล็บเหลี่ยม เนื่องจากสตริงรับประกันว่าจะจับคู่อย่างสมบูรณ์เราไม่สนใจประเภทที่แท้จริงเลยและสิ่งนี้จะช่วยประหยัดบางไบต์ในขั้นตอนต่อไป

+T`p`!`<!*>

ซ้ำ ( +) แทนที่อักขระแต่ละตัวในการแข่งขันทั้งหมด<!*>ด้วย!s นั่นคือเราจับคู่วงเล็บที่ไม่มีเครื่องหมายวงเล็บเหลี่ยมที่ยังไม่ได้ประมวลผลแล้วเปลี่ยนเป็นเครื่องหมายอัศเจรีย์เพิ่มเติม สิ่งนี้จะเปลี่ยนสตริงทั้งหมดยกเว้นเครื่องหมายวงเล็บปิดที่ไม่ตรงกันเป็นเครื่องหมายอัศเจรีย์

\G!

นับจำนวนเครื่องหมายอัศเจรีย์นำหน้าซึ่งเท่ากับตำแหน่ง 0 อิงของเครื่องหมายที่ไม่ใช่เครื่องหมายอัศเจรีย์ตัวแรก (เช่นเครื่องหมายวงเล็บเหลี่ยมที่ไม่ตรงกัน) \Gเบรกการแข่งขันแต่ละครั้งก่อนซึ่งเป็นเหตุผลที่นี้ไม่ได้นับ!หลังจากวงเล็บกล่าวว่า

PHP, 116 ไบต์

for($l=["("=>")","["=>"]","{"=>"}","<"=>">"][$f=$argn[0]];;$d>0?$i++:die("$i"))$d+=$f!=($n=$argn[$i])?$n==$l?-1:0:1;

เวอร์ชั่นออนไลน์

Pythonขนาด 76 ไบต์

f=lambda s,r=[],i=0:(i<1or sum(r))and f(s[1:],r+[(ord(s[0])+1&2)-1],i+1)or i

ฟังก์ชั่นแบบเรียกซ้ำที่ใช้ลำดับที่ 2 LSB เป็นธงสำหรับเคล็ดลับแบบเปิด vs close ที่หลายคนใช้โดย Adnan (และอาจเป็นแบบอื่น) หางกระทบเมื่อยอดรวมสะสมของ-1การเปิดและ1ปิดถึงศูนย์ ดัชนีถูกเก็บไว้ในตัวแปรเนื่องจากมีราคาถูกกว่าการใช้แบบไบต์การlen(r)จัดทำดัชนีเป็นแบบ 1

ลองออนไลน์!

Ruby, 35 34 ไบต์

p$_[/[<{(\[](\g<0>)*[>})\]]/].size

ขึ้นอยู่กับDada คำตอบของ เอาท์พุทเป็นดัชนี 1 ต้องใช้ตัวแปล Ruby พร้อมกับ-nตัวเลือก (การwhile getsวนซ้ำโดยนัย)

แก้ไข: นี่คือ35 34 ไบต์ แต่เป็นอีกจุดเริ่มต้นที่เป็นไปได้เพื่อลดคำตอบนี้เพิ่มเติม

p$_[/[<{(\[](\g<0>)*[>})\]]/]=~/$/

แก้ไข 2: ลบช่องว่างที่ไม่จำเป็นออกหลังจากpนั้น

แก้ไข 3: คำตอบ 34 ไบต์อีกสองสามข้อ

~/[<{(\[](\g<0>)*[>})\]]/;p$&.size
p~/[<{(\[](\g<0>)*[>})\]]/+$&.size

Python 3 , 59 55 50 49 ไบต์

f=lambda s,n=1:n and-~f(s[1:],n+1-(-ord(s[1])&2))

เอาท์พุทเป็นดัชนี 0 สูตรเพื่อกำหนดทิศทางของวงเล็บถูกค้นพบครั้งแรกโดย @ETHProductions และปรับปรุงโดย @Adnan

ลองออนไลน์!

แบตช์ 172 ไบต์

@set/ps=
@set/ai=d=0
:l
@set/ai+=1,d-=1
@set c="%s:~,1%"
@set "s=%s:~1%
@for %%a in ("<" "(" "[" "{")do @if %%a==%c% set/ad+=2&goto l
@if %d% gtr 0 goto l
@echo %i%

1 การจัดทำดัชนี <>s มีตัวอักษรพิเศษแน่นอนในชุดดังนั้นไม่เพียง แต่ฉันต้องพูดมากกว่าทุก แต่ฉันไม่สามารถแม้แต่จะทำเทคนิคเช่นทำให้พวกเขาgotoป้าย

R, 126 ไบต์

s=readline();i=0;r=0;for(c in strsplit(s,"")[[1]]){if(grepl("[\\[\\(\\{<]",c))i=i+1 else i=i-1;if(i==0){print(r);break};r=r+1}

C, 127 ไบต์

ลองออนไลน์

c(x){x-40&x-60&x-91&x-123?-1:1;}
f(i,t)char*t;{return i?f(i+c(*t),t+1):t;}
s(char*t){return f(c(*t),t+1)-t;}

เอาท์พุต

2   ()
4   (<>)
8   <[]{<>}>
2   {}{}{}{}
8   [[]<>[]]