Napisz program (lub funkcję) (nazwijmy go P1), który po uruchomieniu wyświetla inny program P2 tego samego języka i dokładnie 1 bajt dłuższy niż P1.

Program P2 po uruchomieniu powinien wypisać trzeci program P3, który jest o 1 bajt dłuższy niż P2. P3 musi wygenerować program P4, który jest o jeden bajt dłuższy niż P3 itp. To samo dla P5, P6, ..., P∞.

Łańcuch programu powinien iść w nieskończoność lub do miejsca, w którym tłumacz nie jest już w stanie obsłużyć (ale musi pozostać jako teoretycznie poprawny program w języku)

Zasady

• Standardowe luki zabronione
• Wszystkie programy w łańcuchu powinny być w jednym języku
• Nie podano danych wejściowych. Wyjście przechodzi do wartości standardowej lub zwracanej przez funkcję
• Program musi zakończyć się po pewnym czasie. Program, który przestaje generować dane wyjściowe po określonym czasie, ale nigdy się nie kończy, nie kwalifikuje się

Najkrótszy program P1 w bajtach w każdym języku wygrywa!

JavaScript (ES6), 14 12 bajtów

-2 bajty dzięki @Shaggy

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

Testowanie fragmentu kodu

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

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

<pre id=o></pre>

7 , 4 bajty ASCII

1603

Wypróbuj online!

Wiem, że 7 nie jest zwykle kodowane w ASCII, ale tym razem jest to wygodniejsze kodowanie, dlatego dodajemy 1 bajt z każdym uruchomieniem, a nie 3 bity.

Nie jestem również pewien, czy liczy się to jako oszustwo, czy nie. (Zwykle nie jest jasne, czy siódemka jest oszustem, ponieważ przecina granicę na wiele sposobów.) Możesz zrobić porządny argument, że 0koduje 6, ale ogólnie nie jest jasne, skąd pochodzą uzyskane znaki w 7, ponieważ ma tak wiele dziwacznych, ukrytych zachowań.

Ten program drukuje się z 1dołączonym i zrobi to, nawet jeśli dodasz do niego kilka 1s. Oto skomentowany ślad debugowania 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

(W programie nie ma już nic |, więc enatychmiast wyjdzie z programu jako efekt uboczny, co oznacza, że ​​finał 7nigdy się nie uruchomi).

Podstawowe zamieszanie wokół tego, skąd pochodzą wszystkie znaki, polega na tym, że większość poleceń w 7 po prostu generuje dane po uruchomieniu, a następnie 6próbuje odtworzyć sekwencję poleceń, które wytworzyłyby dany fragment danych; często kończy się to na oryginale, ale nie identycznym. (Do celów quiningowych zwykle piszesz program 7 w taki sposób, że wynik będzie prawie taki sam, zwykle różniący się początkowymi lub końcowymi 7s.) Tak więc na przykład 1dane stają się 716, co jest najłatwiejszym sposobem na dołączenie 1do bieżącego ciągu danych. Pierwotnie stworzyliśmy go z 16inną (ale podobną) sekwencją znaków, niszcząc destrukcyjnie jedną z nich|znaczniki, od których zaczęły się dane. (Wydaje mi się, że najlepszym argumentem, że nie jest to dosłowny quine, jest to, że wynik różni się od danych wejściowych!)

Haskell , 74 66 bajtów

EDYTOWAĆ:

• -2 bajty H.PWiz za pomocą <>, a następnie -6, przesuwając (10*)<$>.

Teraz używa nowego, bezpłatnego <>operatora ( Semigroupmnożenie, wymaga GHC 8.4 do pracy bez importu).

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

Wypróbuj online! (Kody z importem, ponieważ TIO nie ma jeszcze GHC 8.4).

Jak to działa

• main=putStr$ jest płytą kotłową, która wyświetla następującą wartość ciągu.

• fst<>showjest funkcją, która pobiera krotkę i zwraca ciąg znaków składający się z pierwszego elementu krotki połączonej z reprezentacją ciągu krotki. To znaczy

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

• (10*)<$>mnoży ostatni element następnej krotki przez 10, dodając cyfrę 0do jego reprezentacji ciągu.

C (gcc) , 134 132 bajty

Nieznaczna przeróbka kanonicznej litery C. Strasznie długo.

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);}

Wypróbuj online!

Rozszczepienie 2 , 7 bajtów

'!+OR!"

Wypróbuj online!

Standardowa Quine rozszczepienia , ale z dodatkową, !która wypisuje dodatkowe 0x01 na początku kodu na każdej iteracji.

Pari / GP , 35 bajtów

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

Wypróbuj online!

Python 2 , 38 bajtów

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

Wypróbuj online!

pieprzenie mózgu , 420 bajtów

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

Wypróbuj online!

Jest to modyfikacja „standardowej” Quine BrainFuck , za pomocą.. każdą dodatkową iterację.

Quine sama koduje znaki Brainfuck jako stos cyfr szesnastkowych: konkretnie cyfry szesnastkowe c-0x2b, które dogodnie są następujące:

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

Kodowanie obejmuje dwa fragmenty kodu: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++przesuwa kodowanie samego kodowania, [[<++++++++++++++++>-]<+++++++++.<]przechodzi stos i drukuje wszystko.

Brudny , 9 bajtów

'"n[!]a!␛

Wypróbuj 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

Jeśli odczyt kodu źródłowego jest dozwolony:

Brudny , 8 bajtów

Q[!]W33!

Wypróbuj online!

Wyjaśniono:

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

Może być ważny:

Brudny , 4 bajty

Q[‼]

Wypróbuj online!

Drukuje kod źródłowy z końcowym znakiem nowej linii.
(I kilka spacji z powodu błędu. Działa to jednak bez nich.)

Pamiętaj, że działa tylko w natywnym zestawie znaków, a nie podczas korzystania z interfejsu użytkownika UTF8 - więc aby wypróbować go w TIO, musisz zastąpić znak, który wypisuje między []s ‼, który jest odpowiednikiem UTF8 dla tego, co drukuje .

Java 8, 162 146 bajtów

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+$","");}

Wypróbuj online.
Wypróbuj pierwszy program wyjściowy ; Wypróbuj drugi program wyjściowy ; Wypróbuj trzeci program wyjściowy .

Wyjaśnienie:

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:

• String sZawiera kod źródłowy niesformatowany.
• %ssłuży do wprowadzania tego ciągu do siebie za pomocą s.format(...).
• %c, %1$ci 34służą do formatowania podwójnych cudzysłowów.
• s.format(s,34,s) łączy to wszystko razem

Część wyzwania:

• +1 dodaje 1 zarówno do niesformatowanego, jak i sformatowanego programu.
• .replaceAll("1+$","");}: Ponieważ chcemy zwiększyć liczbę bajtów w programie tylko o jeden zamiast dwóch, usuwamy wszystkie końcowe 1 przed powrotem.

> <> , 9 bajtów

#o<:}-1:"

Wypróbuj online!

Wariacja na temat klasycznej> <> quine, która po prostu dodaje kolejne polecenie dupe, aby skopiować #przód.

Perl 5 , 32 bajty

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

Wypróbuj online!

GolfScript , 9 bajtów

{'.~1'}.~

Wypróbuj online!

CJam , 9 bajtów

{"_~1"}_~

Wypróbuj online!

Oba te rozwiązania zamieszczam w tej samej odpowiedzi, ponieważ są to tylko trywialne odmiany i działają dokładnie w ten sam sposób. Oba są oparte na typowym quinie GolfScript {'.~'}.~(lub {"_~"}_~w CJam), który jest opisany bardziej szczegółowo np . W mojej poprzedniej odpowiedzi.

Jedyną różnicą jest to, że ten wariant dołącza 1bajt na końcu danych wyjściowych. Tak się składa, że ​​dowolny ciąg 1s (lub dowolny literał całkowity bez wiodących zer) sam w sobie jest trywialnym quine zarówno w GolfScript, jak i CJam, więc wszystkie już obecne na końcu powyższego kodu zostaną po prostu skopiowane dosłownie na wyjście. Ponieważ GolfScript (i CJam) używają liczb całkowitych o dowolnej długości, będzie to działać dla dowolnie długich programów, przynajmniej tak długo, jak długo komputer z uruchomionym kodem ma wystarczającą ilość pamięci, aby go zapisać.

Attache , 76 72 61 bajtów

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

Wypróbuj online!

Standardowy quine, który dodaje spację na końcu xpo każdej iteracji.

Kilka pierwszych iteracji:

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]]

itp.

Attache, 72 bajty

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

Wypróbuj online!

Jest to po prostu odmiana standardowego formatu quine ze zmienną yustawioną na 10*ypo każdej iteracji

Kilka pierwszych iteracji:

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]

itp.

Swift 4 , 89 bajtów

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

Zawiera końcowy znak nowej linii

Wypróbuj online!

Haskell , 88 bajtów

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

Wypróbuj online! Rośnie, przechodząc #do ciągu danych.

Stax , 20 18 bajtów

"34s+cTZL"34s+cTZL

Uruchom i debuguj

Generuje dodatkową spację przed drugim znakiem cudzysłowu podczas każdej iteracji.

Wyjaśnienie

Używa programu "34s+cTZL "34s+cTZLdo wyjaśnienia.

"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 bajty

£↕♣:

Wypróbuj online!

Runiczne Zaklęcia , 6 bajtów

"'<S@>

Wypróbuj online!

Ten był dziwny. Wszystko, co musiałem zrobić, to usunąć ~oryginał z quine znalezionej przez Jo Kinga .

Każde dodatkowe uruchomienie dołącza kolejne <na końcu, np .:

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

Z których nic nie robi.

Bezpośrednia kopia tej odpowiedzi na powiązane wyzwanie. Tak się złożyło, że powiększała się już o 1 bajt przy każdej iteracji (silnym argumentem za tym wyzwaniem jest duplikat tego lub odwrotnie).

Galaretka , 11 bajtów

“⁾;⁶;ØV” ṘV

Wypróbuj online!

Cud , 33 bajty

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

Interesujący wariant normalnego quine, który dodaje 1 po każdej iteracji.

Postęp:

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

Wyjaśnienie

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

Jedną z interesujących części tego quine jest to, że Wonder może działać z dowolną precyzją, więc postęp nie ulegnie zerwaniu po określonej liczbie.

ColdFusion, 277 bajtów

<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>

Jest to trywialna modyfikacja mojej wersji ColdFusion, która dodaje nową linię za każdym razem, gdy jest wywoływana.

Testowane lokalnie na lucee-express-5.2.6.60

Pakiet Windows, 38 36 bajtów

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

Ten kod tworzy plik o nazwie „q” zawierający literę „q”, a następnie dołącza go do oryginalnego pliku. Zauważ, że „::” to alias dla „rem”, który nie wymaga dodatkowego miejsca.

Zaoszczędzono 2 bajty dzięki user3493001.

Gol> <> , 7 bajtów

":r2ssH

Wypróbuj online! Wypróbuj online !! Wypróbuj online !!!

Jest to prosta odmiana zwykłego quinu Gol> <>, ale dodaje kopię Hkażdego uruchomienia. Ponieważ Hpolecenie zatrzymuje program, dodatkowe Hna końcu nie zmienia zachowania.

T-SQL , 175 bajtów

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 @

Najpierw napisałem quine SQL, a następnie zmodyfikowałem go, aby dodać dodatkowe miejsce (nieco zainspirowane tą odpowiedzią ).

Befunge-98 (PyFunge) , 22 19 bajtów

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

Wypróbuj online!

Dodaje <przed ostatnim „każdym pokoleniem.

C # (interaktywny kompilator Visual C #) , 89 bajtów

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

Zainspirowany odpowiedzią Kevina Cruijssena.

Wypróbuj online!