ตีกอล์ฟให้คุณอย่างดีเยี่ยม!

204

โดยใช้ภาษาที่คุณเลือกกอล์ฟควิน

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

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

ไม่มีข้อผิดพลาด - มีการคัดแยกข้อผิดพลาดอยู่แล้ว

คะแนนสำหรับ:

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

Stack Snippet ต่อไปนี้สามารถใช้เพื่อรับมุมมองอย่างรวดเร็วของคะแนนปัจจุบันในแต่ละภาษาและเพื่อให้ทราบว่าภาษาใดมีคำตอบที่มีอยู่และเป้าหมายที่คุณต้องเอาชนะ:

แสดงตัวอย่างรหัส

code-golf  quine 
— Rafe Kettler
แหล่งที่มา
4
คุณไม่ได้หมายความว่า"คุณเป็นกอล์ฟที่ดีสำหรับคุณ!"?
— Mateen Ulhaq
50
@muntoo มันเล่นบน "เรียนรู้คุณ Haskell สำหรับดีมาก"
— Rafe Kettler

คำตอบ:

106

Hexagonyความยาวด้าน17 16, 816 705 ไบต์

180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.

ลองออนไลน์!

นี่คือสิ่งที่ดูเหมือนว่ากางออก:

                1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
               8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
              3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
             1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
            2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
           8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
          5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
         0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
        3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
       5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
      3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
     8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
    8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
   1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
  0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
 " . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
  . . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
   . " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
    . . . . . . . . . . . . . . . . . . . . < . " . . . . .
     " . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
      . . . . . . . = . = . . . . . . . _ . < . " . . . .
       . " . " . > . > . ; . ' . = . : . \ . > . . . . .
        . . . . . . . . . . . . . . . . . . < . " . . .
         " . " . > . \ . ' . % . ' . < . # . > . . . .
          . . . . . . . . . . . _ . . . . . < . " . .
           . " . " . > . # . # . > . < . # . > . . .
            . . . . . . . . . . . . = . = . < . " .
             " . " . > . # . \ . ' . R . / . > . .
              . . . . . . . . . . . . . . . < . "
               . ! . . . . . . . . . . . / . > .
                . . . . . . . . . . . . . . . .

อืมนี่เป็นอารมณ์รถไฟเหาะ ... ฉันหยุดนับจำนวนครั้งที่ฉันสลับไปมาระหว่าง "ฮ่าฮ่านี่มันบ้า" และ "รอถ้าฉันทำสิ่งนี้มันน่าจะทำได้จริง" ข้อ จำกัด ที่บังคับใช้กับรหัสโดยกฎการจัดวางของ Hexagony คือ ... รุนแรง

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

อย่างน้อยฉันก็พิสูจน์แล้วว่าเป็นไปได้ ...

สคริปต์ CJam บางตัวสำหรับการอ้างอิงในอนาคตของฉัน:

— Martin Ender
แหล่งที่มา
51
เรียน pete สิ่งนี้คืออะไร
— Conor O'Brien
2
ใช้เวลานานแค่ไหนในการทำสิ่งนี้?
— Adnan
3
@AndN ฉันได้เล่นกับแนวคิดสำหรับ "แม่แบบ" ทั่วไปตั้งแต่เมื่อวานนี้แล้ว (ที่ไม่เกี่ยวข้องกับการทดสอบจริง ๆ ... แค่พิมพ์บางสิ่งในตารางขนาด 7x7 และดูว่ามันอาจใช้งานได้หรือไม่ .. ฉันอาจทิ้งวิธีครึ่งโหลไปแล้วที่นั่น) การเข้ารหัสที่เกิดขึ้นจริงแล้วเอาตอนเย็นนี้ ... อาจจะ 3 ชั่วโมงฉันจะบอกว่า
— Martin Ender
10
คำพูดไม่สามารถอธิบายได้ว่าฉันประหลาดใจอย่างไรเมื่อเห็นสิ่งนี้ในการดำเนินการกับขั้นตอน IDE แบบลึกลับทีละขั้นตอน ... สำหรับผู้ที่อาจต้องการที่จะเข้าใจสิ่งนี้ Hexagon นี้เข้ารหัสส่วน "ถอดรหัส" เป็นจำนวนเต็มซึ่งพิมพ์ด้วย!แล้ว มิรเรอร์/ในบรรทัดสุดท้ายที่ 2 มันจะเข้าสู่ตัวถอดรหัสเพื่อพิมพ์รหัสตัวถอดรหัสเพื่อให้ quine เสร็จสมบูรณ์ สิ่งนี้มีการใช้ที่น่าอัศจรรย์<และ>อ่านจำนวนเต็มใหญ่มากและสร้างพื้นที่สำหรับจัดเก็บตัวถอดรหัส ฉันชอบที่จะรู้ว่าสิ่งที่ "นับสิบแนวทาง" กำลังพิจารณา?
— Sunny Pun
3
คำอธิบาย? ---
— MD XF
77

MySQL, 167 ตัวอักษร

SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));

ถูกตัอง. :-)

ฉันเขียนสิ่งนี้ด้วยตัวเองจริงๆ ตอนแรกมันถูกโพสต์ในเว็บไซต์ของฉัน

— TehShrike
แหล่งที่มา
72

GolfScript 2 ไบต์

1

(ขึ้นบรรทัดใหม่ตามบันทึกย่อ) ข้อความนี้จะส่งหมายเลข 1 ไปยังสแต็ก ในตอนท้ายของโปรแกรม GolfScript จะพิมพ์รายการทั้งหมดในสแต็ก (โดยไม่มีการเว้นวรรค) จากนั้นพิมพ์บรรทัดใหม่

นี่คือควินจริง (ตามที่ระบุไว้ในคำถาม) เพราะจริง ๆ แล้วรันรหัส; ไม่ใช่แค่ "อ่านไฟล์ต้นฉบับและพิมพ์" (ไม่เหมือนกับการส่ง PHP)

ตัวอย่างอื่น ๆ นี่คือโปรแกรม GolfScript ที่จะพิมพ์12345678:

9,(;
  1. 9: กด 9 ไปที่สแต็ก
  2. ,: ใช้ 9 เป็นอาร์กิวเมนต์ผลักอาร์เรย์[0 1 2 3 4 5 6 7 8]ไปที่สแต็ก
  3. (: ใช้อาร์เรย์เป็นอาร์กิวเมนต์ผลักอาร์เรย์[1 2 3 4 5 6 7 8]และรายการ0ไปยังสแต็ก
  4. ;: ทิ้งรายการบนสุดของสแต็ก

[1 2 3 4 5 6 7 8]สแต็คในขณะนี้มีอาร์เรย์ สิ่งนี้ถูกเขียนไปยังเอาต์พุตมาตรฐานโดยไม่มีช่องว่างระหว่างอิลิเมนต์ตามด้วย newline

— Chris Jester-Young
แหล่งที่มา
18
หรือ PowerShell หรือ PHP :-)
— Joey
6
คุณไม่ได้ย้อนเวลากลับไปและให้แนวคิดแก่นักประดิษฐ์ในการประดิษฐ์ GolfScript ใช่ไหม
— Mateen Ulhaq
78
ในทางเทคนิค1ไม่ใช่ quine ใน GolfScript: มันจะแสดงผล1\nโดยที่\nบรรทัดใหม่จะแสดง อย่างไรก็ตามโปรแกรมสองถ่าน1\n เป็นควิน
— Ilmari Karonen
17
โปรแกรมหนึ่งตัวที่\nอาจจะเป็นยัง?
— ลินน์
10
@Peudonym a quine เป็นโปรแกรมที่พิมพ์แหล่งข้อมูลของตัวเอง ฉันไม่คิดว่าจะมีข้อ จำกัด ใด ๆ เกี่ยวกับ "โครงสร้าง"
— Hugo Zink
71

Brain-Flak , 9.8e580 1.3e562 9.3e516 12818 11024 4452 4332 4240 4200 4180 3852 3656 3616 3540 2485 + 3 = 2488 ไบต์

ตอนนี้เหมาะในจักรวาลที่สังเกตได้!

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

ลองออนไลน์!

คำอธิบาย

Quine นี้ทำงานเหมือน Quines ส่วนใหญ่ในภาษาที่ลึกลับ มันมีสองส่วนเข้ารหัสและถอดรหัส ตัวเข้ารหัสเป็นวงเล็บทั้งหมดที่จุดเริ่มต้นและตัวถอดรหัสเป็นส่วนที่ซับซ้อนมากขึ้นในตอนท้าย

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

อย่างไรก็ตามโปรแกรมนี้ไม่ได้ มันขึ้นอยู่กับความจริงที่ว่าโปรแกรม Brain-Flak นั้นมีความสมดุลในการเข้ารหัสวงเล็บปีกกา 8 ตัวด้วยตัวเลขสูงถึง 5 มันเข้ารหัสพวกเขาดังต่อไปนี้

(       -> 2
<       -> 3
[       -> 4
{       -> 5
),>,],} -> 1

วงเล็บปีกกาปิดทั้งหมดถูกกำหนด 1 เนื่องจากเราสามารถใช้บริบทเพื่อกำหนดว่าต้องใช้วงเล็บใดในสถานการณ์เฉพาะ นี่อาจฟังดูเป็นงานที่น่ากลัวสำหรับโปรแกรม Brain-Flak แต่มันไม่ได้เป็นเช่นนั้น ยกตัวอย่างเช่นการเข้ารหัสต่อไปนี้ด้วยการเปิดวงเล็บปีกกาถอดรหัสและวงเล็บปิดปิดแทนที่ด้วย.:

(.
((..
<([.{...

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

คำอธิบายระดับต่ำ

กำลังดำเนินการ

— Sriotchilism O'Zaic
แหล่งที่มา
25
ฉันคิดว่าคุณชนะการแก้ปัญหาที่ยาวที่สุดสำหรับการแข่งขันกอล์ฟ
— Mego
18
เพิ่งสร้างสนามกอล์ฟที่ใหญ่ที่สุดในประวัติศาสตร์ของ PPCG Nope 9.8e580ยังคงน่าประทับใจอยู่ดี
— Dennis
19
+1 สำหรับการปรับให้เข้ากับจักรวาลที่สังเกตได้ นอกจากนี้ด้วย TIO Nexus ความคิดเห็นควรจะพอดีกับคำตอบ tio.run/nexus/…
— Dennis
3
... สนามกอล์ฟที่ใหญ่มาก ...
— เลมอนที่ถูกทำลายได้
3
ฉันคิดว่าคุณชนะส่วนใหญ่ถูกตัดออก
— Christopher
68

โหมโรง , 5157 4514 2348 1761 1537 664 569 535 423 241 214 184 178 175 169 148 142 136 133 ไบต์

ขอบคุณ Sp3000 สำหรับการบันทึก 3 ไบต์

นี่ค่อนข้างนาน ... (โอเคมันก็ยังยาว ... อย่างน้อยมันก็เต้นBrainfuck C # quine ที่สั้นที่สุดที่รู้จักกันในความท้าทายนี้) แต่มันเป็นควินแรกที่ฉันค้นพบตัวเอง เทคนิคควินมาตรฐานเป็นภาษาอื่น ๆ ) และเท่าที่ฉันรู้ว่าไม่มีใครได้เขียนควินในพรีลูดมาก่อนดังนั้นฉันจึงค่อนข้างภาคภูมิใจในเรื่องนี้ :)

7( -^^^2+8+2-!( 6+ !
  ((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)

ตัวเลขจำนวนมากนั้นเป็นเพียงการเข้ารหัสของรหัสหลักซึ่งเป็นเหตุผลว่าควินินนั้นยาวมาก

ตัวเลขที่เข้ารหัสได้ถูกสร้างขึ้นด้วยสคริปต์ CJamนี้

สิ่งนี้ต้องการล่ามที่สอดคล้องกับมาตรฐานซึ่งพิมพ์อักขระ (ใช้ค่าเป็นรหัสอักขระ) ดังนั้นถ้าคุณกำลังใช้ล่ามหลามNUMERIC_OUTPUT = Falseคุณจะต้องตั้ง

คำอธิบาย

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

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

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

การเข้ารหัส

เนื่องจากรหัสมีเพียงสองเสียงและและ adjacency เป็นรอบ^และvมีความหมายเหมือนกัน นั่นเป็นสิ่งที่ดีเพราะvมีรหัสตัวอักษรที่ใหญ่ที่สุดดังนั้นการหลีกเลี่ยงโดยการใช้รหัส^ทำให้การเข้ารหัสง่ายขึ้น ตอนนี้รหัสอักขระทั้งหมดอยู่ในช่วง 10 ถึง 94 รวมแล้ว ซึ่งหมายความว่าฉันสามารถเข้ารหัสอักขระแต่ละตัวด้วยเลขทศนิยมสองหลัก มีปัญหาอย่างหนึ่งคือ: ตัวละครบางตัวโดยเฉพาะอย่างยิ่ง linefeed มีศูนย์ในการแทนทศนิยมของพวกเขา นั่นเป็นปัญหาเนื่องจากศูนย์ไม่สามารถแยกความแตกต่างได้ง่ายจากด้านล่างของสแต็ก โชคดีที่การแก้ไขนั้นง่าย: เราชดเชยรหัสตัวอักษรด้วย2ดังนั้นเราจึงมีช่วงตั้งแต่ 12 ถึง 96 โดยรวมซึ่งยังคงพอดีกับตัวเลขทศนิยมสองหลัก ตอนนี้ของตัวละครทั้งหมดที่สามารถปรากฏในโปรแกรม Prelude0มี 0 ในการเป็นตัวแทน (50) แต่เราไม่ต้องการ0เลย นั่นคือการเข้ารหัสที่ฉันใช้ผลักตัวเลขแต่ละตัว

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

...9647344257

แยกออกเป็นคู่ ๆ แล้วย้อนกลับจากนั้นลบสองตัวออกแล้วค้นหารหัสอักขระ:

57 42 34 47 96
55 40 32 45 94
 7  (     -  ^

ที่32สอดคล้องกับช่องว่าง แกนกลางทำการแปลงนี้อย่างแน่นอนแล้วพิมพ์อักขระ

หลัก

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

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

7(
  (                   )43... encoding ...57)

อันดับแรกเราผลักดัน7เสียงแรก - หากเราไม่ทำเช่นนี้เราจะไม่เข้าสู่ลูป (สำหรับโครงกระดูกเป็นสิ่งสำคัญเท่านั้นที่นี่ไม่ใช่ศูนย์ ... เพราะเหตุใด7เราจึงเห็นเฉพาะในภายหลัง) . จากนั้นเราเข้าสู่วงหลัก ตอนนี้เสียงที่สองมีวงอื่น ในการผ่านครั้งแรกการวนซ้ำนี้จะถูกข้ามเนื่องจากสแต็กที่สองว่างเปล่า / มีเพียง 0 วินาที ดังนั้นเราจึงกระโดดไปที่การเข้ารหัสและผลักดันตัวเลขเหล่านั้นทั้งหมดลงบนสแต็ก 7เราผลักลงบนกองแรกที่ยังคงมีอยู่ดังนั้นซ้ำห่วง

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

ต่อไปให้ดูที่วงแรกในแกนที่แท้จริง ทำสิ่งต่าง ๆ พร้อมกับ(หรือ)ค่อนข้างน่าสนใจ ฉันได้ทำเครื่องหมายร่างกายห่วงที่นี่ด้วย=:

-^^^2+8+2-!
(#^#(1- )#)
 ==========

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

ดังนั้นเราเริ่มต้นด้วยซิงเกิ้ล-ซึ่งเปลี่ยน7สแต็กแรกเป็น-7... อีกครั้งมากขึ้นในภายหลัง สำหรับวงที่เกิดขึ้นจริง ...

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

^^^
#^#

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

ตอนนี้เรากู้คืนรหัสอักขระจากตัวเลขสองหลัก:

2+8+2-!
(1- )#

ด้านล่างเป็นลูปขนาดเล็กที่ลดค่าตัวเลข 10 หลักเป็นศูนย์ สำหรับการวนซ้ำแต่ละครั้งเราต้องการเพิ่ม 10 ขึ้นไปด้านบน จำไว้ว่าอันแรก2ไม่ได้เป็นส่วนหนึ่งของลูปดังนั้นร่างกายลูปจึง+8+2เพิ่ม 10 (โดยใช้การ2กดก่อนหน้านี้) และการผลักอีก 2 ดังนั้นเมื่อเราทำกับลูปแล้วสแต็กแรกจะมีฐาน - 10 คุ้มค่าและอีก 2 เราลบที่ 2 กับบัญชีสำหรับการชดเชยในการเข้ารหัสและพิมพ์ตัวอักษรด้วย- เพียงเหลือใช้ศูนย์ในตอนท้ายของห่วงด้านล่าง!#

เมื่อลูปนี้เสร็จสมบูรณ์สแต็กที่สองจะว่างเปล่าและสแต็กแรกจะเก็บตัวเลขทั้งหมดในลำดับย้อนกลับ (และ a -7ที่ด้านล่าง) ส่วนที่เหลือค่อนข้างง่าย:

( 6+ !
8(1-)8)#

นี่คือลูปที่สองของคอร์ซึ่งตอนนี้พิมพ์กลับตัวเลขทั้งหมด ในการทำเช่นนั้นเราต้องมีตัวเลข 48 หลักเพื่อให้ได้รหัสอักขระที่ถูกต้อง เราทำสิ่งนี้ด้วยการวนรอบแบบง่าย ๆ ที่รัน8ครั้งและเพิ่ม6ในแต่ละครั้ง ผลลัพธ์จะถูกพิมพ์ด้วย!และ8ท้ายที่สุดจะทำซ้ำในครั้งถัดไป

แล้วเรื่อง-7อะไรล่ะ ใช่ซึ่งเป็นรหัสอักขระของ48 - 7 = 41 )มายากล!

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

— Martin Ender
แหล่งที่มา
1
— Robert Fraser
19
มาร์ตินคุณต้องหยุดที่ไหนซักแห่ง
— seequ
3
ฉันชอบที่นี่มีสนามกอล์ฟรวมมากกว่า 5,000 ไบต์รวมทั้งได้รับทราบถึง Sp3000 สำหรับการบันทึก 3 อย่าง
— Kamil Drakari
2
@KamilDrakari นั่นเป็น 3 ไบต์สุดท้ายแม้ว่าจะเป็นเรื่องใหญ่ ;)
— Martin Ender
57

Hexagonyความยาวด้าน 11, 314 ไบต์

164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q

ลองออนไลน์!

รุ่นเก่ากว่า:

Hexagonyความยาวด้าน 11, 330 ไบต์

362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/

ลองออนไลน์!

Encoder: ลองออนไลน์!

โปรแกรมเทียบเท่ากับรหัส Python นี้โดยประมาณ: ลองออนไลน์!

รหัสที่ยังไม่เปิดเผย:

           3 6 2 0 0 3 5 1 1 5 5
          3 4 2 0 9 6 1 4 2 3 7 6
         6 2 6 1 4 2 6 2 5 2 5 3 9
        0 4 8 6 3 6 5 2 3 9 5 9 4 6
       8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
      0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
     4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
    4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
   5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
  . / : { ; + ' = 1 P ' % ' a { : . . \ .
 . . . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . . . \ 
   . . . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . . . \     
       . . . . . . . . . . . . . . \      
        . . . . . . . . . . . . . \       
         ! $ > < . . . . . . . . \        
          . . @ > { ? 2 ' % < . .         
           . . . . : ; ; 4 Q / .

สอง.s ใช้เวลา 1 บิต อักขระอื่น ๆ ใช้เวลา 1 บิตและหลัก -97 หลัก

คำอธิบาย

คลิกที่ภาพเพื่อดูขนาดที่ใหญ่ขึ้น แต่ละส่วนของคำอธิบายมีรหัส Python ที่สอดคล้องกันเพื่อช่วยให้เข้าใจ

ส่วนข้อมูล

แทนการใช้โครงสร้างที่ซับซ้อนในบางคำตอบอื่น ๆ (มี<, "และบางสิ่งอื่น ๆ ) ผมเพียงแค่ให้ IP ผ่านครึ่งล่าง

ข้อมูล

อันดับแรก IP ทำงานผ่านตัวเลขจำนวนมากและไม่มีตัวเลือก ( .) และมิเรอร์ ( \) แต่ละหลักจะต่อท้ายตัวเลขในหน่วยความจำดังนั้นในที่สุดค่าของหน่วยความจำจะเท่ากับจำนวนที่จุดเริ่มต้นของโปรแกรม

mem = 362003511...99306179

! พิมพ์มัน

stdout.write(str(mem))

และกระโดดผ่านต่อไป$>

<เริ่มต้นจาก หากค่าหน่วยความmemจำเป็นเท็จ ( <= 0เช่นเงื่อนไขmem > 0ไม่เป็นที่พอใจ) เราได้พิมพ์โปรแกรมเสร็จแล้วและควรออก IP จะติดตามเส้นทางบน

ทางออก

(ปล่อยให้ IP วิ่งไปทั่วโลกประมาณ 33 คำสั่งก่อนที่จะกดปุ่ม@(ซึ่งจะยุติโปรแกรม) เพราะวางไว้ที่อื่นจะมีบางไบต์เพิ่ม)

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

# Python                    # Hexagony
# go to memory cell (a)     # {
a = 2                       # ?2
# go to memory cell (b)     # '
b = mem % a                 # %

ตอนนี้หน่วยความจำมีลักษณะดังนี้:

Mem1

หากค่าเป็นจริง:

if b > 0:

รหัสต่อไปนี้จะถูกดำเนินการ:

# Python                    # Hexagony
b = ord('Q')                # Q
b = b*10+4                  # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256))    # ;
stdout.write(chr(b%256))    # ;

ดูคำอธิบายรายละเอียดของQ4ที่MartinEnder คำตอบของ ในระยะสั้นรหัสนี้พิมพ์.สองครั้ง

เดิมทีฉันวางแผนว่าจะพิมพ์.ครั้งเดียว เมื่อฉันมากับสิ่งนี้ (พิมพ์.สองครั้ง) และนำไปใช้งานจะมีการบันทึกข้อมูลประมาณ 10 หลัก

จากนั้น

b = mem // a                # :

นี่คือความจริงสำคัญที่ฉันรู้ว่าช่วยชีวิตฉันไว้ประมาณ 14 หลัก: คุณไม่จำเป็นต้องอยู่ตรงจุดเริ่มต้น

เพื่อให้เข้าใจสิ่งที่ฉันกำลังพูดขอให้มีการเปรียบเทียบ BF (ข้ามสิ่งนี้หากคุณเข้าใจแล้ว)

รับรหัส

while a != 0:
    b, a = a * 2, 0
    a, b = b, 0
    print(a)

สมมติว่าเราปล่อยให้aเป็นค่าของเซลล์ปัจจุบันและbเป็นค่าของเซลล์ด้านขวาการแปลตรงไปตรงมาเพื่อ BF คือ:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
    >[-<+>]       # a, b = b, 0
    <.            # print(a)
]

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

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
                  # implicitly let (a) be at the position of (b) now
    .             # print(a)
]

ซึ่งสั้นกว่าหลายไบต์

นอกจากนี้พฤติกรรมการห่อมุมยังช่วยฉันจากการมี\กระจกอยู่ที่นั่นด้วย - ถ้าไม่มีฉันจะไม่สามารถใส่ตัวเลข (+2 หลักสำหรับ\ตัวเองและ +2 ตัวเลขสำหรับการจับคู่.ทางด้านขวาของมันไม่ต้องพูดถึง ธง)

(รายละเอียด:

  • IP เข้าสู่มุมซ้ายล่างมุ่งหน้าไปทางซ้าย
  • มันบิดเบี้ยวไปที่มุมขวายังคงหัวซ้าย
  • มันเผชิญหน้ากับสิ่ง\ที่สะท้อนออกมาตอนนี้มันหันไปทางขวา
  • มันจะเข้ามุมแล้วบิดงออีกครั้งไปที่มุมล่างซ้าย

)

หากค่า (ของการดำเนินการ mod 2 ด้านบน) เป็นเท็จ (ศูนย์) จากนั้นเราจะปฏิบัติตามเส้นทางนี้:

# Python                 # Hexagony   # Memory visualization after execution
b = mem // a             # :          # click here
base = ord('a') # 97     # a
y = b % base             # '%
offset = 33              # P1
z = y + offset           # ='+
stdout.write(chr(z))     # ;          # click here
mem = b // base          # {:         # click here

ผมจะไม่อธิบายรายละเอียดมากเกินไปที่นี่ แต่ชดเชยเป็นจริงไม่ว่า33แต่สอดคล้องกันพอควร33 256และมีนัยchr% 256

— user202729
แหล่งที่มา
3
ชายนั่นเป็นจำนวนมากที่ไม่มี ops
— Jo King
26
ฉันหัวเราะที่ "เพื่อให้เข้าใจสิ่งที่ฉันกำลังพูดขอให้มีการเปรียบเทียบ [BrainFuck]" เฉพาะใน PPCG ... :)
— ลินน์
2
ฉันเลื่อนเหมือน 3 ครั้งขึ้นไปด้านบนของคำตอบเพื่อ upvote มันเท่านั้นที่จะพบว่าฉันได้ทำไปแล้ว ...
— NieDzejkob
2
310 bytesโดยการใช้ประโยชน์จากพื้นที่ใหม่จากการย่อจำนวน
— Jo King
2
308 ไบต์โดยใช้พื้นที่มากขึ้น
— โจคิง
46

เป็นกลุ่ม 11 ไบต์

q"iq"qP<Esc>hqP
  • iq"qP<Esc>: แทรกข้อความที่ซ้ำกันด้วยตนเองที่ต้องอยู่นอกการบันทึก
  • q"และhqP: บันทึกภายในลงใน""ทะเบียนที่ไม่มีชื่อโดยตรงเพื่อให้สามารถวางตรงกลางได้ นี่hเป็นเพียงการเปลี่ยนตำแหน่งที่จำเป็นเท่านั้น หากคุณวางไว้ในแมโครจะถูกวางลงในผลลัพธ์

แก้ไข

ข้อควรทราบเกี่ยวกับการบันทึกด้วยq": การลงทะเบียนที่ไม่มีชื่อ""เป็นเรื่องตลก มันไม่ใช่การลงทะเบียนที่แท้จริงเหมือนคนอื่น ๆ เนื่องจากข้อความไม่ได้ถูกเก็บไว้ที่นั่น จริงๆแล้วมันเป็นตัวชี้ไปยังรีจิสเตอร์อื่น ๆ (โดยปกติแล้วจะ"-เป็นการลบโดยไม่มีการขึ้นบรรทัดใหม่, "0สำหรับการกระชากหรือ"1การลบด้วยการขึ้นบรรทัดใหม่) q"ทำลายกฎ; "0มันจริงเขียนไป หากคุณ""ได้แล้วชี้ไปที่ลงทะเบียนอื่น ๆ กว่าบาง"0, q"จะเขียนทับ"0แต่ปล่อย""ไม่เปลี่ยนแปลง เมื่อคุณเริ่ม Vim ใหม่ให้""ชี้ไปที่โดยอัตโนมัติ"0ดังนั้นคุณจะไม่เป็นไรในกรณีนั้น

โดยทั่วไป Vim นั้นแปลกและบั๊กกี้

— udioica
แหล่งที่มา
เดี๋ยวก่อนว่าทำไมถึงใช้งานไม่ได้สำหรับฉัน
— เลมอนที่สามารถทำลายได้
@DestructibleWatermelon ไม่สามารถพูดได้อย่างแน่นอน แต่มีคำอธิบายอย่างหนึ่งที่เป็นไปได้มากที่สุด น่าจะเป็นไปได้ในบทความก่อนหน้านี้เพราะมันสามารถสลัดคน อ่านการแก้ไข
— udioica
คุณอาจจะต้องเตรียมบางสิ่งบางอย่างเกี่ยวกับวิธีกดyหรือสิ่งใดก่อนที่จะวิ่ง
— มะนาวที่ถูกทำลายได้
ทำไมคุณไม่ใช้␛เพื่อแสดงการกดปุ่ม <Esc> ส่วนหนึ่งของUnicode บล็อก“ รูปภาพควบคุม”
— mbomb007
4
@ mbomb007 <Esc>สัญกรณ์เป็นมาตรฐานในการจับคู่ Vim ( :help <>) และนั่นคือสิ่งที่ vimgolf.com ใช้ นักท่องเว็บที่มีประสบการณ์จะถูกนำไปใช้อ่าน สำหรับยูนิโค้ดฉันต้องเหล่อ่านตัวอักษรเล็ก ๆ และพวกเขาปิดบังวิธีการพิมพ์และค้นหาไฟล์ช่วยเหลือ
— udioica
44

Cubix , 20 ไบต์

3434Qu$v@!<"OOw\o;/"

เกือบจะได้ \o/ ...

สุทธิ :

    3 4
    3 4
Q u $ v @ ! < "
O O w \ o ; / "
    . .
    . .

ลองออนไลน์

ลองที่นี่ !

หมายเหตุเพิ่มเติม

เรื่องราวความเป็นมา

หลังจากประทับใจในการอ่านคำตอบที่ยอดเยี่ยมนี้โดย @ ais523 ฉันเริ่มคิดเกี่ยวกับการตีกอล์ฟควินินเพิ่มเติม ท้ายที่สุดก็มีไม่กี่ตัวเลือกในนั้นและที่ไม่รู้สึกบีบอัดมาก อย่างไรก็ตามในขณะที่เทคนิคการใช้คำตอบของเขา (และของฉันเช่นกัน) ต้องใช้รหัสเพื่อขยายสายเต็มรูปแบบจำเป็นต้องมีการบันทึกอย่างน้อย 12 ไบต์ มีคำอธิบายหนึ่งในคำอธิบายของเขาที่ทำให้ฉันคิดว่าจริง ๆ :

ในเรื่องของการเล่นกอล์ฟลงควินนี้ต่อไป [... ] มันต้อง [... ] วิธีอื่นเพื่อเป็นตัวแทนของใบหน้าด้านบนของลูกบาศก์ [... ]

ทันใดนั้นเมื่อฉันยืนขึ้นและเดินออกไปหาอะไรดื่มมันทำให้ฉัน: ถ้าโปรแกรมไม่ได้ใช้รหัสตัวอักษร แต่เป็นตัวเลขแทนใบหน้าด้านบน? นี่คือสั้นโดยเฉพาะอย่างยิ่งถ้าจำนวนที่เราพิมพ์มี 2 หลัก Cubix มี 3 คำแนะนำแบบหนึ่งไบต์สำหรับการกดตัวเลขสองหลัก: N, SและQ, ซึ่ง10, 32และ34ตามลำดับ, ดังนั้นนี่ควรจะค่อนข้างกอล์ฟ, ฉันคิดว่า

ความซับซ้อนครั้งแรกของแนวคิดนี้คือใบหน้าด้านบนเต็มไปด้วยตัวเลขที่ไร้ประโยชน์ดังนั้นเราจึงไม่สามารถใช้สิ่งนั้นได้อีก ภาวะแทรกซ้อนที่สองคือใบหน้าด้านบนมีขนาดซึ่งเป็นขนาดลูกบาศก์กำลังสองและมันจำเป็นต้องมีขนาดที่เท่ากันมิฉะนั้นหมายเลขหนึ่งจะจบลงที่ตำแหน่งเริ่มต้นของตัวชี้คำแนะนำ เนื่องจากความยุ่งเหยิงเหล่านี้รหัสของฉันจำเป็นต้องพอดีกับลูกบาศก์ขนาด 2 (ซึ่งอาจมีเพียง 24 ไบต์เท่านั้น 'ดังนั้นฉันจึงต้องออกกอล์ฟอย่างน้อย 21 ไบต์) นอกจากนี้เนื่องจากใบหน้าด้านบนและด้านล่างใช้ไม่ได้ฉันมีเพียง 16 ไบต์ที่มีประสิทธิภาพ

ดังนั้นฉันจึงเริ่มต้นด้วยการเลือกหมายเลขที่จะกลายเป็นครึ่งหนึ่งของใบหน้าด้านบน ฉันเริ่มด้วยN(10) แต่นั่นก็ไม่ได้ผลนักเพราะฉันใช้วิธีพิมพ์ทุกอย่าง ฉันเริ่มต้นใหม่และใช้S(32) ด้วยเหตุผลบางอย่าง นั่นก็ส่งผลให้เป็น quine ที่เหมาะสมหรือดังนั้นฉันคิดว่า มันทำงานได้ดีมาก แต่คำพูดนั้นหายไป จากนั้นมันเกิดขึ้นกับฉันว่าQ(34) จะมีประโยชน์จริงๆ ท้ายที่สุด 34 คือรหัสอักขระของเครื่องหมายคำพูดคู่ซึ่งช่วยให้เราสามารถเก็บไว้ในสแต็คประหยัด (2 ในรูปแบบที่ฉันใช้แล้ว) ไบต์ที่มีค่า หลังจากที่ฉันเปลี่ยนเส้นทาง IP เล็กน้อยสิ่งที่เหลืออยู่คือการออกกำลังกายเพื่อเติมในช่องว่าง

มันทำงานอย่างไร

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

ขั้นตอนที่ 1: การพิมพ์ใบหน้าด้านบน

คำแนะนำที่ไม่เกี่ยวข้องถูกแทนที่ด้วย no-ops ( .) IP เริ่มบรรทัดที่สามทางซ้ายมือชี้ไปทางตะวันออก สแต็คว่างเปล่า (ชัด)

    . .
    . .
Q u . . . . . .
O O . . . . . .
    . .
    . .

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

QOO
Q   # Push 34 (double quotes) to the stack
 OO # Output twice as number (the top face)

สแต็กมีเพียง 34 แสดงถึงอักขระตัวสุดท้ายของแหล่งที่มา

ขั้นตอนที่ 2: เข้ารหัสบรรทัดที่สี่

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

อย่างมีประสิทธิภาพ IP ได้ย้ายหนึ่งตำแหน่งไปทางซ้ายและตอนนี้สแต็กมีการแสดงบรรทัดที่สี่ในรหัสอักขระและลำดับย้อนกลับ

ขั้นตอนที่ 3: ดันข้อความอ้างอิงอีกอัน

เราจำเป็นต้องผลักดันการเสนอราคาอีกครั้งและจะมีวิธีไหนที่ดีไปกว่าการรีไซเคิลโปรแกรมQตอนเริ่มต้นโปรแกรมด้วยการเข้าใกล้จากทางขวา? นี่เป็นโบนัสเพิ่มเติมที่ IP จะเข้าสู่เครื่องหมายคำพูดที่เข้ารหัสบรรทัดที่สามโดยตรง

นี่คือเวอร์ชั่นสุทธิสำหรับขั้นตอนนี้ การเปลี่ยนแปลงที่ไม่เกี่ยวข้องถูกแทนที่ด้วย no-op อีกครั้งไม่มีการใช้งานที่ถูกดำเนินการถูกแทนที่ด้วยแฮชแท็ก ( #) เพื่อวัตถุประสงค์ในการแสดงภาพประกอบและ IP เริ่มต้นที่อักขระสุดท้ายของบรรทัดที่สี่

    . .
    . .
Q u $ . . . . .
. . w \ . . / .
    . #
    . #

IP สิ้นสุดที่บรรทัดที่สามในคำสั่งแรกจะตัดไปจนสุดบรรทัดนั้นเนื่องจากมันชี้ไปทางทิศตะวันตก คำแนะนำต่อไปนี้ (ไม่รวมโฟลว์ควบคุม) ถูก excecuted:

$uQ
$u  # Don't do anthing
  Q # Push the double quote

เครื่องหมายคำพูดคู่นี้แทนหนึ่งในตอนท้ายของบรรทัดที่สาม

ขั้นตอนที่ 4: การเข้ารหัสบรรทัดที่สาม

สิ่งนี้ทำงานเหมือนกับขั้นตอนที่ 2 ดังนั้นโปรดดูคำอธิบายที่นั่น

ขั้นตอนที่ 5: พิมพ์สแต็ก

สแต็กตอนนี้มีบรรทัดที่สี่และสามในลำดับย้อนกลับดังนั้นสิ่งที่เราต้องทำตอนนี้มันพิมพ์ IP เริ่มต้นที่คำสั่งสุดท้ายในบรรทัดที่สามเคลื่อนไปทางตะวันตก นี่คือส่วนที่เกี่ยวข้องของคิวบ์ (อีกครั้งชิ้นส่วนที่ไม่เกี่ยวข้องถูกแทนที่ด้วย no-ops)

    . .
    . .
. . . v @ ! < .
. . . \ o ; / .
    . .
    . .

นี่คือการวนซ้ำตามที่คุณอาจเห็น / คาดหวัง ตัวหลักคือ:

o;
o  # Print top of stack as character
 ; # Delete top of stack

ลูปจะสิ้นสุดลงหากไอเท็มด้านบนเป็น 0 ซึ่งจะเกิดขึ้นเมื่อสแต็กว่างเปล่าเท่านั้น หากลูปสิ้นสุดการ@ดำเนินการจะสิ้นสุดลงโปรแกรม

— ลุค
แหล่งที่มา
หวังว่าฉันจะสามารถ
— โหวตได้
ยินดีต้อนรับเงินรางวัลเสมอ ;-)
— ลูกา
42

Javascript ES6 - 21 ไบต์

$=_=>`$=${$};$()`;$()

ฉันเรียกสิ่งนี้ว่า "The Bling Quine"

บางครั้งคุณต้องเล่นกอล์ฟอย่างมีสไตล์

— Mama Fun Roll
แหล่งที่มา
ไม่!$=_=>`!$=${$}()`()ช่วยให้คุณประหยัด 2 ไบต์?
— Downgoat
Invalid assignment left hand side. หวังว่ามันจะทำงานได้ :(
— Mama Fun Roll
1
@ TùxCräftîñgการกำจัดวงเล็บรอบตัวอักษรแม่แบบใช้งานได้กับฟังก์ชันต้นแบบดั้งเดิมArray.prototype.joinเท่านั้น
— Mama Fun Roll
2
อืมไม่แน่ใจ ฉันเขียนสิ่งนี้ในช่วงหนึ่งปีที่ผ่านมา (ถือว่าใช้ได้แล้ว) และฉันไม่ได้ติดตามการเปลี่ยนแปลงกฎอย่างใกล้ชิดเกินไป อย่างไรก็ตามการเพิ่มalertหรือconsole.logหลังฟังก์ชั่นลูกศรและการตัดสตริงแม่แบบในวงเล็บจะใช้งานได้
— Mama Fun Roll
3
นอกจากนี้ถ้าคุณเรียกใช้สิ่งนี้ใน concole มันจะเขียนทับ $ (ฟังก์ชัน jQuery) บนไซต์นี้และฟังก์ชัน upvote จะไม่ทำงานอีกต่อไป :)
— Steven Palinkas
41

Brainf * ck (755 ตัวอักษร)

นี่เป็นพื้นฐานของเทคนิคที่พัฒนาโดย Erik Bosman (ejbosman ที่ cs.vu.nl) โปรดทราบว่า "Quine ของ ESultanik!" ข้อความเป็นสิ่งจำเป็นจริง ๆ เพื่อให้เป็น quine!

->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
— ESultanik
แหล่งที่มา
13
นั่นเป็นวิธีที่ฉลาดที่จะทำ
— Peter Olson
13
มันทำงานยังไง?
— ภูมิใจ haskeller
3
@proudhaskeller IIRC ส่วนก่อนESultanik's Quine!ตั้งค่าหน่วยความจำเป็นการเข้ารหัสแบบสแต็กESultanik's Quine!และเป็นต้นไปโดยมีหน่วยความจำสองไบต์สำหรับอักขระแต่ละตัว (ค่า ASCII ออฟเซ็ตจาก 0x1F) บิตสุดท้ายของลูปจะผ่านหน่วยความจำก่อนอื่นโดยการสร้าง++>+++…โค้ดสำหรับแต่ละอักขระจากนั้นทำการพิมพ์อักขระ
— ESultanik
4
@CatsAreFluffy พวกเขาจะต้องเป็น quine! ในขณะที่มันเป็นความจริงที่ว่าพวกเขาสามารถลบออกได้หนึ่งก็จะต้องเปลี่ยนรหัสก่อนหน้าเพื่อรักษาคุณสมบัติควิน
— ESultanik
1
นั่นเป็นเรื่องจริง รวมถึงการขึ้นบรรทัดใหม่ด้วย
— CalculatorFeline
36

Hexagonyความยาวด้านข้าง15 14 13 12, 616 533 456 383 ไบต์

หลังจากเล่นกอล์ฟมาหลายวันอย่างระมัดระวังการจัดเรียงลูปและเริ่มต้นใหม่ในที่สุดฉันก็สามารถทำให้มันลงไปในรูปหกเหลี่ยม 12 ด้าน

1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>

ลองออนไลน์!

กางออก:

            1 8 4 5 7 1 1 7 2 4 0 0
           4 9 9 4 0 1 7 6 6 0 7 4 5
          3 2 4 8 0 0 7 8 3 5 4 2 8 1
         0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
        3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
       6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
      5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
     8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
    3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
   5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
  9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
           ! ' < . \ = 6 , ' / > . .
            . . . . . . . . . . . .

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

คำอธิบาย

นี่เป็นการเต้นคำตอบ Hexagony ก่อนหน้าโดยการเข้ารหัส no-ops ( .) ในวิธีที่ต่างออกไป ในขณะที่คำตอบนั้นประหยัดพื้นที่ด้วยการทำให้ตัวละครทุกตัวเป็น.ของฉัน, ฉันเข้ารหัสจำนวนของไม่มีตัวละคร นอกจากนี้ยังหมายถึงแหล่งที่มาไม่จำเป็นต้องถูก จำกัด

นี่ผมใช้การเข้ารหัสฐาน 80 ซึ่งตัวเลขกว่า 16 บ่งชี้ถึงการวิ่งไม่มี Ops และตัวเลขระหว่างวันที่ 16 และ 79 แทนช่วง 32 ( !) ถึง 95 ( _) (ฉันเพียงแค่ตอนนี้ฉันตระหนักถึงความแข็งแรงเล่นกอล์ฟทุก_ท่านออกจากฉัน โค้ด lol) บาง Pythonic pseudocode:

i = absurdly long number
print(i)
base = 80
n = i%base
while n:
    if n < 16:
        print("."*(16-n))
    else:
        print(ASCII(n+16))
    i = i//base
    n = i%base

หมายเลขจะถูกเข้ารหัสในครึ่งแรกของรูปหกเหลี่ยมโดยมีทั้งหมด 

" " > 
 " " > 
  ... etc

ทางด้านซ้ายและ

 > ,
< "
 >
< "
... etc

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

จากนั้นจะเข้าสู่ส่วนด้านล่างผ่าน->:

       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
     ->    ! ' < . \ = 6 , ' / > . .

!พิมพ์หมายเลขและ'นำทางไปยังเซลล์หน่วยความจำด้านขวาก่อนเริ่มการวนซ้ำ P='%mods หมายเลขปัจจุบันโดย 80 หากผลเป็น 0 แล้วขึ้นไปยังยุติ@อื่นลงไปและสร้างเซลล์ที่ติดกับผล mod -16ด้วยค่า

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
                      /
                     /

ตั้งค่าเซลล์เป็น (mod value + -16) หากค่านั้นเป็นลบให้ขึ้นไปที่การแตกแขนง>+'\มิฉะนั้นลงไป

หากค่าเป็นบวก:

 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .

ตัวชี้จะจบลงที่การ;-<ตั้งค่าเซลล์เป็น (ค่า mod - -16) และพิมพ์

ค่าเป็นลบ:

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .

ลงไปที่> ) <ส่วนที่เริ่มวนซ้ำ นี่มันโดดเดี่ยว:

     . . > ) < $ = < . .
      . . . . . . . . .
       \ ' Q 4 ; = " /

ซึ่งประมวลผลโค้ด'Q4;="=ที่พิมพ์.(ขอบคุณอีกครั้งกับ Martin Ender ผู้เขียนโปรแกรมเพื่อค้นหาชุดตัวเลขและตัวอักษรสำหรับอักขระ) และย้ายกลับไปที่เซลล์เริ่มต้น จากนั้นจะเพิ่มขึ้น ( )) เซลล์ค่า mod และวนซ้ำอีกครั้งจนกว่าค่า mod จะเป็นค่าบวก

เมื่อดำเนินการเสร็จแล้วจะมีการเลื่อนขึ้นและเชื่อมต่อกับส่วนอื่น ๆ ที่:

 " " > . / < $ ; - < . . .
            \
             \

ตัวชี้จะเดินทางกลับไปที่จุดเริ่มต้นของการวนซ้ำขนาดใหญ่อีกครั้ง

 " " > . / <--
  . . . = =
   . " " > ' 
    . . . = = 
     . " " > :
      . . . . .
       " " > \ ' . .
        . . . . . . .
         . . " " > P = ' % < . > . . .

วิธีนี้จะดำเนินการ='=:'ซึ่งแบ่งจำนวนปัจจุบัน 80 และนำทางไปยังเซลล์ที่ถูกต้อง

รุ่นเก่า (ความยาวด้าน 13)

343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""

ลองออนไลน์!

ฉันสามารถตีกอล์ฟอีกด้านหนึ่งได้อย่างแน่นอนที่สุด แต่ฉันจะต้องทิ้งมันไว้ในวันพรุ่งนี้เพราะมันจะสาย ปรากฎว่าฉันเป็นคนใจร้อนและแทบรอไม่ไหวในวันพรุ่งนี้ บางทีอีกด้านหนึ่งสามารถเล่นกอล์ฟได้? :( ahhhhhhhhhฉันทำมันแล้ว!

ฉันเล่นกอล์ฟถึงสองหลักด้วยการเข้ารหัส 77 ฐาน แต่มันก็ไม่สำคัญเพราะมันมีจำนวนเดียวกัน

— โจคิง
แหล่งที่มา
13
มันอัศจรรย์มาก. แนวคิดสำหรับการเข้ารหัสแบบรันไทม์แบบไฮบริดนี้เป็นระเบียบจริงๆ :) เตือนฉันให้มอบรางวัลให้คุณถ้าฉันลืม
— Martin Ender
35

PostScript 20 ตัวอักษร

สั้นและถูกกฎหมาย 20 ตัวอักษรรวมถึงการขึ้นบรรทัดใหม่

(dup == =)
dup == =
— KirarinSnow
แหล่งที่มา
33

Cubix , 45 ไบต์

.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"

คุณสามารถทดสอบโค้ดนี้ที่นี่

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

      . . .
      . . >
      . . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
      . . .
      . . .
      . . .

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

ต่างจาก Befunge แต่เราใช้สี่สายตรงนี้แทนที่จะเป็นหนึ่งสาย นี่คือวิธีที่พวกเขาถูกผลักไปยังกองซ้อน;

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

  2. uคำสั่งไม่กลับไปทางขวาเพื่อให้สิ่งต่อไปที่เรากำลังทำงานจาก'"นี้เป็นต้นไปในสายกลาง ที่ผลัก a "ลงบนสแต็ก ล้อมรอบอย่างต่อเนื่องเราตี<ใกล้ด้านซ้ายมือของลูกบาศก์และย้อนกลับ เมื่อเข้าใกล้จากทิศทางนี้เราจะเห็น"คำสั่งธรรมดาไม่ใช่'"ดังนั้นทั้งบรรทัดที่สองจะถูกส่งไปยังสแต็กข้างหลังเหนือบรรทัดที่สามและเครื่องหมายคำพูดคู่

  3. เราเริ่มต้นด้วยการกด a !ลงบนสแต็ก ( '!) และเพิ่มมัน ( )); สิ่งนี้สร้างอัญประกาศคู่โดยไม่จำเป็นต้องมีเครื่องหมายคำพูดคู่ในซอร์สโค้ดของเรา (ซึ่งจะยุติสตริง) มิเรอร์ ( \) สะท้อนทิศทางการดำเนินการขึ้นไปทางเหนือ จากนั้นWคำสั่งก้าวเท้าซ้ายไปทางซ้าย นี่ทำให้เราขึ้นไปบนคอลัมน์ที่เจ็ดซึ่งเพราะนี่คือลูกบาศก์ล้อมรอบไปทางซ้ายในแถวที่สามจากนั้นลงไปที่คอลัมน์ที่สาม เรากดR, เพื่อเลี้ยวขวาและไปทางซ้ายตามแถวบน; จากนั้น$ข้ามRผ่านทางที่เราเข้าสู่โปรแกรมดังนั้นการประมวลผลจะวนไป"ที่ส่วนท้ายของบรรทัดและเราจับบรรทัดแรกเป็นสตริงแบบเดียวกับที่เราทำในวินาทีและครั้งที่สาม

  4. ^คำสั่งส่งเราขึ้นไปทางเหนือคอลัมน์ที่สิบเอ็ดซึ่งเป็น (เพื่อให้ก้อนห่อ) ไปทางทิศใต้ในห้า สิ่งเดียวที่เราพบคือ!(ข้ามถ้าไม่ใช่ศูนย์; ด้านบนของสแต็กไม่ใช่ศูนย์) ซึ่งข้ามoคำสั่งทำให้คอลัมน์ที่ห้าว่างเปล่าได้อย่างมีประสิทธิภาพ ดังนั้นเราจึงย้อนกลับไปที่uคำสั่งซึ่งกลับมาอีกครั้ง แต่คราวนี้เราเหลือไว้ที่คอลัมน์สุดท้ายทางทิศใต้ซึ่งล้อมรอบคอลัมน์ที่สี่ทางทิศเหนือ เราตีราคาสองครั้งในช่วงการกลับรถดังนั้นเราจึงรวบรวมคอลัมน์ที่สี่ทั้งหมดในสตริงจากล่างขึ้นบน ซึ่งแตกต่างจากคำพูดสองครั้งส่วนใหญ่ในโปรแกรมอันนี้ไม่ได้ปิดตัวเอง แต่เป็นการปิดโดยที่มุมบนขวาหมายความว่าเราจับสตริงเก้าตัวอักษร"...>.....

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

ขั้นตอนต่อไปคือการพิมพ์เนื้อหาของสแต็ค หลังจากผลักทั้งหมดแล้ว IP ก็จะขึ้นไปทางเหนือในคอลัมน์ที่สี่ดังนั้นมันจึงไปถึงจุด>นั้นและเข้าสู่วงที่แน่น>>o;?(เช่น "เลี้ยวไปทางทิศตะวันออกหันไปทางตะวันออกส่งออกเป็นตัวละครป๊อปเลี้ยวขวาถ้าเป็นบวก") เนื่องจากบรรทัดที่เจ็ดเต็มไปด้วย NOP ดังนั้นจึงมีการ?ย้อนกลับไปที่บรรทัดแรก>ดังนั้นสิ่งนี้จึงผลักเนื้อหาทั้งหมดของสแต็คได้อย่างมีประสิทธิภาพ ( ?คือไม่มีการวางบนสแต็กเปล่า) เราเกือบจะพิมพ์โปรแกรมทั้งหมด! น่าเสียดายที่มันยังไม่เสร็จ เราไม่มีเครื่องหมายอัญประกาศคู่ท้าย

เมื่อลูปสิ้นสุดลงเราจะสะท้อนไปยังเส้นกลางเคลื่อนไปทางตะวันตกผ่านกระจกคู่หนึ่ง (เราใช้ "ด้านอื่น ๆ " ของ\กระจกก่อนหน้านี้ตอนนี้เรากำลังใช้ด้านตะวันตกเฉียงใต้/กระจกไม่เคยใช้มาก่อน) เราพบ'!ดังนั้นเราจึงกดเครื่องหมายอัศเจรีย์ (เช่น 33 เราใช้ ASCII และ Cubix ไม่แยกความแตกต่างระหว่างจำนวนเต็มและตัวอักษร) ลงบนสแต็ก (สะดวกนี่คือสิ่งเดียวกัน!ซึ่งใช้ข้ามoคำสั่งก่อนหน้านี้) เราพบคู่ของRคำสั่งและใช้คำสั่งเหล่านั้นเพื่อสร้าง "manual" U-turn ( Rคำสั่งที่สองที่นี่ถูกใช้ก่อนหน้านี้เพื่อเข้าถึงคำสั่งแรก แถวดังนั้นจึงเป็นเรื่องธรรมดามากที่จะติดตั้งRคำสั่งอื่นข้างๆWคำสั่งเพื่อก้าวเท้าเลี่ยงไปทางซ้าย ก้าวเท้าเลี่ยงเกิดปัญหาลงใน>คำสั่งในบรรทัดที่สองโดยการตีกลับการดำเนินการกลับมาที่เดิม ดังนั้นเราก้าวเท้าซ้ายไปทางซ้ายอีกครั้ง แต่คราวนี้เราไปทางทิศใต้ดังนั้นคำสั่งต่อไปที่จะดำเนินการคือ)(เพิ่มเครื่องหมายอัศเจรีย์เป็นเครื่องหมายคำพูดคู่) ตามด้วยo(เพื่อส่งออก) ในที่สุดการดำเนินการจะตัดตามบรรทัดที่แปดไปยังคอลัมน์ที่สองซึ่งพบว่า a @เพื่อออกจากโปรแกรม

ฉันขอโทษสำหรับเครื่องหมายอะพอสโทรฟีที่หลงทางในบรรทัดที่สาม มันไม่ได้ทำอะไรในโปรแกรมเวอร์ชั่นนี้ มันเป็นส่วนหนึ่งของความคิดก่อนหน้านี้ที่ฉันมี แต่ที่กลายเป็นว่าไม่จำเป็น อย่างไรก็ตามเมื่อฉันได้รับ quine ทำงานฉันแค่ต้องการส่งมันมากกว่ายุ่งกับมันโดยเฉพาะอย่างยิ่งการลบมันจะไม่เปลี่ยนจำนวนไบต์ ในเรื่องของการลงเล่นควินนี้ฉันไม่แปลกใจถ้ามันเป็นไปได้ที่ 3 × 3 โดยใช้ห้าบรรทัดแรกเท่านั้น แต่ฉันไม่เห็นวิธีที่ชัดเจนในการทำเช่นนั้นและมันต้องการ แม้การบรรจุที่เข้มงวดของการควบคุมการไหลทั้งหมดพร้อมกับวิธีอื่น ๆ ในการเป็นตัวแทนส่วนบนสุดของคิวบ์ (หรือการแก้ไขอัลกอริทึมเพื่อให้สามารถใช้คอลัมน์ที่สี่ต่อไปได้แม้ว่าตอนนี้จะมีความยาวสิบหรือสิบเอ็ดตัวอักษร) .

เยี่ยมมากนี่เป็นคะแนนที่น่าประทับใจมาก ฉันรักวิธีที่คุณเข้ารหัสใบหน้าส่วนบน :)
— Martin Ender
นี่มันช่างเหลือเชื่อจริงๆ! ถ้ามันจะช่วยใด ๆ วิธีที่จะผลักดันอีกคือ" Q
— ETHproductions
1
ว้าว! ฉันไม่เคยคิดเลยว่าจะได้เห็นคิวบิกควิน!
— FlipTack
3
ฉันไม่มีเวลาอ่านคำอธิบายเมื่อวานนี้ แต่ตอนนี้ฉันมี ... แค่ ... ว้าว ฉันไม่สามารถเชื่อได้ว่ามีการใช้อักขระกี่ตัวสำหรับวัตถุประสงค์ที่แตกต่างกันสองหรือสามอย่าง นี่อาจเป็นโปรแกรม Cubix ที่ยอดเยี่ยมที่สุดเท่าที่ฉันเคยเห็นมา
— ETHproductions
คำอธิบายที่ดี
— Robert Fraser
33

Python 2, 30 ไบต์

_='_=%r;print _%%_';print _%_

ถ่ายจากที่นี่

— hallvabo
แหล่งที่มา
1
+1, คุณเอาชนะโซลูชันที่คล้ายกันของฉันดังนั้นฉันจึงลบมัน ควรสังเกตว่าสิ่งนี้ใช้ได้ใน Python 2 เท่านั้น
— nyuszika7h
2
มันดูแปลกกับชื่อตัวแปร_แต่อ่านได้ดีกว่าถ้าคุณกำหนดมันให้กับจดหมายใด ๆ เช่น s:s='s=%r;print s%%s';print s%s
— Ehtesh Choudhury
5
หากวิธีนี้ไม่ใช่การสร้างของคุณเองคุณควรสร้าง Community Wiki ขึ้นมา นอกจากนี้ลิงค์จะตาย
— mbomb007
1
ฉันมาช้าไปงานปาร์ตี้ แต่มีใครสามารถอธิบายวิธีการทำงานนี้ได้บ้าง
— MadTux
9
สิ่งนี้ต้องการให้ป้อนบรรทัดต่อท้ายถูกต้อง ตามที่เป็นอยู่ซอร์สโค้ดไม่ตรงกับเอาท์พุท
— Dennis
32

เป็นกลุ่ม, 17 , 14 การกดแป้น

มีคนอัปโหลดสิ่งนี้แบบสุ่มดังนั้นฉันจำได้ว่ามันมีอยู่จริง เมื่อฉันอ่านมันอีกครั้งฉันคิดว่า "เฮ้ฉันทำได้ดีกว่านั้น!" ดังนั้นฉันจึงตีสองไบต์ มันยังไม่สั้นที่สุด แต่อย่างน้อยก็เป็นการปรับปรุง

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

ฉันภูมิใจในคำตอบนี้จริงๆเพราะสองข้อแรก :

  1. นี่เป็นควินแรกที่ฉันเคยทำและ

  2. เท่าที่ฉันรู้นี่เป็นvim-quineแรกของโลกที่เคยเผยแพร่! ฉันอาจจะผิดเกี่ยวกับเรื่องนี้ดังนั้นถ้าคุณรู้หนึ่งโปรดแจ้งให้เราทราบ

ดังนั้นหลังจากการแนะนำมานานแล้วนี่มันคือ:

qqX"qpAq@q<esc>q@q

ลองออนไลน์!

โปรดทราบว่าเมื่อคุณพิมพ์ออกมานี้ก็จะแสดงการกดแป้นพิมพ์เป็น<esc> ^[สิ่งนี้ยังคงมีความถูกต้องเนื่องจากการ^[แสดงหมายถึง0x1Bซึ่งหลบหนีใน ASCIIและวิธีที่เสียงเรียกภายในแทน<esc>กุญแจสำคัญ

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

vim -u NONE -N -i NONE

หรือพิมพ์qqqก่อนใช้งาน

คำอธิบาย:

qq                  " Start recording into register 'q'
  X                 " Delete one character before the cursor (Once we play this back, it will delete the '@')
   "qp              " Paste register 'q'
      Aq@q<esc>     " Append 'q@q' to this line
               q    " Stop recording
                @q  " Playback register 'q'

ในหมายเหตุด้านคำตอบนี้น่าจะเป็นสถิติโลกสำหรับส่วนใหญ่ 'q ในคำตอบ PPCG หรืออะไร

— DJMcMayhem
แหล่งที่มา
1
2i2i<esc>อยู่ใกล้ ฉันรู้สึกว่าต้องมีสิ่งที่ฉันสามารถทำได้เพื่อให้งานนี้
— Zwei
@zwei ฉันรู้ว่ามันใกล้จะเจ็บแล้ว! ที่จริงแล้ว<Esc>เป็นนัยใน V เพื่อว่างาน น่าเสียดายที่มันเพิ่มบรรทัดใหม่ด้วยซึ่งเป็นสาเหตุที่ฉันยังไม่ได้โพสต์
— DJMcMayhem
q"iq"qbP<Esc>qbPคือ 11 หลังจากที่คุณใส่สิ่งนี้ในredditฉันตรวจสอบ vimgolfing ที่นี่และตัดสินใจที่จะทำบัญชี นี่คือคำตอบที่ฉันโพสต์ที่นั่น
— udioica
2
@udioica คุณสามารถโพสต์สิ่งนั้นเป็นคำตอบได้หรือไม่?
— DJMcMayhem
28

Lost , 120 116 98 96 76 70 66 ไบต์

แก้ไข: ใช่ต่ำกว่า 100

แก้ไข: บันทึกจำนวนไบต์เป็นไบต์โดยสลับไป/ที่บรรทัดล่างสุด

:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////

ลองออนไลน์! + การตรวจสอบกำหนดขึ้นสำหรับทุกรัฐที่เป็นไปได้

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

คำอธิบาย:

/s ทั้งหมดที่อยู่ด้านล่างบรรทัดจะอยู่ที่นั่นเพื่อให้แน่ใจว่าตัวชี้ทั้งหมดที่วางไข่ในทิศทางแนวตั้งหรือบนบรรทัดล่างรับ funneled ในทิศทางที่ถูกต้อง จากนั้นพวกเขาก็จบลงในสถานที่ที่แตกต่างกัน แต่พวกเขาทั้งหมดจบลงด้วยการเข้าสู่

 ^%?>
 ////

ซึ่งจะลบตัวเลขที่ไม่ใช่ศูนย์ทั้งหมดในสแต็ก ([หลังจากที่ล้างออก 0s พิเศษใด ๆ เช่นกัน

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

จากนั้นจะเป็นการเขียนภาษาสองมิติแบบง่าย ๆ โดยการใส่ตัวอักษรสตริง ( ") รอบ ๆ บรรทัดแรกผลัก"อักขระโดยการเว้นวรรค ( :2+) และการขึ้นบรรทัดใหม่ ( 52*) สำหรับบรรทัดที่สองมันจะสร้าง/ตัวละคร ( 95*2+) และทำซ้ำมันเป็นพวง ( >::1?:[:[[[[) ก่อนที่จะสิ้นสุดที่@และการพิมพ์สแต็กโดยปริยาย การ?1หยุดกระบวนการไม่ให้สร้าง 0s มากเกินไปถ้าตัวชี้เข้ามาก่อนกำหนดประหยัดไม่ต้องล้างค่าในภายหลัง

ฉันบันทึก 20 ไบต์ที่นี่ด้วยการทำให้บรรทัดสุดท้ายมีตัวละครเหมือนกันทั้งหมดซึ่งหมายความว่าฉันสามารถเปลี่ยนจากการทำ@ซ้ำไปสู่ตอนจบได้

คำอธิบายเกี่ยวกับกระบวนการดักจับ:

[เป็นตัวละครที่รู้จักกันในชื่อ 'ประตู' หากตัวชี้ไปทางด้านข้างของ a [หรือ a ]มันจะสะท้อนกลับไปทางอื่น ทุกครั้งที่ตัวชี้โต้ตอบกับประตูมันจะสลับไปเป็นประเภทตรงกันข้าม การใช้ความรู้นี้เราสามารถสร้างสูตรอย่างง่ายสำหรับจำนวนครั้งที่คำสั่งจะดำเนินการใน>:[บล็อก

เพิ่มจำนวนเริ่มต้นของคำแนะนำ สำหรับแต่ละ[คำสั่งให้เพิ่มจำนวนคำสั่งทางซ้าย 2 เท่า ตัวอย่างเช่น>::::[:[[[เราเริ่มต้นด้วย 5 เป็นจำนวนเริ่มต้น ประตูแรกมีคำแนะนำ 4 ตัวเพื่อให้เราเพิ่ม 4 * 2 = 8 ถึง 5 เพื่อรับ 13 ส่วนอีกสามประตูมี 5 เสียงทางซ้ายดังนั้นเราเพิ่ม 3 * (5 * 2) = 30 ถึง 13 เพื่อรับ 43 ดำเนินการตามคำแนะนำของ dupe และมี 44 >วินาทีบนสแต็ก กระบวนการเดียวกันนี้สามารถนำไปใช้กับคำแนะนำอื่น ๆ เช่น(การผลักรายการจำนวนมากจากสแต็กไปยังขอบเขตหรือตามที่ใช้ที่นี่เพื่อล้างรายการจากสแต็ก

เคล็ดลับที่ฉันใช้ที่นี่เพื่อหลีกเลี่ยงการทำ1?ซ้ำ0s มากเกินไปคือ หากอักขระเป็น 0 อักขระ?จะไม่ข้าม 1 ซึ่งหมายความว่าอักขระนั้นซ้ำซ้อน 1 สำหรับส่วนที่เหลือของ dupe นี้จะทำให้มันมากง่ายต่อการล้างสแต็คในภายหลัง

— โจคิง
แหล่งที่มา
25

นี่คือquines Ruby ที่สั้นที่สุดสองตัวจาก SO :

_="_=%p;puts _%%_";puts _%_

และ

puts <<2*2,2
puts <<2*2,2
2

อย่าถามฉันว่าวิธีที่สองทำงานอย่างไร ...

— Nakilon
แหล่งที่มา
8
คนที่สองใช้ heredoc <<2เริ่มต้นสตริงในบรรทัดถัดไปและ*2ทำซ้ำสตริง
— Ming-Tang
ทำไมคุณถึงต้องการ 2
— CalculatorFeline
1
@CalculatorFeline มันเป็นตัวยุติของสตริง heredoc (ซึ่งจะต้องปรากฏในบรรทัดของตัวเอง) ไม่จำเป็นต้องเป็น 2: tio.run/##KypNqvz/v6C0pFjBxsZAy0jHgAuFY8D1/z8A
— Martin Ender
25

ฟิชชัน 6 ไบต์

ปรากฏว่าตอนนี้เป็นควิน "เหมาะสม" สั้นที่สุดในบรรดาคำตอบเหล่านี้ 

'!+OR"

คำอธิบาย

การควบคุมการไหลเริ่มต้นที่อะตอมRขวาไป(1,0)เดียว มันกระทบการ"สลับโหมดการพิมพ์จากนั้นล้อมรอบบรรทัดการพิมพ์'!+ORก่อนที่จะกดปุ่มเดียวกัน"อีกครั้งและออกจากโหมดการพิมพ์

ที่ปล่อยให้"ตัวเองถูกพิมพ์ วิธีที่สั้นที่สุดคือ'"O(ซึ่ง'"ทำให้มวลของอะตอมเป็นรหัสตัวอักษร"และOพิมพ์ตัวละครและทำลายอะตอม) แต่ถ้าเราทำสิ่งนี้"มันจะรบกวนโหมดการพิมพ์ ดังนั้นแทนที่จะเราตั้งค่าอะตอมที่จะ'!(น้อยกว่า") แล้วเพิ่มขึ้นด้วย+และจากนั้นOพิมพ์ผลกับ

ทางเลือก

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

8 ไบต์โดยใช้Jump

' |R@JO"

Rอีกครั้งรหัสเริ่มต้นที่ มวลแลกเปลี่ยนและพลังงานที่จะให้@ (0,1)ดังนั้นJทำให้กระโดดอะตอมมากกว่าตรงไปยังO "จากนั้นเหมือนก่อนหน้าทั้งหมดยกเว้น"จะถูกพิมพ์ในโหมดสตริง หลังจากนั้นอะตอมฮิต|ที่จะกลับทิศทางของมันแล้วผ่านการพิมพ์'"O "พื้นที่นั้นค่อนข้างน่ารำคาญ แต่ดูเหมือนว่าจำเป็นเพราะมิฉะนั้น'จะทำให้อะตอมปฏิบัติต่อ|ตัวละครแทนที่จะเป็นกระจก

8 ไบต์โดยใช้สองอะตอม

"'L;R@JO

นี้มีสองอะตอมเริ่มซ้ายไปจากขวาไปจากL Rอะตอมซ้ายจะได้รับค่าที่กำหนดจาก'"นั้นพิมพ์ด้วยทันทีO(และอะตอมถูกทำลาย) สำหรับอะตอมที่ถูกต้องเราจะสลับมวลและพลังงานอีกครั้งข้ามOไปที่ส่วนที่เหลือเพื่อพิมพ์รหัสในโหมดการพิมพ์ หลังจากนั้นค่าของมันจะถูกกำหนดโดยแต่ไม่เป็นไรเพราะอะตอมจะถูกยกเลิกแล้วด้วย'L;

— Martin Ender
แหล่งที่มา
เทคนิคไม่ถูกต้องเนื่องจากขาดการแยกรหัส / ข้อมูลในแหล่งที่มา
— CalculatorFeline
4
@CalculatorFeline ถอดรหัส'!+ "
— Martin Ender
ฉันไม่คุ้นเคยกับฟิชชัน แต่จะได้|R@JO"'ผลหรือคุณยังต้องการพื้นที่นั้นหลังจาก'?
— MildlyMilquetoast
1
@MistahFiggins ฉันคิดอย่างนั้น แต่ที่สำคัญคุณต้องพิมพ์'ครั้งแรก
— Martin Ender
24

จาวาสคริปต์ข้ามเบราว์เซอร์ (41 ตัวอักษร)

มันทำงานได้ในเว็บเบราว์เซอร์ 5 อันดับแรก (IE> = 8, Mozilla Firefox, Google Chrome, Safari, Opera) ใส่ลงในคอนโซลของผู้พัฒนาในหนึ่งในนั้น:

eval(I="'eval(I='+JSON.stringify(I)+')'")

ไม่ใช่ "การโกง" - ไม่เหมือนกับ quine ไบต์เดี่ยวของ Chris Jester-Young เนื่องจากสามารถแก้ไขได้อย่างง่ายดายเพื่อใช้alert()ฟังก์ชัน (ราคา 14 ตัวอักษร):

alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))

หรือแปลงเป็น bookmarklet (ราคา 22 ตัวอักษร):

javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
— PleaseStand
แหล่งที่มา
24

C, 64 60 ไบต์

main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}

จนถึงตอนนี้เป็นควินซีที่รู้จักกันสั้นที่สุด มีเงินรางวัลเพิ่มหากคุณพบว่ามีจำนวนน้อยกว่า

ใช้งานได้ในGCC , ClangและTCCในสภาพแวดล้อมPOSIX มันเรียกใช้พฤติกรรมที่ไม่ได้กำหนดจำนวนมากเกินไปกับพวกเขาทั้งหมด

เพื่อความสนุกนี่คือrepoที่บรรจุควินส์ C ทั้งหมดที่ฉันรู้จัก รู้สึกอิสระที่จะแยก / ประชาสัมพันธ์ถ้าคุณค้นหาหรือเขียนสิ่งที่แตกต่างซึ่งเพิ่มสิ่งใหม่และสร้างสรรค์เหนือสิ่งที่มีอยู่เดิม

โปรดทราบว่าใช้งานได้ในสภาพแวดล้อมASCIIเท่านั้น นี้ทำงานสำหรับEBCDICแต่ยังคงต้องPOSIX ขอให้โชคดีในการค้นหาสภาพแวดล้อม POSIX / EBCDIC

มันทำงานอย่างไร:

  1. main(s)ละเมิดข้อโต้แย้งของประกาศตัวแปรmain untyped จริง s(โปรดทราบsว่าไม่ได้พิมพ์จริง แต่เนื่องจากคอมไพเลอร์ในรายการนำแสดงโดยอัตโนมัติตามความจำเป็นจึงอาจเป็น *)
  2. printf(s="..."ชุดสตริงที่มีให้และส่งผ่านอาร์กิวเมนต์แรกsprintf
  3. smain(s){printf(s=%c%s%1$c,34,s);}มีการตั้งค่า
  4. %cถูกตั้งค่าเป็น ASCII ,34 "สิ่งนี้ทำให้ควินเป็นไปได้ ตอนนี้มีลักษณะเช่นนี้s
    main(s){printf(s="%s%1$c,34,s);}
  5. การ%sตั้งค่าเป็นของsตัวเองซึ่งเป็นไปได้เนื่องจาก # 2 ตอนนี้มีลักษณะเช่นนี้s
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}
  6. %1$cถูกตั้งค่าเป็น ASCII 34 ", printf's แรก ** โต้แย้ง ตอนนี้sดูเหมือนว่า:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
    ... ซึ่งเพิ่งเกิดขึ้นเป็นรหัสต้นฉบับ

* ตัวอย่างขอบคุณที่ @Pavel
อาร์กิวเมนต์แรก ** หลังจากระบุรูปแบบ - sในกรณีนี้ ไม่สามารถอ้างอิงตัวระบุรูปแบบได้

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

main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
— MD XF
แหล่งที่มา
แม้ว่ามันจะไม่นับว่าเป็นการแข่งขัน แต่ผู้ชนะของ "การละเมิดกฎที่เลวร้ายที่สุด" จากการประกวดรหัส C ปี 1994 ระหว่างประเทศ Obfuscated, 1994_smr.cนั้นสั้นลงอย่างแน่นอน
— เรย์
@ เรย์ไม่ได้รับอนุญาต มันไม่ได้เป็นควินที่เหมาะสมโดยคำจำกัดความใด ๆ กฎ quien ถูกเปลี่ยนเนื่องจากโปรแกรมดังกล่าว: P
— MD XF
ฉันเห็นด้วยอย่างสิ้นเชิง แต่มันก็เป็นแฮ็คที่น่าสนใจพอสมควรที่จะกล่าวถึงเมื่อใดก็ตามที่มีคนพูดถึงควินินที่รู้จักกันน้อยที่สุดถ้าเพียงเพื่อเหตุผลทางประวัติศาสตร์
— เรย์
4
sเป็นประเภทintไม่ใช่ "ตัวแปรที่ไม่พิมพ์"
— feersum
2
คอมไพเลอร์เหล่านี้เห็นได้ชัดว่าอนุญาตให้มีการแปลงตัวชี้ไปยัง int โดยปริยาย เห็นได้ชัดว่าจะไม่ทำงานเพราะคุณจะต้องผ่านสายสองครั้งเพื่อs=3 printf
— feersum
24

Java, 528 ไบต์:

โซลูชัน Java ด้วยวิธีการดั้งเดิม:

import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}

ในรูปแบบที่อ่านได้:

import java.math.*;
class a
{
    public static void main (String [] a)
    {
        BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36); 
        int i=0; 
        for (byte c:b.toByteArray ())
        {
            if (++i==92) 
                System.out.print (b.toString (36)); 
            System.out.print ((char) c);
        }
    }
}
— ไม่ทราบผู้ใช้
แหล่งที่มา
มันทำงานยังไง?
— Loovjo
1
@ Loovjo: คล้ายกับโซลูชันอื่น ๆ ที่ตัดโค้ดออกเป็นสองส่วนและแทรก String ทั้งหมดซึ่งจะประมวลรหัสภายในอีกครั้ง แต่รหัสทั้งหมดไม่ได้เป็นเพียงสตริง แต่เข้ารหัสเป็นจำนวนยาวในฐาน 36 (26 ตัวอักษรตามตัวอักษร + 10 หลัก)
— ไม่ทราบผู้ใช้
1
ซึ่งอาจจะสั้นลงถ้าคุณใส่if(++i==92),
— tuskiomi
2
@tuskiomi: ขอบคุณย่อมาจากตัวละครสองตัว
— ผู้ใช้ที่ไม่รู้จัก
1
@userunknown ที่จริงแล้วa*ในขณะที่อาร์เรย์ไม่ออกใน Java นั่นคือ C. บางส่วนอื่น ๆ ในการเล่นกอล์ฟ: import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("abc",36);int i=0;for(int c:b.toByteArray())System.out.printf("%s%c",++i==92?b.toString(36):"",c);}}ซึ่งabcจะเป็นจำนวนเวทมนตร์สตริงที่คำนวณใหม่ ใน java 8+ ก็ยังเป็นไปได้ที่จะเปลี่ยนclass a{public static void mainไปinterface a{static void mainและใน Java 10+ มันเป็นไปได้ที่จะมีการเปลี่ยนแปลงimport java.math.*;และการBigInteger b=new BigInteger( var b=new java.math.BigInteger(
— Kevin Cruijssen
23

ไก่ , 7

chicken

ไม่นี่ไม่ได้สะท้อนโดยตรง :)

— Timtech
แหล่งที่มา
Damnit, คุณชนะฉันไป :)
— Taconut
มันไม่ได้สะท้อนมันเป็นสตริงchicken!
— Erik the Outgolfer
ไม่มีการแยกรหัส / ข้อมูลจึงไม่ถูกต้อง
— CalculatorFeline
10
@CalculatorFeline คุณอ่านกฎหรือไม่
— Timtech
1
@ โจกิ้งฉันไม่คิดว่ามันจะไม่ถูกต้องเพราะกฎของการท้าทายห้ามไม่ให้มีความยาวเป็นศูนย์และการโกง (อ่านไฟล์ต้นฉบับของคุณเอง) ควาย สิ่งเดียวที่ห้าม quines ที่ไม่เหมาะสมคือช่องโหว่มาตรฐาน - ยกเว้นช่องโหว่มาตรฐานโดยทั่วไปจะไม่นำมาใช้กับคำตอบที่ลงวันที่ก่อนวันจริง
— pppery
23

Retina , 20 14 9 7 ไบต์

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

ดังนั้นนี่คือหนึ่งที่เหมาะสม:

>\`
>\`

ลองออนไลน์!

อีกวิธีหนึ่งคือเราสามารถใช้แทน;>

คำอธิบาย

โปรแกรมประกอบด้วยการเปลี่ยนครั้งเดียวซึ่งเราพิมพ์สองครั้ง

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

หากต้องการพิมพ์ผลลัพธ์สองครั้งเราจะห่อมันด้วยสองขั้นตอนผลลัพธ์ ด้านใน\พิมพ์ผลลัพธ์ด้วยการป้อนบรรทัดต่อท้ายและด้านนอก>พิมพ์โดยไม่ป้อน

หากคุณคุ้นเคยกับ Retina คุณอาจสงสัยว่าเกิดอะไรขึ้นกับเอาต์พุตโดยนัยของ Retina การส่งออกโดยนัยของ Retina ทำงานโดยการปิดขั้นตอนสุดท้ายของโปรแกรมในขั้นตอนการส่งออก อย่างไรก็ตามจอประสาทตาไม่ได้ทำเช่นนี้หากขั้นตอนสุดท้ายเป็นระยะผลลัพธ์แล้ว เหตุผลที่เป็นเพราะในโปรแกรมปกติมันมีประโยชน์มากกว่าที่จะสามารถแทนที่สเตจเอาท์พุทโดยนัยด้วยสเปเชี่ยลพิเศษเช่นเดียว\หรือส;ต๊อตเดี่ยว (แทนที่จะต้อง.ก น่าเสียดายที่พฤติกรรมนี้จบลงด้วยการคิดต้นทุนสองไบต์สำหรับควินิน

— Martin Ender
แหล่งที่มา
20

Javascript (36 ถ่าน)

(function a(){alert("("+a+")()")})()

นี่คือ AFAICT ซึ่งเป็นจาวาสคริปต์ที่สั้นที่สุดที่โพสต์ไว้

— Peter Olson
แหล่งที่มา
1
นั่น ... น่าประทับใจ คุณควรอธิบายว่ามันทำงานอย่างไรสำหรับฉัน 8- |
— TehShrike
3
@TehShrike คำแนะนำ: คุณสามารถดูเนื้อหาฟังก์ชั่นโดยการบังคับให้มันเป็นสตริง ตัวอย่างเช่นถ้าคุณมีฟังก์ชั่นนี้คุณสามารถเข้าถึงเนื้อหาของมันโดยการเรียกa a.toString
— Peter Olson
7
ถึงจะเป็นเรื่องอื้อฉาวนี่เป็นเพียงข้ออ้างถ้าการใช้จาวาสคริปต์ของคุณทำให้ฟังก์ชั่นaนั้นเป็นแบบเดียวกับที่เขียนไว้ด้านบน อย่างไรก็ตามผลลัพธ์ของรหัสนี้มีแนวโน้มที่จะเป็น quine ในการใช้งาน JavaScript ใด ๆ
— Ilmari Karonen
1
นี่คือควินเดียวกัน 1 !function a(){alert("!"+a+"()")}()ไบต์สั้น:
— Ismael Miguel
1
(a=()=>alert(($ {a})))()
— Dennis C
19

GolfScript ขนาด 8 ไบต์

ฉันคิดเสมอว่า GolfScript quine สั้นที่สุด (จริง) คือ 9 ไบต์:

{'.~'}.~

ตำแหน่งที่จำเป็นในการป้อนบรรทัดต่อท้ายเนื่องจาก GolfScript พิมพ์บรรทัดการป้อนบรรทัดตามค่าเริ่มต้น

แต่ฉันเพิ่งพบ 8 quine quine ซึ่งทำงานตรงกับข้อ จำกัด linefeed นั้น:

":n`":n`

ลองออนไลน์!

ดังนั้นสิ่งที่จับได้คือ GolfScript ไม่พิมพ์ linefeed ที่ต่อท้าย แต่จะพิมพ์เนื้อหาของnเมื่อสิ้นสุดโปรแกรม เป็นเพียงแค่ที่nมี linefeed ที่จะเริ่มต้นด้วย ดังนั้นความคิดคือการแทนที่ด้วยสตริง":n`"และจากนั้น stringifying นั้นเช่นการคัดลอกในกองพิมพ์ด้วยคำพูดและคัดลอกเก็บไว้ในการnพิมพ์โดยไม่ต้อง

ตามที่ Thomas Kwa ชี้ให้เห็นแล้ว Quine CJam ขนาด 7 ไบต์สามารถปรับให้เป็นโซลูชัน 8 ไบต์ได้:

".p"
.p

อีกครั้งเราต้องการตัวป้อนบรรทัดต่อท้าย

— Martin Ender
แหล่งที่มา
6
Golfscript นั้นแปลก
— CalculatorFeline
19

เขาวงกต , 124 110 53 ไบต์

ขอบคุณ Sp3000 สำหรับการเล่นกอล์ฟ 9 ไบต์ซึ่งอนุญาตให้ฉันเล่นกอล์ฟอีก 7 ครั้ง

44660535853919556129637653276602333!
1
:_98
/8 %
@9_.

ลองออนไลน์!

คำอธิบาย

เขาวงกต 101:

  • เขาวงกตเป็นภาษา 2D ตามสแต็ค สแต็กไม่มีก้นลึกและเต็มไปด้วยเลขศูนย์ดังนั้นการ popping จากสแต็กที่ว่างเปล่าไม่ใช่ข้อผิดพลาด
  • การดำเนินการเริ่มต้นจากอักขระที่ถูกต้องตัวแรก (ที่นี่ด้านซ้ายบน) ที่ทางแยกแต่ละแห่งที่มีเส้นทางที่เป็นไปได้สองทางขึ้นไปสำหรับตัวชี้คำสั่ง (IP) ที่จะใช้ด้านบนของสแต็กจะถูกตรวจสอบเพื่อกำหนดตำแหน่งที่จะไปต่อไป ลบคือเลี้ยวซ้ายศูนย์จะไปข้างหน้าและบวกจะเลี้ยวขวา
  • ตัวเลขในรหัสที่มาไม่ได้ผลักดันจำนวนที่สอดคล้องกัน - n*10 + <digit>แทนพวกเขาปรากฏด้านบนของสแต็คและผลักดัน สิ่งนี้ช่วยให้ง่ายต่อการสร้างจำนวนมาก ในการเริ่มหมายเลขใหม่ให้ใช้_ซึ่งจะเพิ่มจำนวนศูนย์
  • " ไม่มีใครรู้

อันดับแรกฉันจะอธิบายเวอร์ชันที่เรียบง่ายกว่าเล็กน้อยอีกต่อไป แต่จะมีความขลังน้อยลง:

395852936437949826992796242020587432!
"
:_96
/6 %
@9_.

ลองออนไลน์!

แนวคิดหลักคือการเข้ารหัสเนื้อหาหลักของแหล่งที่มาในจำนวนเดียวโดยใช้ฐานขนาดใหญ่บางส่วน หมายเลขนั้นสามารถพิมพ์กลับได้ง่ายก่อนที่จะถอดรหัสเพื่อพิมพ์ส่วนที่เหลือของซอร์สโค้ด การถอดรหัสเป็นเพียงแอปพลิเคชั่นที่ทำซ้ำdivmod baseโดยที่จะพิมพ์modและทำงานต่อไปdivจนกว่าจะถึงศูนย์

โดยการหลีกเลี่ยง{}รหัสตัวอักษรสูงสุดที่เราต้องการคือ_(95) ซึ่งฐาน 96 นั้นเพียงพอ (โดยทำให้ฐานต่ำลง ดังนั้นสิ่งที่เราต้องการเข้ารหัสคือ:

!
"
:_96
/6 %
@9_.

เปลี่ยนตัวละครเหล่านั้นให้เป็นรหัสคะแนนและให้ผลเป็นตัวเลขฐาน 96 (ด้วยตัวเลขที่มีนัยสำคัญน้อยที่สุดที่สอดคล้องกับ!และตัวเลขที่มีความสำคัญมากที่สุด.เพราะนั่นเป็นคำสั่งที่เราจะแยกตัวเลข)

234785020242697299628949734639258593

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

395852936437949826992796242020587432!
"

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

แต่ตอนนี้ IP ได้มาถึงจุดจบแล้ว นั่นหมายความว่ามันหมุนไปรอบ ๆ และตอนนี้ย้ายกลับไปทางทิศตะวันตก (โดยไม่ต้องดำเนินการ!อีกครั้ง) เวลานี้สะดวก IP จะอ่านหมายเลขจากด้านหลังไปข้างหน้าดังนั้นตอนนี้ตัวเลขที่อยู่ด้านบนสุดของสแต็กจะเข้ารหัสส่วนที่เหลือของแหล่งที่มา

เมื่อ IP ชนกับมุมบนซ้ายอีกครั้งนี่ไม่ใช่จุดจบเพราะ IP สามารถเลี้ยวซ้ายได้ดังนั้นจึงทำและเคลื่อนที่ไปทางทิศใต้ นี่"คือ no-op ที่เราต้องการที่นี่เพื่อแยกตัวเลขออกจากลูปหลักของโค้ด การพูดที่:

...
"
:_96
/6 %
@9_.

ตราบใดที่ส่วนบนสุดของสแต็กยังไม่เป็นศูนย์ IP จะทำงานผ่านรหัสที่ค่อนข้างหนาแน่นนี้ในลูปต่อไปนี้:

"
>>>v
^< v
 ^<<

หรือวางเชิงเส้น:

:_96%._96/

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

จริง ๆ แล้วรหัสลูปนั้นค่อนข้างตรงไปตรงมา (การบีบอัดมันไม่แน่นหนาและเป็นแหล่งสนับสนุนหลักของ Sp3000):

:    # Duplicate the remaining encoding number N.
_96  # Push 96, the base.
%.   # Take modulo and print as a character.
_96  # Push 96 again.
/    # Divide N by 96 to move to the next digit.

เมื่อถึงNศูนย์การควบคุมการไหลของการเปลี่ยนแปลง ตอนนี้ IP อยากจะย้ายไปข้างหน้าหลังจาก/(เช่นทิศตะวันตก) แต่มีกำแพงอยู่ตรงนั้น ดังนั้นหากเลี้ยวไปทางทิศตะวันออกให้ดำเนินการ6อีกครั้ง ที่ทำให้ด้านบนของสแต็คบวกดังนั้น IP เลี้ยวขวา (ภาคใต้) 9และดำเนินการ ส่วนบนสุดของสแต็กตอนนี้69แต่สิ่งที่เราใส่ใจคือมันเป็นบวก IP เลี้ยวไปทางขวาอีกครั้ง (ตะวันตก) แล้วเคลื่อนที่ไปยังจุด@ที่ยกเลิกรหัส

สรุปแล้วมันค่อนข้างง่ายจริงๆ

โอเคทีนี้เราจะตัดไบท์ตัวอื่นออกไปได้อย่างไร เห็นได้ชัดว่าไม่มี op ดูเหมือนว่าสิ้นเปลือง แต่เราต้องการแถวเพิ่มเติมที่: ถ้าลูปอยู่ติดกับหมายเลข IP จะย้ายไปที่นั่นทันทีแทนที่จะเคลื่อนที่ข้ามจำนวนทั้งหมด ดังนั้นเราสามารถทำสิ่งที่มีประโยชน์กับที่ไม่มี -op

ในหลักการเราสามารถใช้มันเพื่อเพิ่มตัวเลขสุดท้ายลงในการเข้ารหัส การเข้ารหัสไม่ได้จริงๆต้องเป็นทุกอย่างในบรรทัดแรกที่ ... !เพียงเพื่อให้แน่ใจว่าสิ่งที่เป็นนอกจากนี้ยังได้รับการพิมพ์มี

แม้ว่าจะมีการจับเราไม่สามารถทำสิ่งนี้ได้:

95852936437949826992796242020587432!
3
:_96
/6 %
@9_.

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

แต่บางทีเราสามารถเลือกตัวเลขอื่นได้ เราไม่สนใจจริง ๆ ว่ามี3จุดนั้นอยู่หรือไม่ตราบใดที่เราพบตัวเลขที่เข้ารหัสแหล่งข้อมูลอย่างถูกต้อง น่าเสียดายที่ไม่มีตัวเลข 10 หลักที่ให้การเข้ารหัสซึ่งมีตัวเลขที่สำคัญน้อยที่สุดตรงกับที่เลือกไว้ โชคดีที่มีบางส่วนที่เหลืออยู่ของโค้ดเพื่อให้เราสามารถลองการเข้ารหัสเพิ่มเติมได้สองสามโดยไม่เพิ่มจำนวนไบต์ ฉันพบสามตัวเลือก:

  1. เราสามารถเปลี่ยนไป@ /ในกรณีนี้เราสามารถใช้ตัวเลขใดก็ได้จาก1357และรับการเข้ารหัสที่ตรงกัน อย่างไรก็ตามนี่หมายความว่าโปรแกรมจะยุติข้อผิดพลาดซึ่งได้รับอนุญาต แต่ดูเหมือนจะไม่สะอาดมาก
  2. ช่องว่างไม่ใช่แค่ "กำแพง" เท่านั้น ตัวละครที่ไม่ได้ใช้ทั้งหมดคือตัวอักษรทั้งหมด ถ้าเราใช้ตัวอักษรตัวพิมพ์ใหญ่แล้วเราไม่จำเป็นต้องเพิ่มฐานเพื่อรองรับ (เนื่องจากจุดโค้ดเหล่านั้นอยู่ด้านล่าง_) 26 ตัวเลือกให้ความเป็นไปได้มากมาย เช่นงานAเลขคี่ใด ๆ นี่มันดีกว่านิดหน่อย แต่มันก็ไม่ได้ดูดีอย่างนั้นเพราะคุณไม่เคยใช้ตัวอักษรในรหัสจริงเลย
  3. เราสามารถใช้ฐานที่มากขึ้น ตราบใดที่เราไม่เพิ่มฐานอย่างมีนัยสำคัญจำนวนหลักเลขทศนิยมในการเข้ารหัสจะยังคงเหมือนเดิม (โดยเฉพาะอย่างยิ่งฐานใด ๆ ที่สูงถึง 104 ก็ใช้ได้แม้ว่าฐานที่เกิน 99 จะต้องการอักขระเพิ่มเติมในรหัสจริง) โชคดีที่ฐาน 98 จะช่วยให้การแก้ปัญหาการจับคู่เดียว: เมื่อเราใช้หลัก1, 1การเข้ารหัสที่จะสิ้นสุดลงใน นี่เป็นทางออกเดียวในฐาน 96, 97, 98, 99 ดังนั้นนี่จึงโชคดีมาก และนั่นคือวิธีที่เราท้ายด้วยรหัสที่ด้านบนของคำตอบนี้
— Martin Ender
แหล่งที่มา
19

แพ้แล้ว, 293 262 249 ไบต์

>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\

ลองออนไลน์!

คำอธิบาย

โครงการทั้งหมดนี้ได้รับการขึ้นและลง ฉันยังคงคิดว่ามันเป็นไปไม่ได้และจากนั้นก็เกิดความคิดบ้า ๆ ที่อาจจะใช้ได้

เหตุใด Lost Quine จึงยากนัก

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

ที่ถูกกล่าวว่ามีวิธีการมาตรฐานในการทำสิ่งต่าง ๆ ตัวอย่างเช่นที่นี่เป็นวิธีมาตรฐานในการพิมพ์สตริง

>%?"Stringv"(@
^<<<<<<<<<<<<<

นี่คือสตรีมคอลเล็กชันที่ด้านล่างซึ่งคว้า ips ส่วนใหญ่แล้วดึงไปยังตำแหน่งเริ่มต้น เมื่อถึงจุดเริ่มต้น (ซ้ายบน) เราจะทำให้พวกมันสะอาดด้วยการกำจัดค่าทั้งหมดในสแต็คจากนั้นเปลี่ยนความปลอดภัยของการดันสตริงและออก (ความปลอดภัยเป็นแนวคิดที่ไม่ซ้ำกับ Lost ทุกโปรแกรมจะต้องกดปุ่ม a %ก่อนออกจึงเป็นการป้องกันความเป็นไปได้ที่โปรแกรมจะยกเลิกเมื่อเริ่มต้น) ตอนนี้ความคิดของฉันคือการขยายแบบฟอร์มนี้เป็นควินเต็มเปี่ยม

สิ่งแรกที่ต้องทำคือการทำงานซ้ำลูปเล็กน้อยการวนซ้ำที่มีอยู่นั้นเป็นรูปแบบเฉพาะของสตริง

>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<

เราจำเป็นต้องเพิ่มสตรีมที่สองเพื่อหลีกเลี่ยงความเป็นไปได้ของการ!กระโดดข้ามสตรีมและสร้างลูป

ตอนนี้เราต้องการผสมกับรูปแบบ Quine มาตรฐาน ตั้งแต่ที่หายไปจะขึ้นอยู่มากใน Klein ฉันพื้นขโมยยืม Klien ควินสำหรับมาร์ตินเอนเดอร์

:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<

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

ความคิดที่นี่คือการใช้ประตูเพื่อให้ได้จำนวนลูกศรที่ต้องการ A Door เป็นกระจกชนิดพิเศษที่เปลี่ยนแปลงทุกครั้งที่ถูกโจมตี [สะท้อนถึง ips ที่มาจากทางซ้ายและ]จากทางขวา เมื่อพวกเขาถูกตีด้วย ip จากทั้งสองด้านการวางแนวสวิตช์ เราสามารถสร้างบรรทัดของประตูเหล่านี้และตัวสะท้อนแสงแบบคงที่เพื่อดำเนินการซ้ำ ๆ

>:[[[

จะทำการแสดง:สามครั้ง วิธีนี้ถ้าเราดัน a <ไปที่ stack ก่อนมือเราสามารถทำมันได้มากด้วยไบต์น้อย เราทำ 2 สิ่งเหล่านี้หนึ่งรายการสำหรับแต่ละบรรทัดและในระหว่างนั้นเราวางบรรทัดใหม่อย่างไรก็ตามรายการที่สองต้องการเพียงจนกว่าจะครอบคลุมที่!เราเพิ่มไว้เพื่อสิ่งอื่น ๆ ที่สามารถปล่อยให้เราว่างได้ไม่กี่ไบต์ ตกลงตอนนี้เราต้องเพิ่มลูกศรแนวตั้งลงในสตรีมของเรา นี่คือที่การเพิ่มประสิทธิภาพที่สำคัญเข้ามาแทนที่การเปลี่ยนเส้นทาง ips ทั้งหมดไปที่ "เริ่มต้น" ของโปรแกรมโดยตรงเราจะเปลี่ยนเส้นทางพวกเขาไปทางซ้ายสุดแทนเพราะเรารู้อยู่แล้วว่า ips ที่เริ่มต้นจากซ้ายสุดต้องทำงาน (หรืออย่างน้อยจะทำงานในรุ่นสุดท้าย) เรายังสามารถเปลี่ยนเส้นทางรหัสอื่น ๆ สิ่งนี้ไม่เพียงทำให้ถูกกว่าเป็นไบต์ฉันคิดว่าการเพิ่มประสิทธิภาพนี้เป็นสิ่งที่ทำให้ควินินเป็นไปได้

อย่างไรก็ตามยังมีปัญหาอยู่สิ่งสำคัญที่สุดที่เป็น ips เริ่มต้นหลังจาก>ถูกผลัก แต่ก่อนที่เราจะเริ่มทำสำเนาของมัน ips ดังกล่าวจะเข้าสู่เครื่องถ่ายเอกสารและทำสำเนาจำนวน 0 นี่เป็นสิ่งที่ไม่ดีเพราะกลไกการล้างสแต็กของเราใช้ค่าศูนย์เพื่อกำหนดส่วนล่างของสแต็ก เราจำเป็นต้องเพิ่มวิธีการกองอนามัยที่แข็งแกร่งขึ้น เนื่องจากไม่มีวิธีที่จะบอกได้ว่าสแต็กเตอร์ว่างเปล่าเราจะต้องพยายามทำลายไอเท็มจำนวนมากในสแต็กเท่าที่จะทำได้ ที่นี่เราจะใช้วิธีการของประตูที่อธิบายไว้ก่อนหน้านี้อีกครั้ง เราจะเพิ่ม((((((((((([[[[[[[[[[[[[[ที่ส่วนท้ายของบรรทัดแรกทันทีหลังจาก sanitizor กำจัดศูนย์

ขณะนี้มีปัญหาอีกข้อหนึ่งเนื่องจากเราเปลี่ยนเส้นทางของเราไปที่ ips ซ้ายบนเริ่มต้นที่%และการเลื่อนลงจะปิดความปลอดภัยแล้วและจะออกก่อนเวลาอันควร ดังนั้นเราต้องปิดความปลอดภัย เราทำสิ่งนี้โดยการเพิ่ม a #ไปยังสตรีมวิธีที่ ips ที่ไหลผ่านสตรีมจะถูกปิด แต่ ips ที่ผ่านการฆ่าเชื้อแล้วจะไม่ #จะต้องเขียนยากเข้าไปในบรรทัดแรกเช่นกัน

แค่นี้ก็หวังว่าคุณจะเข้าใจว่ามันใช้งานได้อย่างไรตอนนี้

— Sriotchilism O'Zaic
แหล่งที่มา
: / typos จำนวนมากและลิงก์ที่ขาดหายไป
— เฉพาะ ASCII เท่านั้น
17

Yup , 1165 879 606 561 540 522 498 + 7 = 505 ไบต์

ต้องการ-cheatแฟล็กเพื่ออนุญาตนิยามของนามแฝง

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

ลองออนไลน์!

คำอธิบาย

มีสองส่วนนี้ (เช่นเดียวกับ quines ส่วนใหญ่) ข้อมูล:

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212

และตัวถอดรหัส:

=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

ข้อมูลเป็นเพียงการเข้ารหัสแบบไบนารี่ของตัวถอดรหัส แต่ละตัวจะ0เริ่มตัวละครใหม่และ1s และ2s คือ0- และ1-bits ตามลำดับ

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

ต่อไปเราจะกำหนดคำสั่งเพิ่มเติม:

0e-=<;
0<-=>;
:0~--=1;
1>=2;

<ลดค่าส่วนบนสุดของสแต็>ก 1(ค่อนข้างไม่ได้ตั้งใจ) เพิ่มด้านบนของสแต็กเป็นสองเท่า 2เพิ่มเป็นสองเท่าและเพิ่มขึ้น ด้วยคำจำกัดความเหล่านี้สิ่งที่คล้ายกัน0221111จะทำให้มีค่า 48 (110000 ในรูปแบบไบนารี) บนสแต็ก

32 ไบต์ที่เหลือทำการถอดรหัสจริงในสองส่วน ก่อนอื่นเราต้องสร้างสายอักขระข้อมูลใหม่

0%                ` Push a zero and then the data.
{                 ` For each value...
  {               `   Until that value is zero...
    >0<~{~>~<<}>  `   divmod 2. The div is the input to the next iteration,
                  `   the mod gives us the next bit.
    >>]           `   Increment twice (gives 2 or 3) and put at the bottom
                  `   of the stack.
  }
  >]              ` Increment the 0 and put it at the bottom as well.
}
$                 ` Reverse the entire stack.
{<#}              ` Decrement and print each number.

และในที่สุดเราก็ดันข้อมูลอีกครั้งและพิมพ์แต่ละค่าเป็นอักขระ:

%{@}

สำหรับการอ้างอิงในอนาคตนี่คือสคริปต์ CJamเพื่อเข้ารหัสข้อมูล

— Martin Ender
แหล่งที่มา
17

Fueue , 423 ไบต์

Fueue เป็น esolang แบบอิงคิวซึ่งโปรแกรมที่รันอยู่คือคิว

)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

ลองออนไลน์!

มันทำงานอย่างไร

คำอธิบายนี้อาจจะใช่หรือไม่ใช่ว่าจะพ้นมือ ในทางกลับกันผมไม่ทราบวิธีที่จะอธิบายมันมากสั้นในทางที่ฉันหวังว่าผู้คนสามารถทำตาม

แผ่นโกง Fueue

ดูบทความ esolang wikiสำหรับรายละเอียดรวมถึงฟีเจอร์บางอย่างที่ไม่ได้ใช้ในโปรแกรมนี้

  • โปรแกรมเริ่มต้นคือสถานะเริ่มต้นของคิวซึ่งสามารถมีองค์ประกอบต่อไปนี้:

    • จำนวนเต็มตามตัวอักษร (เฉพาะที่ไม่เป็นลบในแหล่งที่มา แต่สามารถคำนวณได้ในเชิงลบ) ซึ่งดำเนินการพิมพ์ตัวอักษร
    • บล็อกที่ซ้อนกันแบบสี่เหลี่ยมจัตุรัสวงเล็บเหลี่ยมเฉื่อยเฉื่อย (เก็บรักษาไว้เหมือนเดิมยกเว้นบางฟังก์ชันทำหน้าที่แทนบล็อก)
    • ฟังก์ชั่นอาร์กิวเมนต์ของมันคือองค์ประกอบที่ตามมาทันทีในคิว:
      • +*/-%: เลขคณิตของจำนวนเต็ม ( -คือ unary, %negation เชิงตรรกะ) เฉื่อยถ้าไม่ได้รับข้อโต้แย้งตัวเลข
      • ()<: ใส่องค์ประกอบในวงเล็บ, ลบวงเล็บออกจากบล็อก, เพิ่มองค์ประกอบสุดท้ายที่จะบล็อก สองหลังมีความเฉื่อยเว้นแต่ตามมาด้วยบล็อก
      • ~:: swap ซ้ำซ้อน
      • $: คัดลอก (ใช้หมายเลข + องค์ประกอบ) เฉื่อยก่อนไม่ใช่ตัวเลข
      • H: หยุดโปรแกรม

    โปรดทราบว่าในขณะที่[]ทำรัง()อย่า - ส่วนหลังเป็นเพียงฟังก์ชันแยกกัน

ไวยากรณ์การติดตามการดำเนินการ

ช่องว่างเป็นทางเลือกใน Fueue ยกเว้นระหว่างตัวเลข ในการติดตามการดำเนินการต่อไปนี้จะถูกใช้เพื่อแนะนำโครงสร้างโปรแกรมโดยเฉพาะ:

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

วงเล็บปีกกา{}(ไม่ใช้ใน Fueue) ใช้ในการติดตามเพื่อแสดงผลลัพธ์จำนวนเต็มของนิพจน์ทางคณิตศาสตร์ ซึ่งรวมถึงตัวเลขติดลบเนื่องจาก Fueue มีเพียงตัวอักษรที่ไม่เป็นลบเท่านั้น - -เป็นฟังก์ชันปฏิเสธ

ชื่อ metavariable ต่างๆและ...ใช้เพื่อแสดงถึงค่าและตัวย่อ

กลยุทธ์ล่าช้า

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

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

กลยุทธ์เหล่านี้จะไม่ถูกกล่าวถึงเป็นรายบุคคลในด้านล่าง:

  • )[A]หน่วงAเวลาสำหรับรอบ (อาจเป็นวิธีที่ง่ายที่สุดและอ่านง่ายที่สุด)
  • ~efสลับองค์ประกอบeและfการดำเนินการที่ล่าช้า (อาจเป็นอย่างน้อยที่อ่านได้ แต่มักจะสั้นที่สุดสำหรับความล่าช้าเล็กน้อย)
  • $1eeความล่าช้าในองค์ประกอบเดียว
  • -และ%มีประโยชน์สำหรับการหน่วงเวลาตัวเลข (อันหลังสำหรับ0และ1.)
  • เมื่อหน่วงเวลาองค์ประกอบที่เท่ากันหลายอย่างในแถว:หรือ$สามารถใช้เพื่อสร้างพวกเขาจากหนึ่งเดียว
  • (nล้อมรอบnในวงเล็บซึ่งอาจถูกลบออกในภายหลังตามความสะดวก สิ่งนี้มีความสำคัญอย่างยิ่งสำหรับการคำนวณตัวเลขเนื่องจากตัวเลขไม่สามารถคัดลอกได้โดยไม่ใส่ในบล็อก

โครงสร้างโดยรวม

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

นี่คือวิธีที่โปรแกรมเริ่มต้นถูกแบ่งระหว่างพวกเขา:

A:  )$$4255%%1(~
B:  ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:  
D:  (H-
E:  
F:  
G:  ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

ตัวเลขขนาดใหญ่ที่ส่วนท้ายของโปรแกรมเข้ารหัสส่วนที่เหลือในทางกลับกันเป็นตัวเลขสองหลักต่อตัวอักษรโดยมี 30 ลบออกจากแต่ละค่า ASCII (เช่นเช่น10เข้ารหัส a (.)

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

  • ส่วน G ถอดรหัส bignum เป็นตัวเลข ASCII (เช่นตัวเลข0เป็นจำนวนเต็ม48) โดยแยกเลขนัยสำคัญน้อยที่สุดก่อน มันผลิตหนึ่งหลักทุก ๆ 15 รอบ
  • ส่วน F ประกอบด้วยค่า ASCII หลักที่ผลิต (ภายในแต่ละบล็อก) จนกระทั่งส่วน E สามารถใช้งานได้
  • ส่วน E จัดการกับตัวเลขที่ผลิตได้ครั้งละสองคู่โดยจับคู่กับบล็อกของแบบฟอร์ม[x[y]]และพิมพ์อักขระที่เข้ารหัสของแต่ละคู่
  • ส่วน D ประกอบด้วยบล็อกซ้อนกันลึกค่อยๆสร้างขึ้นจาก[x[y]]บล็อกในลักษณะที่เมื่อมันมีตัวเลขทั้งหมดมันสามารถเรียกใช้เพื่อพิมพ์ทั้งหมดของพวกเขาแล้วหยุดโปรแกรมทั้งหมด
  • ส่วน C จัดการการก่อสร้างของส่วน D และสร้างส่วน E อีกครั้ง
  • ส่วน B จะสร้างส่วน C ใหม่เช่นเดียวกับตัวเองทุกๆ 30 รอบ
  • ส่วน A นับถอยหลังจนถึงรอบการทำซ้ำครั้งสุดท้ายของส่วนอื่น ๆ จากนั้นจะยกเลิกส่วน B และเรียกใช้ส่วน D

หมวดก

ส่วน A จัดการกำหนดการสิ้นสุดของโปรแกรม ใช้เวลา 4258 รอบในการลดลงเป็นฟังก์ชั่นสลับเดียว~ซึ่งจะทำการปรับไปยังส่วน B ที่หยุดลูปหลักและเริ่มการทำงานส่วน D แทน

)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
  • $ฟังก์ชั่นสร้าง 4255 ฉบับต่อไป%ในขณะที่(ห่อ~ในวงเล็บ
  • แต่ละรอบสุดท้าย%จะถูกนำมาใช้เพื่อสลับหมายเลขต่อไปนี้ระหว่างและ01
  • เมื่อหมดแล้ว%s จะ$1สร้าง 1 สำเนาของ[~](NOP ที่มีประสิทธิภาพ) และในรอบต่อไปจะเป็นการ)ลบวงเล็บ

มาตรา B

มาตรา B จัดการการสร้างใหม่เช่นเดียวกับการวนซ้ำใหม่ของส่วน C ทุก ๆ 30 รอบ

) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]            [BkB]
)$ $24%     %0  :<  [~:)~)]    ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1   < < [~:)~)] [BkB]   [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0      < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1         [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                    (1)
~:) ~)[BkB]                 [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB]                 ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]      (2)
) [BkB] [BkB]               $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
  • :ซ้ำบล็อกขนาดใหญ่ต่อไปนี้ (สำเนาย่อว่า[BkB]) แล้ว)เอาวงเล็บจากสำเนาแรก
  • $$24%%0 ตั้งค่าการนับถอยหลังคล้ายกับที่อยู่ในส่วน A
  • ในขณะที่สิ่งนี้นับถอยหลัง:<เปลี่ยนเป็น<<และ~สลับสองบล็อกโดยวางโค้ดสำหรับส่วน C ใหม่ล่าสุด
  • ทั้งสอง<ฟังก์ชั่นบรรจุสองบล็อกสุดท้ายเข้าไปในบล็อกแรก - นี่คือการทำซ้ำในการทำซ้ำปกติ แต่จะช่วยให้~จากส่วน A เพื่อทำงานในตอนท้าย
  • (1) เมื่อการนับถอยหลังเสร็จสิ้นการ)ลบวงเล็บเหลี่ยมด้านนอก ถัดไป~:)จะเปลี่ยนเป็น):และ~)สลับ a )ไปยังจุดเริ่มต้นของรหัสส่วน C
  • (2) ตอน B ตอนนี้กลับมาที่วัฏจักรเริ่มต้นในขณะที่ a )กำลังจะลบวงเล็บเพื่อเริ่มการวนซ้ำใหม่ของส่วน C

ในการทำซ้ำขั้นสุดท้าย~ส่วนจาก A จะปรากฏที่จุด (1) ด้านบน:

~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                  (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]              )

การ~สลับ)ข้ามบล็อกและไปยังส่วน C ป้องกันไม่ให้ส่วน B กลับมาทำงานอีกครั้ง

หมวด C

ส่วน C จัดการการผสานคู่อักขระใหม่เข้ากับบล็อกของส่วน D และสร้างการวนซ้ำใหม่ของส่วน E

ด้านล่างแสดงการวนซ้ำทั่วไปด้วยxและyแสดงถึงรหัส ASCII ของตัวเลข ในการวนซ้ำครั้งแรกองค์ประกอบ "D" และ "E" ที่เข้ามาจะเป็นค่าเริ่มต้น[H]และ-แทนเนื่องจากไม่มีส่วนก่อนหน้า E ถูกเรียกใช้เพื่อสร้างคู่อักขระหลักใด ๆ

C                                               D             E
$11~ )  ~<[[+$4--498+*-:~-10)):])<~]  [)))~]  < [)))~[...]]   [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~]  < [)))~] [)))~[...][x[y]]]
~~~ ~~~     )  ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~       ~ )   [)))~[....]]                                  [[+$4--498+*-:~-10)):])<~]
                                              ~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
                                                [)))~[....]]  ~[+$4--498+*-:~-10)):])<~
  • นี่ใช้วิธีการซิงโครไนซ์ที่แตกต่างซึ่งฉันค้นพบสำหรับคำตอบนี้ เมื่อคุณมีฟังก์ชั่นการสลับหลายครั้ง~ในหนึ่งแถวแถวนั้นจะลดลงเหลือประมาณ 2/3 ในแต่ละรอบ (เพราะหนึ่งครั้งจะ~สลับสองครั้งหลังจากนั้น) แต่บางครั้งก็มีส่วนที่เหลือ~ซึ่งทำให้เกิดความเสียหายอย่างระมัดระวัง
  • $11~ผลิตเช่นแถว ถัดไป~สลับ a <ข้ามบล็อกต่อไปนี้ อีกประการหนึ่ง<ที่สิ้นสุดผนวกหลักคู่บล็อกใหม่ (ตัวเลข x และ y เป็นรหัส ASCII) ในส่วน D บล็อก
  • รอบถัดไป~แถวมี~~ที่เหลือซึ่ง swaps กว่าดังต่อไปนี้~ )อีก<ส่วนจะผนวกส่วน D เข้ากับ[)))~]บล็อก
  • ถัดไปผู้ที่สลับ~ตัวจะสลับบล็อกต่อไปนี้ด้วยรหัส E ส่วนใหม่ทั่วทั้งบล็อกส่วน D จากนั้นสิ่งที่เหลืออยู่ใหม่จะทำการ~สลับ)ไปมาและท้ายที่สุด~~ใน~แถวสุดท้ายจะสลับหนึ่งในนั้นข้ามไปยังส่วน E เช่นเดียวกับที่)ได้ลบวงเล็บ

ในการทำซ้ำขั้นสุดท้ายส่วน A ~ได้สลับ)ส่วนข้ามส่วน B และเป็นส่วน C อย่างไรก็ตามส่วน C นั้นมีอายุสั้นมากจนมันหายไปแล้วและ)จบลงที่จุดเริ่มต้นของส่วน D

มาตรา D

ส่วน D จัดการการพิมพ์ตัวเลขขนาดใหญ่สุดท้ายและหยุดโปรแกรม ในระหว่างการรันโปรแกรมส่วนใหญ่มันเป็นบล็อกเฉื่อยที่ส่วน B-G ร่วมมือในการสร้าง

    (H -
    [H]-
    ⋮
    [)))~[H-]]                  After one iteration of section C
    ⋮
    [)))~[)))~[H-][49[49]]]]    Second iteration, after E has also run
    ⋮
)   [)))~[...]]     [49[48]]    Final printing starts as ) is swapped in
    ))) ~[...][49[48]]
    )) )[49[48]] [...]
    )) 49 [48][...]             Print first 1
    ) )[48] [...]
    ) 48 [...]                  Print 0
    )[...]                      Recurse to inner block
    ...
    ⋮
    )[H-]                       Innermost block reached
    H -                         Program halts
  • ในรอบแรกของโปรแกรม(แรปฟังก์ชัน halting Hในวงเล็บเหลี่ยม -ต่อไปนี้ก็จะถูกนำมาใช้เป็นองค์ประกอบหุ่นสำหรับซ้ำแรกแทนที่จะเป็นคู่หลัก
  • ตัวเลขจริงคู่แรกที่รวมกันนั้น[49[49]]สอดคล้องกับรอบสุดท้าย11ในตัวเลข
  • สุดท้ายคู่หลัก[49[48]](ตรงกับ10จุดเริ่มต้นของตัวเลขนั้น) จะไม่ได้จัดตั้งขึ้นจริงลงในบล็อก แต่นี้จะทำให้ความแตกต่างที่ไม่มี)[A[B]]และเทียบเท่าทั้งสองกลายเป็น)[A][B]A[B]

หลังจากการทำซ้ำครั้งสุดท้ายการ)สลับไปทางขวาจากส่วน B มาถึงและบล็อกส่วน D ถูก deblocked )))~ที่จุดเริ่มต้นของบล็อกย่อยแต่ละทำให้แน่ใจว่าทุกส่วนจะดำเนินการในลำดับที่ถูกต้อง ในที่สุดบล็อกด้านในสุดมีโปรแกรมHหยุด

มาตรา E

ส่วน E จัดการกับการรวมกันของตัวเลข ASCII คู่ที่ผลิตโดยส่วน G และทั้งสองพิมพ์อักขระที่เข้ารหัสที่สอดคล้องกันและส่งบล็อกที่มีคู่รวมกันไปทางซ้ายเพื่อส่วน C และ D

อีกครั้งด้านล่างแสดงการทำซ้ำโดยทั่วไปด้วยxและyเป็นตัวแทนของรหัส ASCII ของตัวเลข

E                                                   F
~ [+$4--498+*-:~-10)):] )              <  ~         [y] [x]
) [+$4--498+*-:~-10)):]                   < [x] [y]
+ $4-  - 498  +*- :~ -10 ) )              : [x[y]]
+---  -{-498} +*- ~~{-10} )       ) [x[y]]  [x[y]]
+--    - 498  +*   -{-10}       ~ ) x  [y]  [x[y]]
+-    -{-498} +               * 10 x  )[y]  [x[y]]
+      - 498                    + {10*x} y  [x[y]]
                         + {-498} {10*x+y}  [x[y]]
{10*x+y-498}  [x[y]]
[x[y]]
  • บล็อกหลักที่เข้ามาจะถูกสับเปลี่ยนจากนั้นบล็อก y จะถูกผนวกเข้ากับบล็อก x และบล็อกทั้งคู่จะถูกคัดลอก หนึ่งสำเนาจะถูกปล่อยไว้จนถึงจุดสิ้นสุดสำหรับส่วน C และ D
  • สำเนาอื่น ๆ จะถูก deblocked อีกครั้งจากนั้นลำดับฟังก์ชั่นทางคณิตศาสตร์จะถูกนำไปใช้ในการคำนวณ10*x+y-498ค่า ASCII ของอักขระที่เข้ารหัส 498 = 10*48+48-30เป็นการ48ยกเลิกการเข้ารหัส ASCII ของxและyในขณะที่30เลื่อนการเข้ารหัสจาก00–99ไป30–129เป็นซึ่งรวมถึง ASCII ที่พิมพ์ได้ทั้งหมด
  • หมายเลขผลลัพธ์จะถูกปล่อยให้ดำเนินการซึ่งพิมพ์อักขระของมัน

หมวด F

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

[y] [x] ...

มาตรา G

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

เนื่องจากไม่มีการตรวจสอบการหยุดพักจริง ๆ แล้วมันจะยังคงผลิต0ตัวเลขต่อไปเมื่อตัวเลขได้ลดลงเหลือ 0 จนกระทั่งส่วน D หยุดโปรแกรมทั้งหมดด้วยHฟังก์ชัน

[BkG] ตัวย่อของบล็อกโค้ดเริ่มต้นขนาดใหญ่ซึ่งใช้สำหรับการเรพลิเคตตัวเองเพื่อเริ่มต้นการทำซ้ำใหม่

การเริ่มต้นในรอบแรก:

) :~  : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
)  ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]     ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]       ~ : [10...11]  [BkG]

โดยทั่วไปการวนซ้ำNหมายถึงจำนวนที่จะแบ่ง:

) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]        ~ : [N]  [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 )         : [N]  : [BkG]
)  ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]  +5 5     ) [N]  [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]               ~ 10 N  [N] [BkG] [BkG]
) ~:~  ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~]               / N 10  [N] [BkG] [BkG]
)  ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                 ( {N/10}  [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                    : [{N/10}]  [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 )           ~ ~ [{N/10}]  [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 )             ) [{N/10}]  ~ [{N/10}] [N]  [BkG] [BkG]
)  ~ * [):~[$1(+48]):~+]  -10            ~ ) {N/10}  [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+]               * {-10} {N/10}  ) [N]  [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~                 + {-10*(N/10)} N  [{N/10}] [BkG] [BkG]
)  ~ ~ [$1(+48]  )                 ~ ~ {N%10}  [{N/10}] [BkG] [BkG]
) [$1(+48]                 ~ ) {N%10}  ~ [{N/10}] [BkG]  [BkG]
$1(                     + 48 {N%10}    ) [BkG]  [{N/10}] [BkG]
                        ( {48+N%10}   BkG [{N/10}] [BkG]            New iteration starts
                        [{48+N%10}]   ....
  • ความล่าช้าของหยดที่นี่มีขนดกโดยเฉพาะ อย่างไรก็ตามเคล็ดลับการหน่วงเวลาใหม่เท่านั้นที่จะใช้+:5แทน--10การหน่วงเวลา10สองรอบ อนึ่งมีเพียงหนึ่ง10ในโปรแกรมเท่านั้นที่ได้รับความช่วยเหลือ
  • [N]และ[BkG]บล็อกซ้ำแล้วหนึ่งชุดโดยแบ่งเป็นN10
  • [{N/10}]ซ้ำแล้วฟังก์ชั่นทางคณิตศาสตร์มากขึ้นมีการใช้ในการคำนวณรหัส ASCII ของหลักสุดท้ายของการเป็นN 48+((-10)*(N/10)+N)บล็อกที่มีรหัส ASCII นี้เหลือไว้สำหรับส่วน F
  • สำเนาอื่น ๆ ของการ[{N/10}]แลกเปลี่ยนระหว่าง[BkG]บล็อกเพื่อตั้งค่าเริ่มต้นของการทำซ้ำใหม่

โบนัสควินิน (540 ไบต์)

)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63

ลองออนไลน์!

เนื่องจากฉันไม่แน่ใจว่าวิธีใดจะสั้นที่สุดฉันลองเข้ารหัสตัวอักษรเป็นตัวเลขสองหลักคั่นด้วย(s รหัสหลักสั้นลงเล็กน้อย แต่การแสดงข้อมูลที่ใหญ่กว่า 50% ทำขึ้นเพื่อมัน ไม่เหมือนตีกอล์ฟเหมือนกับที่ฉันหยุดเมื่อฉันรู้ว่ามันจะไม่ชนะ มันมีข้อดีอย่างหนึ่ง: มันไม่จำเป็นต้องมีการใช้งานด้วยการสนับสนุน bignum

โครงสร้างโดยรวมของมันค่อนข้างคล้ายกับโครงสร้างหลัก ส่วน G หายไปเนื่องจากการแสดงข้อมูลเติมในส่วน F โดยตรง อย่างไรก็ตามส่วน E ต้องทำการคำนวณ divmod ที่คล้ายกันเพื่อสร้างตัวเลขของตัวเลขสองหลักใหม่

— Ørjan Johansen
แหล่งที่มา
1
คุณควรตีกอล์ฟคำอธิบาย XD
— VFDan
1
)$n[)](เป็นไบต์ที่สั้นลงสำหรับตัวนับการหน่วงเวลา
— jimmy23013
15

เยลลี่ 3 ไบต์

”ṘṘ

ลองออนไลน์!

การตรวจสอบ

$ echo $LANG
en_US
$ xxd -g 1 quine.jelly
0000000: ff cc cc                                         ...
$ ./jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...

มันทำงานอย่างไร

”ṘṘ    Main link. No input.

”Ṙ     Set the return value to the character 'Ṙ'.
  Ṙ    Print a string representation of the return value.
       This prints: ”Ṙ
       (implicit) Print the return value.
       This prints: Ṙ
— เดนนิส
แหล่งที่มา
ล่ามเวอร์ชันนี้ใช้อะไร? เมื่อฉันทดสอบมันจะแสดงผลเป็น UTF-8 แม้ว่าอินพุตอยู่ในเพจเจลลี่ของเจลลี่ (และการเปลี่ยนการเข้ารหัสจะทำให้มันไม่ใช่แบบ a-quine)
1
การเข้ารหัสของเอาต์พุตขึ้นอยู่กับการตั้งค่าของเทอร์มินัลของคุณ: หากตั้งค่าเป็น UTF-x จะใช้การเข้ารหัสนั้น หากตั้งค่าเป็นอย่างอื่นจะใช้หน้ารหัสของ Jelly บน Linux LANG=en_USทำได้แค่นั้น tio.run/nexus/bash#@@/…
— Dennis
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.