วัตถุประสงค์ของคุณ: กำหนดสตริงของวงเล็บให้ส่งค่าระยะทางต่ำสุดของDamerau-Levenshteinเพื่อเปลี่ยนสตริงอินพุตให้เป็นสตริงที่วงเล็บมีความสมดุล

อินพุต

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

ระยะทาง Damerau-Levenshtein

ระยะทาง Damerau-Levenshtein ระหว่างสองสายคือจำนวนขั้นต่ำของการแทรกการลบการแทนที่อักขระเดี่ยวและการสลับ (การสลับ) ของอักขระสองตัวที่อยู่ติดกัน

เอาท์พุต

เอาต์พุตควรเป็นระยะทางต่ำสุดของ Damerau-Levenshtein ระหว่างสตริงอินพุตและสตริงที่ตรงกับเครื่องหมายวงเล็บ เอาต์พุตควรเป็นตัวเลขไม่ใช่สตริงที่สมดุล

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

()
[]{}

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

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

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

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

(ขอบคุณ @DJMcMayhem สำหรับคำจำกัดความ)

กรณีทดสอบ

Input                   Possible Balanced       Output

Empty                   Empty                   0
[](){}<>                [](){}<>                0           
[(){}<>                 [(){}<>]                1           
[(])                    []()                    1           
[[[[[[[[                [][][][]                4
(](<>}[>(}>><(>(({}]    ()(<>)[(<><>){}]        7
>]{])<                  []{()}                  3
([)}}>[                 (){}<>                  4
{<((<<][{{}>[<)         <>(<<[]>{}>[])          5
{><({((})>}}}{(}}       {<><({()})>}{}{()}      4
(](<)>}[>(}>>{]<<(]]    (<()<><<>()>>[])<()>    9
}})(                    {}()                    2

(ขอบคุณ @WheatWizard สำหรับแก้ปัญหากรณีทดสอบครึ่งหนึ่ง)

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

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

Retina, 254 252 264 248 240 232 267 ไบต์

ขอบคุณ @AnthonyPham, @officialaimm และ @MistahFiggins สำหรับการชี้จุดบกพร่อง

T`[]()`:;'"
+`'-*"|:-*;|{-*}|<-*>
-
+`'(\W+)"|:(\W+);|{(\W+)}|<(\W+)>
A$1$2$3$+B
+`'(\D+)"|:(\D+);|{(\D+)}|<(\D+)>
6$1$2$3$+9
(.*)(}{|"'|;:|><)
1$1
-

A6B9|6A9B
1
A6+B9+|A6+.B9+.|A+6.B+9
11
T`':{";}`<<<>
(.*)(<\W|\W>)
1$1
+`<(.*A.*B.*)?\W|\W(.*A.*B.*)?>
1$1$2
\W|6B|1

ลองออนไลน์!

วิธีการแก้ปัญหาแรงแบบไม่ดุเดือด! มันใช้งานได้กับทุกกรณีทดสอบและยังพบข้อผิดพลาดในที่เดียว

-2 ไบต์ขอบคุณ @MartinEnder ( ${4}ถึง$+)

+12 ไบต์ไปยังบัญชีสำหรับกรณีการแลกเปลี่ยนเพิ่มเติม

-16 ไบต์โดยการใช้คลาสอักขระให้ดีขึ้น

-8 ไบต์โดยการลบข้อ จำกัด ที่ไม่จำเป็นในการแลกเปลี่ยน สิ่งนี้แก้ไขข้อผิดพลาดด้วย :)

-10 ไบต์โดยการรวมตรรกะการแลกเปลี่ยนเป็น regex เดียว

+2 ไบต์ไปยังบัญชีสำหรับการแลกเปลี่ยนที่ต่อเนื่อง

+ มากมายสำหรับการแก้ไขข้อบกพร่องต่างๆ **

คำอธิบาย:

T`[]()`:;'"ใช้เพื่อแทนที่ประเภทวงเล็บพิเศษเพื่อความสะดวก อันดับแรกเราซ้ำแทนที่วงเล็บตรงทั้งหมดกับ-, ABหรือ69ขึ้นอยู่กับว่าพวกเขาจะอยู่ติดกันหรือไม่

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

ต่อไปเราลอง "แทนที่" โดยการลบคู่ของวงเล็บเหลี่ยมที่ไม่ตรงกันซึ่งไม่ทับซ้อนวงเล็บที่จับคู่แล้วและเพิ่ม1ไปยังสตริง

สุดท้าย\W|6B|1ข้อหาใด ๆ ที่เหลือวงเล็บเดียวบวกจำนวน1s

** ฉันกำลังใช้งานเวอร์ชั่นที่สั้นกว่าซึ่งใช้คุณสมบัติการแบ่งบรรทัดของ Retina แม้ว่าฉันจะเจอปัญหามากดังนั้นมันอาจใช้เวลาสักครู่

Brain-Flak , 1,350 ไบต์

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

ลองออนไลน์!

ด้วยการเปรียบเทียบความเร็วคงที่และการยกเลิกการอ้างอิงตัวชี้อัลกอริทึมนี้คือ O (n ³ ) น่าเสียดายที่ Brain-Flak ไม่มีโปรแกรมเหล่านี้ดังนั้นโปรแกรมนี้จึงทำงานในเวลา O (n ⁵ ) แทน กรณีทดสอบที่ยาวที่สุดใช้เวลาประมาณ 15 นาที

ลดความซับซ้อนของผลลัพธ์

เพื่อที่จะเห็นว่าอัลกอริทึมของฉันทำงานได้เราต้องแสดงผลลัพธ์บางอย่างที่ลดพื้นที่การค้นหาอย่างมาก ผลลัพธ์เหล่านี้ขึ้นอยู่กับความจริงที่ว่าเป้าหมายนั้นเป็นทั้งภาษาแทนที่จะเป็นสตริงเดียวเท่านั้น

• ไม่จำเป็นต้องมีการแทรก แต่คุณสามารถลบวงเล็บที่อักขระที่แทรกเข้าไปจะจับคู่กันได้ในที่สุด

• คุณไม่จำเป็นต้องลบวงเล็บจากนั้นสลับสองเพื่อนบ้าน หากต้องการดูสิ่งนี้สมมติว่ามีวงเล็บเหลี่ยมที่ถูกลบ(ดังนั้นเราจึงเปลี่ยนa(cเป็นcaสองขั้นตอน ด้วยการเปลี่ยนcและแทรกสำเนาเราสามารถเข้าถึงca()สองขั้นตอนโดยไม่ต้องสลับ (การแทรกนี้สามารถลบได้โดยกฎด้านบน)

• วงเล็บเดียวกันไม่จำเป็นต้องสลับสองครั้ง นี่เป็นข้อเท็จจริงมาตรฐานเกี่ยวกับระยะทาง Damerau-Levenshtein โดยทั่วไป

ผลการลดความซับซ้อนอื่น ๆ ที่ฉันไม่ได้ใช้เพราะการบัญชีสำหรับพวกเขาจะมีค่าใช้จ่ายเป็นไบต์:

• หากมีการสลับวงเล็บสองอันและไม่ตรงกันซึ่งกันและกันการจับคู่ในที่สุดกับแต่ละวงเล็บจะไม่มีการเปลี่ยนแปลงหรือสลับกัน

อัลกอริทึม

เมื่อสตริงใดลดลงเป็นสตริงที่สมดุลหนึ่งในสิ่งต่อไปนี้จะเป็นจริง:

• วงเล็บแรกถูกลบ
• วงเล็บแรกยังคงอยู่ที่ตำแหน่งและตรงกับวงเล็บในบางตำแหน่งk(อาจเกิดขึ้นหลังจากเปลี่ยนหนึ่งหรือทั้งสองอย่าง)
• kวงเล็บแรกจะสลับกับที่สองซึ่งจะตรงกับตัวยึดที่ตำแหน่ง

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

ซึ่งหมายความว่าอาจใช้วิธีการเขียนโปรแกรมแบบไดนามิก เนื่องจากวงเล็บปีกกาแบบสลับไม่จำเป็นต้องสลับอีกครั้งเราเพียง แต่ต้องพิจารณาสตริงย่อยที่ต่อเนื่องกันเท่านั้นเช่นเดียวกับองค์ประกอบที่เกิดขึ้นจากการลบอักขระตัวที่สองและ / หรือตัวอักษรสุดท้ายจากสตริงย่อยนั้น ดังนั้นมีเพียง O (n ² ) ลำดับที่เราต้องดู แต่ละวิธีมี O (n) วิธีที่เป็นไปได้ในการจับคู่ (หรือลบ) วงเล็บแรกดังนั้นอัลกอริทึมจะเป็น O (n ³ ) ภายใต้เงื่อนไขข้างต้น

โครงสร้างข้อมูล

สแต็คด้านขวามีวงเล็บจากสตริงเดิมที่มีสองไบต์ต่อวงเล็บ รายการแรกเป็นตัวกำหนดทั้งวงเล็บและได้รับเลือกให้วงเล็บที่ตรงกันมีความแตกต่าง 1 อย่างแน่นอนรายการที่สองจะกำหนดว่าเป็นวงเล็บเปิดหรือวงเล็บปิด: นี่เป็นการกำหนดว่าต้องใช้การเปลี่ยนแปลงกี่ครั้งในการจับคู่สองวงเล็บ ซึ่งกันและกัน ไม่มีศูนย์โดยนัยที่ด้านล่างนี้ชัดเจนดังนั้นเราจึงสามารถใช้[]เพื่อให้ได้ความยาวทั้งหมดของสตริงนี้

สตริงย่อยแต่ละอันภายใต้การพิจารณาจะแสดงเป็นตัวเลขสองตัวในช่วง 0 ถึง 2n: หนึ่งสำหรับตำแหน่งเริ่มต้นและหนึ่งสำหรับสิ้นสุด การตีความมีดังนี้:

• สตริงย่อยเริ่มต้นที่2kจะเริ่มต้นที่ตำแหน่งk(ดัชนี 0) และอักขระที่สองจะไม่ถูกลบออก
• สตริงย่อยเริ่มต้นที่2k+1จะเริ่มต้นที่ตำแหน่งkและตัวละครที่สองจะถูกลบออกเนื่องจากมีการสลับซ้าย
• สตริงย่อยที่ลงท้ายด้วย2kจะสิ้นสุดก่อนตำแหน่งk(กล่าวคือช่วงนั้นเป็นแบบรวมซ้ายและขวาสุดเท่านั้น)
• สตริงย่อยที่ลงท้ายด้วย2k-1จะสิ้นสุดก่อนตำแหน่งkและอักขระสุดท้ายจะถูกลบออกเนื่องจากมีการสลับไปทางขวา

บางช่วง ( kไปk+1, 2k+1ไป2k+1, 2k+1ไป2k+3และ2k+1จะ2k+5) ทำให้ไม่มีความรู้สึกทางกายภาพ บางรายการแสดงเป็นค่ากลางอยู่แล้วเนื่องจากง่ายกว่าการเพิ่มการตรวจสอบเพิ่มเติมเพื่อหลีกเลี่ยง

สแต็กด้านซ้ายเก็บจำนวนการแก้ไขที่จำเป็นในการแปลงสตริงย่อยแต่ละรายการเป็นสตริงที่สมดุล แก้ไขระยะทางสำหรับช่วงเวลาจะถูกเก็บไว้ที่ระดับความลึก(x,y)x + y(y-1)/2

ในระหว่างการวนรอบภายในรายการจะถูกเพิ่มไว้เหนือสแต็กด้านซ้ายเพื่อแสดงถึงการเคลื่อนไหวที่เป็นไปได้ รายการเหล่านี้มีความยาว 5 ไบต์ นับจากด้านบนตัวเลขที่มีd+1, y1, x1, y2, x2ที่ย้ายค่าใช้จ่ายในdการแก้ไขตามขั้นตอนและแบ่งย่อยลงไปและ(x1,y1)(x2,y2)

รหัส

รายละเอียดที่จะมา สำหรับตอนนี้นี่คือสำเนาการทำงานของฉันของรหัส ความคิดเห็นบางอย่างอาจไม่สอดคล้องกับคำศัพท์

# Determine bracket type for each byte of input
{({}(())(<>))<>({(()()()())<{({}[()])<>}{}>}{}<>({<({}[()])>{()(<{}>)}}{}{}<>))<>}

# For every possible interval length:
<>([[]]){

  # Compute actual length
  ([[]({}()<>)]<>)

  # Note: switching stacks in this loop costs only 2 bytes.
  # For each starting position:
  # Update/save position and length
  <>{(({}())<<>(({})<

    # Get endpoints
    (({}(<()>))<>({}))

    # If length more than 3:
    ([(())()()]){<>({}())}{}{

      # Clean up length-3 left over from comparison
      <>{}<>

      # Initialize counter at 2
      # This counter will be 1 in the loop if we're using a swap at the beginning, 0 otherwise
      ({}())

      # For each counter value:
      {

        # Decrement counter and put on third stack
        (((({}<

          # Do mod 2 for end position
          (({}<>)<{({}()<([(){}])>)}{}>)<>

          # Do mod 2 for start position
          (({}(<>))<{({}()<([(){}])>)}{}<>>)

        # Subtract 1 from counter if swap already happened
        ><>({}))(<

          # Compute start position of substrings to consider
          (((({}({})[()])[()()]<>({}))

            # Compute start position of matches to consider
            <>[({})({}){}]({}<>))<>

            # Compute end position of matches to consider
            [(({}<>)<>({}<>)<>)]

          # Push total distance of matches
          )

        # Push counter as base cost of moves
        # Also push additional copy to deal with length 5 intervals starting with an even number
        <>>)))[()](<()>)<

          # With match distance on stack
          <>(({})<

            # Move to location in input data
            ({}{}()){({}()<({}<>)<>>)}{}

            # Make copy of opening bracket to match
            <>(({})<<>(({}<>))>)

          # Mark as first comparison (swap allowed)
          <>(())>)

          # For each bracket to match with:
          {({}[()()]<

            (<([(

              # If swap is allowed in this position:
              {

                # Subtract 1 from cost
                [{}]

                # Add 1 back if swap doesn't perfectly match
                <(({})()<>[({})]<>)>{()(<{}>)}

              }{}

              # Shift copy of first bracket over, while computing differences
              <(({})<>[()({}<(({}<<>({}<>)<>(({})<>)>)<>[(){}])<>>)]<>)>

              # Add 1 if not perfectly matched
              {()(<{}>)}{}

              # Add 1 if neither bracket faces the other
              # Keep 0 on stack to return here
              (){[()](<{}>)}

              # Return to start of brackets
              <<>{({}<>)<>}{}>

            # Add to base cost and place under base cost
            )]({}{}))>)

            # Return to spot in brackets
            # Zero here means swap not allowed for next bracket
            <>{({}<>)<>}

          >)}

          # Cleanup and move everything to right stack
          {}{}<>{}{}{({}<>)<>}{}

          # Remove one copy of base cost, and move list of costs to right stack
          {}(<>)<>{({}<>)<>}{}

          # If swap at end of substring, remove second-last match
          {(<{}>)<>{({}<>)<>}<>({}<{}>){({}<>)<>}}{}

          # Put end of substring on third stack
          ((({}<({}({})({})<

            # If swap at beginning of substring, remove first match
            {{}<>{}(<>)}{}

            # Move start of substring to other stack for safekeeping
            (((({}<({}<>)>)<>)))

          # Create "deletion" record, excluding cost
          <>>)<>>)<>

          # Move data to left stack
          <({}<({}<<>

            # Add cost to deletion record
            (()())

          >)>)>)

          # Put start position on third stack under end position
          <<>({}<

            # For each matching bracket cost:
            {}{

              # Move cost to left stack
              ({}<>)

              # Make three configurations
              ([()()()]){

                # Increment counter
                ((({}()()<>))[()]<

                  # Increment cost in first and third configurations
                  (({()(<{}>)}{})<>({}<

                    # Keep last position constant
                    (({}<

                      # Beginning of second interval: 1, 2, 1 past end of first
                      <>({}[()()]

                        # End of first interval: -3, -1, 1 plus current position
                        (()[({})({})]

                          # Move current position in first and third configurations
                          ({[()](<{}>)}{}<>{}<

                            (({})<>)

                          >)

                        <>)

                      )

                    >)<>)

                  >)<>)

                  # Move data back to left stack
                  <>({}<({}<({}<({}<>)>)>)>)

                >)

              }{}

            {}<>}

            # Eliminate last entry
            # NOTE: This could remove the deletion record if no possible matches.  This is no loss (probably).
            <>{}{}{}{}{}{}{}{}

        # Restore loop variables
        >)>)>)

      }{}

      # With current endpoints on third stack:
      ({}<({}<

        # For all entries
        {

          # Compute locations and move to right stack
          ({}<(({}){({}())}{}{}<(({}){({}())}{}{}<>)>)>)<>

        }

        # For all entries (now on right stack):
        <>{

          # Cost of match
          ((({}

            # Do twice:
            (()()){([{}](

              # Add cost of resulting substrings
              <({}(<()>)<>){({}<({}<>)>(())<>)}{}>({})<<>{{}({}<>)<>}{}>

            # Evaluate as sum of two runs
            ))([{}()]{})}{}

          )))

          # Find smaller of cost and current minimum
          <>(({}))<>{<>({}[()])}{}

          # Push new minimum in place of old minimum
          ({}<<>{}{}{<>}>)

          <>{}

        }

        # Subtract 1 if nonzero
        <>(({}<>){[()](<{}>)}{})(<>)

      >)>)

      <>(<({}<>)>)<>

    # Otherwise (length 3 or less), use 1 from earlier as cost.
    # Note that length 0-1 is impossible here.
    }<>{}

    # With cost on third stack:
    ({}<

      # Find slot number to store cost of interval
      (({}){({}())}{}{})

      # Move to slot
      {({}<({}<>)>(())<>)}{}

    # Store new cost
    {}>)

    # Move other slots back where they should be
    <>{{}({}<>)<>}{}

  Restore length/position for next iteration
  >)<>>)}

  # Clear length/position from inner loop
  {}<>([[]{}])

}{}

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

Haskell , 797 ไบต์

import Data.Array;import Data.Function;import Data.List;
e=length;f=fst;o=map;s=listArray;u=minimum;b p=let{m=e p;x=s(1,m)p;
v=s(1,m)(listArray('(','}')[0,0..]:[v!i//[(x!i,i)]|i<-[1..m-1]]);
d q=let{n=e q;y=s(1,n)q;t(a,b)=listArray((a,b),(m,n));
c=t(1,1)[sum[1|x!i/=y!j]|i<-[1..m],j<-[1..n]];
d=t(-1,-1)[if i<0||j<0then m+n else 
if i*j<1then(i+j)else u[1+d!(i-1,j),1+d!(i,j-1),c!(i,j)+d!(i-1,j-1),
let{k=v!i!(y!j)-1;l=w!(i,j-1)-1}in-3+i+j-k-l+d!(k,l)]|i<-[-1..m],j<-[-1..n]];
w=t(1,0)[if j>0&&c!(i,j)>0then w!(i,j-1)else j|i<-[1..m],j<-[0..n]]}in d!(m,n);
a=s(0,div m 2)([(m,"")]:[(concat.take 2.groupBy(on(==)f).sort.o(\q->(d q,q)))(
[b:c++[d]|[b,d]<-words"() <> [] {}",(_,c)<-a!(l-1)]++
concat[[b++d,d++b]|k<-[1..div l 2],(_,b)<-a!k,(_,d)<-a!(l-k)])|l<-[1..div m 2]]);
}in u(o(f.head)(elems a))

ลองออนไลน์!