সংকুচিত মস্তিষ্ক-ফ্ল্যাক প্রসারিত করুন

Question

এই চ্যালেঞ্জটি এপ্রিল 2018 এর লটএম চ্যালেঞ্জের পাশাপাশি ব্রেন- ফ্লকের দ্বিতীয় জন্মদিনের অংশ হিসাবে পোস্ট করা হয়েছিল

---

আমি ভাবছিলাম মস্তিষ্ক-ফ্লাক প্রোগ্রামগুলি এনকোড করার সবচেয়ে কার্যকর উপায় কী হবে। সুস্পষ্ট কাজটি করার জন্য, যেহেতু কেবলমাত্র 8 টি বৈধ অক্ষর রয়েছে তাই প্রতিটি অক্ষরকে 3-বিট ক্রমের ম্যাপ করা। এটি অবশ্যই খুব কার্যকর, তবে এটি এখনও খুব বাড়াবাড়ি। মস্তিষ্ক-ফ্ল্যাক কোডের কয়েকটি বৈশিষ্ট্য রয়েছে যা আমরা এনকোডিংটি সংক্ষিপ্ত করার জন্য সুবিধা নিতে পারি।

• নীলাদগুলি, যা সবগুলি 2 টি ম্যাচ করা বন্ধনী দ্বারা উপস্থাপিত হয়, 2 টির পরিবর্তে তথ্যের একক ইউনিট হিসাবে সত্যই কাজ করে we

• এটি একটি কম স্পষ্ট, তবে মনডগুলির সমাপনী বাইটগুলিও নিরর্থক। আপনি কি ভাবতে পারেন যে '?'নীচের স্নিপেটে চরিত্রগুলি কী উপস্থাপন করে?

   {(({}?<>?<>?
  

  যদি আমরা ধরে নিই যে ইনপুটটি বৈধ মস্তিষ্ক-ফ্লাক কোড, তবে সেই প্রশ্ন চিহ্নগুলির প্রত্যেকটির জন্য কেবল একটি বিকল্প রয়েছে। এর অর্থ হ'ল আমরা প্রতিটি ক্লোজিং বন্ধনীর প্রতিনিধিত্ব করতে নিবিড়ভাবে একটি নিকট মনড চরিত্র ব্যবহার করতে পারি । চরিত্রটি ছোট রাখার অতিরিক্ত সুবিধা রয়েছে যা হফম্যান এনকোডিংটি ব্যবহার করতে চাইলে এটি যথেষ্ট সাহায্য করবে। যেহেতু ঘনিষ্ঠ মোনাড চরিত্রটি সম্ভবত বিস্তৃত মার্জিন দ্বারা সর্বাধিক সাধারণ চরিত্র হতে পারে, তাই এটি একক বিট দ্বারা প্রতিনিধিত্ব করা যেতে পারে যা অত্যন্ত দক্ষ।

এই দুটি কৌশলটি নিম্নলিখিত অ্যালগরিদমের মাধ্যমে মস্তিষ্ক-ফ্ল্যাঙ্ক কোডটি সংকুচিত করতে দেবে:

1. একটি মোনাডের প্রতিটি বন্ধ হওয়া বন্ধনী প্রতিস্থাপন করুন |। বা অন্য কথায়, প্রতিটি বার বন্ধনী বন্ধ করুন যা বারের সাথে এটির উদ্বোধনী ম্যাচের আগে নয় replace তাই ...

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

   হবে

   (({}|<(()()()||{}|
   

2. বন্ধ হওয়া বন্ধনী সহ প্রতিটি নীলাদ প্রতিস্থাপন করুন। অতএব, মিলিত বন্ধনীগুলির মধ্যে কিছুই নেই নিচের ম্যাপিংটি ব্যবহার করে:

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

   এখন আমাদের শেষ উদাহরণ হয়ে যায়:

   ((}|<()))||}|
   

3. চলমান |অক্ষরগুলি সরান । কারণ আমরা জানি যে মোট বারের মোট সংখ্যাটি ({[<অক্ষরের মোট সংখ্যার সমান হওয়া উচিত , যদি এখানে প্রান্তটিতে নিখোঁজ থাকে, তবে আমরা সেগুলি নির্ধারণ করতে পারি। সুতরাং যেমন একটি উদাহরণ:

   ({({})({}[()])})
   

   হবে

   ({(}|(}[)
   

আজকের জন্য আপনার চ্যালেঞ্জ এই প্রক্রিয়াটি বিপরীত করা।

সংক্ষিপ্ত মস্তিষ্ক-ফ্ল্যাকের একটি স্ট্রিং দেওয়া হয়েছে যাতে কেবলমাত্র অক্ষর থাকে (){}[]<>|, এটিকে মূল মস্তিষ্ক-ফ্ল্যাক কোডে প্রসারিত করুন। আপনি ধরে নিতে পারেন যে ইনপুটটি সর্বদা বৈধ মস্তিষ্কের-প্রান্তে প্রসারিত হবে। এর অর্থ ইনপুটটির কোনও উপসর্গ অক্ষরের |চেয়ে বেশি কখনই থাকবে না ({[<।

ইনপুটটিতে পিছনের |অক্ষর থাকবে না । এগুলি অবশ্যই প্রসঙ্গ থেকে অনুমান করা উচিত।

যথারীতি, আপনি একটি সম্পূর্ণ প্রোগ্রাম বা কোনও ফাংশন জমা দিতে পারেন এবং ইনপুট / আউটপুট ফর্ম্যাটগুলি অনুমোদিত iss এবং যেহেতু এটি একটি কোড-গল্ফ , তাই আপনার কোডটি উত্স কোডের দৈর্ঘ্য দ্বারা বাইটে স্কোর করা হবে, যত কম স্কোর হবে তত ভাল।

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

এখানে কিছু পরীক্ষার মামলা রয়েছে। আপনি যদি আরও বেশি চান, আপনি এই অজগর স্ক্রিপ্ট এবং ব্রেন-ফ্লাক উইকি দিয়ে নিজের পরীক্ষার কেস তৈরি করতে পারেন , যেখানে এই পরীক্ষাগুলির বেশিরভাগই আসে।

#Compressed code
#Original code

())))
(()()()())


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

({(}|(}[)|||}
({({})({}[()])}{})


(((()))||(](((}}||(}([(((}))||||(]((}}|}|}}|||]||]|[))||(}))|}(}|(}]]|}
((((()()()))([]((({}{}))({}([((({}()())))]([](({}{}){}){}{})))[]))[])[()()])({}()()){}({})({}[][]){}

Comments

প্রতিভা। একেবারে প্রতিভা। আপনার একটি উপজাত ভাষা করা উচিত।

— এনএইচ।

@NH। ব্যক্তিগতভাবে, আমি এমন ভাষাগুলির মতো অনুভব করি যা কেবলমাত্র এনকোডিংয়ের চেয়ে আলাদা হয় সত্যই বিরক্তিকর।

— DJMcMayhem

@ ডিজে তবে এটি কম বাইট নিতে পারে এবং তাই গল্ফ করার পক্ষে আরও ভাল।

— এনএইচ।

মস্তিষ্ক-ফ্ল্যাক গল্ফিংয়ে ভাল হওয়ার জন্য ডিজাইন করা হয়নি।

— ডিজেএমসিএমহেম

Answer 1

ব্রেন-ফ্লাক , 952 916 818 বাইট

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

স্ক্র্যাচ থেকে তুলনামূলক তুলনায় তুলনামূলক তুলনামূলক বন্ধনী গণনা করে 360 বাইট সংরক্ষণ করা হয়েছে (যেমন ')'= '(' + 1পরিবর্তে (((5 * 2) * 2) * 2) + 1)

ডিজেএমসিএমহেম থেকে কিছু প্রত্যক্ষ প্রতিস্থাপন সহ 34 বাইট সংরক্ষণ করা হয়েছে

>]}হ্যান্ডলিং কোডটি ওভারল্যাপ করে 10 বাইট সংরক্ষণ করা হয়েছে

রোলগুলি নকল করে 118 বাইট সংরক্ষণ করা হয়েছে

প্রথম রোলটি সহজ করার জন্য খালি স্ট্যাকের সুবিধা নিয়ে 40 বাইট সংরক্ষণ করা

আরও সংক্ষিপ্ত রোল কোড সক্ষম করে -1 দিয়ে ইওএফ চিহ্নিত করে 48 বাইট সংরক্ষণ করা হয়েছে

স্টক ব্যবহার করে 36 টি বাইট সংরক্ষণ করা আমার নিজের পরিবর্তে লজিকের সমান

আউটপুট তৈরির আরও কার্যকর উপায় খুঁজে পেয়ে জো কিংকে 98 বাইট সংরক্ষণ করা হয়েছে

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

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

এখানে ব্যাখ্যা , টিআইও এটি আরও সহজে ফর্ম্যাট করে

বোনাস উত্তর:

সংকুচিত ব্রেন-ফ্লাক 583 বাইট

{((}|[((()))))|}|}|}||(){[)|(<}|||}|{}((}|)>|(>||}(>|>((}|[((()))|}|})|{(}[)|||}||(){[)|(<}|||}|(}>}|>((}|[(((()))))|}|}||}}||(){[)|(<}|||}|(}>}|>((}|[((((()))))|}|}|})||}}||(){[)|(<}|||}|(}>}|{}(<(>(}|))>||||}>((}|[((()))))|}|}|})||(){[)|(<}|||}|{}((}|[)||(>|>(<(}<{(}>|>|}||||>{(}>|>|}(>||}(>|>((}|[((((()))))|}||}})||}}||(){[)|(<}|||}|(}>}|>((}|[(((()))))|}|}|)|}}||(){[)|(<}|||}|(}>}|>((}|[((((()))))|}|}|})|)|}}||(){[)|(<}|||}|(}>}|{}>(<((}|[))||(>|>(<(}<{(}>|>|}||||>{(}>|>|}|||}>((}|[((((()))))|}|}|)|}}|}||(){[)|(<}|||}|{}}(<(>}>||||}(>|>(<(}<{(}>|>|}||||>{(}>|>|}>|}{(}>|>|>

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

(দ্রষ্টব্য যে উপরের লিঙ্কটি চলবে না কারণ টিআইওর সংকোচিত মস্তিষ্ক-ফ্ল্যাক ইন্টারপ্রেটার নেই You আপনি এখানে ব্রেইন-ফ্ল্যাঙ্কে ট্রান্সপ্লার খুঁজে পেতে পারেন )

আমি চেক করেছি যে এই ব্রেন-বিমানবিধ্বংসী কামান থেকে transpiling ব্যবহার করে বৈধ এই টুল, এখন দক্ষ যথেষ্ট যে সময়জ্ঞান আউট সম্ভাবনা কম।

Comments

ব্রেইন-ফ্ল্যাঙ্কে প্রথমবারের মতো গল্ফ করা, এবং এর ফলস্বরূপ? কি দারুন.

— এরিক আউটগল্ফার

আপনি সর্বদা প্রতিস্থাপন করতে পারেন <>(<()>)সঙ্গে (<>)। এছাড়াও, আপনি পরিবর্তন করতে পারেন (<>{}<>)(<()>)থেকে(<(<>{}<>)>)

— DJMcMayhem

@ জোকিং আমি কীভাবে জানতাম না, আমি প্রতি

— ইফ

এটি গল্ফিংয়ের বাইরে .. এটি খাঁটি পাগলামি। অভিনন্দন!

— আর্থার অ্যাটআউট

@ জোকিং এই পরিবর্তনটি আমার প্রত্যাশার চেয়েও সহজ এবং কার্যকর ছিল এবং এখন উত্তরের অন্তর্ভুক্ত রয়েছে

— কামিল দ্রাকারী

Answer 2

রেটিনা 0.8.2 , 103 98 বাইট

[])}>]
$&;
T`])}>|`[({<;
r`(.*)((;)|(?<-3>.))*
$&$.1$*;
(?<=(.)((;)|(?<-3>.))*);
;$1
T`;-{`_>-}`;.

এটি অনলাইন চেষ্টা করুন! লিঙ্কে পরীক্ষার কেস অন্তর্ভুক্ত রয়েছে। সম্পাদনা করুন: @ মার্টিনইেন্ডারের অনুপ্রেরণা সহ 5 বাইট সংরক্ষণ করা হয়েছে। ব্যাখ্যা:

[])}>]
$&;
T`])}>|`[({<;

একটি রাখুন ;যে বন্ধ বন্ধনী পরে এবং তাদের সব খোলা বন্ধনী পরিবর্তন, এবং পরিবর্তন |করার জন্য গুলি ;খুব গুলি।

r`(.*)((;)|(?<-3>.))*
$&$.1$*;

মেলে না এমন উন্মুক্ত বন্ধনীগুলির সংখ্যা গণনা করুন এবং এতে অনেকগুলি যুক্ত করুন ;।

(?<=(.)((;)|(?<-3>.))*);
;$1

প্রতিটি খোলার ব্র্যাকেটটি এর সাথে মিলে কপি করুন ;।

T`;-{`_>-}`;.

অনুলিপি করা বন্ধনীগুলি ফ্লিপ করুন এবং ;গুলি মুছুন ।

Comments

আপনি যদি |এরকম কোনও কিছুতে অনুবাদ করেন তবে আপনি পালানো সমস্ত বার এড়াতে পারেন !। এটি এমনকি বাইট খরচ করবে না যদি আপনি অনুবাদ >-}করতে <-{(যা আমি মনে করি দেয় zজন্য |)।

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

@ মার্টিনইেন্ডার নিশ্চিত নন যে আমি আপনার বিষয়েটি বুঝতে পেরেছি তবে zযাইহোক আমি আরও কিছু বাইট শেভ করার পদ্ধতি নিয়ে এসেছি।

— নীল

Answer 3

টিআইএস , 670 666 বাইট

^{পিছনে লাফানোর জন্য এগিয়ে লাফ দেওয়ার জন্য -4 বাইট}

কোড:

@0
MOV UP RIGHT
@1
MOV ANY ACC
SUB 41
NOP
NOP
NOP
NOP
NOP
NOP
NOP
NOP
MOV ACC DOWN
@2
NOP
MOV 124 LEFT
@3
MOV ANY DOWN
@4
MOV UP ACC
JGZ O
MOV 40 LEFT
JLZ (
MOV 41 LEFT
JRO 3
O:SUB 21
MOV ACC DOWN
JRO -8
(:MOV 41 RIGHT
@5
MOV ANY DOWN
@6
MOV ANY DOWN
@7
MOV UP ACC
JGZ O
MOV 60 LEFT
JLZ <
MOV 62 LEFT
JRO 3
O:SUB 31
MOV ACC DOWN
JRO -8
<:MOV 62 RIGHT
@8
MOV ANY DOWN
@9
MOV ANY DOWN
@10
S:MOV UP ACC
JGZ O
MOV 91 LEFT
JLZ [
MOV 93 LEFT
JRO 3
O:SUB 31
MOV ACC DOWN
JRO -8
[:MOV 93 RIGHT
@11
MOV ANY DOWN
@12
MOV ANY DOWN
@13
MOV UP ACC
JEZ |
MOV 123 LEFT
JLZ {
MOV 125 LEFT
JRO 2
|:MOV DOWN LEFT
JRO -7
{:MOV 125 RIGHT
@14
MOV ANY DOWN
@15
MOV UP DOWN
@16
MOV UP LEFT

লেআউট:

6 3
CCCCCCCCCCCCCCCCSC
I0 ASCII -
O0 ASCII -

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

আমি সন্দেহ করি এটি সবচেয়ে ছোট, তবে এটি আরও ছোট করার কোনও উপায় আমি দেখছি না। দুর্ভাগ্যক্রমে, সমস্ত NOPএস সময়সীমার জন্য প্রয়োজনীয় বলে মনে হচ্ছে এবং আমি ভিতরে @14থেকে পঠনের কারণে বর্তমানে স্ট্যাকটি রাখতে পারি না ।ANY@11

এই সমাধানের কাঠামোটি নিম্নরূপ:

Input
  |
  V
  0    1:synchro  2:EOF
  3    4:parens     5
  6    7:angles     8
  9   10:squares   11
 12   13:curlies   14
 15      stack     16
  |
  V
Output

একটি খোলা ব্রেস দেখে, ওপেনটি আউটপুট হতে বাম কলামের সাথে প্রেরণ করা হয় এবং ডান কলাম বরাবর বন্ধটি স্ট্যাকের কাছে প্রেরণ করা হয়।

একটি কাছাকাছি ধনুর্বন্ধনী দেখে, খোলা এবং কাছাকাছি উভয় আউটপুট হতে বাম কলাম বরাবর প্রেরণ করা হয়।

পাইপটি দেখার পরে, স্ট্যাকটি পপ করে আউটপুট প্রেরণ করা হয়।

ইওএফ-এর পরে, @1থেকে @2ইনপুট স্ট্রিমের পরিবর্তে, থেকে পড়া শুরু হবে @0। @2পাইপের অন্তহীন স্ট্রিম উত্পাদন করে, তাই স্ট্যাকটি শুকিয়ে যাবে।

ইনপুট এবং স্ট্যাক উভয় শেষ হয়ে গেলে, প্রোগ্রামটি বন্ধ হয়ে যায়।

সতর্কতা: টিআইএসের সীমাবদ্ধতার কারণে স্ট্যাকের আকার 15 টি সীমাবদ্ধ If

Answer 4

জাভাস্ক্রিপ্ট (ES6), 107 বাইট

অক্ষরের অ্যারে হিসাবে ইনপুট নেয়। একটি স্ট্রিং প্রদান করে।

a=>a.map(c=>(n=(S='|()[]{}<>').indexOf(c))?n&1?(s=[S[n+1],...s],c):S[n-1]+c:s.shift(),s=[]).join``+s.join``

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

Comments

একটি অক্ষরের অ্যারেও ফিরিয়ে দিয়ে 102 বাইট ।

— শেগি

@ শেগি ধন্যবাদ! তবে আসলেই কি এটি 1-অক্ষর এবং 2-বর্ণের স্ট্রিংগুলি একসাথে মিশ্রিত করার অনুমতি দেয়?

— আর্নৌল্ড

হুম ... হ্যাঁ, এটি এটিকে "অনুমতিপ্রাপ্ত" আউটপুটটিতে চাপ দিচ্ছে।

— শেগি

@ ডিজেএমসিমেহেম আপনি কি দয়া করে নতুন আউটপুট ফর্ম্যাটটি দেখুন এবং তা গ্রহণযোগ্য কিনা তা আমাদের জানান?

— আর্নল্ড

@ আর্নল্ড হুহ, এমন কোনও কারণে যা আমাকে পিং করে না। আমি মনে করি আমি না বলব। অক্ষরের একটি বিন্যাস বা এক স্ট্রিং উভয় মান বিন্যাসে, কিন্তু স্ট্রিং একটি অ্যারে আমাকে বৈধ বলে মনে হচ্ছে না

— DJMcMayhem

Answer 5

হাস্কেল, 127 121 বাইট

(""#)
(u:t)#('|':b)=u:t#b 
s#(c:b)|elem c")>]}"=m c:c:s#b|q<-m c:s=c:q#b
s#b=b++s
m c="> < ] [)(} {"!!mod(fromEnum c-6)27

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

সম্পাদনা করুন: -6 বাইটস মিলিয়ে বন্ধনীটি খুঁজে পেতে লাইকোনির ফাংশন ব্যবহার করে ।

Answer 6

রুবি , 104 বাইট

a=[];$<.chars{|c|r="|[{(<>)}]";i=r.index(c);i<1||(i<5?a:$>)<<r[-i];$>.<<i<1?a.pop: c};$><<a.reverse.join

এটি একটি সম্পূর্ণ প্রোগ্রাম যা কনসোলকে আউটপুট করে। (i<5?a:$>)<<r[-i]আমি যে দুর্দান্ত গল্ফগুলি করেছি তা হ'ল।

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

রুবি , 106 বাইট

->s{a=[];(s.chars.map{|c|r="|>)}][{(<";d=r[-i=r.index(c)];i<5||a<<d;i<1?a.pop: i<5?d+c:c}+a.reverse).join}

এটি আমার প্রথম সমাধান। একটি বেনাম ল্যাম্বদা ফাংশন যা স্ট্রিংগুলি গ্রহণ করে এবং প্রদান করে।

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

Answer 7

ব্রেন-ফ্লাক , 606 548 496 418 394 390 বাইট

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

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

আমি কামিল দ্রাকারীর উত্তরটি গল্ফ করে এইটি শুরু করেছি , তবে এটি আমার থেকে দূরে চলে গেল যেখানে আমি পৃথক উত্তর হিসাবে পোস্ট করার সিদ্ধান্ত নিয়েছি।

ব্যাখ্যা:

{ #While input on stack
	((({})))(<>)	#Preserve copy of the character
	(((((		#Push the differences between start bracket characters
	((([(())()()()]){}){}){}())	#Push -31, 1
	(()))				#Push -30, 1
	(((())()())()){}{})		#Push -19, 1
	){}[()])			#Push -39
	({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}<><{}>)	#If the character is any of the start brackets
	{({}({})<>)(<>)}{}					#Push the current character + TOS to the other stack

	({}<>)(<>)
	(((((		#Push the differences between end bracket characters
	((([(())()()()]){}){}){}())	#Push -31, 1
	(()))				#Push -30, 1
	(((())()){}()){})		#Push -19, 1
	){})				#Push -40
	({<(({}<>{}[()]))>[()]{()(<{}>)}{}<>}{}<>)	#If the character is any of the end brackets
	{(<({}(<()>)<>({})<{({}<>)<>}>)>)<>{({}<>)<>}}{}	#Push the character + TOS to the output

	({}()<>)	#If the character is not a |
	{{}({}<>)((<>))}{}	#Move current character to the other stack and push a zero
	{}		#Pop the top value of the stack, either the | or a 0
	<>(<({}(<()>)<><{({}<>)<>}>)>)<>{({}<>)<>}{}<>	#And push top of other stack to the output
}{}
{({}{}<>)<>}<>	#Reverse output and append the excess end brackets

এবং অবশ্যই...

সংক্ষিপ্ত মস্তিষ্ক-ফ্লাক, 285 বাইট:

{(((}|||(>|(((((((([()|)))||}|}|})|()||((()|))|)|}}||}[)||({<((}>}[)||||){[)|(<}|||}>|}><}||{(}(}|>|(>||}(}>|(>|(((((((([()|)))||}|}|})|()||((()|)|})|}||}|({<((}>}[)||||[)|{)(<}|||}>|}>|{(<(}(<)||>(}|<{(}>|>|||||>{(}>|>||}(})>|{}(}>|((>|||}}>(<(}(<)||><{(}>|>|||||>{(}>|>|}>|}{(}}>|>|>

Comments

খুব চিত্তাকর্ষক গল্ফিং! আমি এটির তাড়াতাড়ি লক্ষ্য না করায় আমি নিজের মধ্যে হতাশ, এটি কীভাবে কাজ করে তা বুঝতে আমাকে পরে তা অনুভব করতে হবে।

— কামিল দ্রাকারী

Answer 8

জাভা 10, 424 বাইট

s->{int i=0;for(var c:s.toCharArray()){if("(<[{".indexOf(c)>-1)i++;if(c=='|')i--;}for(;i-->0;)s+='|';s=s.replace(")","()").replace(">","<>").replace("]","[]").replace("}","{}");char[]c=s.toCharArray(),r=new char[124];r[40]=41;r[60]=62;r[91]=93;r['{']='}';var o="";for(;++i<c.length ;){if(c[i]=='|'){c[i]=o.charAt(0);o=o.substring(1);}if("(<[{".indexOf(c[i])>-1&")>]}".indexOf(i+1<c.length?c[i+1]:0)<0)o=r[c[i]]+o;}return c;}

এটি একপ্রকার দীর্ঘ, তবে কীভাবে এটি আরও ছোট করা যায় তা আমি বুঝতে পারি না। যদিও এটি একটি দুর্দান্ত চ্যালেঞ্জ।

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

অবরুদ্ধ সংস্করণ:

s -> { // lambda taking a String argument and returning a char[]
    int i = 0; // used for counting the number of '|'s that have been removed at the end of the input
    for(var c : s.toCharArray()) { // look at every character
        if("(<[{".indexOf(c) > -1) // if it's an open monad character
            i++; // we will need one more '|'
        if(c == '|') // if it's a close monad character
            i--; // we will need one '|' less
    }
    for(; i-- > 0; ) // add as many '|'
        s += '|';    // as necessary
    s = s.replace(")", "()").replace(">", "<>").replace("]", "[]").replace("}", "{}"); // replace compressed nilads with their uncompressed versions
    char[] c = s.toCharArray(), // from now on working on a char[] is more efficient since we will only be comparing and replacing
    r = new char[124]; // map open monad characters to their counterparts:
    r[40] = 41;   // '(' to ')'
    r[60] = 62;   // '<' to '>'
    r[91] = 93;   // '[' to ']'
    r['{'] = '}'; // '{' to '}'
    var o = ""; // we use this String as a kind of stack to keep track of the last open monad character we saw
    for(; ++i < c.length ;) { // iterate over the length of the expanded code
        if(c[i] == '|') { // if the current character is a close monad character
            c[i] = o.charAt(0); // replace it with the top of the stack
            o = o.substring(1); // and pop the stack
        }
        if("(<[{".indexOf(c[i]) > -1 // if the current character is an open monad/nilad character
         & ")>]}".indexOf(i+1 < c.length ? c[i+1] : 0) < 0) // and it's not part of a nilad (we need to test for length here to avoid overshooting)
            o = r[c[i]]+o; // using the mapping we established, push the corresponding character onto the stack
    }
    return c; // return the uncompressed code
}

Answer 9

পাইথন 2, 188 184 180 177 174 173 বাইট

p,q='([{<',')]}>'
d,s,a=dict(zip(p,q)),[],''
for c in input():
 if c in d:a+=c;s+=[c]
 elif'|'==c:a+=d[s.pop()]
 else:a+=dict(zip(q,p))[c]+c
for c in s[::-1]:a+=d[c]
print a

ডিজেএমসিএমহেমকে 4 বাইট সংরক্ষণ করা হয়েছে।
এটি অনলাইন চেষ্টা করুন!

Comments

180

— DJMcMayhem

২ য় থেকে শেষ লাইনের সাথে

— গণ্ডগোল

@ ডিজেএমসিএমহেম এটি কেবলমাত্র sখালি শেষ হলেই কাজ করে । অন্যথায়, আপনি ভুল শেষে অতিরিক্ত অক্ষর দিয়ে শেষ।

Answer 10

পাইথন 3 , 122 বাইট

D='()<>[]{} '
def f(x):
 a=s=''
 for c in x:i=D.find(c);a+=i<0and s[0]or D[i-(i&1):i+1];s=D[i+1][i&1:]+s[i<0:]
 return a+s

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

Answer 11

হাস্কেল , 152 বাইট

fst.p
m c="> < ] [)(} {"!!mod(fromEnum c-6)27
p(c:r)|elem c")]}>",(s,t)<-p r=(m c:c:s,t)|c/='|',(s,'|':t)<-p$r++"|",(u,v)<-p t=(c:s++m c:u,v)
p e=("",e)

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন । pএকটি পুনরাবৃত্ত পার্সার প্রয়োগ করে, যা সাধারণ ব্যাকরণের জন্য কিল ওভার হতে পারে।

Comments

mমেলা বন্ধনীটি খুঁজে পেতে দুর্দান্ত ফাংশন ।

— নিমি

Answer 12

পাইথন 2 , 244 বাইট

s=input()
B='([{<'
C=')]}>'
Z=zip(B,C)
P=sum(map(s.count,B))-s.count('|')
for i,j in Z:s=s.replace(j,i+j)
s+=P*'|'
b=[0]
for i in s:[b.pop()for j,k in Z if j==b[-1]<k==i];b+=[i][:i in B];s=i=='|'and s.replace(i,C[B.find(b.pop())],1)or s
print s

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

এই কাজটি পেতে এক বা দুই ঘন্টারও বেশি সময় লেগেছে ...