Tulis sebuah program (atau fungsi) (sebut saja P1), yang ketika dijalankan, mengeluarkan P2 program lain dari bahasa yang sama dan tepatnya 1 byte lebih panjang dari P1.

Program P2 saat dijalankan, harus mengeluarkan program ke-3 P3 yang 1 byte lebih panjang dari P2. P3 harus menampilkan program P4 yang satu byte lebih panjang dari P3, dll. Hal yang sama untuk P5, P6, ..., P∞.

Rantai program harus pergi tanpa batas waktu, atau ke tempat di mana penerjemah tidak dapat menangani lagi (tetapi harus tetap sebagai program yang secara teoritis valid dalam bahasa)

Aturan

• Celah standar dilarang
• Semua program dalam rantai harus dalam satu bahasa
• Tidak ada input yang diberikan. Output menuju ke stdout atau nilai pengembalian fungsi
• Program harus berakhir setelah periode waktu tertentu. Program yang berhenti menghasilkan output setelah titik waktu tertentu tetapi tidak pernah berakhir tidak memenuhi syarat

P1 program terpendek dalam byte di setiap bahasa menang!

JavaScript (ES6), 14 12 byte

-2 byte terima kasih kepada @Shaggy

f=_=>"f=_"+f

Cuplikan pengujian

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

7 , 4 byte ASCII

1603

Cobalah online!

Saya tahu bahwa 7 biasanya tidak dikodekan dalam ASCII, tapi kali ini ini adalah pengkodean yang lebih nyaman sehingga kami menambahkan 1 byte setiap kali dijalankan, bukan 3 bit.

Saya juga tidak yakin apakah ini dianggap curang atau tidak. (Biasanya tidak jelas apakah 7 quine curang atau tidak, karena melintasi garis batas dalam beberapa cara.) Anda dapat membuat argumen yang layak untuk 0mengkodekan 6, tetapi secara umum tidak jelas dari mana karakter yang dihasilkan "berasal dari" "di 7 karena memiliki begitu banyak, perilaku aneh, cukup aneh.

Program ini mencetak dirinya sendiri dengan 1menambahkan, dan akan melakukannya bahkan jika Anda menambahkan sejumlah 1untuk itu. Inilah jejak debug yang dikomentari 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(Tidak ada yang |tersisa dalam program, jadi eakan segera keluar dari program sebagai efek samping, artinya final 7tidak pernah berjalan).

Kebingungan dasar tentang dari mana semua karakter berasal adalah bahwa sebagian besar perintah di 7 hanya menghasilkan data saat dijalankan, dan kemudian 6mencoba untuk merekonstruksi urutan perintah yang akan menghasilkan fragmen data yang diberikan; ini seringkali berakhir dekat dengan, tetapi tidak identik dengan, aslinya. (Untuk tujuan quining, Anda biasanya menulis program 7 sedemikian rupa sehingga hasilnya akan hampir sama, biasanya berbeda dalam memimpin atau mengikuti 7.) Jadi misalnya, 1dalam data menjadi 716, yang merupakan cara termudah untuk menambahkan 1ke string data saat ini. Kami awalnya memproduksinya dengan 16, urutan karakter yang berbeda (tetapi serupa), secara destruktif menghapus salah satu|penanda data dimulai dengan. (Saya kira mungkin argumen terbaik bahwa ini bukan quine literal-satunya adalah bahwa output berbeda dari input!)

Haskell , 74 66 byte

EDIT:

• -2 byte oleh H.PWiz dengan menggunakan <>, lalu -6 dengan memindahkan (10*)<$>.

Ini sekarang menggunakan <>operator baru yang bebas ( Semigroupperkalian, membutuhkan GHC 8.4 untuk bekerja tanpa impor.)

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Cobalah online! (Curang dengan impor karena TIO belum memiliki GHC 8.4.)

Bagaimana itu bekerja

• main=putStr$ adalah boilerplate untuk menampilkan nilai string berikut.

• fst<>showadalah fungsi yang mengambil tuple, dan mengembalikan string yang terdiri dari elemen pertama tuple yang digabungkan dengan representasi string tuple. Yaitu

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>mengalikan elemen terakhir dari tuple berikut dengan 10, menambahkan digit 0ke representasi stringnya.

C (gcc) , 134 132 byte

Pengerjaan ulang sedikit dari quine C canonical. Sangat panjang.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Cobalah online!

Fisi 2 , 7 byte

'!+OR!"

Cobalah online!

Kueri Fisi standar , tetapi dengan tambahan !yang mencetak 0x01 tambahan di awal kode pada setiap iterasi.

Pari / GP , 35 byte

(f=(x)->print1("(f="f")("1x")"))(1)

Cobalah online!

Python 2 , 38 byte

s="print's=%r;exec s'%(s+'#')";exec s

Cobalah online!

brainfuck , 420 byte

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Cobalah online!

Ini adalah modifikasi pada quine BrainFuck "standar" , dengan tanda .akhir pada .setiap iterasi tambahan .

Quine itu sendiri mengkodekan karakter Brainfuck sebagai tumpukan digit hex: khususnya, digit hex c-0x2b, yang dengan mudah adalah sebagai berikut:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

Pengkodean mencakup dua cuplikan kode: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++mendorong pengodean pengkodean itu sendiri, dan [[<++++++++++++++++>-]<+++++++++.<]berjalan di tumpukan dan mencetak semuanya.

Kotor , 9 byte

'"n[!]a!␛

Cobalah online!

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Jika membaca kode sumber diperbolehkan:

Kotor , 8 byte

Q[!]W33!

Cobalah online!

Dijelaskan:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Mungkin valid:

Kotor , 4 byte

Q[‼]

Cobalah online!

Ini mencetak kode sumber dengan baris baru.
(Dan banyak ruang, karena bug. Ia bekerja sama tanpa mereka.)

Perhatikan bahwa ini hanya bekerja di set karakter asli, dan tidak ketika Anda menggunakan front-end UTF8 - jadi untuk mencobanya pada TIO Anda perlu mengganti karakter yang dihasilkannya antara huruf []s ‼, yang merupakan nilai setara UTF8 untuk pencetakannya .

Java 8, 162 146 byte

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

Cobalah online.
Coba program keluaran pertama ; Coba program keluaran kedua ; Coba program keluaran ketiga .

Penjelasan:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -part :

• Ini String sberisi kode sumber yang tidak diformat.
• %sdigunakan untuk memasukkan String ini ke dalam dirinya sendiri dengan s.format(...).
• %c, %1$cdan 34digunakan untuk memformat tanda kutip ganda.
• s.format(s,34,s) menempatkan semuanya bersama-sama

Bagian tantangan:

• +1 menambahkan 1 ke program yang tidak diformat dan diformat.
• .replaceAll("1+$","");}: Karena kami hanya ingin meningkatkan byte-count program dengan satu alih-alih dua, kami menghapus trailing 1s sebelum kembali.

> <> , 9 byte

#o<:}-1:"

Cobalah online!

Variasi pada quine klasik> <>, yang hanya menambahkan perintah dupe lain untuk menyalin #di depan.

Perl 5 , 32 byte

$_=q{say"\$_=q{$_
};eval"};eval

Cobalah online!

GolfScript , 9 byte

{'.~1'}.~

Cobalah online!

CJam , 9 byte

{"_~1"}_~

Cobalah online!

Saya memposting kedua solusi ini dalam jawaban yang sama, karena keduanya hanya variasi sepele satu sama lain dan bekerja dengan cara yang persis sama. Keduanya didasarkan pada quine GolfScript umum {'.~'}.~(atau {"_~"}_~dalam CJam), yang dijelaskan secara lebih rinci misalnya dalam jawaban saya sebelumnya.

Satu-satunya perbedaan adalah bahwa varian ini menambahkan 1byte ke akhir outputnya. Seperti yang terjadi, string apa pun dari 1s (atau bilangan bulat integer lainnya tanpa angka nol di depan) itu sendiri adalah quine sepele di GolfScript dan CJam, jadi siapa pun yang sudah ada di akhir kode di atas hanya akan disalin kata demi kata ke output. Karena GolfScript (dan CJam) menggunakan bilangan bulat panjang sewenang-wenang, ini akan bekerja untuk program panjang yang sewenang-wenang, setidaknya selama komputer yang menjalankan kode memiliki cukup memori untuk menyimpannya.

Attache , 76 72 61 byte

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Cobalah online!

Quine standar yang menambahkan ruang ke akhir xsetelah setiap iterasi.

Beberapa iterasi pertama:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

dll.

Attache, 72 byte

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Cobalah online!

Ini hanyalah variasi dari quine format standar, dengan variabel yyang diatur 10*ysetelah setiap iterasi

Beberapa iterasi pertama:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

dll.

Swift 4 , 89 bytes

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Termasuk baris baru yang tertinggal

Cobalah online!

Haskell , 88 byte

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Cobalah online! Tumbuh dengan menambahkan terlebih dahulu #ke string data.

Stax , 20 18 byte

"34s+cTZL"34s+cTZL

Jalankan dan debug itu

Menghasilkan ruang ekstra sebelum tanda kutip kedua setiap iterasi.

Penjelasan

Menggunakan program "34s+cTZL "34s+cTZLuntuk menjelaskan.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Jstx , 4 byte

£↕♣:

Cobalah online!

Pesona Rise , 6 byte

"'<S@>

Cobalah online!

Yang ini aneh. Yang harus saya lakukan adalah menghapus a ~dari quine asli yang ditemukan oleh Jo King .

Setiap tambahan menjalankan menambahkan yang lain <sampai akhir, misalnya:

"'<S@><<<<<<<<<

Semuanya tidak melakukan apa-apa.

Salinan langsung jawaban ini pada tantangan terkait. Kebetulan sudah tumbuh 1 byte setiap iterasi (argumen kuat untuk tantangan ini menjadi duplikat dari yang satu atau sebaliknya).

Jelly , 11 byte

“⁾;⁶;ØV” ṘV

Cobalah online!

Bertanya-tanya , 33 byte

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Varian yang menarik pada quine normal yang menambahkan 1 setelah setiap iterasi.

Kemajuan:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Penjelasan

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

Salah satu bagian yang menarik dari quine ini adalah Wonder dapat bekerja dengan jumlah presisi yang sewenang-wenang, sehingga progres tidak akan terputus setelah sejumlah tertentu.

ColdFusion, 277 byte

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Ini adalah modifikasi sepele dari quine ColdFusion saya yang menambahkan baris baru setiap kali namanya.

Diuji secara lokal pada lucee-express-5.2.6.60

Windows Batch, 38 36 byte

echo|set/p"=q">q&copy/b/y %0+q %0
::

Kode ini membuat file yang disebut "q", yang mengandung huruf 'q', dan kemudian menambahkannya ke file asli. Perhatikan bahwa "::" adalah alias untuk "rem" yang tidak memerlukan ruang tambahan.

Disimpan 2 byte berkat pengguna3493001.

Gol> <> , 7 byte

":r2ssH

Cobalah online! Cobalah online !! Cobalah online !!!

Ini adalah variasi sederhana dari Gol biasa > <> quine tetapi menambahkan salinan Hsetiap kali dijalankan. Karena Hperintah menghentikan program, tambahan Hdi akhir tidak mengubah perilaku.

T-SQL , 175 byte

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

Pertama saya menulis quine SQL, kemudian saya memodifikasinya untuk menambah ruang tambahan (agak terinspirasi oleh jawaban ini ).

Befunge-98 (PyFunge) , 22 19 byte

r:#,_ #;'D2/'<,,@;"

Cobalah online!

Menambahkan <sebelum yang terakhir "setiap generasi.

C # (Visual C # Interactive Compiler) , 89 byte

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Terinspirasi oleh jawaban Kevin Cruijssen.

Cobalah online!