งาน

คุณจะได้รับสตริงในการป้อนข้อมูลประกอบเพียงตัวละครจากที่aไปzเช่นการป้อนข้อมูลจะตรงกับ /^[a-z]*$/regex

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

ตัวอย่าง

โปรแกรมของคุณจะได้รับอินพุตabcและเอาต์พุต:

...abc...

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

...abc...

นั่นคือมันส่งออกตัวเอง

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์

อ้างอิง

• สิ่งที่ถือว่าเป็นควินที่เหมาะสม?

Python 3, 57 61 bytes

lambda x:"s='s=%r;print(s%%s)';print(s%s)".replace('s',x+'x')

ใช้ python 3 quine พื้นฐานจากที่นี่และแทนที่ชื่อตัวแปรด้วยอินพุต

หมายเหตุ:ในฐานะที่เป็นแหลมออกโดยไฮเปอร์นิวตริโนในความคิดเห็นนี้ไม่ได้ผลสำหรับคำหลักลิขสิทธิ์เช่นfor, ifฯลฯ

การต่ออักขระที่ไม่มีคำหลักที่สงวนไว้ลงท้ายด้วยเช่น'x'หรือหมายเลขใด ๆ จะแก้ไขสิ่งนี้ (Ørjan Johansen)

เยลลี่ขนาด 9 ไบต์

เครื่องกำเนิดไฟฟ้า

;“¶Øv”ṾØv

ลองออนไลน์!

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

;“¶Øv”ṾØv  Main link. Argument: s (string of letters)

;“¶Øv”     Concatenate s and the string "\nØv".
      Ṿ    Uneval; get its string representation.
           (implicit) Print the previous return value since the next link is an
           otherwise unparsable nilad.
       Øv  Set the return value to "Ṙv".

ควิน

หากอินพุตเป็นquineโปรแกรมต่อไปนี้จะถูกสร้างขึ้น

“quine
Øv”Ṙv

ลองออนไลน์!

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

นี่คือ Quine Jelly มาตรฐาน ครั้งแรก

“quine
Øv”

"quine\nØv"ชุดอาร์กิวเมนต์ด้านซ้ายและค่าส่งกลับสตริง

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

หลังจากนั้นvนำอาร์กิวเมนต์ซ้ายและส่งผ่านเป็นอินพุตไปยังโปรแกรม Jelly

quine
Øv

ในโปรแกรม Jelly ทั้งหมดจะมีการดำเนินการเฉพาะลิงก์หลัก (กำหนดในบรรทัดสุดท้าย) ดังนั้นบรรทัดแรกจะถูกละเว้นทั้งหมด

ในที่สุดØvตั้งค่าส่งคืน"Ṙv"เป็นซึ่งจะถูกพิมพ์โดยปริยายเมื่อโปรแกรมภายนอกเสร็จสิ้น

Haskell , 51 ไบต์

q รับสตริงและส่งคืนสตริง

q s|t<-"main=putStr$fst`mappend`show$"=t++show(t,s)

ลองออนไลน์!

ตัวอย่างผลลัพธ์สำหรับputStr$q"test":

main=putStr$fst`mappend`show$("main=putStr$fst`mappend`show$","test")

ลองออนไลน์!

• วางข้อความ quine หลักและสตริงที่ต้องการใน tuple
• ใช้fstเพื่อแยกข้อความหลัก
• ใช้showเพื่อเปลี่ยน tuple ทั้งหมดเป็นสตริง
• ใช้mappendเพื่อรวมฟังก์ชั่นก่อนหน้าทั้งสอง สะดวกmappendในสองฟังก์ชั่นที่ให้ฟังก์ชั่นที่ใช้แต่ละฟังก์ชั่นกับอาร์กิวเมนต์ของมันและรวมผลลัพธ์กับmappendประเภทผลลัพธ์ (นี่คือการต่อสายสตริง)

อันเดอร์ 14 ไบต์

(~aSaS(:^)S):^

ลองออนไลน์!

ใช้เป็น(test)(~aSaS(:^)S):^- ซึ่งเป็นตัวเอง quine

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

• อันเดอร์โหลดเป็นภาษาที่ลึกลับ (ตามสแต็ก) ไม่รองรับอินพุตการอ่านดังนั้นการขัดแย้งใด ๆ จะถูกวางลงบนสแต็กในตอนแรก
• (test)และ(~aSaS(:^)S)เป็นตัวอักษรสตริงดังนั้นวางตัวเองบนสแต็คกับหลังอยู่ด้านบน
• :ทำซ้ำ(~aSaS(:^)S)สตริงที่ด้านบนของสแต็กจากนั้น^รันเนื้อหาในรูปของโปรแกรมย่อย
• ~สลับองค์ประกอบสองอันดับแรกบนสแต็กดังนั้นตอนนี้จึง(test)เป็นสุดยอด
• aล้อม(test)ด้วยเครื่องหมายวงเล็บพิเศษ
• Sใช้สตริง((test))ที่ด้านบนของสแต็กและพิมพ์โดยไม่มีวงเล็บด้านนอก (ซึ่งเป็นเพียงแค่ตัวอักษรไวยากรณ์)
• ตอนนี้aSพิมพ์ส่วนที่เหลือ(~aSaS(:^)S)บนสแต็กในทำนองเดียวกัน (พร้อมวงเล็บ)
• ที่ล่าสุดพิมพ์สุดท้าย(:^)S:^

อันเดอร์ 14 ไบต์

a(aS(:^)S)~*:^

ลองออนไลน์!

แนวทางที่แตกต่างจากคำตอบ Underload อื่น ๆ ; มากกว่าตัวเองเป็นควินนี่สร้างควิน ที่น่าสนใจคือมีจำนวนไบต์เท่ากัน นี่คือฟังก์ชันที่รับอาร์กิวเมนต์จากสแต็กและเอาต์พุตไปยังเอาต์พุตมาตรฐาน

คำอธิบาย

a(aS(:^)S)~*:^
a               Generate a string literal containing the input
 (aS(:^)S)~*    Prepend "aS(:^)S"
            :^  Mockingbird: run the resulting function with itself as argument

ฟังก์ชั่นที่ได้จะเป็นดังนี้:

aS(:^)S(input)
aS              Print a string literal containing the argument
  (:^)S         Print ":^"
       (input)  Push "input" onto the stack

ในคำอื่น ๆ :^มันพิมพ์สตริงตัวอักษรที่มีตัวเองตาม นี่เป็นควินอย่างชัดเจน (เพราะสิ่งที่เพิ่งพิมพ์ออกมานั้นเหมือนกับรหัสที่เราเรียกใช้เพื่อทำงานในตอนแรก)

V , 9 ไบต์

ñ"qPxÉÑ~j

ลองออนไลน์!

นี่คือการดัดแปลงของquine V มาตรฐานและฉันภูมิใจที่นี่นานกว่าหนึ่งไบต์

hexdump:

00000000: f122 7150 78c9 d17e 6a                   ."qPx..~j

คำอธิบาย:

ñ           " Record the following commands into register 'q'
 "qP        " Paste register 'q' before all input
    x       " Delete the last character of what we just pasted (this will be a 'ÿ')
     ÉÑ     " Insert 'Ñ' at the beginning of this line
       ~    " Toggle the case of this character
        j   " Move down a line. During playback, this will cancel playback of the current macro,
            " So everything after here is a NOOP

จากนั้นการบันทึกจะหยุดและเล่นโดยปริยาย สิ่งนี้จะสร้างผลลัพธ์ต่อไปนี้:

ñ"qPxÉÑ~jHello

เนื่องจากjจะทำให้การเล่นมาโครไม่Helloสามารถทำงานได้

Python 2, 38 ไบต์

แม้ว่าอินพุตจำเป็นต้องใช้เพื่อรองรับเท่านั้น แต่a-zควรทำงานกับอินพุตบรรทัดเดียวที่ไม่มี NUL ไบต์

s='s=%r;print s%%s#'+input();print s%s

ลองออนไลน์

สำหรับการป้อนข้อมูลabcควินที่เกิดขึ้นคือ:

s='s=%r;print s%%s#abc';print s%s#abc

ลองออนไลน์

RProgN 2 , 15 ไบต์

"{']C'.%q[}]C"F

อธิบาย

ใช้รูปแบบ

{']C'.%q[}]C}

ซึ่ง%qเป็นอินพุต qouted สร้างรสชาติของ quine

{']C'."Some Text"[}]C

ซึ่งเป็น quine RProgN2 มาตรฐาน{']C'.}]Cนั่นคือก่อนที่จะเสร็จสิ้นจะผนวกและทำลายสตริงที่ป้อนเข้า

ลองออนไลน์!

เรติน่า 14 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

\(\`^
¶\(*S1`|

ลองออนไลน์!

สำหรับอินพุตxเอาต์พุตนี้:

\(*S1`|x
\(*S1`|x

คำอธิบาย

เอาท์พุทคือการเปลี่ยนแปลงเล็ก ๆ น้อย ๆ ของควินมาตรฐาน เราเพียงแค่ใช้ regex |xแทนregex ที่ว่างเปล่า เนื่องจากการ|อนุญาตยังคง (และจัดลำดับความสำคัญ) และการจับคู่ว่างเปล่าฟังก์ชันการทำงานเองจึงไม่ได้รับผลกระทบและเนื่องจากxจะมีเพียงตัวอักษรเท่านั้นจึงรับประกันได้ว่าจะเป็นไวยากรณ์ของ regex ที่ถูกต้อง

การพิมพ์นี้ใช้เทคนิคที่คล้ายกับควินเองจริงๆ เพื่อหลีกเลี่ยงความซ้ำซ้อนของควินินเราใส่¶\(*S1`|เพียงครั้งเดียวในจุดเริ่มต้นของสตริง นั่นคือครึ่งหนึ่งของรหัสที่มา หากต้องการพิมพ์สองครั้งโดยไม่ต้องป้อนบรรทัดเราใช้การกำหนดค่า\(\ซึ่งรวมโปรแกรมทั้งหมดไว้ในกลุ่มและทำให้ทั้งขั้นตอนนั้นรวมถึงกลุ่มที่บรรจุผลลัพธ์ที่พิมพ์โดยไม่ต้องป้อนบรรทัด

Japt , 14 ไบต์

"\"iQ ²ª`"+U ²

ทดสอบออนไลน์! สำหรับอินพุตของabcเอาต์พุต

"iQ ²ª`abc"iQ ²ª`abc

ซึ่งเอาท์พุทตัวเอง ทดสอบออนไลน์!

คำอธิบาย

นี่คือส่วนขยายของ Japt quine ที่สามารถรับน้ำหนักได้มาตรฐาน:

"iQ ²"iQ ²

"iQ ²"      // Take this string.  iQ ²
      iQ    // Insert a quote.    "iQ ²
         ²  // Repeat this twice. "iQ ²"iQ ²
            // Implicit: output result of last expression

แต่ที่แตกต่างคือการที่เราผนวกª`abcที่สิ้นสุดซึ่งใน JavaScript ||"abc"เป็นพื้น เนื่องจากผลลัพธ์ของส่วนแรกจะเป็นสตริงที่ไม่ว่างเปล่า (ความจริง) จึง||ไม่มีการเรียกใช้

มีหลายทางเลือกที่มีความยาวเท่ากัน:

"iQ ²ª`abc"iQ ²ª`abc   quine||"abc"
"iQ ²ª$abc"iQ ²ª$abc   quine||abc
"iQ ²ª{abc"iQ ²ª{abc   quine||function(){ ... }
"iQ ²ªXabc"iQ ²ªXabc   quine||X.a(...) (X could be any uppercase letter or digit)
"iQ ²//abc"iQ ²//abc   quine//abc      (// is a comment in JS/Japt)
"iQ ²;[abc"iQ ²;[abc   quine;          (unmatched [ causes a parsing error)

CJam , 16 14 ไบต์

"`_~"q`';++`_~

ลองออนไลน์!

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

"`_~"           e# Push "`_~"
     q`         e# Push a string representation of the input (input wrapped in quotes)
       ';       e# Push a semicolon
         ++     e# Concatenate all this together
           `    e# Get the string representation of the resulting string
            _~  e# Duplicate it and eval it (pushing the original string on the stack again)

"`_~\"test\";"`_~"test";ซึ่งสิ่งที่ต้องการเอาท์พุท

JavaScript ขนาด 21 ไบต์

$=_=>`$=${$}/*${_}*/`

Perl 5 , 35 ไบต์

$_=q{say"\$_=q{$_};eval"#}.<>;eval

ลองออนไลน์!