สมองสะเก็ดระเบิดเป็นภาษาทัวริง-tarpit สแต็คตามที่เขียนร่วมกันระหว่างฉันDJMcMayhemและ1000000000

ผู้ใช้บางคนมีประสบการณ์มากในวิธีที่ลึกลับของ Brain-Flak ดังนั้นฉันจึงคิดว่าเป็นความคิดที่ดีที่จะตั้งคำถามนี้เป็นวิธีสำหรับเราและหวังว่าคนอื่น ๆ จะแบ่งปันความรู้ของเรากับชุมชนและลดอุปสรรคในการเข้าใช้ภาษานี้ "ออกแบบมาให้เจ็บปวดใช้" และอาจสอนพวกเราด้วยประสบการณ์มากขึ้นด้วยเทคนิคใหม่ ๆ

ดังนั้นคุณมีเคล็ดลับอะไรสำหรับการเล่นกอล์ฟในสมองที่สะบัด? ฉันกำลังมองหาความคิดที่สามารถนำไปใช้กับปัญหารหัสกอล์ฟโดยทั่วไปซึ่งอย่างน้อยค่อนข้างเฉพาะกับสมองสะบัด (เช่น "ลบความคิดเห็น" ไม่ใช่คำตอบ)

กรุณาโพสต์หนึ่งเคล็ดลับต่อคำตอบ

ใช้กองที่สาม

หากคุณอ่านชื่อเรื่องคุณอาจสับสนเล็กน้อย แน่นอนมีเพียงสองกองใน Brain-Flak? อย่างไรก็ตามฉันรับรองว่ามันมีอยู่จริงและเป็นหนึ่งในเครื่องมือที่ทรงพลังที่สุดหากไม่ใช่เครื่องมือที่ทรงพลังที่สุดในการเขียนและเล่นเกม Brain-Flak

"กองที่สาม" คืออะไร?

โปรแกรม Brain-Flak ทุกโปรแกรมใช้กองซ้อนที่สามในทางเดียว แต่ส่วนใหญ่ของการใช้งานอยู่เบื้องหลังและมันมักจะมีประโยชน์ในการละเลยข้อเท็จจริงที่มีอยู่ แต่ละวงเล็บในโปรแกรมสามารถเพิ่มหรือลบหนึ่งรายการจากสแต็ก เหล็กดัดที่เปิดสามอัน([<ทั้งหมดจะเพิ่มไอเท็มลงในสแต็กในขณะที่เหล็กทั้งสามคอนจูเกต)]>ทั้งหมดจะลบไอเท็มออกจากสแต็ก มูลค่าของรายการในสแต็กคือมูลค่าของขอบเขตปัจจุบันของโปรแกรมและการใช้ nilads จะแก้ไขค่านี้ในบางวิธี วงเล็บปิด)มีฟังก์ชั่นพิเศษในการย้ายองค์ประกอบจากกองที่สามไปยังกองซ้อนปัจจุบัน การผลักดัน

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

ตัวอย่าง

เราจะเดินผ่านโปรแกรมต่อไปนี้ โปรแกรมนี้พุช-3, 1, -2ไปยังสแต็ก

(([()()()])(()))

เราเริ่มต้นด้วยวงเล็บปีกกาเปิดสามอันซึ่งทั้งหมดผลักศูนย์ให้เป็นกองที่สาม

สแต็คของเราตอนนี้มีลักษณะเช่นนี้กองที่สามคือกองที่อยู่ทางขวาและกองที่ใช้งานอยู่นั้น^อยู่ใต้:

        0
        0
  0  0  0
  ^

(([()()()])(()))
   ^

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

        3
        0
  0  0  0
  ^

(([()()()])(()))
         ^

ตอนนี้เราพบ]ตามที่ระบุไว้ก่อนที่จะปิดวงเล็บปีกกาลบรายการจากกองที่สาม แต่]มีฟังก์ชั่นการลบองค์ประกอบมันลบออกจากด้านบนของกอง ดังนั้นสแต็คใหม่ของเราจะมีลักษณะดังนี้:

       -3
  0  0  0
  ^

(([()()()])(()))
          ^

เรื่องนี้ทำให้รู้สึก; [...]การปฏิเสธจึง]ควรลบลง

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

 -3  0 -3
  ^

(([()()()])(()))
           ^

อีกครั้งที่เราพบกับหนึ่งในสามวงเล็บปีกเปิดของเราดังนั้นเราจะเพิ่มองค์ประกอบอื่นในกองที่สามของเรา

        0
 -3  0 -3
  ^

(([()()()])(()))
            ^

ตามที่เราได้กล่าวไปแล้วก่อนหน้านี้ว่า()จะเพิ่มจำนวนกองซ้อนที่สามขึ้นหนึ่งอันดับ

        1
 -3  0 -3
  ^

(([()()()])(()))
              ^

และ)จะย้ายด้านบนของกองที่สามไปยังกองที่ใช้งานอยู่และเพิ่มลงไป

  1
 -3  0 -2
  ^

(([()()()])(()))
               ^

ครั้งสุดท้ายที่)ย้ายกองที่สามไปยังกองที่ใช้งานอยู่และเนื่องจากไม่มีองค์ประกอบที่เหลืออยู่ในกองที่สามเพื่อให้เพิ่มไม่ทำอะไรเลย

 -2
  1
 -3  0
  ^

(([()()()])(()))
                ^

โปรแกรมสิ้นสุดลงดังนั้นเราจึงยกเลิกและส่งออก

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

ตกลงอะไร

ตกลงตอนนี้คุณเข้าใจ Stack ที่สาม แต่ "แล้วอะไรล่ะ" คุณใช้มันไปแล้วแม้ว่าคุณจะไม่ได้เรียกมันว่า "กองที่สาม" การคิดในแง่ของกองที่สามช่วยให้คุณเล่นกอล์ฟได้อย่างไร?

ให้ดูที่ปัญหา คุณต้องการที่จะใช้สามเหลี่ยมของจำนวน นี่คือผลรวมของตัวเลขทั้งหมดน้อยกว่า n

วิธีการหนึ่งอาจเป็นการสร้างแอคคูมูเลเตอร์บน offstack และเพิ่มเข้าไปเมื่อคุณนับถอยหลัง สิ่งนี้สร้างรหัสที่มีลักษณะดังนี้:

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

ลองออนไลน์!

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

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

ลองออนไลน์

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

เมื่อไหร่ที่ฉันจะใช้กองที่สาม?

เมื่อไรก็ตามที่คุณเริ่มทำงานกับปัญหาใหม่ใน Brain-Flak คุณควรคิดกับตัวเองว่าฉันจะทำสิ่งนี้อย่างไรกับ Third Stack ในใจ อย่างไรก็ตามตามกฎทั่วไปของหัวแม่มือเมื่อใดก็ตามที่คุณต้องติดตามการสะสมบางประเภทหรือมีผลรวมสะสมเป็นความคิดที่ดีที่จะลองวางมันลงบนกองซ้อนที่สามของคุณแทนที่จะเป็นกองซ้อนสองตัวจริง

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

ข้อ จำกัด ของกองที่สาม

กองที่สามนั้นทรงพลังมากในหลาย ๆ ทาง แต่มันมาพร้อมกับข้อ จำกัด และข้อเสียของมันเอง

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

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

ข้อสรุป

The Third Stack เป็นเครื่องมือที่ทรงพลังและฉันคิดว่ามันสำคัญสำหรับผู้ใช้ Brain-Flak ทุกคน ต้องใช้ความคุ้นเคยและต้องการเปลี่ยนวิธีคิดของคุณเกี่ยวกับการเขียนโปรแกรมใน Brain-Flak แต่เมื่อใช้อย่างถูกต้องจะทำให้ความแตกต่างระหว่างความดีและความมหัศจรรย์เมื่อเล่นกอล์ฟ

cheatsheet

นี่คือรายการของการดำเนินการและสิ่งที่ส่งผลกระทบต่อกองที่สาม

 Operation  |                 Action
====================================================
   (,[,<    | Put a zero on top of the Third Stack
----------------------------------------------------
     )      | Add the top of the Third Stack to the
            | second element and move it to the 
            | active stack
----------------------------------------------------
     ]      | Subtract the top of the Third Stack
            | from the second element and pop it
----------------------------------------------------
     >      | Pop the top of the Third Stack
----------------------------------------------------
     ()     | Add one to the top of the Third Stack
----------------------------------------------------
     {}     | Pop the top of the active stack and
            | add it to the top of the Third Stack
----------------------------------------------------
     []     | Add the stack height to the Third
            | Stack
----------------------------------------------------
   <>,{,}   | Nothing

การค้นหาโมดูลัส / ส่วนที่เหลือ

การค้นหาn modulo mเป็นหนึ่งในการดำเนินการทางคณิตศาสตร์ขั้นพื้นฐานที่สำคัญสำหรับความท้าทายมากมาย สำหรับกรณีm> 0และn> = 0อาจใช้ตัวอย่างข้อมูลขนาด 46- ไบต์ต่อไปนี้ ก็ถือว่าnอยู่ด้านบนของสแต็คที่ใช้งานกับม.หนึ่งลงถัดไปและแทนที่ด้วยn mod เมตร มันทำให้ส่วนที่เหลือของกองเหมือนเดิม

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

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

. n m;
({}(<>))<>
{   . m; r 0   (r = n - km)
    (({}))
    . m m; r 0
    {({}[()])<>}
    {}
}
m-n%m-1 m; . 0
{}<>([{}()]{})
. n%m;

Push-Pop Redundancy

นี่เป็นเรื่องใหญ่ นอกจากนี้ยังเป็นบิตที่เหมาะสมยิ่ง

แนวคิดก็คือว่าถ้าคุณผลักดันบางสิ่งและจากนั้นเปิดมันโดยไม่ทำอะไรเลยคุณไม่ควรผลักมันเลย

ตัวอย่างเช่นถ้าคุณต้องการย้ายบางสิ่งบางอย่างไปยัง offstack แล้วเพิ่มเข้าไปคุณอาจเขียนรหัสต่อไปนี้:

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

สิ่งนี้ง่ายกว่านี้:

({}<>())

โปรแกรมแรกหยิบรายการที่ย้ายมันหยิบขึ้นมาอีกครั้งและเพิ่มหนึ่งในขณะที่รายการที่สองทำทั้งสองอย่างในบัดดล

ตัวอย่างนั้นง่าย แต่มันก็ซับซ้อนขึ้นมาก ยกตัวอย่างเช่น

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

การลดลงจะชัดเจนน้อยลง แต่สามารถลดป๊อปที่ 4 ในโปรแกรมได้ด้วยการกดครั้งที่ 2 เช่น:

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

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

เพิ่มประสิทธิภาพจำนวนเต็มของคุณ

จำนวนเต็มน่าเบื่อที่จะแสดงใน Brain-Flak โชคดีที่เรามีคำถามที่จะช่วยGolf a Brain-Flak Integerให้คุณ (โปรดทราบว่าคำถามได้รับการออกแบบมาเพื่อส่งจำนวนเต็มไปยังสแต็กดังนั้นความซ้ำซ้อนของป๊อปอัปอาจนำไปใช้กับโปรแกรมที่สมจริงยิ่งขึ้น)

ดันเคาน์เตอร์วนพิเศษ

บ่อยครั้งที่คุณต้องการทำสิ่งที่ชอบ

ดำเนินการXกับทุกองค์ประกอบในสแต็ก

หรือ

ดำเนินการXกับทุกคู่ขององค์ประกอบที่อยู่ติดกันในสแต็ก

เมื่ออินพุตอาจมี '0 หรือผลลัพธ์ของการดำเนินการXอาจให้ 0 นี่เป็นสิ่งที่ไม่สะดวกจริงๆ เพราะคุณจะต้องทำ:

([])
{

  {}

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

}

เมื่อต้องการทำXให้กับแต่ละองค์ประกอบแล้วหลังจากนั้น

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

เพื่อย้อนกลับอาร์เรย์อีกครั้ง

แม้เลวถ้าเรา operatiing อยู่ในคู่ขององค์ประกอบที่อยู่ติดกันเราจะต้องทำในสถานที่ของ([][()]) ([])สิ่งนี้ไม่สะดวกจริงๆ นี่คือเคล็ดลับ: ในขณะที่คุณกำลังทำXแต่ละองค์ประกอบผลักดัน1X(element)มากกว่าบนสลับสแต็คที่เหมาะสมดังกล่าวข้างต้น จากนั้นในขณะที่คุณย้อนกลับไปคุณสามารถทำได้

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

นี่คือ 8 ไบต์ที่สั้นลงดังนั้นเมื่อคุณคำนึงถึงรหัสพิเศษที่จะผลัก 1 คุณจะสิ้นสุดการบันทึก 4-6 ไบต์ สำหรับตัวอย่างที่เป็นรูปธรรมมากขึ้นให้เปรียบเทียบงานในการรับ deltas ของอาร์เรย์ หากไม่มีเคล็ดลับนี้คุณจะต้อง:

([][()]){

    {}

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

    ([][()])

}{}{}<>

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

สำหรับ 62 ด้วยเคล็ดลับนี้คุณจะมี

([][()]){

    {}

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

    ([][()])

}{}{}<>

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

สำหรับ 58. ถ้าใช้วิธีที่ถูกต้อง (ตัวอย่างเช่นการย้อนกลับก่อนและลบสองสิ่งใน([][()])ภายหลัง) สิ่งนี้สามารถบันทึกได้มากขึ้นในสถานการณ์จำลอง

ใช้ประโยชน์จาก nilad 'ความสูงสแต็ค'

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

งาน Let 's ผ่านนี้กับความท้าทายสมมุติ: CATเอาท์พุท วิธีที่ไม่ใช่กอล์ฟคือการใช้นักกอล์ฟจำนวนเต็มออนไลน์เพื่อผลัก 67, 65 และ 84 สิ่งนี้ให้:

(((((()()()()){}){}){}()){}())

(((((()()()()){}){}){}){}())

((((((()()()){}()){}){})){}{})

(ขึ้นบรรทัดใหม่เพื่อความชัดเจน) นี่คือ 88 ไบต์และไม่ใช่ว่ายอดเยี่ยม หากเราผลักดันความแตกต่างติดต่อกันระหว่างค่าเราสามารถประหยัดได้มาก ดังนั้นเราจึงห่อจำนวนครั้งแรกในการผลักดันการโทรและลบที่ 2:

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

จากนั้นเราจะใช้รหัสนี้ห่อมันในการผลักดันการโทรและเพิ่ม 19 ไปที่สิ้นสุด:

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

นี่คือ 62 ไบต์สำหรับสนามกอล์ฟขนาด 26 ไบต์!

ตอนนี้ที่นี่คือที่ที่เราจะได้ใช้ประโยชน์จาก nilad ความสูงของสแต็ค เมื่อถึงเวลาที่เราจะเริ่มต้นผลักดัน 19 เรารู้ว่ามีอยู่แล้ว 2 รายการในกองจึงจะประเมิน[] 2เราสามารถใช้สิ่งนี้เพื่อสร้าง 19 ในไบต์ที่น้อยลง วิธีที่ชัดเจนคือการเปลี่ยนภายในเพื่อ()()() ()[]วิธีนี้ช่วยได้เพียงสองไบต์เท่านั้น ด้วยการแก้ไขเพิ่มเติมบางอย่างปรากฎว่าเราสามารถผลัก 19 ด้วย

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

นี่ช่วยเราได้ 6 ไบต์ ตอนนี้เราลดเหลือ 56

คุณสามารถเห็นเคล็ดลับนี้ถูกใช้อย่างมีประสิทธิภาพมากกับคำตอบเหล่านี้:

• สวัสดีชาวโลก V1

• สวัสดีชาวโลก V2

• Magic The Gathering, Friends หรือ Foe

• เอาท์พุทที่ขาดหายไปจำนวนเต็ม

• Diagonal Alphabet (ส่วนตัวที่ฉันชอบ)

ใช้วิกิ

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

วนซ้ำดีกว่า

นี่เป็นวิธีง่ายๆ:

โครงสร้างที่ค่อนข้างธรรมดาคือ:

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

คุณต้องการวนซ้ำ n ครั้ง แต่ยังคงเก็บ n ไว้ อย่างไรก็ตามสิ่งนี้สามารถเขียนเป็น:

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

เพื่อบันทึก 2 ไบต์

กระบวนทัศน์ที่พบได้ทั่วไปอีกอย่างหนึ่งก็คือ

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

ซึ่งจะวนซ้ำและสะสมทั้งกอง เนื่องจากคณิตศาสตร์แฟนซีบางอย่างนี้เป็นเช่นเดียวกับ:

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

ตรวจสอบเนกาทีฟของคุณ

บางครั้งคุณสามารถตีกอล์ฟได้ไม่กี่ไบต์โดยเลือกกลยุทธ์ที่จะคัดค้านโมนา[...]ด

ตัวอย่างง่ายๆคือในที่ซ้อนกัน[...]s ยกตัวอย่างเช่น[()()()[()()]]อาจเป็นเพียงแค่[()()()]()()

สมมติว่าคุณต้องการตรวจสอบว่าค่าเป็นหนึ่งในวงเล็บเริ่มต้น(<{[หรือไม่ ความพยายามครั้งแรกคือการผลักดันความแตกต่างระหว่างตัวละครแต่ละตัวและวนรอบการลบ

({}<(((((       #Push the differences between start bracket characters
(((()()()()){}){}){})   #Push 32
[()])                   #Push 31
[((()()())()){}{}])     #Push 20
){})><>)                #Push 40
<>({<(([{}]<>{}))>(){[()](<{}>)}<>})

อย่างไรก็ตามคุณสามารถบันทึก 4bytes ได้โดยการกดความแตกต่างของเวอร์ชันเชิงลบแทน!

({}<(((((       #Push the differences between start bracket characters
((([()()()()]){}){}){}) #Push -32
())                     #Push -31
((()()())()){}{})       #Push -20
){})><>)                #Push -40
<>({<(({}<>{}))>(){[()](<{}>)}<>})

โดยทั่วไปแล้วสิ่งนี้ไม่ได้ช่วยให้คุณประหยัดมากนัก แต่มันก็มีความพยายามเพียงเล็กน้อยที่จะเปลี่ยนแปลงสิ่ง[...]รอบตัว ระวังสถานการณ์ที่คุณสามารถกดลบตัวนับแทนค่าบวกเพื่อบันทึกในการเพิ่มขึ้นหลาย ๆ ครั้งแทนที่จะลดลงในภายหลัง หรือสลับ(a[b])กับ([a]b)เพื่อสร้างความแตกต่างระหว่างตัวเลขสองตัวเป็นลบแทนที่จะเป็นบวก