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

หากโปรแกรมดั้งเดิมของคุณคือDerp:

Derp -> Derp (must return itself as output to be a quine)

DerpDerp -> DDeerrpp
(the "Derp" is copied twice, so each character in the output has to be copied twice)

DerpDerpDerp -> DDDeeerrrppp
etc. etc.

โปรดทราบว่าคุณได้รับอนุญาตให้มีช่องว่างในโปรแกรม "base" ของคุณ แต่จะถูกนับเมื่อ "interweaving" สมมติว่าโปรแกรมของคุณคือ

Derp 
{newline}

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

Derp 
Derp 
{newline}

คุณต้องส่งออก

DDeerrpp  
{newline}
{newline}

โปรดทราบว่ามี2ช่องว่างเพิ่มเติมหลังจากDDeerrppช่องว่างพิเศษหลังจากที่

กฎและข้อกำหนด:

• โปรแกรมของคุณต้องมีอักขระที่แตกต่างอย่างน้อยสองตัว (ซึ่งแสดงว่ารหัสของคุณต้องมีความยาวอย่างน้อย 2 ไบต์)
• ใช้กฎมาตรฐานควินิน

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

ฟิชชัน 6 ไบต์

'!+OR"

ลองออนไลน์! ลองสองชุด! ลองสาม!

คำอธิบาย

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

เพื่อความสมบูรณ์ฉันจะขอย้ำอีกครั้งว่าโปรแกรมทำงานอย่างไร ไม่ว่าเราจะทำซ้ำโปรแกรมหรือไม่ (เช่น'!+OR"'!+OR"'!+OR") แต่ละอะตอมจะเห็นรหัสต่อไปนี้:

R"'!+OR"'!+O

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

Python 2.7, 377 310 304 194 191 ไบต์!

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

def f():
 import threading as T,inspect as i;global t,a,i
 try:t.cancel()
 except:a=0
 a+=1;t=T.Timer(1,d);t.start()
def d():print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")
f()

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

หากเราลองรันด้วยซอร์สโค้ดเดียวกัน x2 เราจะได้ผลลัพธ์ที่ถูกต้องเช่นกัน คุณสามารถลองที่นี่ x3, x4 ฯลฯ ทำงานได้ตามที่คาดหวัง

ไม่พอใจกับคำอธิบาย:

def f():                                   # Defines a central function f
    import threading as T,inspect as i     # Imports threading and inspect
    global t,a,i                           # Global vars
    try:
        t.cancel()                         # Tries to cancel Timer from previous code
    except:
        a = 0                              # Reached when code is 1st copy; initializes a.
    a += 1                                 # a++; this is the number of copies thus far.
    t = T.Timer(1,d)               # Creates, then starts a timer to call function
    t.start()                              # d in 1 second.

def d():                                   # Prints out the source code; the quine part.
    print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")

f()                                        # Calls f()!

CJam , 19 ไบต์

{]W=s"_~"+T):Te*}_~

ลองออนไลน์!

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

{               }_~  Define an anonymous code block (function).
                 _~  Push a copy, and execute the copy.
 ]W=                 Wrap the entire stack in an array and select its last element.
                     This discards whatever was on the stack before the original
                     code block, which is needed for subsequent iterations.
    s"_~"+           Cast the code block to string, push "_~", and concatenate.
                     This pushes the stringified source code on the stack.
          T):T       Push T (initially 0), increment it, and save the result in T.
              e*     Repeat each character in the stringified source code T times.

RProgN , 66 ไบต์

ช่องว่างที่สำคัญคือความตายของฉัน

[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R 

อธิบาย

[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R   #
[                                                                   # Pop whatever is already on the stack, if anything.
  "[ %q ] F 0 1 + `0 = `. { 0 m } R "                               # This string contains basically the entire function.
                                      ] F                           # ] F duplicates the string, and then F formats it, which in this case puts the first string into the second at %q, surrounded by qoutes.
                                          0 1 + `0 =                # I needed an Incrementer, so I chose 0. 0, is conveniently, pre initilized at 0. And because RProgN is horrifying, you can remap the number functions as they're just more variables. So this increments 0 every time the group is called.
                                                     `. { 0 m } R   # Replace each character with itself repeated '0' times. Because '0' is an incrementer, each time the script is called, the amount of times the characters are repeated increase.

ท่านผู้ดีฉันเป็นสัตว์ประหลาด ...

ลองออนไลน์!

Perl 5, 107 ไบต์

$_=q[$_=q[S];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}

Ungolfed:

$_ = '...INSERT_SOURCE_HERE...';      # Standard quine
s/INSERT_SOURCE_HERE/$_;
$a++;                                 # Count the number of repetitions
END {
    s/./$&x$a/eg;                     # Interweave
    print if $a;                      # Print...
    $a=0;                             # ...but only once
}

ลองออนไลน์!

Python 3 , 122 121 112 ไบต์

s='try:from atexit import*;n+=1\nexcept:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])';exec(s);

ลองใช้ออนไลน์: หนึ่งสำเนา | สองชุด | สามชุด | สี่ชุดพร้อมการตรวจสอบอัตโนมัติ

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

สิ่งนี้ใช้ Python quine มาตรฐาน: เก็บรหัสที่คุณต้องการใช้ในตัวแปร (เป็นสตริง); รวมตรรกะในสตริงนั้นเพื่อพิมพ์ตัวเองทุกอย่างก่อนหน้าและทุกอย่างหลังจากนั้น จากนั้นรันสตริงนั้น

รหัสที่ดำเนินการผ่านสายอักขระsมีดังต่อไปนี้

try:from atexit import*;n+=1
except:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])

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

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

ตัวจัดการทางออกที่ลงทะเบียน

lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s]

จะถูกเรียกใช้ก่อนที่โปรแกรมจะเสร็จสิ้น แลมบ์ดาที่ตัวเองสร้างสตริง"s=%r;exec(s);"%s- %rสร้างตัวแทนสตริงของอาร์กิวเมนต์ขวา ( s ) ซึ่งรวมถึงทุกอย่างระหว่างราคาเดียวและคำพูดของตัวเอง - แล้ว iterates มากกว่าตัวละคร สำหรับตัวละครแต่ละตัวคเราก็พิมพ์nสำเนาของค การส่งผ่านc*nเป็นอาร์กิวเมนต์ที่ตั้งชื่อendเพื่อprintหมายความว่าจะไม่มีการป้อนบรรทัดต่อท้าย

CJam , 14 ไบต์

{s"_~"+]:.+}_~

ลองออนไลน์!

คำอธิบาย

{s"_~"+]:.+}_~
{s"_~"+    }_~ Basic quine operator.
       ]:.+    Append each character to corresponding element of the previous result if existed.