বন্ধনী ভারসাম্য

Question

আপনার উদ্দেশ্য: বন্ধনীগুলির একটি স্ট্রিং দেওয়া হয়েছে, ইনপুট স্ট্রিংটিকে স্ট্রিংয়ে রূপান্তর করতে প্রয়োজনীয় ন্যূনতম ডামেরাউ-লেভেনস্টাইন দূরত্ব আউটপুট করুন যেখানে বন্ধনীগুলি ভারসাম্যযুক্ত।

ইনপুট

ইনপুট স্ট্রিংটিতে কেবল বন্ধনী এবং অন্য কোনও অক্ষর থাকবে। এটি হ'ল এটি কোনও চরিত্রের সমন্বয় (){}[]<>। আপনি স্ট্রিং বা অক্ষরের অ্যারে হিসাবে ইনপুট নিতে পারেন। আপনি ইনপুট স্ট্রিং সম্পর্কে অন্য কোনও অনুমান নাও করতে পারেন; এটি নির্বিচারে দীর্ঘ হতে পারে (আপনার ভাষা দ্বারা সমর্থিত সর্বাধিক আকার পর্যন্ত), এটি খালি থাকতে পারে, বন্ধনীগুলি ইতিমধ্যে ভারসাম্যপূর্ণ হতে পারে ইত্যাদি etc.

ডামেরাউ-লেভেনস্টেইন দূরত্ব

দুটি স্ট্রিংয়ের মধ্যে ডামেরাউ-লেভেনস্টেইন দূরত্ব হ'ল সন্নিবেশ, মুছে ফেলা, একক-চরিত্রের বিকল্প এবং দুটি সংলগ্ন অক্ষরের ট্রান্সপোজিশন (অদলবদল) এর সর্বনিম্ন সংখ্যা।

আউটপুট

আউটপুটটি ইনপুট স্ট্রিং এবং একটি স্ট্রিংয়ের মধ্যে ন্যূনতম ডামেরাউ-লেভেনস্টেইন দূরত্ব হওয়া উচিত যাতে বন্ধনীগুলি মিলে যায়। আউটপুট একটি সংখ্যা হওয়া উচিত , ফলাফলের ভারসাম্যযুক্ত স্ট্রিং নয়।

খোলার এবং বন্ধ করার বন্ধনীগুলি সঠিক ক্রমে থাকে এবং সেগুলির ভিতরে কোনও অক্ষর না থাকলে, একটি জোড়া বন্ধনী "মিলিত" হিসাবে বিবেচিত হয় as

()
[]{}

অথবা এর অভ্যন্তরের প্রতিটি উপ-উপাদানগুলির সাথেও যদি মিল হয়।

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

উপ-উপাদানগুলি গভীরভাবে কয়েকটি স্তরকে বাসাতে পারে।

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

(সংজ্ঞার জন্য @ ডিজেএমসিমেহেমকে ধন্যবাদ)

পরীক্ষার মামলা

Input                   Possible Balanced       Output

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

(পরীক্ষার অর্ধেকটি সমাধানের জন্য @ ওয়েট উইজার্ডকে ধন্যবাদ)

এটি কোড-গল্ফ , সবচেয়ে কম বাইট জয়!

আপনার জমাগুলি পরীক্ষাযোগ্য হওয়া উচিত, এর অর্থ এটি প্রতিটি পরীক্ষার ক্ষেত্রে এক ঘণ্টার বেশি সময় না নিয়ে ফলাফল আউটপুট করে।

Comments

আপনার নিজের বন্ধনীগুলিকে ভারসাম্য করুন: পি

— ক্রিস্টোফার

আমি অবাক হব যদি আমরা এই চ্যালেঞ্জটির একক সঠিক অ-ব্রুটফোর্ড উত্তরও দেখতে পাই।

— orlp

@SIGSEGV যে উত্তর 1. এটা কোন ব্যাপার কিনা তোমার মত এটা সামঞ্জস্য বজায় রাখা না [<>]বা []<>বা<>

— নাথন মেরিল

@ বিজান নাহ, এটি এত সহজ করে তুলবে না এবং ততক্ষণে, ব্রেইন-ফ্লকের জন্মদিন শীঘ্রই আসবে!

— পাভেল

@Qwr এর সীমা কেন? সময় সীমা শুধুমাত্র প্রদত্ত পরীক্ষার ক্ষেত্রে প্রযোজ্য, বড় ইনপুটগুলির জন্য আপনার প্রোগ্রামটি বিশ্বের সমস্ত সময় নিতে পারে।

— পাভেল

Answer 1

রেটিনা, 254 252 264 248 240 232 267 বাইট

বাগ আঙ্গুল দেখানোর জন্য @ অ্যান্থনিফ্যাম, @ আফিসিয়াআলাইম এবং @ মিস্টাফিগিনসকে ধন্যবাদ

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 বাইট

টানা অদলবদল করতে অ্যাকাউন্টে +2 বাইট

বিভিন্ন বাগ বাগের জন্য অনেকগুলি **

ব্যাখ্যা:

T`[]()`:;'"সুবিধার জন্য বিশেষ বন্ধনী প্রকার প্রতিস্থাপন করতে ব্যবহৃত হয়। প্রথমত, আমরা যাও recursively সঙ্গে সব মিলেছে বন্ধনী প্রতিস্থাপন -, ABবা 69কিনা তারা সংলগ্ন বা না উপর নির্ভর করে।

তারপরে, নতুন "ম্যাচ করা বন্ধনী" মুছে ফেলা এবং 1স্ট্রিংয়ের শুরুতে একটি যুক্ত করে দরকারী "অদলবদল" সঞ্চালিত হয় । আমরা -খালি স্ট্রিংটিও প্রতিস্থাপন করি কারণ এটি কেবল উপরের অদলবদলের জন্য ব্যবহৃত হয়েছিল।

এরপরে, আমরা ইতিমধ্যে ম্যাচ করা বন্ধনীগুলি ওভারল্যাপ না 1করে এবং স্ট্রিংয়ের সাথে একটি যুক্ত করে তুলনামূলক তুলনামূলক বন্ধনীগুলির জোড়া সরিয়ে "প্রতিস্থাপনগুলি" চেষ্টা করি ।

অবশেষে, \W|6B|1অবশিষ্ট যেকোন একক বন্ধনী এবং আরও সংখ্যার গণনা করে 1।

** আমি বর্তমানে একটি সংক্ষিপ্ত সংস্করণে কাজ করছি যা রেটিনার লাইন বিভাজন বৈশিষ্ট্যগুলি ব্যবহার করে, যদিও আমি যথেষ্ট সমস্যায় পড়েছিলাম যাতে এটি কিছুটা সময় নিতে পারে।

Comments

এটি ${4}সংক্ষিপ্ত করা যেতে পারে $+। যদিও এটি কাজ করার গ্যারান্টিযুক্ত আমি খুব কৌতূহলী।

— মার্টিন এন্ডার

টুইটারে আমি নিশ্চিত না যে এটি সর্বদা কার্যকর হয় তবে এটি প্রদত্ত পরীক্ষাগুলির ক্ষেত্রে অন্তত কাজ করে এবং আমি যে

— গণিত জাঙ্কি

প্রদত্ত [{][}] [] [[][][][][][]] [][][][][][][][][][][][], আপনি }প্রথম বন্ধনীর প্রথম জোড়ার অভ্যন্তরে কেবল অদলবদল করতে পারেন এবং এটি ভারসাম্যপূর্ণ রাখতে পারেন। ইনপুটটিকে আরও কিছুটা পাঠযোগ্য করে তোলার জন্য ব্যবধান ব্যবহৃত হয়। আপনি 3 আউটপুট করেছেন তবে এটি সত্যই এক হওয়া উচিত।

— অ্যান্টনি ফ্যাম

@ অ্যান্থনিফ্যাম ধন্যবাদ! আমি মনে করি আমি জানি কেন এটি কাজ করছে না, আমি এটির সমাধানের জন্য একটি চতুর

— গণিত জাঙ্কি

এমনকি উইডার্ডটি এটি [{]}1 প্রদান করে তবে [{][]}2 ফেরত দেয়

— অ্যান্থনি ফ্যাম

Answer 2

ব্রেন-ফ্লাক , 1350 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ধ্রুবক-গতির তুলনা এবং পয়েন্টার ডেরেফারেন্সিং সহ এই অ্যালগরিদমটি হ'ল (এন ³ )। দুর্ভাগ্যক্রমে, মস্তিষ্ক-ফ্ল্যাকগুলির মধ্যে একটিও নেই, সুতরাং এই প্রোগ্রামটি পরিবর্তে ও (এন ⁵ ) সময়ে চলে। দীর্ঘতম পরীক্ষার ক্ষেত্রে প্রায় 15 মিনিট সময় লাগে।

সরলকরণের ফলাফল

আমার অ্যালগরিদম কাজ করে তা দেখতে, আমাদের কিছু ফলাফল দেখাতে হবে যা অনুসন্ধানের স্থানটি যথেষ্ট পরিমাণে হ্রাস করে। এই ফলাফলগুলি নির্ভর করে যে লক্ষ্যমাত্র একটি নির্দিষ্ট স্ট্রিংয়ের পরিবর্তে একটি সম্পূর্ণ ভাষা।

• কোন সন্নিবেশ প্রয়োজন হয় না। পরিবর্তে, আপনি কেবল সন্নিবেশ করা চরিত্রটি শেষ পর্যন্ত মেলে এমন বন্ধনীটি সরিয়ে ফেলতে পারেন।

• আপনার কোনও ব্র্যাকেট অপসারণ করার প্রয়োজন হবে না, তারপরে তার দুটি প্রতিবেশী অদলবদল করুন। এই দেখার জন্য, wlog অনুমান অপসারিত বন্ধনী হয় (, তাই আমরা রূপান্তর করা হয় a(cথেকে caদুই ধাপ হবে। cএকটি অনুলিপি পরিবর্তন এবং ca()in োকানোর মাধ্যমে আমরা অদলবদল ছাড়াই দুটি ধাপে পৌঁছাতে পারি । (এই সন্নিবেশটি উপরের বিধি দ্বারা সরানো যেতে পারে can)

• একই বন্ধনী কখনও কখনও দু'বার অদলবদল করার প্রয়োজন হবে না। এটি সাধারণভাবে দামেরু-লেভেনস্টেইন দূরত্ব সম্পর্কে একটি স্ট্যান্ডার্ড তথ্য।

আর একটি সরল ফলাফল যা আমি ব্যবহার করি নি, কারণ তাদের জন্য অ্যাকাউন্টিংয়ের জন্য বাইট খরচ পড়বে:

• যদি দুটি বন্ধনী অদলবদল করা হয় এবং তারা একে অপরের সাথে মেলে না, তবে সেই বন্ধনীগুলির প্রত্যেকের সাথে শেষ ম্যাচটি কখনই পরিবর্তন বা অদলবদল করা যাবে না।

অ্যালগরিদম

যখন কোনও স্ট্রিং ভারসাম্যযুক্ত স্ট্রিংয়ে কমে যায়, নিম্নলিখিতগুলির মধ্যে একটি সত্য হবে:

• প্রথম বন্ধনী মুছে ফেলা হয়।
• প্রথম ব্র্যাকেটটি যেখানে থাকে সেখানেই থাকে এবং কোনও অবস্থানে ব্র্যাকেটের সাথে মেলে k(সম্ভবত তাদের দুটি বা উভয় পরিবর্তনের পরে)।
• প্রথম বন্ধনীটি দ্বিতীয়টির সাথে অদলবদল করা হয়, যা পরিবর্তে বন্ধনী অবস্থানের সাথে মেলে k।

দ্বিতীয় ক্ষেত্রে, অবস্থানের বন্ধনীটি kতার এক প্রতিবেশীর সাথে অদলবদল হতে পারে। পরের দুটি ক্ষেত্রে উভয়ের মধ্যে, (সম্ভবত নতুন) প্রথম বন্ধনী এবং বন্ধনী অবস্থানে শুরু হওয়া বন্ধনীগুলির মধ্যে kভারসাম্যযুক্ত স্ট্রিংতে অবশ্যই সম্পাদনা করতে হবে, যেমন স্ট্রিংয়ের পরে সমস্ত কিছু থাকে k।

এর অর্থ একটি গতিশীল প্রোগ্রামিং পদ্ধতির ব্যবহার করা যেতে পারে। যেহেতু একটি অদলবদল বন্ধনী আবার অদলবদল করার দরকার নেই, তাই আমাদের কেবল সংক্ষিপ্ত সাবস্ট্রিংগুলি বিবেচনা করতে হবে, পাশাপাশি এই জাতীয় স্তর থেকে দ্বিতীয় অক্ষর এবং / বা পেনাল্টিমেট চরিত্রটি সরিয়ে গঠিত উপসর্গগুলিও বিবেচনা করা উচিত। অতএব, কেবলমাত্র ও (এন ² ) উপসূত্রগুলি আমাদের দেখতে হবে। এগুলির প্রত্যেকেরই প্রথম বন্ধনীটি মেলানোর (বা মোছার) সম্ভাব্য উপায় রয়েছে, সুতরাং উপরের শর্তগুলির মধ্যে অ্যালগরিদম ও (এন ³ ) হবে।

তথ্য কাঠামো

ডান স্ট্যাকটিতে বন্ধনীতে দুটি বাইট সহ মূল স্ট্রিং থেকে বন্ধনী অন্তর্ভুক্ত রয়েছে। প্রথম এন্ট্রি পুরো ব্র্যাকেটটি নির্ধারণ করে এবং এমনটি নির্বাচন করা হয় যা ম্যাচ করা বন্ধনীগুলির ঠিক 1 এর পার্থক্য রয়েছে have দ্বিতীয় এন্ট্রি কেবল এটি খোলার বন্ধনী বা বন্ধক বন্ধনী কিনা তা নির্ধারণ করে: এটি দুটি ব্রোকেটের সাথে মিলিত হতে কত পরিবর্তন নেয় তা নির্ধারণ করে একে অপরকে. এর নীচে কোনও অন্তর্নিহিত শূন্যগুলি কখনও সুস্পষ্টভাবে তৈরি করা হয় না, যাতে আমরা []এই স্ট্রিংয়ের মোট দৈর্ঘ্য পেতে ব্যবহার করতে পারি।

বিবেচনাধীন প্রতিটি স্ট্রেরিং 0 থেকে 2n ব্যাপ্তির দুটি সংখ্যা দ্বারা প্রতিনিধিত্ব করা হয়: একটি শুরুর অবস্থানের জন্য এবং শেষের জন্য একটি one ব্যাখ্যাটি নিম্নরূপ:

• শুরু হওয়া একটি স্ট্রিং 2kপজিশনে শুরু হবে k(0-indexed), এবং দ্বিতীয় অক্ষরটি সরানো হবে না।
• শুরু হওয়া একটি স্ট্রিং 2k+1পজিশনে শুরু হবে kএবং দ্বিতীয় অক্ষরটি অদলবদল হয়ে যাওয়ার কারণে মুছে ফেলা হবে।
• একটি স্ট্রিংয়ের সমাপ্তি 2kঅবস্থানের ঠিক আগে শেষ হবে k(যেমন, পরিসীমাটি বাম-সমেত এবং ডান-একচেটিয়া।)
• একটি স্ট্রিংয়ের সমাপ্তি 2k-1অবস্থানের ঠিক আগেই শেষ হবে kএবং ডান দিকের অদলবদলের কারণে পেনাল্টিমেট চরিত্রটি সরানো হবে।

কিছু ব্যাপ্তি ( kto k+1, 2k+1to 2k+1, 2k+1to 2k+3এবং 2k+1to 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
  {}<>([[]{}])

}{}

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

Answer 3

হাস্কেল , 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))

এটি অনলাইন চেষ্টা করুন!

Comments

গতকাল আমি এখানে পড়লাম যে অনুগ্রহটি আগামীকালের আগে শেষ হবে না তাই আমি প্রতিযোগিতা করতে চেয়েছিলাম যে en.wikedia.org/wiki/… আলগোরিদিম প্রয়োগের একটি বাস্তবায়ন বর্তমানের খুব দ্রুত রেটিনা হিউরিস্টিকের তুলনায় আরও সঠিক মানগুলি গণনা করে!

— রোমান সিজবোরা

না, এটি সর্বোপরি পুরষ্কারের যোগ্য নয় কারণ আমি ভুলভাবে বলে দিয়েছি যে এটি 2400 এর মধ্যে 4 অক্ষর 4 দূরের 18 টি চরিত্রকে আঁকিয়ে ফেলতে পারে তবে 22 টি চরিত্রের দূরত্ব 9 সমানভাবে 3600 এর দশকের দিকেও ছড়িয়ে যাবে যা দুঃখের সাথে নয়।

— রোমান সিজবোরা