ब्रैकेट को संतुलित करें


24

आपका उद्देश्य: कोष्ठक की एक स्ट्रिंग को देखते हुए, इनपुट स्ट्रिंग को एक स्ट्रिंग में बदलने के लिए आवश्यक न्यूनतम डैमेरू-लेवेन्शिन दूरी की आवश्यकता होती है जहां कोष्ठक संतुलित होते हैं।

इनपुट

इनपुट स्ट्रिंग में केवल ब्रैकेट होंगे और कोई अन्य वर्ण नहीं होगा। अर्थात्, यह किसी भी वर्ण का संयोजन है (){}[]<>। आप या तो एक स्ट्रिंग या वर्णों के एक सरणी के रूप में इनपुट ले सकते हैं। आप इनपुट स्ट्रिंग के बारे में कोई अन्य धारणा नहीं बना सकते हैं; यह मनमाने ढंग से लंबा हो सकता है (आपकी भाषा द्वारा समर्थित अधिकतम आकार तक), यह खाली हो सकता है, कोष्ठक पहले से ही संतुलित हो सकते हैं, आदि।

दमेराऊ-लेवेंसाइटिन दूरी

दो तार के बीच दमेरु-लेवेन्शिन दूरी दो आसन्न वर्णों के सम्मिलन, विलोपन, एकल-वर्ण प्रतिस्थापन और ट्रांसपोज़िशन (स्वैपिंग) की न्यूनतम संख्या है।

उत्पादन

आउटपुट इनपुट स्ट्रिंग और एक स्ट्रिंग के बीच न्यूनतम डैमेरू-लेवेन्शिन दूरी होनी चाहिए जिसमें ब्रैकेट्स का मिलान होता है। आउटपुट एक संख्या होना चाहिए , परिणामस्वरूप संतुलित स्ट्रिंग नहीं।

कोष्ठक की एक जोड़ी को "मिलान" माना जाता है यदि उद्घाटन और समापन कोष्ठक सही क्रम में हैं और उनके अंदर कोई वर्ण नहीं है, जैसे कि

()
[]{}

या अगर उसके अंदर का हर उप-तत्व भी मेल खाता हो।

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

उप-तत्वों को गहरी कई परतों में घोंसला भी बनाया जा सकता है।

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

(परिभाषा के लिए @DJMcMayhem का धन्यवाद)

परीक्षण के मामलों

Input                   Possible Balanced       Output

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

(परीक्षण मामलों के आधे हल करने के लिए @WheatWizard को धन्यवाद)

यह , सबसे कम बाइट्स जीतता है!

आपकी प्रस्तुतियाँ परीक्षण योग्य होनी चाहिए, जिसका अर्थ है कि यह प्रत्येक परीक्षण मामले के लिए एक घंटे से अधिक समय में परिणाम देना चाहिए।


9
अपने स्वयं के कोष्ठक को संतुलित करें: P
क्रिस्टोफर

3
मुझे आश्चर्य होगा अगर हम इस चुनौती का एक भी सही नॉन-ब्रूटफोर्स उत्तर देखेंगे।
orlp

5
@SIGSEGV का उत्तर है कि 1. यह मायने नहीं रखता है कि आप इसे पसंद करते हैं [<>]या []<>या<>
नाथन मेरिल

3
@ बजन नाह, यह बहुत आसान नहीं बना देगा, और इसके अलावा, ब्रेन-फ्लैक का जन्मदिन जल्द ही आ रहा है!
पावेल

3
@qwr की एक सीमा क्यों है? समय सीमा केवल दिए गए परीक्षण मामलों के लिए लागू होती है, बड़े इनपुट के लिए आपका कार्यक्रम दुनिया में हर समय ले सकता है।
पावेल

जवाबों:


13

रेटिना, 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 (in ) के ${4}लिए धन्यवाद$+

+12 बाइट्स अतिरिक्त स्वैपिंग मामलों के लिए खाते में हैं

चरित्र वर्ग का बेहतर उपयोग करके -16 बाइट्स

-8 स्वैपिंग पर एक अनावश्यक प्रतिबंध को हटाकर बाइट्स। यह भी एक बग तय किया :)

-10 बाइट्स स्वैपिंग लॉजिक को सिंगल रेगेक्स में मिला कर

+2 बाइट्स लगातार स्वैप के लिए खाते में

+ विभिन्न बग फिक्स के लिए कई **

स्पष्टीकरण:

T`[]()`:;'"सुविधा के लिए विशेष ब्रैकेट प्रकारों को बदलने के लिए उपयोग किया जाता है। सबसे पहले, हम सभी मिलान किए गए कोष्ठक के साथ पुनरावर्ती रूप से प्रतिस्थापित करते हैं -, ABया 69इस पर निर्भर करते हैं कि वे आसन्न हैं या नहीं।

फिर, उपयोगी "स्वैपिंग" नए मिलान वाले ब्रैकेट को हटाकर और 1स्ट्रिंग की शुरुआत में जोड़कर किया जाता है। हम -खाली स्ट्रिंग के साथ भी प्रतिस्थापित करते हैं, क्योंकि यह सिर्फ ऊपर की स्वैपिंग के लिए इस्तेमाल किया जा रहा था।

अगला, हम बेजोड़ कोष्ठकों के जोड़े को हटाकर "प्रतिस्थापन" का प्रयास करते हैं जो पहले से मिलान किए गए ब्रैकेट को ओवरलैप नहीं करते हैं और 1स्ट्रिंग में जोड़ते हैं ।

अंत में, \W|6B|1किसी भी बचे हुए एकल ब्रैकेट और साथ ही एस की संख्या गिना जाता है 1

** मैं वर्तमान में एक छोटे संस्करण पर काम कर रहा हूं, जो रेटिना की लाइन विभाजन सुविधाओं का उपयोग करता है, हालांकि मैं काफी समस्या में भाग गया, इसलिए इसमें काफी समय लग सकता है।


यही कारण है कि ${4}करने के लिए छोटा किया जा सकता $+। मैं बहुत उत्सुक हूं कि यह काम करने की गारंटी क्यों है।
मार्टिन एंडर

@MartinEnder धन्यवाद! मुझे यकीन नहीं है कि यह हमेशा काम करता है, लेकिन यह कम से कम प्रदान किए गए परीक्षण मामलों के लिए काम करता है, और कुछ बढ़त के मामले जो मेरे साथ आए थे
गणित नशेड़ी

2
दिया [{][}] [] [[][][][][][]] [][][][][][][][][][][][], आप बस }कोष्ठक की पहली जोड़ी के अंदर स्वैप कर सकते हैं और इसे संतुलित कर सकते हैं। रिक्ति का उपयोग इनपुट को थोड़ा अधिक पठनीय बनाने के लिए किया जाता है। आपने 3 आउटपुट दिए लेकिन यह वास्तव में एक होना चाहिए।
एंथनी फाम

@AnthonyPham धन्यवाद! मुझे लगता है कि मुझे पता है कि यह काम क्यों नहीं कर रहा है, मैं इसे ठीक करने के लिए एक चतुर तरीका खोजने की कोशिश करूंगा
गणित नशेड़ी

यहां तक ​​कि अजीब है कि [{]}1 रिटर्न लेकिन [{][]}रिटर्न 2।
एंथनी फाम

12

ब्रेन-फ्लैक , 1350 बाइट्स

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

इसे ऑनलाइन आज़माएं!

निरंतर गति की तुलना और पॉइंटर डेरेफ़रिंग के साथ, यह एल्गोरिथ्म ओ (एन 3 ) है। दुर्भाग्य से, ब्रेन-फ्लैक के पास इनमें से कोई भी नहीं है, इसलिए यह कार्यक्रम इसके बजाय ओ (एन 5 ) समय में चलता है । सबसे लंबे समय तक परीक्षण के मामले में लगभग 15 मिनट लगते हैं।

सरल परिणाम

यह देखने के लिए कि मेरा एल्गोरिथ्म काम करता है, हमें कुछ परिणाम दिखाने की आवश्यकता है जो खोज स्थान को काफी कम कर देते हैं। ये परिणाम इस तथ्य पर निर्भर करते हैं कि लक्ष्य केवल एक विशिष्ट स्ट्रिंग के बजाय पूरी भाषा है।

  • किसी प्रविष्टि की आवश्यकता नहीं है। इसके बजाय, आप केवल उस ब्रैकेट को हटा सकते हैं जो सम्मिलित वर्ण अंततः मेल खाएगा।

  • आपको एक ब्रैकेट को निकालने की आवश्यकता नहीं होगी, फिर इसके दो पड़ोसियों को स्वैप करें। इस देखने के लिए, मान लेते हैं कि wlog हटा ब्रैकेट है (, तो हम बदलने कर रहे हैं a(cकरने के लिए caदो चरणों में। cकॉपी बदलने और डालने से, हम ca()बिना स्वैप के दो चरणों में पहुंच सकते हैं । (इस प्रविष्टि को उपरोक्त नियम द्वारा हटाया जा सकता है।)

  • एक ही ब्रैकेट को दो बार स्वैप करने की आवश्यकता नहीं होगी। यह सामान्य तौर पर दमरेउ-लेवेन्शिन दूरी के बारे में एक मानक तथ्य है।

एक और सरलीकृत परिणाम जो मैंने उपयोग नहीं किया, क्योंकि उनके लिए लेखांकन के लिए बाइट्स खर्च होंगे:

  • यदि दो कोष्ठक की अदला-बदली की जाती है, और वे एक-दूसरे से मेल नहीं खाते हैं, तो उन कोष्ठकों में से प्रत्येक के लिए अंतिम मैच कभी नहीं बदला जाएगा या स्वैप नहीं किया जाएगा।

एल्गोरिथ्म

जब किसी स्ट्रिंग को संतुलित स्ट्रिंग में घटाया जाता है, तो निम्न में से कोई एक सत्य होगा:

  • पहले ब्रैकेट को हटा दिया जाता है।
  • पहला ब्रैकेट जहां है वहीं रहता है और किसी स्थिति में ब्रैकेट से मेल खाता है k(संभवतः एक या दोनों को बदलने के बाद)।
  • पहले ब्रैकेट को दूसरे के साथ स्वैप किया जाता है, जो बदले में स्थिति पर ब्रैकेट से मेल खाता है k

दूसरे मामले में, स्थिति में ब्रैकेट kअपने किसी पड़ोसी के साथ अदला-बदली कर सकता है। बाद के दो मामलों में, (संभवतः नए) पहले ब्रैकेट और स्थिति में शुरू होने वाले ब्रैकेट के बीच kएक संतुलित स्ट्रिंग को संपादित किया जाना चाहिए, क्योंकि स्ट्रिंग में सब कुछ शामिल है k

इसका मतलब है कि एक गतिशील प्रोग्रामिंग दृष्टिकोण का उपयोग किया जा सकता है। चूंकि एक स्वैप किए गए ब्रैकेट को फिर से स्वैप करने की आवश्यकता नहीं होती है, हमें केवल सन्निहित पदार्थों पर विचार करने की आवश्यकता होती है, साथ ही दूसरे विकल्प और / या इस तरह के एक विकल्प से दंडात्मक चरित्र को हटाकर गठन के बाद। इसलिए, केवल O (n 2 ) अनुवर्ती हैं जिन्हें हमें देखने की आवश्यकता है। उनमें से प्रत्येक के पास पहले ब्रैकेट से मिलान (या हटाने) के लिए ओ (एन) संभव तरीके हैं, इसलिए एल्गोरिथ्म ऊपर की शर्तों के तहत ओ (एन 3 ) होगा।

डेटा संरचना

दाएं स्टैक में मूल स्ट्रिंग से ब्रैकेट शामिल हैं, जिसमें दो बाइट प्रति ब्रैकेट हैं। पहली प्रविष्टि पूरे ब्रैकेट को निर्धारित करती है, और इस तरह से चुना जाता है कि मिलान किए गए ब्रैकेट में बिल्कुल अंतर होता है। 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
  {}<>([[]{}])

}{}

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

2

हास्केल , 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))

इसे ऑनलाइन आज़माएं!


कल मैंने यहां पढ़ा कि इनाम कल से पहले खत्म नहीं होगा इसलिए मैं चुनाव लड़ना चाहता था कि en.wikipedia.org/wiki/… एल्गोरिदम को लागू करने वाला कार्यान्वयन वर्तमान बहुत तेजी से रेटिना अनुमानीकरण की तुलना में अधिक सही मूल्यों की गणना करता है!
रोमन Czyborra

नहीं, यह सब के बाद पुरस्कार के योग्य नहीं है क्योंकि मैंने गलत तरीके से एक्सट्रपलेशन किया कि इसके किरदारों को 2400s @ 800MHz में 18 वर्णों के 4 दूर कर दिया गया है, 22 वर्णों के 9 को समान रूप से 3600 के करीब समान रूप से ग्रो करेगा जो दुख की बात नहीं होगी।
बजे रोमन Czyborra
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.