เมตาควินเป็นโปรแกรมที่ไม่ได้เป็นควิน แต่มีเอาต์พุตเมื่อรันเป็นโปรแกรมในภาษาเดียวกันจะเป็นควิน

เป้าหมายของความท้าทายนี้คือการเขียน metaquine นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดชนะด้วยคำตอบแรกสุดที่ใช้เป็น tiebreaker โปรดทราบว่ามีเพียงโปรแกรมเต็มรูปแบบที่ยอมรับได้เนื่องจากคำจำกัดความของควิน

กฏสำหรับ Quines

ยอมรับ Quines จริงเท่านั้น นั่นคือคุณต้องพิมพ์คำต่อคำทั้งหมดเพื่อ STDOUT โดยไม่ต้อง :

• อ่านซอร์สโค้ดของคุณโดยตรงหรือโดยอ้อม
• อาศัยสภาพแวดล้อม REPL ซึ่งเพียงประเมินและพิมพ์นิพจน์ทุกครั้งที่คุณป้อน
• อาศัยคุณสมบัติภาษาที่เพิ่งพิมพ์ออกมาในบางกรณี
• ใช้ข้อความแสดงข้อผิดพลาดหรือ STDERR เพื่อเขียนทั้งหมดหรือบางส่วนของควิน (คุณสามารถเขียนสิ่งต่าง ๆ ไปยัง STDERR หรือสร้างข้อผิดพลาด / เตือนไม่ใช่ข้อผิดพลาดได้ตราบใดที่ STDOUT เป็นควินินที่ถูกต้องและข้อความผิดพลาดไม่ได้เป็นส่วนหนึ่งของมัน)
• ซอร์สโค้ดประกอบด้วยตัวอักษรล้วนๆ (ไม่ว่าจะเป็นตัวอักษรสตริงตัวอักษรตัวเลข ฯลฯ ) และ / หรือ NOP

เอาท์พุทที่ไม่สามารถปราบปรามได้ (เช่นประกาศลิขสิทธิ์ข้อความเริ่มต้น / ปิดเครื่องหรือฟีดบรรทัดต่อท้าย) อาจถูกละเว้นในเอาต์พุตเพื่อประโยชน์ของ quine

ตัวอย่าง

ไม่สนใจกฎที่ห้ามโปรแกรมที่มีตัวอักษรเท่านั้นและมีการสร้างควินนิ่งในตัวนี่จะเป็น metaquine อย่างจริงจัง:

"Q"

โปรแกรมประกอบด้วยสตริงตัวอักษรเดียว"Q"ซึ่งถูกพิมพ์โดยปริยายที่เอาต์พุต เมื่อเรียกใช้เอาต์พุต ( Q) จะเป็น quine ( Qเป็นฟังก์ชัน quine ในตัว)

CJam, 6 ไบต์

"_p"_p

พิมพ์

"_p"
_p

ซึ่งเป็นควินที่เหมาะสมที่สั้นที่สุดใน CJam

ทดสอบที่นี่

คำอธิบาย

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

"_p"  e# Push this string.
_     e# Duplicate it.
p     e# Print a string representation of the top of the stack (i.e. the string with
      e# quotes) followed by a linefeed.
      e# The other copy is then printed automatically at the end of the program, without
      e# stringifying it.

หมายเหตุด้านข้าง

งานเดียวกันใน GolfScript เป็น

".p".p

ซึ่งพิมพ์

".p"
.p

ด้วย linefeed ต่อท้ายซึ่งจะเป็นหนึ่งในควินที่รู้จักกันสั้นที่สุด

Pyth, 12 11 10 9 ไบต์

เคาะออกอีกหนึ่งไบต์ด้วย @ Pietu1998

jN B".[9N

ภาพพิมพ์นี้

.[9N".[9N

ซึ่งเป็นควินใน Pyth คุณสามารถลองมันออกมาที่นี่

ฟิชชัน 6 ไบต์

!+OR"'

พิมพ์

'!+OR"

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

ลองออนไลน์!

Javascript ES6, 21 ไบต์

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

จิ๊บจ๊อย

Python 2, 29 ไบต์

_="_=%r;print _%%_";print _%_

เปลี่ยนจาก python quine สั้นที่รู้จักกันดีกลายเป็น metaquine ได้อย่างง่ายดาย :)

และเนื่องจากเราไม่ต้องกังวลเกี่ยวกับการจับคู่ขึ้นบรรทัดใหม่ metaquine จึงสั้นกว่าจริง ๆ !

Japt 15 15ไบต์

Q+"+Q ³s7J" ²

ทดสอบออนไลน์!

โปรแกรมนี้ให้ผลลัพธ์

"+Q ³s7J"+Q ³s7J

ซึ่งเป็นควินที่รู้จักกันสั้นที่สุดใน Japt

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

Q+"..." // Take a quotation mark plus this string.  "+Q ³s7J
²       // Repeat it twice.                         "+Q ³s7J"+Q ³s7J
        // Implicit output

รุ่นที่ไม่ใช่การแข่งขัน 11 ไบต์

Q+"+Q ²é" ²

ฉันเพิ่งเพิ่ม éคำสั่ง "หมุน" ดังนั้น

"+Q ²é"+Q ²é

ตอนนี้เป็น quine ที่ถูกต้อง

ทับทิม, 25 23

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

สร้างคลาสสิก Ruby HEREdoc quine

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

วิธีการแก้ปัญหาเก่า

_='_=%p;$><<_%%_';$><<_%_

สร้างตัวเองยกเว้นด้วยเครื่องหมายคำพูดเดี่ยวแทนที่ด้วยเครื่องหมายคำพูดคู่

JavaScript ขนาด 50 ไบต์

a="a=%s;console.log(a,uneval(a))";eval(a.slice(5))

อิงจากJS quine ที่ไม่มีการอ่านที่สั้นที่สุดที่มนุษย์รู้จักแต่สั้น 8 ไบต์ที่ดี พิมพ์

a="a=%s;console.log(a,uneval(a))";console.log(a,uneval(a))

ซึ่งเป็นควิน

ปลา (> <>) 17 ไบต์

สิ่งนี้ทำงานได้โดยใช้ปลาคลาสสิก quine "r00g!;oooooooo|แต่เพิ่มสิ่ง{ที่เลื่อนทั้งกองไปทางซ้ายเพื่อให้โปรแกรมดั้งเดิมไม่ได้เป็นควิน แต่มันเป็นผลลัพธ์เมื่อทำงานคือ

"{r00g!;oooooooo|

ขาออก:

"r00g!;oooooooo|

ซึ่งเป็นปลาควิน!

เยลลี่ 3 ไบต์ (ไม่แข่งขัน)

น่าเสียดายที่อะตอมที่ต้องการนั้นมีอายุน้อยกว่า 2 สัปดาห์โดยประมาณ

Metaquine

”Ṙv

ลองออนไลน์!

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

”Ṙv  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  v  Dyadic eval; evaluate the return value with the left argument as argument.
     Executing the atom Ṙ on the argument 'Ṙ' prints a string representation of
     the character, i.e., the string "”Ṙ".
     Finally, v returns its unaltered argument, which is printed implicitly.

ควิน

”ṘṘ

ลองออนไลน์!

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

”ṘṘ  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  Ṙ  Print a string representation of the character, i.e., the string "”Ṙ".
     (implicit) Print the unaltered return value.

เนื่องจากตัวที่สองṘพิมพ์อักขระสองตัวแรก ( ”Ṙ) นี่คือ quine ที่เหมาะสมตามคำจำกัดความของเรา

Octopen-Baru, 22 ไบต์

** คำตอบที่ไม่ใช่การแข่งขัน

愛[35211].pack歩U')

เอาท์พุททับทิม

puts [35211].pack(' U')

見ซึ่งเอาท์พุท ซึ่งเป็นควินใน Octopen-Baru!

7 , 2 ไบต์, ภาษาลงวันที่ท้าทาย

โปรแกรมมีความยาวสองไบต์และสามารถตีความได้หลายวิธี เป็นการถ่ายโอนข้อมูล hex:

00000000: 4ff4                                     O.

เป็นเพจรหัส 437:

O⌠

หรือส่วนใหญ่อ่านได้ง่ายในฐานแปด (ซึ่ง 7 ใช้ดั้งเดิม):

237723

ลองออนไลน์!

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

อนึ่งโปรแกรมนี้เป็นpalindromeเป็นเลขฐานสิบหก แต่ส่วนใหญ่เป็นเรื่องบังเอิญ

อันเดอร์โหลด, 11 ไบต์

(:aSS)::aSS

ค่อนข้างง่าย มันพิมพ์ออกมา(:aSS):aSSซึ่งเป็นมาตรฐาน Underload Quine

Brachylogขนาด 12 ไบต์

"~k;?w₁"gjw₃

ลองออนไลน์!

หนึ่งใน 132 รูปแบบ metaquine ที่มีความยาวเท่ากันใน quine I ที่แปลจากQuine Brachylog v1 (ไม่ใช่การโกง) ของ Fatalize ที่จริงฉันเขียนโปรแกรม (ที่ไม่ใช่กอล์ฟและโง่โดยรวม) เพื่อพิมพ์ทั้งหมดของพวกเขาออก:

{[[";?","gj","jḍ"],"₁₃₅₇"]j∋ᵐ{ḍ≠&};"\"~~k~ww~w\"~ww~w~n"}ᶠ{lw" metaquines generated:
"ẉ&}w₁ᵐ

ลองออนไลน์!

มีสองส่วนของควินเดิมซึ่งจะถูกแทนที่อย่างไม่สมเหตุผลคือ;?สามารถเปลี่ยนgjหรือjḍและ₁สามารถเปลี่ยน₃, หรือ₅ ₇ถ้าเราเก็บหรือเปลี่ยนแปลงมันนอกตัวอักษรสตริงในทางเดียวและภายในสตริงตัวอักษรในวิธีที่แตกต่างกันแล้วผลลัพธ์จะไม่ตรงกับแหล่งที่มาเพราะตัวแปรใดก็ตามที่มีอยู่ภายในตัวอักษรสตริงจะถูกพิมพ์ทั้งภายในและภายนอก ส่งผลให้ quine ซึ่งไม่ใช่โปรแกรมเริ่มต้นทำงาน

;?,, gjและjḍสามารถแทนกันได้เนื่องจากทั้งสามคู่สตริงตัวอักษรกับตัวเอง: เนื่องจากรูปแบบของโปรแกรมตัวแปรอินพุต?ถูกรวมเป็นหนึ่งเดียวกับสตริงดังนั้น;?จับคู่สตริงกับตัวเอง โดยไม่คำนึงถึงเลย์เอาต์gjห่อสตริงในรายการที่ต่อกันกับตัวเอง ในทำนองเดียวกันjḍconcatenates สตริงกับตัวเองแล้วแยกครึ่ง

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

Befunge-93, 22 ไบต์

"+1_@#`+39:,g0:">:#,_@

ฉันเพิ่งเอา quine มาตรฐานใส่ไว้ในเครื่องหมายคำพูดกลับด้าน

มันเพิ่ม 8 ตัวอักษรในควินปกติดังนั้นจึงเป็นไปได้มากที่จะมีทางออกที่ดีกว่า

Turtlèd , 52 ไบต์ (ไม่ใช่การแข่งขัน)

1 น้อยกว่าควินต้นฉบับ

@##'@r,r,r-{ +.r_}r{ +.r_}"#'@r,r,r-{ +.r_}r{ +.r_}"

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

Lua ขนาด 45 ไบต์

รหัสควินินไม่ใช่ของฉัน

s="s=%qprint(s:format(s))"print(s:format(s));

จะส่งผลให้

s="s=%qprint(s:format(s))"print(s:format(s))

ซึ่งเป็นควิน ดีใจที่;เป็นตัวเลือกใน Lua

มีขนาด 7 ไบต์

การไม่แข่งขันเมื่อภาษาโพสต์ความท้าทาย

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

95 34_"

ลองออนไลน์! ผลลัพธ์นี้:

95 34
_"

ซึ่งเป็นระยะเวลาที่สั้นเร่งเร้าควิน - คำอธิบายเกี่ยวกับวิธีการทำงานสามารถพบได้ที่นี่

หรือใช้H5-34_"งานได้กับจำนวนไบต์เดียวกัน

โฟมขนาด 14 ไบต์

[. .'|: ~|]: ~

นี้พิมพ์ควินโฟมที่สองที่สามารถพบได้ที่นี่ อันนี้สั้นกว่าจริงเพราะ.จะใส่ช่องว่างระหว่างองค์ประกอบแต่ละอันเสมอ แต่แถบในโทเค็นที่สามทำให้ฉันสามารถเว้นช่องว่างไว้ก่อนหน้าได้

Husk , 6 ไบต์

D"S+s¨

ลองออนไลน์!

S+s"S+s"พิมพ์แกลบควินมาตรฐาน

 "S+s¨    The string S+s"
D         concatenated with itself.

ควินอธิบาย:

   "S+s"    The string S+s
 +          concatenated with
S           itself passed through
  s         the function which returns its string representation.