Tantangan Anda sederhana. Tulis dua program yang tidak berbagi karakter yang menghasilkan satu sama lain.

Contoh

Dua program P dan Q adalah quine yang saling eksklusif jika:

1. P output Q
2. Q output P
3. Tidak ada karakter c yang termasuk P dan Q
4. Setiap program P dan Q adalah quine yang tepat
   1. Ini menghitung quines kosong dan quine yang membaca kode sumbernya sendiri (atau yang lain) tidak valid .

Lebih banyak aturan

• Panjang gabungan terpendek dari semua program ini akan menang. Artinya, ukuran ( P ) + ukuran ( Q ) adalah skor Anda, dan skor terendah menang.
• Kedua program dalam bahasa yang sama
• Setiap program dapat berupa program atau fungsi lengkap, dan tidak harus sama.
  • Sebagai contoh, P mungkin merupakan program lengkap dan Q mungkin suatu fungsi.

Verifikasi

Ini Coba online! cuplikan di sini dapat memverifikasi apakah dua program bersifat eksklusif atau tidak. Masukan dimasukkan dalam dua argumen pertama.

> <> , Nilai: 41 + 41 = 82

Sunting: keduanya berisi 3. Tetap

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

dan

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

Cobalah online! (tukar baris untuk mendapatkan hasil lainnya) Dengan verifikasi kali ini!

><>adalah bahasa yang sangat sulit untuk digunakan di sini, karena hanya ada satu cara untuk menghasilkan karakter, perintah o. Untungnya, kita dapat menggunakan perintah p ut untuk menempatkan okode sumber dalam eksekusi, seperti dalam Pemrograman saya di jawaban Dunia Pristine .

Yang ini mengambil banyak trial and error. Saya mulai dengan dua program yang saling eksklusif:

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

dan

"r00gr40g8+X0pN+?Y0.data

Masing-masing mengubah dirinya dan datanya dengan N, yang pertama mengurangkan dan yang kedua menambahkan. Ini kemudian menampilkan ini secara terbalik. Intinya adalah bahwa data setelah masing-masing program adalah program lain secara terbalik, digeser oleh N. ( Xadalah nomor sel di mana program perlu meletakkan odan Y adalah sel di mana penunjuk loop kembali ke. ?Adalah tempat yang odiletakkan) .

Keduanya mengikuti struktur yang sama, diwakili dengan cara yang berbeda. Mereka menjalankan string literal di seluruh kode, menambahkannya ke stack. Mereka menciptakan kembali perintah string literal yang mereka gunakan dan meletakkannya di bagian bawah tumpukan. Mereka berputar di atas tumpukan, menambahkan / mengurangi N ke setiap karakter dan mencetaknya.

Program pertama menggunakan 'string literal, dan sederhana d3*}untuk membuat nilai 39 dan mendorongnya ke bagian bawah tumpukan. Yang kedua menggunakan "string literal dengan fungsi yang sama. Itu rmembalik tumpukan, gets karakter di sel 0,0 dan membalikkan tumpukan lagi. Kemudian gets nilai pada sel 4.0 ( g) dan menambahkan 8 untuk mendapatkan odan menempatkannya di X.

Kedua program menggunakan metode pengulangan yang berbeda. Program pertama menggunakan perintah lewati ( !) untuk menjalankan hanya setengah instruksi saat ke kiri, membalikkan arah dan menjalankan setengah lainnya. Yang kedua menggunakan perintah lompat ( .) untuk melompat mundur ke awal loop di sel Y. Keduanya berjalan sampai tidak ada lagi item di stack dan kesalahan program.

Saya mengalami sejumlah masalah dengan sebagian besar nilai N yang lebih rendah, karena menggeser satu karakter akan mengubahnya menjadi karakter lain yang penting untuk program itu (dan karena itu tidak dapat digunakan sebagai data untuk program lain) atau dua karakter dari dua program akan berubah menjadi karakter yang sama. Sebagai contoh:

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

dll.

Akhirnya saya sampai ke 10 ( a), di mana saya bisa menghindari masalah ini. Mungkin ada versi yang lebih pendek di mana shift dibalik, dan program pertama menambahkan N sementara yang kedua menguranginya. Ini mungkin lebih buruk, karena program pertama umumnya di ujung bawah skala ASCII, jadi mengurangi lebih baik untuk menghindari konflik.

Keempat (64-bit little-endian gforth) , 428 + 637 = 1065 byte

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 

Cobalah online!

Skrip verifikasi

Terima kasih kepada @Nathaniel untuk gagasan menggunakan Forth - dia mengingatkan saya dalam komentar bahwa Forth tidak peka huruf besar-kecil . Kemudian datang perubahan suasana hati - saya telah menemukan alasan mengapa ini tidak akan berhasil, diikuti oleh solusi untuk masalah ini, lagi dan lagi. Semua sambil memutar sepeda pelatihan dalam ruangan saya seperti spinner gelisah oversized dan cacat (Anda hanya perlu mengambil salah satu ujung handle bar dan memiringkannya sedikit).

Sebelum menulis program ini, saya membuat konsep karakter apa yang dapat digunakan oleh program mana. Secara khusus, program kedua hanya dapat menggunakan huruf besar, angka desimal, tab, dan koma. Ini berarti bahwa program pertama semuanya huruf kecil, tetapi saya menggunakan beberapa huruf besar untuk nilai ASCII mereka.

Karena tab sulit digunakan, sebagai gantinya saya akan menggunakan spasi dalam penjelasan.

Program pertama berbentuk s" code"code- s"mulai string literal, yang kemudian diproses oleh salinan kedua kode - kerangka kerja standar quine. Namun, alih-alih mengeluarkan kode sumbernya sendiri, itu akan membuat program lain, yang terlihat seperti ini:

• HERE
• Untuk setiap 8 byte dalam string asli, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Ini menggunakan ruang data Forth. HEREmengembalikan pointer ke ujung area ruang data yang saat ini dialokasikan, dan ,menambahkan sel diisi dengan angka padanya. Oleh karena itu, tiga poin pertama dapat dilihat seperti string literal yang dibuat menggunakan s". Untuk menyelesaikan program kedua:

• EMIT mengeluarkan karakter yang diberi nilai ASCII, jadi:
  • 115 EMIT mencetak huruf kecil s
  • 34 EMIT mencetak karakter kutipan "
  • 9 EMIT mencetak tab
• 2DUPmenduplikasi dua elemen teratas pada stack ( a b -- a b a b ), ini dia pointer ke dan panjang string
• TYPE mencetak string untuk menampilkan salinan kode yang pertama
• 34 EMITmencetak kutipan penutup ", dan akhirnya
• TYPE menampilkan salinan kedua kode

Mari kita lihat bagaimana program pertama bekerja. Dalam banyak kasus, angka harus dihindari, yang dilakukan menggunakan 'xekstensi sintaksis gforth untuk literal karakter, dan kadang-kadang mengurangi nilai ruang ASCII, yang dapat diperoleh dengan menggunakan 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.

Untuk menyelesaikan ini, saya ingin mengatakan bahwa saya mencoba menggunakan EVALUATE, tetapi program kedua menjadi lebih besar dari yang disajikan di atas. Bagaimanapun, ini dia:

: 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

Jika Anda berhasil mengurangi jumlah ini untuk mengalahkan s" ..."...pendekatan saya , silakan dan posting sebagai jawaban Anda sendiri.

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

Kedua program mencetak ke output standar.

Program perl pertama berisi sebagian besar karakter ASCII yang dapat dicetak dan baris baru, dan berakhir tepat satu baris baru, tetapi dua huruf ÿ mewakili byte non-ASCII \ xFF:

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

Yang kedua sebagian besar berisi byte non-ASCII, termasuk beberapa karakter kontrol tinggi yang digantikan oleh bintang di pos ini, dan tidak ada baris baru sama sekali:

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

Hexdump dari program pertama xxdadalah:

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

Dan hexdump dari program kedua adalah:

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

Dalam program kedua, string yang dikutip (panjang 189 byte, dibatasi oleh tildes) adalah keseluruhan program pertama kecuali baris akhir final, hanya dikodekan dengan bitwise melengkapi setiap byte. Program kedua hanya menerjemahkan string dengan melengkapi masing-masing byte, yang dilakukan oleh ~operator dalam perl. Program mencetak string yang didekodekan diikuti oleh baris baru ( saymetode menambahkan baris baru).

Dalam konstruksi ini, decoder dari program kedua hanya menggunakan enam karakter ASCII yang berbeda, sehingga program pertama bisa dibilang sewenang-wenang, asalkan hanya berisi karakter ASCII dan tidak termasuk keenam karakter tersebut. Tidak sulit untuk menulis program perl tanpa menggunakan lima karakter tersebut. Logika quine aktual dengan demikian dalam program pertama.

Dalam program pertama, logika quine menggunakan kamus panjang 11 kata @f, dan mengumpulkan output dari kata-kata itu. Kata-kata pertama mengulangi sebagian besar kode sumber dari program pertama. Kata-kata lainnya adalah karakter tunggal spesifik. Sebagai contoh, kata 5 adalah tilde, yang merupakan pembatas untuk dua string literal dalam program kedua. Daftar angka di antara tanda kurung adalah resep untuk mencetak kata-kata dalam urutan apa. Ini adalah metode konstruksi umum yang cukup biasa untuk quines, satu-satunya twist dalam hal ini adalah bahwa kata-kata kamus pertama dicetak dengan byte-bitnya yang dilengkapi bitwise.

Haskell , 306 + 624 = 930 byte

Program 1: Fungsi anonim mengambil argumen dummy dan mengembalikan string.

(\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))"

Cobalah online!

Program 2: q[[40,...]]pada akhirnya adalah fungsi anonim mengambil argumen dummy dan mengembalikan string.

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

Cobalah online!

Set karakter 1 (termasuk spasi):

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

Kumpulan karakter 2 (termasuk baris baru):

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

Karena hanya set 1 berisi karakter non-ASCII, byte UTF-8 mereka juga terpisah.

Bagaimana itu bekerja

• Program 1 umumnya ditulis dengan ekspresi lambda, spasi dan tanda kurung, penggunaan bebas fungsi alfanumerik bawaan, dan dengan data quine sebagai string literal pada akhirnya.

  • Kode inti Program 1 sendiri diubah menjadi data literal string hanya dengan mengelilinginya dengan tanda kutip.
    • Untuk mendukung hal ini, setiap backslash diikuti oleh aatau b, yang membentuk urutan pelarian yang valid yang melakukan perjalanan pulang pergi show.
    • Manfaat kecil lainnya adalah a, bdan cmerupakan satu-satunya huruf kecil yang kode ASCIInya kurang dari 100, menghemat satu digit dalam pengkodean numerik yang digunakan oleh program 2.
  • Pengkodean string string kode inti program 2 lebih dikaburkan dengan menggunakan Unicode non-ASCII: Setiap karakter ditambahkan 182 ke titik kode untuk memastikan tidak ada tumpang tindih dengan karakter asli.
    • 182 dulu 128, sampai saya menyadari saya bisa menyalahgunakan fakta bahwa 182 adalah dua kali panjang string literal untuk kode program 1 untuk mempersingkat decoding. (Sebagai bonus, program 2 dapat menggunakan baris baru.)

• Program 2 umumnya ditulis dengan persamaan fungsi tingkat atas (kecuali untuk yang anonim akhir), karakter literal dan angka desimal, sintaksis daftar / rentang dan operator, dan dengan data quine sebagai daftar daftar Ints pada akhirnya.

  • Kode inti Program 1 dikodekan sebagai daftar poin kode, dengan kutipan ganda akhir.
  • Kode inti Program 2 dikodekan sebagai daftar titik kode dari string literal yang digunakan dalam program 1, masih bergeser ke atas oleh 182.

Panduan, program 1

• bdan cadalah nilai-nilai string literal untuk program 2 dan 1, masing-masing, diberikan sebagai argumen akhir untuk ekspresi lambda. ()adalah argumen dummy semata-mata untuk memenuhi aturan PPCG bahwa program harus mendefinisikan suatu fungsi.
• foldr(\a->map pred)b(show()>>c)mendekode string bke kode inti program 2 dengan menerapkannya map predbeberapa kali sama dengan panjang show()>>c == c++c, atau 182.
• tail(show c)mengkonversi string cke kode inti program 1, dengan kutipan ganda akhir ditambahkan.
• :pure bmenggabungkan ini dalam daftar dengan string b.
• map(map fromEnum)$ mengkonversi string ke daftar poin kode.
• `mappend`show(...) membuat serial daftar yang dihasilkan dari daftar dan akhirnya menambahkannya ke kode inti program 2.

Panduan, program 2

• Tingkat tertinggi z~z=[[['@','0'..]!!4..]!!z]adalah fungsi yang mengubah kode kembali ke karakter (diperlukan untuk menulis karena tidak semua karakter toEnumtersedia).
  • Argumen titik kode juga disebut z. Penanda kemalasan ~tidak memiliki efek pada posisi ini tetapi menghindari karakter spasi.
  • ['@','0'..] adalah rentang daftar loncatan mundur mulai dari kode ASCII 64, kemudian melompat 16 ke bawah setiap langkah.
  • Menerapkan !!4ini memberi \NULkarakter.
  • Membungkusnya dalam [ ..]rentang memberikan daftar semua karakter, yang !!zdiindeks.
  • Karakter akhirnya dibungkus dalam daftar tunggal. Ini memungkinkan pemetaan fungsi zmenggunakan daftar =<<alih-alih yang tidak tersedia mapdan <$>.
• Tingkat teratas q[x,q]_=z=<<x++q++[34,34]++xadalah fungsi membangun program 1 dari daftar data quine.
  • xadalah data untuk inti dari program 1 (termasuk penawaran ganda akhir) dan bagian dalam qadalah data yang dikaburkan untuk inti dari program 2. _adalah argumen dummy lain semata-mata untuk membuat fungsi anonim akhir menjadi fungsi alih-alih hanya string.
  • x++q++[34,34]++x menyatukan potongan-potongan, termasuk dua tanda kutip ganda dengan kode ASCII 34.
  • z=<<membangun program 1 dengan memetakan zrangkaian untuk mengkonversi dari titik kode ke karakter.
• Final q[[40,...]]adalah fungsi anonim yang dikombinasikan qdengan data quine.

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

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

Cobalah online!

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

Cobalah online!

Program pertama melakukan hal berikut:

“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: 'ỌṘ'.

Ini meninggalkan string 79,7806,8318,7885,7769,338,115dan ỌṘsebagai dua argumen rantai dan mereka secara implisit digabungkan dan dicetak pada akhirnya.

Program kedua menghitung chr( Ọ) dari daftar angka yang kembali OṾ⁾ọṙŒs. Ṙmencetak “OṾ⁾ọṙŒs”(dengan tanda kutip) dan mengembalikan input, meninggalkan “OṾ⁾ọṙŒs”OṾ⁾ọṙŒssebagai output penuh.

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

"lF{3+|3d*HqlJJJQpp2

Cobalah online!

'5ssTMMMotK-g6.6~Io

Cobalah online!

Verifikasi online!

Bagaimana mereka bekerja

"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

Diadaptasi dari jawaban Jo King> <> . Memiliki lebih banyak perintah alternatif untuk keluaran dan pengulangan, tidak perlu gatau p, dan dua badan utama menjadi jauh lebih pendek.

Perbedaan utama lainnya adalah saya membuat kutipan lawan langsung di atas tumpukan. Dengan cara ini, sedikit lebih mudah untuk mempertahankan yang lain quote + my code + opponent code(reversed and shifted).