พื้นหลัง

Stack Catsเป็นภาษาลึกลับที่สามารถย้อนกลับได้โดย Martin Ender แต่ละคำสั่งใน Stack Cats เป็นทั้งการผกผันของตัวเอง (แสดงเป็นตัวอักษรสมมาตรเช่น-_:T|) หรือมีคำสั่งผกผันของมัน (แสดงเป็นภาพสะท้อนในกระจกเช่น() {} [] <>) Stack Cats มีความต้องการด้านไวยากรณ์ที่แข็งแกร่งซึ่งโปรแกรมทั้งหมดควรเป็นภาพสะท้อนของตัวมันเอง โปรดทราบว่านี้หมายถึงการที่ถูกต้องโปรแกรมใด ๆ Stack แมวเป็นแอมบิแกรมภาพกระจกสะท้อนธรรมชาติ

นี่คือชุดคำสั่งทั้งหมดของ Stack Cats:

• Self-สมมาตร: !*+-:=ITX^_|
• คู่สมมาตร: () {} [] <> \/

อักขระอื่น ๆ ไม่ถูกต้อง อินพุตใด ๆ ที่มีอักขระที่ไม่ได้อยู่ในชุดอักขระด้านบนควรเอาต์พุตเท็จ

ภาษามีข้อ จำกัด เพิ่มเติมที่()และ{}คู่ต้องสมดุลเสมอ แต่เพื่อความเรียบง่ายคุณไม่จำเป็นต้องตรวจสอบเงื่อนไขนี้

ต่อไปนี้เป็นตัวอย่างของโปรแกรมStack Cats ที่ถูกต้อง (อีกครั้งโปรดทราบว่าคุณไม่ได้ตรวจสอบการล้อเลียนที่สมดุล):

{[+]==[+]}
[)>^<(]
({T)}|{(T})
<(*]{[:!-_:>}<[<)*(>]>{<:_-!:]}[*)>

สิ่งเหล่านี้ไม่ใช่:

b<+>d
())(
({[<++<]})

ท้าทาย

เขียนโปรแกรมหรือฟังก์ชันที่กำหนดว่าสตริงที่กำหนดเป็นโปรแกรม Stack Cats ที่ถูกต้อง รหัสของคุณควรเป็นภาพสะท้อนในกระจกเงาตามธรรมชาติซึ่งหมายถึง:

• รหัสของคุณควรเป็นภาพสะท้อนของตัวมันเอง
  • รหัสของคุณอาจมีการขึ้นบรรทัดใหม่อย่างน้อยหนึ่งบรรทัดตราบใดที่รหัสทั้งหมดแสดงตามธรรมชาติเป็นภาพสะท้อนของตัวเอง
  • คุณสามารถละเว้นหรือเพิ่มช่องว่างที่ต่อท้ายในแต่ละบรรทัดได้เนื่องจากจะไม่เปลี่ยนการแสดงผล
  • ไม่อนุญาตให้ใช้อักขระแท็บเนื่องจากมีความคลุมเครือบนหน้าจอ

หมายเหตุ:รหัสของคุณไม่จำเป็นต้องเป็นโปรแกรม Stack Cats ที่ถูกต้อง มันอาจมีอักขระพิเศษบางตัวที่ไม่ได้รับอนุญาตใน Stack Cats (ดูด้านล่างสำหรับรายการทั้งหมด)

ตัวอย่างเช่นสองโปรแกรมต่อไปนี้เป็นแบบสมมาตร (และการส่งที่ถูกต้อง ) ในขณะที่โปรแกรมที่สามไม่ใช่:

({bTd})
[<q|p>]

({bTd})
  IXI

({bTd})
IXI

• เกี่ยวกับ "mirror symmetry" จะมีการพิจารณาความสมมาตรสไตล์ Stack Cats เท่านั้น (เช่น({IH})ไม่ใช่การส่งที่ถูกต้องแม้ว่าจะมีความสมมาตรของกระจกก็ตาม)
• รหัสของคุณสามารถมีชุดอักขระเหล่านี้เท่านั้นและขึ้นบรรทัดใหม่:
  • สมมาตรด้วยตนเอง: space ( 0x20) +!"'*+-.8:=AHIMOTUVWXY^_ovwx|
  • คู่สมมาตร: () /\ <> [] bd pq {}

ชุดอักขระถูกเลือกให้เป็นแบบสมมาตรหรือแบบสมมาตรอย่างเคร่งครัดเมื่อแสดงเป็นรหัสใน SE

อินพุตและเอาต์พุต

ช่วงอินพุตเป็นสตริงหนึ่งบรรทัดของอักขระ ASCII ที่พิมพ์ได้

คุณสามารถเลือกที่จะรับเข้าเป็นสตริงรายการตัวอักษรหรือรายการค่า ASCII

คุณสามารถเลือกที่จะส่งออกอย่างใดอย่างหนึ่ง:

• ค่าความจริง / เท็จใด ๆ ตามที่กำหนดโดยภาษาที่คุณเลือก
  • ค่าผลลัพธ์ที่แท้จริงอาจแตกต่างกันไประหว่างอินพุต (เช่นเอาท์พุท 1 สำหรับอินพุตจริงและ 2 สำหรับอีกอันหนึ่ง)
  • ไม่อนุญาตให้สลับค่าความจริงและเท็จ
• ค่าคงที่สองค่าใด ๆ สำหรับจริง / เท็จตามลำดับ
  • ในกรณีนี้ค่าผลลัพธ์ควรเป็นหนึ่งในสองค่าคงที่

คุณควรระบุวิธีการป้อนข้อมูลและค่าผลลัพธ์ในการส่งของคุณ

สภาพการชนะ

นี่คือcode-golfดังนั้นไบต์ต่ำสุดในแต่ละภาษาจะชนะ

หมายเหตุ

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้ามตามปกติ
• แน่นอนว่าคุณสามารถแก้ปัญหานี้ได้ใน Stack Cats แต่โอกาสคือคุณไม่สามารถใช้การตั้งค่าสถานะที่อนุญาตให้ลดขนาดรหัสลงครึ่งหนึ่ง และเป็นภาษาที่ใช้ยากมากในการรับ: P

JavaScript (ES6), 487 467 378 298 292 280 266 264 ไบต์

บันทึก 14 ไบต์ขอบคุณ @Bubbler

I=>(V=v=>!I[v]||((T=o=>[[]][+!!A[o]]||[(I[v]!=A[o]||A)[o^o<88/8]]+T(++o))(8-8)==I.pop())*V(++v))(V|(A='(){}[]<>\\/ !*+-:=ITX^_|'))//\\(('|_^XTI=:-+*! \//<>[]{}()'=A)|V)((v++)V*(()qoq.I==(8-8)((o++)T+[[8\88>o^o](A||[o]A=![v]I)]||[[o]A!!+][[]]<=o=T))||[v]I!<=v=V)<=I

กำหนดฟังก์ชั่นไม่ระบุชื่อที่ใช้อาร์เรย์ของตัวอักษรและส่งออกผลลัพธ์ที่ต้องการ เอาท์พุทเป็นความจริง / เท็จ; มักจะ1/ แต่สตริงที่ว่างเปล่าให้0true

อย่างไร?

เคล็ดลับที่ชัดเจนที่สุดคือใช้//\\เป็นจุดศูนย์กลางเพื่อแสดงความคิดเห็นเกี่ยวกับโค้ดที่ทำมิรเรอร์ หลังจากนั้นมันจะกลายเป็นเกมของการหาวิธีที่สั้นที่สุดในการแก้ปัญหาโดยใช้ชุดอักขระที่กำหนดเท่านั้น

ปัญหาแรกที่เราพบคือการขาดคำหลักและบิวด์อิน เรายังมีปาฏิหาริย์อยู่.pop()แต่ทุกอย่างจะต้องทำผ่านตัวดำเนินการที่อนุญาต (ซึ่งรวมถึงa[b]และf(c)) ด้วยการวนซ้ำเพื่อเลียนแบบลูป

ปัญหาที่สองคือการขาดตัวดำเนินการเชิงตรรกะ ทั้ง&และ?ได้รับอนุญาตซึ่งหมายความว่าเพียง||ประกอบการตัดสินใจเราสามารถใช้เป็น ดังนั้นเราต้องจัดโครงสร้างตรรกะของเราอย่างรอบคอบเพื่อให้ได้สิ่งนี้

สิ่งแรกที่ฉันทำคือการกำหนดฟังก์ชั่นTที่สะท้อนถึงตัวละครแต่ละตัว แนวคิดพื้นฐานคือการวนรอบอักขระแต่ละตัวในสตริงของตัวอักษรแบบมิเรอร์สามารถทดสอบแต่ละตัวเพื่อความเท่าเทียมกับอักขระที่กำหนด ถ้ามันเท่ากันเราจะคืนค่าของมัน - char at index^1for (){}[]<>\/หรือ char เอง

ปัญหาแรกที่ฉันพบที่นี่คือการได้รับ char chared หรือค่าเท็จในการทำซ้ำแต่ละครั้ง ในที่สุดโซลูชันที่ฉันคิดขึ้นมาคือตัวละครอินพุตอยู่(x!=A[o]||A)[o^o<88/8]ที่ไหนxคือตัวอักษรแบบAมิเรอร์และoเป็นดัชนีปัจจุบัน หากxไม่เหมือนกันA[o]สิ่งนี้จะช่วยให้trueและการแสดงออกของดัชนีประเมินเพื่อundefined; มิฉะนั้นจะถูกเปิดใช้งานและเราจบลงด้วยการ||AA[o^(o<11)]

ปัญหาที่สองคือวิธีการยกเลิกการสอบถามซ้ำ ผมพบว่าวิธีที่ดีที่สุดที่จะทำเช่นนี้ก็คือการเชื่อมผลของทุกซ้ำกลับสตริงว่างเมื่อตอนท้ายของAจะมาถึง ของขวัญนี้เรามีสองปัญหาต่อไป: การแปลงundefinedเพื่อล้างสตริงและกลับสตริงว่าง||บางสิ่งบางอย่าง สิ่งเหล่านี้สามารถแก้ไขได้ด้วยการละเมิดอาเรย์:[a]+""ให้การแทนค่าสตริงaหรือสตริงว่างถ้าaไม่ได้กำหนด ในฐานะโบนัสนั้น[]เป็นความจริง แต่ stringifies กับสตริงว่างดังนั้นเราจึงสามารถใช้สิ่งนี้เป็น "สตริงว่างเปล่าที่เป็นความจริง" ได้อย่างสะดวก

ตอนนี้เราสามารถใช้Tฟังก์ชั่นเพื่อสะท้อนอักขระเดี่ยว ๆ ได้ เราทำสิ่งนี้ซ้ำ ๆ โดยเปรียบเทียบมิเรอร์ของI[v++]ถึงI.pop()จนจบอาร์เรย์ของตัวอักษร เราไม่สามารถใช้&&หรือ&ตรวจสอบว่าการเปรียบเทียบทั้งหมดเป็นความจริงหรือไม่ แต่ให้ใช้*แทน การคูณผลลัพธ์ทั้งหมดเหล่านี้เข้าด้วยกันจะช่วยให้1หากตัวละครทุกตัวเป็นมิเรอร์ของอีกฝ่ายหนึ่งหรือ0หากการเปรียบเทียบใด ๆ ล้มเหลว

และนั่นเป็นวิธีการที่คำตอบนี้ใช้งานได้จริง ฉันอาจจะไม่อธิบายอย่างชัดเจนดังนั้นโปรดถามคำถามที่คุณอาจมีและชี้ให้เห็นข้อผิดพลาดใด ๆ ที่ฉันทำ

Stax , 76 70 ไบต์

:Wx^^MH_=_"{([</!*+-:=ITX^_|":W-!*pq*!-W:"|_^XTI=:-+*!\>])}"_=_HM^^xW:

เรียกใช้และแก้ไขข้อบกพร่อง

Stax เป็นเพื่อนของ Stack Cats และมี internals เพื่อสร้างครึ่งหลังของโปรแกรม Stack Cats จากครึ่งแรก หากเราไม่สนใจข้อ จำกัด ของแหล่งที่มาและไม่จำเป็นต้องตรวจสอบชุดอักขระนี่คือโซลูชัน 4 ไบต์:

4 ไบต์

:R_=

เรียกใช้และแก้ไขข้อบกพร่อง

คำอธิบาย

:Wx^^MH_=_"{([</!*+-:=ITX^_|":W-!*pq...
:W                                         "Mirror" the string
                                           Equivalent to appending the reverse of the string to itself
                                           And map `{([</\>])}` to its mirror in the appended string
  x^^                                      2, but we can't just use `2` here ...
     MH                                    Partition the "mirror"ed string to two parts, take the later part.
       _=                                  The string is the same as the original one (*)
                                           `:Wx^^MH_=` is just `:R_=`, but we can't use `R` here ...
         _                                 Input string
          "{([</!*+-:=ITX^_|":W-           Remove valid characters from input
                                !          The final string is empty (**)
                                 *         (*) and (**)
                                  p        Pop and print result
                                   q       Peek stack and print
                                           Since the stack is now empty, this causes the program to terminate
                                    ...    Not executed