Amacınız, her birinden sonra yeni bir çizgiyle süresiz olarak kendini basacak bir program oluşturmak. Böylece, programınız bir liner ise, çıktının her satırında tekrarlanacaktır.

Örnek

Programı:

A

Çıktı:

A
A
A
...

kurallar

• Bir pasaj veya işlev değil, eksiksiz bir program olmalıdır.
• Program yığın taşması veya özyineleme sınırı hataları olmadan sonsuza kadar döngü yapmalıdır.
• Çıktı stdout veya en yakın alternatiftir.
• Program girişi kabul edilmedi.
• Programın dosyasını açmak veya harici bir kaynağa erişmek gibi standart boşluklara izin verilmez. Boş programlara standart bir boşluk olarak izin verilmez.
• Program kodunuz izleyen bir yeni satırla bitiyorsa, bu, sonlar arasındaki gerekli yeni satır sayılmaz ve başka bir tane yazdırmanız gerekir.
• codegolf - En kısa kod kazanır!

Fisyon, 7 bayt

'!+!NR"

Şimdiye kadar bulduğum en kısa Fission quine üzerinde oldukça basit bir değişiklik : Sadece bir yıkıcı olmayan !yerine Obir Nyeni satır ekledim .

Sonuç olarak, işte nasıl çalıştığı: kontrol akışı Rdoğru bir atomla başlar. "dize modunu değiştirir, bir sonraki basılana kadar her şey anlamına gelir ": bu durumda '!+!NR. Bu, "yazdırılacak olan yeni çizgiyi ve bırakır . '!atomun kütlesini 33'e ayarlar, +onu 34'e yükseltir (karakter kodu ") ve !alıntıyı yazdırır. Nyeni bir satır yazdırır ve Rşimdi bu durumda işlem dışıdır, bu nedenle döngü yeniden başlar.

Aşağıdaki 7 baytlık çözüm de çalışır:

"NR'!+!

> <> , 16 bayt

'ard3*o50l2)?.~~

Geleneksel> <> quine çok fazla os kullanıyor , bu yüzden baskı için bir döngü kullanıyoruz. Her atlamadan önce, 5 ve 0 tuşlarına basacağız (nereye atlanacağının koordinatları), sonra .hala basılacak bir şey varsa birlikte atlıyoruz veya ilk iki değeri ile açıyoruz ~~.

(Yığın taşması kuralını unuttuğumdan bu yana 16 sürümüne döndüm.)

CJam, 13 bayt

{_o"_g
"o1}_g

Çevrimiçi tercüman program sona ermeden hiçbir şey yazdırmaz, bu nedenle Java tercümanında bunu test etmeniz gerekir.

açıklama

Sonunda bitmeyen genelleştirilmiş bir CJam kuğu _~.

{_o"_g
"o1}

Bu sadece bir bloğu iter. _gbloğu çoğaltır ve istifin üstü truthy iken (koşulu atarken) arka arkaya yürütür.

Şimdi bloğun içinde, bloğun diğer kopyası hala yığında. İle çoğaltır, yazdırır _ove sonra bunu _gardından yeni bir satır izleriz (kuyruklar arasında gereken yeni satır) "_g\n"o. Sonunda 1döngü için tekrarlamak için yığına bastırıyoruz, çünkü maalesef, CJam'da bloklar truthy (ya da falsy) değildir.

Python 2, 39

While döngüsünü normal bir sine eklemek önemsiz olduğu için Python'da çok ilginç bir iş değil.

c='while 2:print"c=%r;exec c"%c';exec c

Perl 5.10+, 40 37 bayt

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

veya (ayrıca 37 bayt)

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

İle çağır -M5.010veya -Ekomut satırı bayrağıyla, örneğin

$ perl -E '$_=q{say"\$_=q{$_};eval"while 1};eval'
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
...

Orijinal çözümümden 3 bayt attığım için Ilmari Karonen'e teşekkür ederim:

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

Bu, yukarıdaki 37 baytlık kısa çözümlerin yanı sıra, Ilmari'nin diğer yayınlarından birinde ilk gördüğümde, aşağıdaki sıranın basit varyasyonlarıdır :

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

Orijinal çözümüme eklediğim her şey bir whiledöngü olduğundan, kredinin çoğunu hak ediyor. :-)

Kendi kendini değiştiren Brainf *** (SMBF) , 14 bayt

Sondaki yeni satırın \ndeğişmez, Unix, yeni satır olması gerekir (ASCII kod 10).

[<[<]>[.>]<.]\n

Açıklama:

Kod, işaretçiyi kaynak kodunun en soluna taşır, ardından yeni satır da dahil olmak üzere (kuralın iki kez b / c) hepsini yazdırır. Döngü devam ediyor.

PowerShell, 143 Bayt

$d='$d={0}{1}{0}{2}while(1){3}Write($d -f [char]39,$d,"`n",[char]123,[char]125){4}'
while(1){Write($d -f [char]39,$d,"`n",[char]123,[char]125)}

Rosetta Code PowerShell quine'den yola çıkarak , bunun mümkün olan en kısa yol olmadığından eminim. PowerShell'de dize değiştirme biçimlendirmesi bunun için çok zordur, çünkü değiştirmeleri nereye koyacağımızla {}aynı sınırlayıcılar kod bloklarını da sınırlandırır while{}, bu nedenle [char]kodu bir demet kesen döküm kullanmak zorundayız .

Düşük yük, 25 bayt

İlk defa böyle bir şey denedim ve tüm kuralları bir kaç satır gibi takip edip etmediğinden emin değilim. Newline biraz acı vericiydi.

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

Befunge , 30 20 bayt

<,+55,*2+98_ #!,#:<"

Yeni bir çizgiyi basan ve çizgiyi tamamlarsa yığında -1 açılan popüler bir befunge quine çeşididir.
Ne yazık ki, Befunge bir satırda bir şeyler yaparken ayrıntılı bir şekilde ele alıyor. Yapabileceğim tüm launchpad'leri ( #) kaldırmaya çalıştım , ancak bazı komutları (gibi ,) atlamak için içeride kalmak zorunda kaldım .

değişiklikler:

30-20 -> temel sırayı, string girişi kullanan özel bir terimle değiştirdim. Bu şekilde, dallanma çok daha kolaydır.

Eski:

:0g,:93*`>0-10 #,+$#: #5 _1+>

Bunun optimal olduğunu sanmıyorum, ancak şimdilik kabul edilebilir.

K, 30 bayt

{f:$_f;{x}{`0:f,"[]\n";1}/1}[]

R, 34 bayt

repeat{write(commandArgs()[5],'')}

komut satırından aşağıdaki gibi çağırmak için:

Rscript -e "repeat{write(commandArgs()[5],'')}"

> <>, 31 29 bayt

Geleneksel > <> sıranın basit bir şekilde değiştirilmesi .

"ar00gc0.0+efooooooooooooooo|

Çalıştırmak için buraya yapıştırın , 'Gönder'i tıklayın, ardından' Başlat'ı tıklayın (animasyon olmadan çalışmak işe yaramaz). Yürütme hızını artırmak için çekinmeyin.

Python 2,48 bayt

c='c=\'%s\';while 1:print c%c';while 1:print c%c

GolfScript, 16 bayt

{.".do
":n\p}.do

Bu, Martin Büttner'ın CJam girişine çok benziyordu . İlginç bir özellik, ".do"göründüğü gibi, yazdırıldığında bloğa eklemenin en kısa yolunun satır sonlandırıcısına atamak olmasıdır n. (Tabii ki, aynı zamanda nnormalde içeren bir dizeyi değiştirmek için dizeye gerçek bir yeni satır eklememiz gerekir.) Aynı dize (GolfScript'te truthy olan) da dodöngünün çıkmasını sağlamak için yığında bırakılır. sonsuza kadar çalışır.

BASH, 76 bayt

Sadece, özellikle burada PowerShell ile direnemedim :)

while true;do
a ()
{
    echo while true\;do
    declare -f a
    echo a\;done
}
a;done

Boşluk bir EXACT kopyası için önemlidir.

Javascript (ES6), 64

for(;;(_=>console.log(`for(;;(_=>${arguments.callee})());`))());

Alternatif olarak (ayrıca 64)

a="for(;;)console.log(`a=${JSON.stringify(a)};eval(a)`)";eval(a)

Mikroscript , 22 bayt

"f1{CqxCanx"f1{CqxCanx

Esolangs makalesinden Quine'ın göre: "fCqxah"fCqxah. Dil otomatik kapanma diş telleri gerektiği gibi, ki bu olmadan iki bayt daha uzun olacağını açıklar.

Toplu iş, 10 (dosya adı uzunluğu için + 4)

Bunun iki nedenden dolayı hak edip etmediğinden emin değilim:

• Teknik olarak, nasıl yapılandırıldığına bağlı olarak, Windows komut kabuğundan kaynaklanan metinsel yan etkiler olabilir veya olmayabilir.
• Bu program kendini ismiyle çağırıyor ve bunun kurallar tarafından yasaklanıp yasaklanmadığından emin değilim (özellikle "program dosyasını açmamak" kuralı). Metni okumak ve yazdırmak amacıyla kendisini açmıyor; sadece kendini yeniden çalıştırıyor. Ayrıca, dosya sistemi yapısı eski okul toplu komut dosyalarının (çoğu zaman program durumunu depolamak için bile kullanılır) ayrılmaz bir parçasıdır. Bu nedenle, bunun 5. kuralı ihlal edip etmediğinden emin değilim.

Kod (q.bat adlı bir program için):

echo on&&q

Seylan , 210 208 bayt

Elbette bu bir şey kazanmayacak ...

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

Orijinal:

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

Quine'mi iki gün öncesindenwhile(true){...} döngü ekleyerek değiştirdim , bu yüzden Quine'nin 185 baytından 210'a geliyorum (artık yeni satır karakterine ihtiyacım yok). Ama sonra bir while(1<2){...}döngünün iki bayt daha kısa olduğunu gördüm :

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

(Ceylon'da for(;;)Java gibi bir döngü yoktur ve bu döngü için diş tellerine de ihtiyaç vardır.)

PowerShell, 132 107 Bayt

$a='$a={0}{1}{0};for(){2}$a-f[char]39,$a,[char]123,[char]125{3}';for(){$a-f[char]39,$a,[char]123,[char]125}

Rosetta Quine (@AdmBorkBork ile aynı) dayanarak dize değiştirmek için biçimlendirme kullanmamasına rağmen ... belki bir for döngüsüne geçmek ve biçimlendirmeyi kullanmak en iyisi olur mu?

Eminim AdmBorkBork geri döndüyse, bunu çok fazla yenerdi: P

EDIT For döngüsü ve değiştirmeleri, selefime teşekkür etti.

Eski deneme:

$a='$a=;for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}';for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}

Ruby, 41 39 bayt

Burada bulunan Ruby sorgularından birinin modifikasyonu .

_="_=%p;loop{puts _%%_}";loop{puts _%_}

Java 10, 194 bayt

interface M{static void main(String[]a){for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";;)System.out.println(s.format(s,34,s));}}

Açıklama:

Çevrimiçi deneyin (60 saniye sonra zaman aşımına uğradı).

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";
                                //   Unformatted source code
        ;)                      //   Loop indefinitely
       System.out.println(      //    Print with trailing new-line:
         s.format(s,34,s));}}   //     The formatted source code

quine -parça:

• Dize s, biçimlendirilmemiş kaynak kodunu içerir.
• %sbu String'i 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ı:

• for(;;) süresiz döngü yapmak için kullanılır.
• System.out.println(...) izleyen yeni satır ile yazdırmak için kullanılır

Funky , 29 bayt

f=@print`f=[f]for)f()`for)f()

Çevrimiçi deneyin!

RProgN 2,7 bayt

«]³]]p:

Çevrimiçi deneyin!

Jöle , 14 bayt

“;@ṾṄṛ¢”;@ṾṄṛ¢

Çevrimiçi deneyin!

Pyth, 11 bayt

#jN B"#jN B

Burada dene!

Brachylog , 16 bayt

∋"∋~kgjẉ₁⊥"gjẉ₁⊥

Online olarak deneyemezsiniz , ancak kurulumumda çalıştığını doğruladım.

Brachylog , 18 bayt

∋"∋~kgjw₁⊥~n"gjw₁⊥

Çevrimiçi deneyin!

Bu quine'nin alternatif versiyonundan uyarlanmış, başlangıçta her şeyin üstesinden gelmek için tasarladığım bir geri izleme hackiyle . İki bayt harcar, ~nçünkü ẉ(normal bir satırsonu ile yazdırmak için kullanılan normal yol), TIO'da karakter kodlaması ile ilgili bazı garip sorunlara çarpar ve dizginin içine yerleştirilen gerçek bir satırsonu ~kgibi yazdırılır \n.

               w      Print
 "∋~kgjw₁⊥~n"         "∋~kgjw₁⊥~n"
∋                     which is an element of
                      the (unused and unconstrained) input
                ₁     formatted
          ~n          (so that the ~n is replaced with a newline)
             gj       with itself
   ~k                 (so that the ~k is replaced with the string in quotes),
                 ⊥    then try again.

Yana w₁bir liste olarak girdi alır [string to be formatted, formatting arguments]ile bir listede bir dize sarma, gdaha sonra kendisine ardarda eklemek jkendisi ile biçimlendirilmiş sağlar. Programa giriş yapılmaması nedeniyle, programın başında dolaylı olarak bulunan giriş değişkeni herhangi bir değeri alabilir, böylece "∋~kgjw₁⊥~n"bir eleman olarak içeren ve tek bir tane yaratan sonsuz sayıda listeden biriyle sınırlandırılabilir. kaynağını yazdırdıktan sonra programın isabet etmesiyle geriye doğru gidilecek seçim noktası ⊥.

Python 3.6, 48 43 bayt.

@Jo King sayesinde -5 bayt

x='while 1:print("x=%r;exec(x)"%x)';exec(x)

Gol> <> , 10 bayt

"r2sslRoao

Çevrimiçi deneyin!

Bu muhtemelen daha aşağı golf olabilir