Program A, çalıştırıldığında program B kodunu, B ise A kaynağını verir.

Gereksinimler:

• Her iki programda yalnızca bir dil
• Programlar farklı. Kendini çıkaran bir program uygun değildir.
• Her iki program boş değil veya en az 1 bayt uzunluğunda. Hem kaynak hem de çıktıdaki son satırlar yok sayılıyor
• stdin kapalı. Hiçbir şey okumayın (böylece kaynağı okuyamaz ve değiştiremezsiniz). Çıktı stdout'a gider.
  Düzenleme: stdin bağlı /dev/null. Netleştirilirse kapatılmasını sipariş edebilirsiniz.
• randomİşlevleri kullanmayın .

Ek:

• Mümkünse açıklamalar yapın

Puan toplam uzunluğu . Son satır, programı etkilemiyorsa sayılmaz.

CJam , 13 + 13 = 26 bayt

{sYZe\"_~"}_~

Çevrimiçi deneyin!

çıktılar

{sZYe\"_~"}_~

açıklama

{       e# Standard quine framework, leaves a copy of the block on the stack
        e# for the block itself to process.
  s     e# Stringify the block.
  YZe\  e# Swap the characters at indices 2 and 3, which are Y and Z themselves.
  "_~"  e# Push the "_~" to complete the quine.
}_~

Yana e\ikinci ve üçüncü işlenen içinde değişmeli olduğunu, diğer program takas, aynı işi Zve Ygeri orijinal düzene.

CJam ,11 + 13 = 24 11 + 12 = 23 bayt

"N^_p"
N^_p

Çevrimiçi deneyin!

Çıktılar:

"N^_p
"
N^_p

Çıktı 13 bayt var, ancak:

Son satır, programı etkilemiyorsa sayılmaz.

Bu yüzden, bundan faydalanmak için mekanı yeni bir satıra değiştirdim.

En kısa CJam uygun quine dayanmaktadır:

"_p"
_p

Ve N^dizgiyi, yeni bir satır yoksa yeni bir satır ekleyen yeni bir satırla xor yapmak ve varsa, her karakterin benzersiz olduğu bir dize için çıkartmaktır.

Sanırım bu soruyu quine sorusunda gördüm ama bulamadım.

RProgN2 , 3 + 3 = 6 bayt

İlk program:

0
1

Çevrimiçi deneyin!

İkinci program:

1
0

Çevrimiçi deneyin!

-2 sayesinde Martin Ender'e .

C, 95 + 95 = 190 bayt

16 * 2 bayt tasarruf için @ immibis için teşekkürler!

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Çevrimiçi deneyin!

Çıktılar:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=0^1;printf(s,34,s,34,i);}

Çevrimiçi deneyin!

Hangi çıktılar:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Javascript, 67 + 67 = 134 bayt

1. program:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=0))

2. program:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=1))

Bu Herman Lauenstein’ın Tri-interquine’e verdiği cevaba dayanıyor

Javascript (Geçersiz kaynak kodunu okur), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 bayt

Tushar sayesinde 20 bayt, Craig Ayre sayesinde 6 bayt, kamoroso94 sayesinde 16 bayt

1. program:

f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()

2. program:

f=_=>alert(("f="+f).replace(1,a=>+!+a)+";f()");f()

1'leri 0'larla değiştirir ve bunun tersi de geçerlidir. Her ikisi de aynı şeyi yapar, sadece kaynak kodları nedeniyle farklı çıktılar üretir.

Python 2,63 + 63 = 126 bayt

Çevrimiçi deneyin

İlk program:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

çıktılar:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

İkinci program:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Çıktılar:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

JavaScript ( JsShell ), 35 + 34 = 69 bayt

1:

(f=x=>print(`(f=${f})(${-x})`))(-1)

2:

(f=x=>print(`(f=${f})(${-x})`))(1)

Mathematica, 43 + 44 = 87 bayt

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -1 1]

ve

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -(-1)]

asmutils sh, 16 + 16 bayt, "stdin kapalı" kuralını kötüye kullanıyor.

#!/bin/sh
tr x y

Stdin kapalı olduğundan ve sh komut dosyasını ilk kullanılabilir tutamağa açacağından (modern kabukları gibi yüksek sayıdaki bir tutamağa taşımak yerine) tr, komut dosyasının bir kopyasını daha önce açmadan okumayı bitirir.

Bu interquine taşıma kapasitesine sahip ancak bir taşıma yükünü eklemek zor.

Buna ek olarak, bu orijinal sürüm o günlerde kullandığım eski çekirdekte çılgınca bir böcek kullanmaktadır. (Bu çekirdeğin ne olduğunu bilmiyorum - Daha sonra bunun aygıtlar için farklı büyük ve küçük sayıları olduğunu öğrendim.) Eğer ABI'yi düzeltirseniz, interminin hala işe yaramayacağını belirten değişiklikler. Asmutils sh'in çalışıp çalışmadığını unuturum, ama yaparsa, bu modern bir versiyondur:

exec dd skip=0 | tr x y

Bu, asmutils dd'deki kasıtlı bir hatayı kötüye kullanır; eğer yapabiliyorsa, atlamak için llseek olarak adlandırdığı bir performans optimizasyonuna sahiptir, ancak bir baytı kurtarmak için SEEK_CUR yerine SEEK_SET'i geçer. Bu stderr üzerinde çöp, stdout'taki interquine ile sonuçlanır. Asmutils dd'nin stderr spam'i engelleme seçeneği yoktur.

Düşük yük , 32 + 32 = 64 bayt

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

Ortak Lisp, 58 karakter

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

... ya da 24 karakter *print-circle*global olarak ayarlanmış varsayılırsa sakıncası yoksa T:

#1=(print '(write '#1#))

Kodun basılmış temsili, #1#takip eden cons hücresine işaret eden döngüsel bir yapı olarak okunur #1=. Programları, yürütülmemeleri için teklif ediyoruz. Yana *print-circle*T, REPL baskı sırasında bu okuyucu değişkenleri yaymak üzere özen; Yukarıdaki kodun yazdırdığı ve döndürdüğü şey şudur:

#1=(write '(print '#1#)) 

Yukarıdaki kodu değerlendirdiğimizde, şunu yazdırır:

#1=(print '(write '#1#))

*print-circle*Uygun bir uygulamada NIL olan varsayılan değerine bağlı kalmak istiyorsanız, değişkeni geçici olarak yeniden bağlamanız gerekir:

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

LET'in bedeninde, şeyleri *print-circle*T olmakla basarız. Böylece elde ederiz:

#1=(write
    '(let ((*print-circle* t))
       (print '#1#))
    :circle t) 

Gördüğünüz gibi, yeni program yeniden bağlamadı *print-circle*, ancak kullandığımızdan write, alt seviye işlevi olan kullandığımızdan , printgibi ek argümanları iletebiliriz :circle. Kod daha sonra beklendiği gibi çalışır:

#1=(let ((*print-circle* t))
     (print '(write '#1# :circle t)))

Ancak, dairesel yapıların dikkat çekerken şeyler yazdırmak hem çünkü rağmen değil, bir repl içinde bir komut dosyası olarak yukarıdaki programları çalıştırmak için gereken writeve printaynı zamanda basılıyor değeri döndürür; ve varsayılan bir REPL'de, değer de basılır, ancak *print-circle*T'nin olduğu dinamik bağlamın dışında

> <> , 16 + 16 = 32 bayt

":1-}80.r   !#o#

ve

#o#!   r.08}-1:"

Çevrimiçi deneyin!

Bu, programda bir atlama kullanarak çalışır, ilk programlar atlama, yığının tersini atlar (yığını tersine çevirirse, bir satır olur). İkinci program tersini atlamaz ancak programın akışı tarafından tersine çevrildi, sonra orijinali oluşturacak.

Bu kod bir hata ile bitecek.

RPGN 2 + 7 = 14 bayt

Sadece baskı siparişlerini kötüye kullanmak yerine RProgN'nin daha iyi kullanıldığını göstermeye çalışmak istedim ...

1
«\1\-

ve...

0
«\1\-

Açıklaması

1   # Push the constant, 1. (Or 0, depending on the program)

«\1\-
«       # Define a function from this to the matching », in this case there isn't any, so define it from this to the end of the program, then continue processing.
 \      # Flip the defined function under the constant.
  1\-   # Get 1 - Constant.

Bu, yığını baş aşağı yazdırdığı için, önce yeni sabit basılır, ardından fonksiyonun stringifed versiyonu basılır.

Çevrimiçi deneyin!

LOGO , 65 + 66 = 131 bayt

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] 1]

ve

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] -1]

Python 3, 74 + 74 = 148 bayt

a='a=%r;b=%r;print(b%%(b,a))';b='b=%r;a=%r;print(a%%(a,b))';print(b%(b,a))

ve

b='b=%r;a=%r;print(a%%(a,b))';a='a=%r;b=%r;print(b%%(b,a))';print(a%(a,b))

ben de anlamıyorum

> <> , 12 + 12 = 24 bayt

'3d*!|o|!-c:

ve

':c-!|o|!*d3

Çevrimiçi deneyin!

Her iki program da kodu yığına eklemek için tam anlamıyla bir kaydırma dizgisi kullanır, ardından 'komutu farklı yöntemlerle üretir . Yığını yazdırırken kodu geriye doğru iter ancak 'ön tarafta kalır. Üreten çeşitli varyasyonlar vardır '; 3d*, d3*, 00g, :c-Zaman ile eşleştirilmiş 3d*ve :9-eşleştirilmiş zaman00g .

Befunge-98'de 13 * 2 bayt için gönderime çok benzer bir çözüm

"2+ck, @,kc+2

Stax , 18 + 20 = 38 bayt

"Vn|^34bL"Vn|^34bL

Çevrimiçi çalıştırın ve hata ayıklayın!

"Vn|^34bL
"Vn|^34bL

Çevrimiçi çalıştırın ve hata ayıklayın!

açıklama

Bütünlüğü için eklendi. @ Jimmy23013 kullanıcısının CJam kullanıcısının cevabı. Set xor komutunu kullanarak yeni satırları değiştirir.

Javascript (ES6), 36 + 36 = 72 bayt

Program 1:

f=n=>('f='+f).replace(/4|5/g,n=>n^1)

Program 2:

f=n=>('f='+f).replace(/5|4/g,n=>n^1)

Bu programlar kendilerini klonlama yoluyla çalışır ve değiştirme 5ile 4ve 4ile5

console.log((
    f=n=>('f='+f).replace(/4|5/g,n=>n^1)
)())
console.log((
    f=n=>('f='+f).replace(/5|4/g,n=>n^1)
)())

Klein , 26 24 bayt

<:3+@+3<:"

Çevrimiçi deneyin!

açıklama

Bu benim kaynağımın geriye doğru yazdırdığı Klein Quine'im ile aynı şekilde çalışır ve bunu "sonuncusu palindromic olarak alır ve bundan sonar kaçar. Bu yüzden yapmamız gereken tek şey işlevini bozmadan palindromik yapmamaktır. By anahtarlama <ve :biz işlevselliği ile müdahale olmadan bunu başardık.

Pari / GP , 36 + 36 = 72 bayt

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!