underloadเป็นกองตาม tarpit กึ่งการทำงานที่สร้างขึ้นโดยais523 เมื่อไม่นานมานี้ฉันพยายามเล่นกอล์ฟเพราะมันเป็นภาษาที่งดงามอย่างน่าประหลาดใจ

คุณมีเคล็ดลับอะไรสำหรับการเล่นกอล์ฟใน Underload? (หนึ่งเคล็ดลับต่อคำตอบ)

ใช้ *สำหรับการส่งออก

เพราะคุณสามารถส่งออกโดยออกสตริงในกองก็อาจจะมีประโยชน์ในการสะสมสตริงโดยใช้มากกว่าการแสดงผลด้วย* Sสมมติว่าความท้าทายของคุณคือ "รับสายและต่อเติมช่องว่าง" วิธีที่จะทำกับเอาต์พุตจะเป็น:

S( )S

วิธีที่จะทำด้วย*ในอีกทางหนึ่งคือ byte สั้น:

( )*

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

ใช้พจนานุกรมของฟังก์ชั่นที่นำกลับมาใช้ซ้ำแล้วซ้ำอีก

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

ในการเรียงลำดับของโปรแกรมที่มีขนาดใหญ่กว่าซึ่งอาจได้รับประโยชน์จากฟังก์ชั่นที่นำกลับมาใช้ใหม่หลายวิธีการแก้ปัญหาที่คุณสามารถใช้คือการสร้างฟังก์ชั่นขนาดใหญ่หนึ่งที่สามารถตอบสนองวัตถุประสงค์ของพวกเขาขึ้นอยู่กับวิธีที่เรียกว่า หรือใช้ลำดับการโทรที่ยาวกว่าเพียงแค่^ฟังก์ชั่นที่เขียนอย่างระมัดระวังสามารถแยกความแตกต่าง^^จากการใช้งานได้โดยไม่สูญเสียความสามารถในการใช้งานในอนาคต^:^จาก^*^จาก^~^ให้คุณสี่ที่แตกต่างกันลำดับที่ค่อนข้างสั้น) คุณยังสามารถเก็บสิ่งที่มีประโยชน์อื่น ๆ เช่นสตริงที่คุณใช้หลายครั้งใน "พจนานุกรม" นี้ โปรดทราบว่าหากคุณใช้พจนานุกรมอย่างหนักมันอาจทำให้รู้สึกเป็นควิน ๆ ผลักตัวสำเนาของตัวเองกลับไปที่สแต็กเพื่อที่คุณไม่จำเป็นต้องคัดลอกด้วยตนเอง:

เลือกรูปแบบข้อมูลเฉพาะสำหรับการดำเนินการตามความต้องการของปัญหา

ตัวอย่างง่ายๆการใช้งานที่พบเห็นได้ทั่วไปของ booleans นั้นเป็น!()เท็จ (เช่นจำนวนเต็ม 0) และสตริง null สำหรับจริง (เช่นจำนวนเต็ม 1) แต่ถ้าคุณมีปัญหาที่ยึดตาม XOR เชิงตรรกะอย่างหนัก การใช้สตริง null สำหรับ false และ~true (รูปแบบข้อมูลนี้สามารถแปลงเป็นรูปแบบบูลีนอื่น ๆ ได้โดยใช้(false)~(true)~^!และอนุญาตให้มีการปรับใช้*XOR สั้น ๆ

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

การลดลง "สกปรก"

วิธีที่บริสุทธิ์จากการใช้งานเพื่อลดจำนวนของศาสนจักรคือใช้ฟังก์ชันแคลคูลัสแลมบ์ดา:

\n.n(\p.\z.z($(pT))(pT))(\z.z0[whatever you define the predecessor of 0 to be])

โดยที่ 0 = \ x. \ yy, T = \ x. \ yx และ $ คือผู้สืบทอด

เขียนซ้ำใน Underload นี่คือ 28 ไบต์:

(!())~(!())~(!:(:)~*(*)*~)~^!

นี่เป็นไร แต่เราสามารถใช้ประโยชน์จากคุณสมบัติที่มีประโยชน์ของ Underload ได้นั่นคือ:!และ()*ไม่มีการใช้งาน ซึ่งหมายความว่าสำหรับจำนวนn, :ⁿ!!()()*ⁿ(ที่cⁿจะcทำซ้ำnครั้ง) อัตราผลตอบแทน n-1 ตัวอย่างเช่นการทำสิ่งนี้เพื่อเลข 3 ของศาสนจักรให้สิ่งนี้:

:::!!()()***

การลบคู่ที่ไม่มี op เราจะได้รับ:

:*

อันไหนคือ 2

ดังนั้นนี่คือการดำเนินการรุ่นใหม่และสั้นกว่า:

:(:)~^(!!()())*~(*)~^*

นี่คือ 7 ไบต์ที่สั้นกว่า

ใส่ค่าสแต็กที่ไม่ต้องการลงในพื้นที่โปรแกรม

อันเดอร์โหลดมีสองสแต็ก - สแต็กของสตริงและสแต็กของคำสั่งที่ประกอบขึ้นเป็นซอร์สโค้ด ^คำสั่งของ Underload ช่วยให้เราสามารถย้ายสตริงจากสแต็กเก่าไปยังหลัง โดยการทำเช่นนี้เราสามารถบันทึกการจัดการกองซ้อนที่ไม่จำเป็นจำนวนมากได้

ตัวอย่างเช่นสมมติว่าเรามี(a)(b)(c)ในสแต็คหลักและเราต้องการที่จะเชื่อมด้านล่างสององค์ประกอบไม่สนใจที่จะได้รับ(c) (ab)(c)วิธีที่ไร้เดียงสาในการทำเช่นนี้คือการหมุนสแต็กเพื่อรับ(c)(a)(b)และจากนั้นประสานและสลับกลับ:

a~a~*~a*^*~

นี้ไม่ดี. การใช้a~a~*~a*^เพื่อหมุนสแต็กเช่นนี้มีค่าใช้จ่ายสูงมากและควรหลีกเลี่ยงเมื่อเป็นไปได้ ด้วยการใส่(c)พื้นที่โปรแกรมแทนสิ่งนี้สามารถทำให้สั้นลงสี่ไบต์:

a(*)~*^

แนวคิดคือการใช้คำแนะนำที่คุณต้องการดำเนินการแล้วเพิ่มคำสั่งเพื่อผลักดัน(c)กลับไปที่จุดสิ้นสุดแล้วประเมินผลลัพธ์ ซึ่งหมายความว่าเราไม่ต้องกังวล(c)จนกว่าจะถูกผลักกลับหลังจากเราทำเสร็จแล้ว