ความท้าทายนี้ถูกโพสต์เป็นส่วนหนึ่งของความท้าทาย LotMในเดือนเมษายน 2018เช่นเดียวกับวันเกิดปีที่ 2 ของ Brain-flak

ฉันกำลังคิดเกี่ยวกับวิธีที่มีประสิทธิภาพมากที่สุดในการเข้ารหัสโปรแกรมสะกิดสมอง สิ่งที่ชัดเจนที่ต้องทำเนื่องจากมีอักขระที่ใช้ได้เพียง 8 ตัวเท่านั้นคือการจับคู่อักขระแต่ละตัวกับลำดับ 3 บิต นี้มีประสิทธิภาพมาก แต่ก็ยังซ้ำซ้อนมาก มีคุณสมบัติบางอย่างของรหัสสมองสะเก็ดระเบิดที่เราสามารถใช้ประโยชน์จากการเข้ารหัสให้สั้นลงได้

• nilads ซึ่งถูกแสดงด้วยวงเล็บ 2 ตัวที่จับคู่กันทำหน้าที่เป็นหน่วยเดียวของข้อมูลมากกว่า 2 ถ้าเราแทนที่แต่ละวงเล็บด้วยอักขระไบต์เดียวสิ่งนี้จะทำให้การเข้ารหัสมีขนาดเล็กลงโดยไม่สูญเสียข้อมูลใด ๆ

• อันนี้ไม่ชัดเจน แต่ไบต์การปิดของ monads นั้นซ้ำซ้อนเช่นกัน คิดว่าคุณสามารถเดาได้ว่า'?'ตัวละครนั้นเป็นตัวแทนอะไรในตัวอย่างต่อไปนี้

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

  หากเราสมมติว่าการป้อนข้อมูลนั้นเป็นรหัสสมองที่ถูกต้องแสดงว่ามีเพียงตัวเลือกเดียวสำหรับเครื่องหมายคำถามแต่ละข้อ ซึ่งหมายความว่าเราสามารถใช้ตัวอักษรmonad อย่างใกล้ชิดเพื่อแทนวงเล็บปิดทุกอัน สิ่งนี้มีประโยชน์เพิ่มเติมในการทำให้ชุดอักขระมีขนาดเล็กซึ่งจะช่วยได้อย่างมากหากเราต้องการใช้การเข้ารหัส huffman เนื่องจากตัวละครmonad closeน่าจะเป็นตัวละครที่พบได้บ่อยที่สุดโดยมีระยะขอบที่กว้างจึงอาจเป็นเพียงบิตเดียวซึ่งมีประสิทธิภาพอย่างมหาศาล

เทคนิคสองอย่างนี้จะให้เราบีบอัดโค้ดที่ทำให้สมองสะบัดผ่านอัลกอริทึมต่อไปนี้:

1. เปลี่ยนทุกๆวงเล็บปิดของ monad |กับ หรือกล่าวอีกนัยหนึ่งให้แทนที่วงเล็บปิดทุกอันที่ไม่ได้นำหน้าด้วยการเปิดการจับคู่ด้วยแถบ ดังนั้น...

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

   จะกลายเป็น

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

2. แทนที่ nilad ทุกตัวด้วยวงเล็บปิด ดังนั้นการจับคู่วงเล็บที่ไม่มีสิ่งใดในนั้นจึงใช้การจับคู่ดังต่อไปนี้:

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

   ตอนนี้ตัวอย่างสุดท้ายของเรากลายเป็น:

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

3. ลบ|อักขระต่อท้าย เพราะเรารู้ว่าจำนวนบาร์ทั้งหมดควรเท่ากับจำนวน({[<ตัวอักษรทั้งหมดหากมีบาร์ที่ส่วนท้ายหายไปเราสามารถอนุมานได้ ตัวอย่างเช่น:

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

   จะกลายเป็น

   ({(}|(}[)
   

ความท้าทายของคุณในวันนี้คือการย้อนกระบวนการนี้

รับสายของสมอง - บีบอัดที่มีเพียงตัวอักษร(){}[]<>|ขยายเข้าไปในสมองสะเก็ดรหัสต้นฉบับ - คุณสามารถสันนิษฐานได้ว่าสัญญาณที่ป้อนเข้านั้นจะขยายไปยังส่วนที่ถูกต้องของสมอง ซึ่งหมายความว่าไม่มีคำนำหน้าของอินพุตจะมี|มากกว่า({[<อักขระ

อินพุตจะไม่มี|อักขระต่อท้าย สิ่งเหล่านี้จะต้องอนุมานจากบริบท

ตามปกติคุณสามารถส่งทั้งโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบและรูปแบบอินพุต / เอาท์พุตอนุญาต และเนื่องจากนี่คือรหัสกอล์ฟรหัสของคุณจะถูกทำคะแนนตามความยาวของซอร์สโค้ดเป็นไบต์ดังนั้นยิ่งคะแนนยิ่งน้อย

กรณีทดสอบ

นี่คือกรณีทดสอบบางส่วน หากคุณต้องการมากกว่านี้คุณสามารถสร้างกรณีทดสอบของคุณเองด้วยสคริปต์ไพ ธ อนและBrain-Flak Wikiซึ่งเป็นที่มาของกรณีทดสอบส่วนใหญ่มาจาก

#Compressed code
#Original code

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


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

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


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

Brain-Flak , 952 916 818 ไบต์

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

บันทึก 360 ไบต์ด้วยการคำนวณวงเล็บที่อยู่ตรงข้ามมากกว่าการลบ (เช่น')'= '(' + 1แทน(((5 * 2) * 2) * 2) + 1)

บันทึก 34 ไบต์ด้วยการแทนที่โดยตรงจาก DJMcMayhem

บันทึก 10 ไบต์ด้วยการซ้อนทับ>]}รหัสการจัดการ

บันทึกแล้ว 118 ไบต์โดยการลบข้อมูลซ้ำซ้อน

บันทึก 40 ไบต์โดยใช้ประโยชน์จากสแต็กเปล่าเพื่อทำให้การหมุนครั้งแรกง่ายขึ้น

บันทึก 48 ไบต์ด้วยการทำเครื่องหมาย EOF ด้วย -1 ทำให้สามารถใช้งานรหัสม้วนที่รัดกุมยิ่งขึ้น

บันทึก 36 ไบต์โดยใช้สต็อคเท่ากับตรรกะแทนที่จะเป็นของฉันเอง

บันทึก 98 ไบต์ด้วย Jo King เพื่อค้นหาวิธีที่มีประสิทธิภาพในการสร้างเอาต์พุต

ลองออนไลน์!

ครั้งแรกที่เล่นกอล์ฟใน Brain-Flak ดังนั้นอาจมีการปรับปรุงที่ใหญ่มาก แต่ก็ใช้งานได้ จำนวนมากคัดลอก / วางที่จะจัดการกับแต่ละประเภทวงเล็บและขอบคุณใหญ่กับเครื่องกำเนิดไฟฟ้าจำนวนเต็มอัตโนมัติและม้วน snippet จากที่นี่

คำอธิบายที่นี่รูปแบบ TIO ง่ายขึ้น

คำตอบโบนัส:

บีบอัด Brain-Flak 583 ไบต์

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

ลองออนไลน์!

(โปรดทราบว่าลิงก์ด้านบนไม่ทำงานเนื่องจาก TIO ไม่มีตัวแปล Brain-Flak ที่บีบอัดคุณสามารถค้นหา transpiler ไปที่ Brain-Flak ที่นี่ )

ผมได้ตรวจสอบว่าถูกต้องโดย transpiling เพื่อ Brain-Flak ใช้นี้เครื่องมือที่มีประสิทธิภาพเพียงพอในขณะนี้ว่าระยะเวลาออกไม่น่าเป็น

เรติน่า 0.8.2 , 103 98 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ แก้ไข: บันทึก 5 ไบต์ด้วยแรงบันดาลใจจาก @MartinEnder คำอธิบาย:

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

ใส่ a ;วงเล็บทุกหลังปิดและเปลี่ยนพวกเขาทั้งหมดเพื่อเปิดวงเล็บและเปลี่ยน|s เป็น;s เกินไป

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

นับจำนวนวงเล็บเปิดที่ไม่ตรงกันและเพิ่มจำนวน;นั้น

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

;คัดลอกแต่ละวงเล็บเปิดการจับคู่ของมัน

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

พลิกวงเล็บที่คัดลอกแล้วลบ;s

มอก . 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 -

ลองออนไลน์!

ฉันสงสัยว่านี่เล็ก แต่ฉันไม่เห็นวิธีที่จะทำให้มันเล็กลง แต่น่าเสียดายที่ทุกNOPs ดูเหมือนสิ่งที่จำเป็นสำหรับการกำหนดเวลาและผมก็ไม่สามารถใส่สแต็คที่@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

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

เมื่อเห็นวงเล็บปิดทั้งเปิดและปิดจะถูกส่งไปตามคอลัมน์ด้านซ้ายเพื่อส่งออก

เมื่อเห็นไปป์สแตกจะถูกตอกและส่งไปยังเอาต์พุต

เมื่อ EOF, @1จะเริ่มต้นจากการอ่านแทนการสตรีมใส่จาก@2 สร้างกระแสของท่อที่ไม่มีที่สิ้นสุดดังนั้นสแต็กจะถูกระบายออก@0@2

เมื่อทั้งอินพุตและสแต็กหมดลงโปรแกรมจะหยุดทำงาน

คำเตือน: เนื่องจากข้อ จำกัด ของ TIS ขนาดของสแต็กจะถูก จำกัด ไว้ที่ 15 หากมีสิ่งใดซ้อนอยู่ลึกกว่านั้น

JavaScript (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``

ลองออนไลน์!

Haskell, 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 ไบต์โดยใช้ @ Laikoni ของฟังก์ชันเพื่อหาวงเล็บที่ตรงกัน

Ruby , 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]จะต้องเป็นหนึ่งในสนามกอล์ฟที่เจ๋งที่สุดที่ฉันเคยทำมา

ลองออนไลน์!

Ruby , 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}

นี่เป็นทางออกแรกของฉัน ฟังก์ชั่นแลมบ์ดานิรนามที่รับและส่งคืนสตริง

ลองออนไลน์!

Brain-Flak , 606 548 496 418 394 390 ไบต์

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

ลองออนไลน์!

ฉันเริ่มต้นด้วยการเล่นกอล์ฟคำตอบของ Kamil Drakariแต่มันก็ห่างจากฉันไปจนถึงจุดที่ฉันตัดสินใจที่จะโพสต์มันเป็นคำตอบที่แยกจากกัน

คำอธิบาย:

{ #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

และแน่นอน ...

บีบอัด Brain-Flak ขนาด 285 ไบต์:

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

Java 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
}

Python 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 ไบต์ขอบคุณ DJMcMayhem
ลองออนไลน์!

Python 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

ลองออนไลน์!

Haskell , 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ใช้เครื่องมือแยกวิเคราะห์แบบเรียกซ้ำซึ่งอาจใช้เวลานานกว่าการฆ่าสำหรับไวยากรณ์อย่างง่าย

Python 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

ลองออนไลน์!

ใช้เวลามากกว่าหนึ่งหรือสองชั่วโมงกว่าจะได้งานนี้ ...