แนวคิด

เขียนโปรแกรมที่ส่งออกรหัสในภาษาการเขียนโปรแกรม รหัสนั้นเมื่อดำเนินการจะต้องส่งออกโปรแกรมต้นฉบับ

กฎระเบียบ

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

Bash + coreutils 11 ไบต์

tr xy yx<$0

ภาพพิมพ์นี้

tr yx xy<$0

ลองออนไลน์!

ในทางกลับกันที่พิมพ์

tr xy yx<$0

หอยทาก 0 ไบต์

โปรแกรมที่สองคือ

1

โปรแกรมแรกนับจำนวนการจับคู่ของรูปแบบที่ว่างเปล่าในอินพุตว่าง (ซึ่งมีพื้นที่ 0 จริง ๆ แต่รูปแบบจะทำงานอย่างน้อยหนึ่งครั้งเป็นแฮ็คเสมอเพื่ออนุญาตให้โปรแกรมตัดสินใจว่าต้องการพิมพ์ด้วยอินพุตว่าง) โปรแกรมที่สองเริ่มต้นด้วย quantifier (เช่น{1}ใน regex) ซึ่งทำให้เกิดข้อผิดพลาดในการแยกวิเคราะห์ เนื่องจากโปรแกรมวิเคราะห์คำไม่สำเร็จ STDOUT จึงเป็นสตริงว่าง

7 , 2 ไบต์

7 ใช้ชุดอักขระ 3 บิต แต่รับอินพุตที่บรรจุเป็นไบต์ (และอ้างอิงจาก meta ภาษาที่มีชุดอักขระย่อยไบต์จะถูกนับโดยใช้ไบต์สำหรับไฟล์บนดิสก์ ) นี่คือxxdดัมพ์ของโปรแกรม:

00000000: 4cf4                                     L.

เมื่อให้ไฟล์นี้แก่ล่าม 7 มันจะส่งออกโปรแกรมต่อไปนี้:

00000000: 4fa6 7f                                  O..

ซึ่งจะเป็นการส่งออกโปรแกรมต้นฉบับอีกครั้ง

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

231 7 23 โปรแกรมต้นฉบับแยกออกเป็นแปด
231 กด237บนสแต็ก
    23 กด23ลงบนสแต็ก
             (โดยนัย) ผนวกสำเนาของส่วนบนสุดของสแต็กเข้ากับโปรแกรม
      2       สำเนาด้านบนสุดของสแต็ก (ปัจจุบัน23 )
        3      ด้านบนสุดของสแต็กองค์ประกอบป๊อปสแต็กที่สอง

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

231 7 23 23
             (โดยนัย) ผนวกสำเนาของส่วนบนสุดของสแต็กเข้ากับโปรแกรม
        2     สำเนาด้านบนสุดของสแต็ก (ปัจจุบัน237 )
          3    ด้านบนสุดของสแต็กองค์ประกอบป๊อปสแต็คที่สองที่สอง
           7   ผลักองค์ประกอบที่ว่างลงบนสแต็ก

ณ จุดนี้ไม่มีอะไรเลยนอกจากองค์ประกอบสแต็คที่ว่างเปล่าบนสแต็กดังนั้นโปรแกรมจึงออก เราส่งออก23ก่อนหน้านี้ ถ้าเราหนี237(และเราจะต้องเพราะมันมีคำสั่ง unrepresentable) 7231ที่เราได้รับ ที่รับเอาท์พุทโดยตรงทำให้ผลลัพธ์สุดท้ายของโปรแกรม237231(จัดรูปแบบในลักษณะเดียวกันกับโปรแกรมเช่นถูกบีบอัดเป็นไบต์) 4fa67fที่ (สามารถสังเกตได้ว่าสิ่ง1นั้นไม่มีประโยชน์อย่างสิ้นเชิงในแง่ของผลกระทบต่อผลผลิตเหตุผลเดียวที่ทำให้โปรแกรมทั้งสองแตกต่างกัน)

การ237231ดำเนินการเกือบจะเหมือนกันทุกประการ ความแตกต่างก็คือการ1ทำงานที่ไร้ประโยชน์หลังจากการพิมพ์ครั้งแรก (และองค์ประกอบที่ว่างเปล่าจะถูกลบโดยปริยายในครั้งที่สองเมื่อถึงจุดสิ้นสุดของโปรแกรมปัจจุบัน) อีกครั้ง231ผลลัพธ์ที่23จบลงก็คือผลลัพธ์ที่นำหน้าด้วย a 7และเราได้รับ231723คือโปรแกรมดั้งเดิม

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

2  3  1  7  2  3
010011001111010011(1...)
4   c   f   4   padding

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

Python 3, 297 279 251 243 225 218 208 180 126 111 ไบต์

แบบไม่โกง:

A=''';print(("A="+("'"*3+A)*2).translate({65:66,66:65}))''';print(("A="+("'"*3+A)*2).translate({65:66,66:65}))

ภาพพิมพ์นี้:

B=''';print(("B="+("'"*3+B)*2).translate({65:66,66:65}))''';print(("B="+("'"*3+B)*2).translate({65:66,66:65}))

ซึ่งเมื่อดำเนินการพิมพ์โปรแกรมต้นฉบับ

แบตช์ 14 ไบต์

@echo @type %0

ซึ่งเมื่อทำงานเป็นcyclicquine.batเอาท์พุท

@type cyclicquine.bat

ซึ่งเมื่อรันเอาต์พุตไฟล์แบตช์ดั้งเดิม

RProgN , 4 ไบต์

ชุมชนดูเหมือนจะคิดว่าสิ่งนี้เป็นเหมือนการโกงควินินซึ่งเป็นไปตามเกณฑ์

1
2

ด้วยการขึ้นบรรทัดใหม่

ภาพพิมพ์นี้

2
1

ด้วยการขึ้นบรรทัดใหม่ซึ่งพิมพ์รหัสแรก

RProgN พิมพ์กองซ้อนดังนั้นจากบนลงล่าง

ลองออนไลน์!

Jolf, 6 ไบต์

1q_a_q

เมื่อรันผลลัพธ์นี้:

q_a_q1

1q_a_qซึ่งในการเปิดเอาท์พุท

ลองที่นี่!

คำอธิบาย

1q_a_q
1       the digit one (ignored)
 q      the source code (ignored)
     q  the source code
    _   reversed
   a    and outputted
 _      and reversed (ignored)

q_a_q1
q       the source code (ignored)
     1  the digit one (ignored)
    q   the source code
   _    reversed
  a     and outputted
 _      and reversed (ignored)

JavaScript (ES6), 69 60 59 ไบต์

(_0=_=>console.log(`(_0=${_0})()`.replace(/0/g,n=>+!+n)))()

ขาออก:

(_1=_=>console.log(`(_1=${_1})()`.replace(/1/g,n=>+!+n)))()

-1 ไบต์ (@ETHProductions): ใช้ 0 ใน regex แทน \ d

Bash + Sed, 15 ไบต์

ความคิดเช่นเดียวกับคำตอบของเดนนิส

sed y/xz/zx/ $0

Bash, Catและ Rev, 19 16 ไบต์

rev $0 # 0$  ver

-3 ขอบคุณ @izabera

> <>, 16 ไบต์

"$r00gol?!;50.01

ลองที่นี่!

เอาท์พุท

"$r00gol?!;50.10

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