Zorluğun basittir. Birbirini oluşturan karakterleri paylaşmayan iki program yazın.

Örnek

İki program P ve Q , eğer münhasır özel quines:

1. P, Q çıkışları
2. Q çıkışı P
3. Herhangi bir karakter var c hem ait P ve Q
4. Her program P ve S olan uygun quines
   1. Bu, boş dizeleri sayar ve kendi (veya diğerlerinin) kaynak kodunu geçersiz olarak okuyan sorguları sayar .

Daha fazla kural

• Bu programların en kısa birleşik uzunluğu kazanır. Diğer bir deyişle, size ( P ) + size ( Q ), puanınız ve en düşük puan kazanır.
• Her iki program aynı dilde
• Her program tam bir program veya işlev olabilir ve aynı olmaları gerekmez.
  • Örneğin, P tam bir program olabilir ve Q bir fonksiyon olabilir.

Doğrulama

Bu çevrimiçi deneyin! Buradaki kod parçacığı, iki programın karşılıklı olarak dışlanıp dışlanmadığını doğrulayabilir. Girişler ilk iki argümana yazılır.

> <> , Puan: 41 + 41 = 82

Düzenleme: ikisi de 3 içeriyordu. Sabit

'd3*}>a!o-!<<8:5@lI55>@z:5ll55>>q:>|q::|,

ve

"r00gr40g44++bb+0p64++?b6+0.22#eW4s )Z

Çevrimiçi deneyin! (diğer çıktıyı almak için satırları değiştirin) Bu sefer doğrulama ile!

><>Burada kullanımı zor bir dildir, çünkü karakterleri basmak için tek bir komut vardır o. Neyse ki, kullanabileceğimiz p bir yere komuta ut obenim gibi, yürütme sırasında kaynak kodunda bir bozulmamış Dünya içinde Programlama cevap.

Bu bir çok deneme yanılma aldı. Karşılıklı iki özel programla başladım:

'd3*}>N!o-!<<data

ve

"r00gr40g8+X0pN+?Y0.data

Her biri kendini ve verilerini N ile dönüştürür, ilki çıkarır, ikincisi eklenir. Daha sonra bunu tersine verir. Nokta, her bir program sonra veri N. kaydırılır ters Diğer program olmasıdır ( Xprogramı ihtiyaçlarını koymak için hücre sayısı olduğu ove Y'nin göstergesinin geri döngüleri hücresidir. ?Nerede okonur) .

Her ikisi de farklı şekillerde temsil edilen aynı yapıyı takip eder. Bir kod dizgesini tüm kod boyunca çalıştırıp yığına eklerler. Kullandıkları dizgi değişmez komutunu yeniden oluştururlar ve yığının altına koyarlar. Yığın üzerinde dönerek her karaktere N ekler / çıkarır ve basarlar.

İlk program, 'değişmez dizgiyi kullanır ve d3*}39 değerini oluşturmak ve onu yığının altına itmek için basittir . İkincisi ", aynı işlevle aynı dizge olarak kullanılır. Bu r, yığın everses ghücre 0,0 karakteri ETS ve tekrar yığın tersine çevirir. Daha sonra g4.0 ( g) hücresindeki değeri alır ve elde etmek için 8 ekler.o ve X'e koyar.

Her iki program da farklı bir döngü yöntemi kullanır. İlk program, !sola giderken talimatların yalnızca yarısını çalıştırmak için atlama komutunu ( ) kullanır, yönü tersine çevirir ve diğer yarısını çalıştırır. İkincisi, .Y hücresindeki döngünün başlangıcına geriye doğru atlamak için jump komutunu ( ) kullanır . Bunların ikisi de yığında daha fazla öğe kalmamasına ve program hatalarına kadar çalışır.

N'nin düşük değerlerinin çoğuyla ilgili bir takım sorunlara rastladım, çünkü bir karakterin kaydırılması onu o program için gerekli olan başka bir karaktere dönüştürecektir (ve bu nedenle diğer program için veri olarak kullanılamaz) ya da iki karakter iki program aynı karaktere geçer. Örneğin:

1. ++1 = ,= --1
2. .+2 = 0
3. *= --3
4. g+4 = k= o-4

vb.

Sonunda abu sorunlardan kaçınabildiğim 10'a ( ) gittim. Vardiyaların ters çevrildiği daha kısa bir versiyon olabilir ve ikincisi çıkartırken ilk program N ekliyordur. İlk program genellikle ASCII ölçeğinin alt ucunda olduğu için, bu durum daha da kötü olabilir, bu nedenle çıkarmaları çatışmalardan kaçınmak için daha iyidir.

İleri (64-bit küçük-endian gforth) , 428 + 637 = 1065 bayt

s"	:	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n":	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n

HERE 3245244174817823034 , 7784873317282429705 , 665135765556913417 , 7161128521877883194 , 682868438367668581 , 679209482717038957 , 680053688600562035 , 678116140452874542 , 682868623551327527 , 680649414991612219 , 682868636436227367 , 7136360695317203258 , 7809815063433470312 , 8458896374132993033 , 5487364764302575984 , 7810758020979846409 , 680166068077538156 , 4181938639603318386 , 8081438386390920713 , 8793687458429085449 , 2812844354006760201 , 7784826166316108147 , 676210045490917385 , 681493840106293616 , 7521866046790788135 , 679491013524025953 , 7928991804732031527 , 216 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE 

Çevrimiçi deneyin!

Doğrulama betiği

@Nathaniel'e Forth kullanma fikri için teşekkür etti - Forth'un büyük-küçük harf duyarlı olmadığını yorumlarında bana hatırlattı . Sonra ruh hali değişti - Bunun işe yaramayacağının nedenlerini buldum, ardından bu sorunlara tekrar tekrar çözüm buldum. Tüm bunlar benim iç mekan antrenman bisikletimi çok yönlü ve şekilsiz bir fidget iplikçi gibi döndürürken (sadece tutma çubuğunun bir ucunu tutup biraz eğmeniz gerekir).

Bu programları yazmadan önce, hangi programın hangi karakterleri kullanabileceğini yazdım. Özellikle, ikinci program yalnızca büyük harf, ondalık basamak, sekme ve virgül kullanabilir. Bu, ilk programın tümü küçük harf olduğu anlamına gelir, ancak ASCII değerleri için bazı büyük harfler kullandım.

Sekmeler hantaldır, çünkü açıklamada boşluk kullanırım.

İlk program biçimindedir s" code"code- s"başlangıçta bir hazır bilgi dizgesidir, daha sonra kodun ikinci kopyası tarafından işlenir - standart bir quine çerçevesi. Bununla birlikte, kendi kaynak kodunu çıkarmak yerine, şuna benzeyen başka bir program yaratacaktır:

• HERE
• Orijinal dizedeki her 8 bayt için, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Bu, Forth'un veri alanını kullanır. HEREişaretçiyi o anda ayrılan veri alanı alanının sonuna döndürür ve ,sayı ile dolu bir hücre ekler. Bu nedenle, ilk üç madde işareti noktası kullanılarak oluşturulan bir dizge harfi gibi görülebilir s". İkinci programı bitirmek için:

• EMIT ASCII değeri verilen bir karakter çıktı, yani:
  • 115 EMIT küçük harf yazdırır s
  • 34 EMIT alıntı karakterini yazdırır "
  • 9 EMIT sekme yazdırır
• 2DUPyığındaki ilk iki öğeyi çoğaltır ( a b -- a b a b ), işte işaretçi ve dizenin uzunluğu
• TYPE kodun ilk kopyasını çıkarmak için bir dize yazdırır
• 34 EMITkapanış teklifini yazdırır "ve son olarak
• TYPE kodun ikinci kopyasını çıkarır

İlk programın nasıl çalıştığını görelim. Birçok durumda sayılar kullanılarak yapılır ki, kaçınılması gereken adres 'xkullanılarak elde edilebilir mekanın ASCII değerini, çıkarılarak bazen karakter sayılların gforth sözdizimi uzantısı ve bl:

s" ..."      \ the data
: l bl - ;   \ define a word, `l`, that subtracts 32
: m l emit ; \ define a word, `m`, that outputs a character. Because 32 is
             \ subtracted using `l`, lowercase characters are converted to
             \ uppercase, and uppercase characters are converted to some
             \ symbols, which will become useful later
: z m m m m space ; \ `z` outputs four characters using `m`, followed by a
                    \ space. This is very useful because all words used in the
                    \ second program are four characters long
: p . 't 'i 'm 'e z ; \ define a word, `p`, that, given a number, outputs that
                      \ number, followed by a space, `EMIT`, and another space
'e 'r 'e 'h z \ here is where outputting the second program starts - `HERE `
: q \ define a helper word, `q`, that will be called only once. This is done
    \ because loop constructs like do...loop can't be used outside of a word.
  >r \ q is called with the address and the length of the data string. >r saves
     \ the length on the return stack, because we don't need it right now. While
     \ it might seem like this is too complicated to be the best way of doing
     \ this for codegolf, just discaring the length would be done using four
     \ characters - `drop`, which would give you the same bytecount if you could
     \ get the length again in... 0 characters.
  char l \ get a character from after the call to q, which is `;`, with the
         \ ASCII value of $3B, subtract $20 to get $1B, the number of 64-bit
         \ literals necessary to encode the string in the second program.
  bl l \ a roundabout way to get 0
  do   \ iterate from 0 (inclusive) to $1B (exclusive)
    \ on the start of each iteration, the address of the cell we are currently
    \ processing is on the top of the stack.
    dup @ . \ print the value. The address is still on the stack.
    'L m space \ the ASCII value of L is exactly $20 larger than the one of ,
    cell+ \ go to the next cell
  loop
  r> . \ print the length of the string
;
: n 'e 'p 'y 't z ; \ define a word, `n`, that outputs `TYPE`
q ; \ call q, and provide the semicolon for `char` (used to encode the length
    \ of the string in 64-bit words). Changing this to an uppercase U should
    \ make this work on 32-bit systems, but I don't have one handy to check that
's p \ print the code that outputs the lowercase s
'B l p \ likewise, 'B l <=> $42 - $20 <=> $22 <=> the ASCII value of a comma
#tab p \ print the code that outputs a tab
'p 'u 'd 'Q char+ z \ char+ is the best way to add 1 without using any digits.
                    \ it is used here to change the Q to an R, which can't be
                    \ used because of `HERE` in the second program. R has an
                    \ ASCII value exactly $20 larger than the ASCII value of 2,
                    \ so this line outputs the `2DUP`.
n 'B l p n \ output TYPE 34 EMIT TYPE to finish the second program. Note the
           \ that the final `n` introduces a trailing space. Trying to remove
           \ it adds bytes.

Bunu bitirmek için, kullanmaya çalıştığımı söylemek isterim EVALUATE, ancak ikinci program yukarıda sunulanların hepsinden daha büyük hale gelir. Neyse, işte burada:

: s s" ; s evaluate"s" : l bl - ; : m l emit ; : d here $b $a - allot c! ; : c here swap dup allot move ; : q bl l do #tab emit dup @ bl l u.r cell+ #tab emit 'L m loop ; here bl 'B l 's bl 's bl 'Z l d d d d d d d -rot c bl 'B l 's 'B l d d d d s c 'B l d c 'e 'r 'e 'h m m m m 'A q #tab emit 'e 'p 'y 't m m m m"; s evaluate

Benim s" ..."...yaklaşımımı aşacak kadar golf oynamayı başarırsan , devam et ve kendi cevabını gönder.

Perl, (311 + 630 = 941 bayt) 190 + 198 = 388 bayt

Her iki program da standart çıktıya yazdırır.

İlk perl programı çoğunlukla yazdırılabilir ASCII karakterleri ve yeni satırlar içerir ve tam olarak bir satırsonunda biter, ancak iki harf AS ASCII olmayan bayt \ xFF'yi temsil eder:

@f='^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]'^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]

İkincisi, bu yazıdaki yıldızlarla değiştirilen birkaç yüksek kontrol karakteri ve hiç yeni satır içermeyen çoğunlukla ASCII olmayan baytları içerir:

say$~~q~¿*ÂØ¡Ý*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓʢءÝ*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓÊ¢~

İlk programın hexdump değeri xxdşöyledir:

00000000: 4066 3d27 5e22 ff22 7839 323b 4066 3d28  @f='^"."x92;@f=(
00000010: 4066 2c63 6872 2966 6f72 2031 3135 2c39  @f,chr)for 115,9
00000020: 372c 3132 312c 3336 2c31 3236 2c31 3931  7,121,36,126,191
00000030: 2c31 3533 2c31 3934 2c32 3136 2c31 3133  ,153,194,216,113
00000040: 3b70 7269 6e74 4066 5b31 2e2e 352c 352c  ;print@f[1..5,5,
00000050: 3130 2c35 2e2e 392c 302c 392c 302c 355d  10,5..9,0,9,0,5]
00000060: 275e 22ff 2278 3932 3b40 663d 2840 662c  '^"."x92;@f=(@f,
00000070: 6368 7229 666f 7220 3131 352c 3937 2c31  chr)for 115,97,1
00000080: 3231 2c33 362c 3132 362c 3139 312c 3135  21,36,126,191,15
00000090: 332c 3139 342c 3231 362c 3131 333b 7072  3,194,216,113;pr
000000a0: 696e 7440 665b 312e 2e35 2c35 2c31 302c  int@f[1..5,5,10,
000000b0: 352e 2e39 2c30 2c39 2c30 2c35 5d0a       5..9,0,9,0,5].

Ve ikinci programın altıgen sayısı:

00000000: 7361 7924 7e7e 717e bf99 c2d8 a1dd 00dd  say$~~q~........
00000010: 87c6 cdc4 bf99 c2d7 bf99 d39c 978d d699  ................
00000020: 908d dfce ceca d3c6 c8d3 cecd ced3 ccc9  ................
00000030: d3ce cdc9 d3ce c6ce d3ce cacc d3ce c6cb  ................
00000040: d3cd cec9 d3ce cecc c48f 8d96 918b bf99  ................
00000050: a4ce d1d1 cad3 cad3 cecf d3ca d1d1 c6d3  ................
00000060: cfd3 c6d3 cfd3 caa2 d8a1 dd00 dd87 c6cd  ................
00000070: c4bf 99c2 d7bf 99d3 9c97 8dd6 9990 8ddf  ................
00000080: cece cad3 c6c8 d3ce cdce d3cc c9d3 cecd  ................
00000090: c9d3 cec6 ced3 ceca ccd3 cec6 cbd3 cdce  ................
000000a0: c9d3 cece ccc4 8f8d 9691 8bbf 99a4 ced1  ................
000000b0: d1ca d3ca d3ce cfd3 cad1 d1c6 d3cf d3c6  ................
000000c0: d3cf d3ca a27e                           .....~

İkinci programda, alıntılanan dize (uzunluğuyla 189 bayt uzunluğunda, onlarla sınırlandırılmış), son satırsonu dışındaki ilk programdır, sadece her baytı bitsel olarak tamamlayarak kodlanır. İkinci program, ~operatörün perl'de yaptığı her bir baytı tamamlayarak dizenin kodunu çözer . Program, kodu çözülen dizgiyi ve ardından yeni bir satır yazdırır (say yöntem yeni satır ekler).

Bu yapımda, ikinci programın kod çözücüsü yalnızca altı farklı ASCII karakterini kullanır, bu nedenle ilk program yalnızca ASCII karakterlerini içerdiği ve bu altı karakteri hariç tuttuğu sürece, keyfi bir şekilde yapılabilir. Bu beş karakteri kullanmadan herhangi bir perl programı yazmak zor değil. Bu nedenle gerçek quine mantığı ilk programdadır.

İlk programda, quine mantığı 11 kelimelik bir uzun sözlük kullanır @fve bu kelimelerin çıktısını toplar. İlk kelimeler, ilk programın kaynak kodunun çoğunu tekrarlar. Kelimelerin geri kalanı belirli tek karakterlerdir. Örneğin, 5 kelimesi, ikinci programdaki iki string değişmezi için sınırlayıcı olan bir tildedir. Parantezler arasındaki sayıların listesi, hangi sırayla hangi kelimelerin basılacağına ilişkin reçetedir. Bu, sıralar için oldukça sıradan bir genel yapım yöntemidir, bu durumda tek büküm, ilk sözlük kelimelerinin baytları tamamlanmış şekilde basılmasıdır.

Haskell , 306 + 624 = 930 bayt

Program 1: yapay bir argüman alarak ve bir dize döndüren anonim bir işlev.

(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"İĴİóđđđÝöÝâÝæÝääē××êääē××İēÀħđĮâħēĕóİóòòĮááħááđéêâéêēááĮÀħ""(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"

Çevrimiçi deneyin!

Program 2: q[[40,...]]sonunda kukla bir argüman alarak ve bir dize döndüren adsız bir işlevdir.

z~z=[[['@','0'..]!!4..]!!z]
q[x,q]_=z=<<x++q++[34,34]++x
q[[40,92,98,32,99,40,41,45,62,102,111,108,100,114,40,92,97,45,62,109,97,112,32,112,114,101,100,41,98,40,115,104,111,119,40,41,62,62,99,41,96,109,97,112,112,101,110,100,96,115,104,111,119,40,109,97,112,40,109,97,112,32,102,114,111,109,69,110,117,109,41,36,116,97,105,108,40,115,104,111,119,32,99,41,58,112,117,114,101,32,98,41,41,34],[304,308,304,243,273,273,273,221,246,221,226,221,230,221,228,228,275,215,215,234,228,228,275,215,215,304,275,192,295,273,302,226,295,275,277,243,304,243,242,242,302,225,225,295,225,225,273,233,234,226,233,234,275,225,225,302,192,295]]

Çevrimiçi deneyin!

Karakter kümesi 1 (boşluk içerir):

 "$()-:>E\`abcdefhilmnoprstuw×ÝáâäæéêñòóöđēĕħĮİĴ

Karakter seti 2 (yeni satır dahil):

!'+,.0123456789<=@[]_qxz~

Yalnızca set 1 ASCII olmayan karakterler içerdiğinden, UTF-8 baytları da ayrılır.

Nasıl çalışır

• Program 1 genellikle lambda ifadeleri, boşluklar ve parantezler, yerleşik alfanümerik fonksiyonların serbest kullanımı ve sonunda string değişmezleri olarak quine verileriyle yazılır.

  • Program 1'in kendi çekirdek kodu, basitçe alıntı işaretleriyle çevrelenerek string değişmez verilerine dönüştürülür.
    • Bunu desteklemek için, her ters eğik çizgiyi aya da takip eder b, ki bu, içinden geçen geçerli kaçış dizileri oluşturur show.
    • Başka bir küçük fayda a, bve cASCII kodları 100'den küçük olan tek küçük harflerdir, program 2 tarafından kullanılan sayısal kodlamada bir rakamı kaydeder.
  • Program 2'nin çekirdek kodunun dizgesel kodlaması, ASCII olmayan Unicode kullanılarak daha karışıktır: Her karakter, orijinal karakterlerle çakışmadığından emin olmak için kod noktasına 182 eklenir.
    • 182 128 idi, ta ki, 182'nin kod çözmeyi kısaltmak için program 1'in kodu için iki kat uzunluğunun iki katı olduğu gerçeğini kötüye kullanabilirim. (Bonus olarak, program 2 yeni satırları kullanabilir.)

• Program 2, genellikle üst seviye fonksiyon denklemleriyle (son isimsiz olanlar hariç), karakter değişmezleri ve ondalık sayılar, liste / aralık sözdizimi ve işleçleri ve Intsonunda s listelerinin listesi olarak veri verileriyle yazılır .

  • Program 1'in ana kodu, son bir çift alıntı ile kod noktalarının bir listesi olarak kodlanır.
  • Program 2'nin ana kodu, program 1'de kullanılan string değişmezinin kod noktalarının listesi olarak kodlanmıştır, yine de 182'ye kadar kaydırılmıştır.

İlerleyiş, program 1

• bve csırasıyla lambda ifadesine son argümanlar olarak verilen, sırasıyla program 2 ve 1 için dize değişmezlerinin değerleridir. ()sadece PPCG'nin, programın bir fonksiyon tanımlaması gerektiği kuralını yerine getirmek için kukla bir argümandır.
• foldr(\a->map pred)b(show()>>c), uzunluğuna eşit bir sayıya buygulayarak dizgiyi programın ana koduna dönüştürür , veya .map predshow()>>c == c++c182
• tail(show c)dizeyi cson bir çift alıntı eklenmiş olarak programın 1 temel koduna dönüştürür .
• :pure bBunu bir listede dizeyle birleştirir b.
• map(map fromEnum)$ dizeleri kod noktalarının listesine dönüştürür.
• `mappend`show(...) Elde edilen listelerin listesini seri hale getirir ve nihayetinde programın 2 temel koduna ekler.

İlerleme, program 2

• Üst seviye z~z=[[['@','0'..]!!4..]!!z], kod noktalarını tekrar karakterlere dönüştüren bir işlevdir (içindeki tüm karakterler toEnummevcut olmadığından yazmak için gereklidir .)
  • Kod noktası argümanı da denir z. Tembellik belirteci ~bu pozisyonda bir etkiye sahip değildir, ancak boşluk karakterinden kaçınır.
  • ['@','0'..] ASCII kod 64'te başlayan, ardından her adımda 16 aşağı atlayan geriye doğru bir adım listesi aralığıdır.
  • Buna uygulamak !!4bir \NULkarakter verir .
  • Bir [ ..]aralıktaki sarma, !!zdizin oluşturan tüm karakterlerin bir listesini verir .
  • Karakter sonunda tekil bir listeye sarılır. Bu , kullanılamayan ve yerine işlevini zkullanarak listelerde eşlemeyi sağlar .=<<map<$>
• Üst seviye q[x,q]_=z=<<x++q++[34,34]++x, quine veri listesinden program 1'i yapan bir fonksiyondur.
  • xprogram 1'in çekirdeği için veriler (son bir çifte alıntı dahil) ve iç qkısmı program 2'nin çekirdeği için gizlenmiş verilerdir, _yalnızca son adsız işlevi yalnızca bir dize yerine bir işlev yapmak için başka bir kukla argümandır.
  • x++q++[34,34]++x ASCII kod 34 ile iki çift alıntı işareti dahil parçaları birleştirir.
  • z=<<Program 1'i zkod noktalarından karakterlere dönüştürmek için birleştirme üzerinde eşleyerek oluşturur .
• Final q[[40,...]], qquine verileriyle birleştirilen adsız bir işlevdir .

Jelly , _{128 90 87 86 85 79} 16 + 32 = 48 bayt

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs

Çevrimiçi deneyin!

79,7806,8318,7885,7769,338,115ỌṘ

Çevrimiçi deneyin!

İlk program aşağıdakileri yapar:

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs
“OṾ⁾ọṙŒs”          String literal: 'OṾ⁾ọṙŒs'
         O         ord: [79, 7806, 8318,...]
          Ṿ        Uneval. Returns '79,7806,8318,7885,7769,338,115'
           ⁾ọṙ     Two character string literal: 'ọṙ'
              Œs   Swap case the two char literal: 'ỌṘ'.

Bu, dizeleri bırakır 79,7806,8318,7885,7769,338,115ve ỌṘzincirin iki argümanı olarak ve sonunda birleştirilir ve yazdırılır.

İkinci program, dönen sayı listesinin chr( Ọ) değerini hesaplar OṾ⁾ọṙŒs. Ṙyazdırır “OṾ⁾ọṙŒs”(tırnak işaretleri içinde) ve girişi, “OṾ⁾ọṙŒs”OṾ⁾ọṙŒstam çıktı olarak bırakır .

Gol> <> , _{23 + 23 = 46 22 + 22 = 44} 20 + 20 = 40 bayt

"lF{3+|3d*HqlJJJQpp2

Çevrimiçi deneyin!

'5ssTMMMotK-g6.6~Io

Çevrimiçi deneyin!

Çevrimiçi olarak doğrulayın!

Onlar nasıl çalışır

"lF{3+|3d*HqlJJJQpp2

"..."        Push everything to the stack
 lF{3+|      Add 3 to everything on the stack
       3d*   Push 39 `'`
          H  Print everything on the stack (from the top) and halt

'5ssTMMMotK-g6.6~Io

'...'        Push everything to the stack
 5ss         Push 37 (34 `"` + 3)
    T    t   Loop indefinitely...
     MMMo      Decrement 3 times, pop and print
               At the end, `o` tries to print charcode -3, which is fishy (thanks Jo King)
               Program terminates

Jo King's> <> cevabından uyarlanmıştır . Çıktı ve tekrarlama için çok daha fazla alternatif komut olması durumunda, gya da buna gerek yoktu pve iki ana yapı çok daha kısaldı.

Diğer bir önemli fark, rakibin teklifini doğrudan yığının en üstünde oluşturmamdır. Bu şekilde, değişmezliğini korumak biraz daha kolaydı quote + my code + opponent code(reversed and shifted).