Çalıştırıldığında, aynı dilin P2 programını P1'den tam olarak 1 bayt daha uzun veren bir program (veya fonksiyon) yazalım (P1 diyelim).

Çalışırken P2 programı, P2'den 1 byte daha uzun bir 3. program P3 vermelidir. P3, P3, vs.'den bir bayttan daha uzun bir program P4 vermelidir. P5, P6, ..., P∞ için de aynı.

Program zinciri süresiz olarak veya tercümanın artık idare edemediği bir yere gitmelidir (ancak dilde teorik olarak geçerli bir program olarak kalmalıdır)

kurallar

• Standart boşluklar yasaktır
• Zincirdeki tüm programlar tek dilde olmalıdır
• Hiçbir giriş yapılmamıştır. Çıktı stdout veya işlev dönüş değerine gider
• Program bir süre sonra bitmelidir. Belli bir zaman noktasından sonra çıktı üretmeyi durduran ancak hiçbir zaman sonlanmayan bir program

Her dilde bayt cinsinden en kısa P1 programı kazanır!

JavaScript (ES6), 14 12 bayt

@Shaggy sayesinde -2 bayt

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

Test snippet'ini test etme

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

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

<pre id=o></pre>

ASCII 7 , 4 bayt

1603

Çevrimiçi deneyin!

7'nin normalde ASCII'de kodlanmadığını biliyorum, ancak bu sefer daha uygun bir kodlama, böylece her çalıştırmada 3 bit değil 1 bayt ekliyoruz.

Bunun hile olarak sayılıp sayılmadığından da emin değilim. (Sınırın çeşitli şekillerde birbirinden ayrılmasından dolayı, 7 kuyruğun hile yapıp yapmadığının bilinmemesi olağandır.) 0Kodları kodlayan iyi bir argüman yapabilirsin 6, ancak genel olarak sonuçta ortaya çıkan karakterlerin "nereden geldiği belirsizdir. “7'de, çünkü çok, oldukça tuhaf, örtük davranışlar var.

Bu program 1ekli olarak kendini yazdırır ve 1ona birkaç tane ekleseniz bile bunu yapar. İşte yorumlanmış bir hata ayıklama izi 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

( |Programda hiç bir şey kalmadı, bu nedenle programdan ehemen bir yan etki olarak çıkacak, yani finallerin 7hiç bitmeyeceği anlamına gelecektir ).

Tüm karakterlerin nereden geldiğiyle ilgili temel karışıklık, 7'deki çoğu komutun yalnızca çalıştırıldığında veri üretmesi ve ardından 6verilen veri parçasını üreten bir dizi komutun yeniden oluşturulmaya çalışılmasıdır; Bu genellikle, orjinaline yakın fakat aynı değildir. (Sorgulama amaçları için, normal olarak öncü veya takip edenlerden farklı olacak şekilde, sonucun hemen hemen aynı olacak şekilde bir 7 programı yazarsınız 7.) Örneğin, 1verilerde 716, eklemenin en kolay yolu bu olur. 1Geçerli veri dizgisine Başlangıçta 16, farklı bir (ama benzer) karakter dizisi ile ürettik ,|ile başlayan verileri işaretler. (Sanırım bunun salt anlamıyla bir yalın olmadığının en iyi argümanı, çıktının girdiden farklı olduğudur!)

Haskell , 74 66 bayt

DÜZENLE:

• H.PWiz kullanarak -2 bayt <>, ardından hareket ettirerek -6 (10*)<$>.

Bu şimdi yeni serbest <>operatörü kullanır ( Semigroupçarpma, GHC 8.4'ün içe aktarılmadan çalışması gerekir.)

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

Çevrimiçi deneyin! (TIO’nun henüz GHC 8.4 olmadığından ithal edilen hileler.)

Nasıl çalışır

• main=putStr$ aşağıdaki dize değerini çıkarmak için bir kaynaktır.

• fst<>showbir demet alan ve dize dizesi gösterimi ile birleştirilen dizinin ilk elemanından oluşan bir dize döndüren bir işlevdir. yani

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

• (10*)<$>Aşağıdaki dizinin son öğesini 10 ile çarparak 0dize temsiline bir basamak ekler .

C (gcc) , 134 132 bayt

Kanonik C kininin yeniden işlenmesi. Korkunç derecede uzun.

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

Çevrimiçi deneyin!

Fisyon 2 , 7 bayt

'!+OR!"

Çevrimiçi deneyin!

Standart Fission quine , ancak !her yinelemede kodun başında ek bir 0x01 yazdıran bir ekstra ile .

Pari / GP , 35 bayt

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

Çevrimiçi deneyin!

Python 2,38 bayt

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

Çevrimiçi deneyin!

brainfuck , 420 bayt

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

Çevrimiçi deneyin!

Bu "standart" bir değişiklik olduğu brainfuck Quine'a bir ile, .sonunda fazladan bir on çiviler de .her yineleme.

Quine, Brainfuck karakterlerini onaltılık basamaklardan oluşan bir yığın olarak kodlar: özellikle c-0x2belverişli şekilde aşağıdakilerden oluşan onaltılık basamaklar :

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

Kodlama iki kod parçasını kapsar: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++kodlamanın kendisinin kodlamasını zorlar [[<++++++++++++++++>-]<+++++++++.<]ve yığını yürür ve her şeyi yazdırır.

Kirli , 9 bayt

'"n[!]a!␛

Çevrimiçi deneyin!

'   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

Kaynak kod okumasına izin verilirse:

Kirli , 8 bayt

Q[!]W33!

Çevrimiçi deneyin!

Açıklaması:

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

Geçerli olabilir:

Kirli , 4 bayt

Q[‼]

Çevrimiçi deneyin!

Kaynak kodu izleyen bir yeni satır ile yazdırır.
(Ve bir hata nedeniyle bir sürü boşluk. Yine de onlar olmadan aynı şekilde çalışır.)

Not sadece yerli karakter kümesinde çalışır ve UTF8 ön uç kullanımı değilken o - böylece o arasındaki çıkışı karakteri değiştirmeniz gerekiyor TIO üzerinde denemek []ile s ‼neyi 's baskı için UTF8 eşdeğerdir, .

Java 8, 162 146 bayt

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

Çevrimiçi deneyin.
İlk çıktı programını deneyin ; İkinci çıktı programını deneyin ; Üçüncü çıktı programını deneyin .

Açıklama:

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 sBiçimlendirilmemiş kaynak kodu içerir.
• %sbu stringi kendi içine girmek için kullanılır s.format(...).
• %c, %1$cVe 34çift tırnak biçimlendirmek için kullanılır.
• s.format(s,34,s) hepsini bir araya getirir

Zorluk kısmı:

• +1 hem biçimlendirilmemiş hem de biçimlendirilmiş programa 1 ekler.
• .replaceAll("1+$","");}: Program bayt sayısını yalnızca iki yerine bir artırmak istediğimiz için, geri dönmeden önce sondaki 1s'yi kaldırdık.

> <> , 9 bayt

#o<:}-1:"

Çevrimiçi deneyin!

Klasik> <> quine'daki varyasyon #, ön cepheyi kopyalamak için başka bir dupe komutu ekler .

Perl 5 , 32 bayt

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

Çevrimiçi deneyin!

GolfScript , 9 bayt

{'.~1'}.~

Çevrimiçi deneyin!

CJam , 9 bayt

{"_~1"}_~

Çevrimiçi deneyin!

Bu çözümlerin her ikisini de aynı cevaba gönderiyorum, çünkü bunlar birbirlerinin önemsiz varyasyonları ve tamamen aynı şekilde çalışıyorlar. Her ikisi de , örneğin bu önceki cevabımda daha ayrıntılı olarak açıklanan ortak GolfScript quine {'.~'}.~(veya {"_~"}_~CJam'da) dayanıyor .

Tek fark bu varyantın 1çıktısının sonuna bir bayt eklemesidir . Olduğu gibi, herhangi bir 1s dizgisi (veya baştaki sıfırları içermeyen herhangi bir tamsayı değişmezi) kendisi GolfScript ve CJam'da önemsiz bir sıradır, bu nedenle yukarıdaki kodun sonunda bulunanlar çıktıya kopyalanacaktır. GolfScript (ve CJam) isteğe bağlı uzunlukta tamsayılar kullandığından, en azından kodu çalıştıran bilgisayar saklamak için yeterli belleğe sahip olduğu sürece, isteğe bağlı olarak uzun programlar için çalışacaktır.

Ataşesi , 76 72 61 bayt

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

Çevrimiçi deneyin!

xHer yinelemenin sonuna bir boşluk ekleyen standart bir tane .

İlk birkaç yineleme:

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

vb.

Ataşesi, 72 bayt

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

Çevrimiçi deneyin!

Bu sadece standart yineleme kodunun varyasyonudur, her yinelemeden sonra yayarlanmış bir değişken10*y

İlk birkaç yineleme:

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]

vb.

Swift 4 , 89 bayt

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

İzleyen bir newline içerir

Çevrimiçi deneyin!

Haskell , 88 bayt

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

Çevrimiçi deneyin! #Veri dizisine hazırlayarak büyür .

Stax , 20 18 bayt

"34s+cTZL"34s+cTZL

Koş ve hata ayıkla

Her tekrarlamada 2. tırnak işaretinden önce fazladan boşluk oluşturur.

açıklama

Açıklamak için programı kullanır "34s+cTZL "34s+cTZL.

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

£↕♣:

Çevrimiçi deneyin!

Runik Büyüleri , 6 bayt

"'<S@>

Çevrimiçi deneyin!

Bu çok garipti. Tek yapmam gereken, Jo King tarafından~ bulunan orjinal sırttan kaldırmaktı .

Her ek çalıştırma sonuna kadar ekler <, örneğin:

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

Hepsi hiçbir şey yapmaz.

Bu cevabın doğrudan bir kopyası ilgili bir soruna. Her yinelemede 1 baytlık bir büyüme gerçekleşti (bu mücadelenin güçlü bir argümanı, bunun bir kopyası veya tam tersi).

Jöle , 11 bayt

“⁾;⁶;ØV” ṘV

Çevrimiçi deneyin!

Wonder , 33 bayt

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

Her yinelemeden sonra 1 ekleyen normal quine üzerinde ilginç bir değişken.

İlerleme:

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

açıklama

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

Bu quine'nin ilginç bölümlerinden biri Wonder'ın çok sayıda keyfi hassasiyetle çalışabilmesidir, bu nedenle ilerleme belirli bir miktardan sonra kırılmaz.

ColdFusion, 277 bayt

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

Bu, her çağrıldığında yeni bir satır ekleyen ColdFusion quine'mde önemsiz bir değişiklik .

Yerel olarak lucee-express-5.2.6.60'da test edildi

Windows Toplu İşi, 38 36 bayt

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

Bu kod "q" harfini içeren, 'q' harfini içeren bir dosya oluşturur ve sonra dosyayı orijinal dosyaya ekler. "::" ek bir alan gerektirmeyen "rem" için bir takma addır.

User3493001 sayesinde 2 bayt kaydedildi.

Gol> <> , 7 bayt

":r2ssH

Çevrimiçi deneyin! Çevrimiçi deneyin !! Çevrimiçi deneyin !!!

Bu, normal Gol> <> quine öğesinin basit bir varyasyonudur, ancak Hher çalıştırıldığında bir kopyasını ekler . Yana Hkomut programı durdurur, ek Hucunda davranışını değiştirmez.

T-SQL , 175 bayt

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 @

Önce bir SQL quine yazdım, sonra ekstra bir boşluk eklemek için değiştirdim ( bu cevaptan biraz esinlenerek ).

Befunge-98 (PyFunge) , 22 19 bayt

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

Çevrimiçi deneyin!

Her nesilde <sondan önce "ekler.

C # (Visual C # Etkileşimli Derleyici) , 89 bayt

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

Kevin Cruijssen'in cevabından ilham aldı.

Çevrimiçi deneyin!