Thử thách của bạn rất đơn giản. Viết hai chương trình chia sẻ không có ký tự nào xuất ra lẫn nhau.

Thí dụ

Hai chương trình P và Q là hai loại trừ lẫn nhau nếu:

1. P đầu ra Q
2. Q đầu ra P
3. Không có ký tự c thuộc cả P và Q
4. Mỗi chương trình P và Q là các quines thích hợp
   1. Điều này tính các quines trống và quines đọc mã nguồn của riêng chúng (hoặc của cái khác) là không hợp lệ .

Thêm quy tắc

• Thời lượng kết hợp ngắn nhất của các chương trình này sẽ thắng. Nghĩa là, kích thước ( P ) + kích thước ( Q ) là điểm của bạn và điểm thấp nhất sẽ thắng.
• Cả hai chương trình đều trong cùng một ngôn ngữ
• Mỗi chương trình có thể là một chương trình hoặc chức năng đầy đủ và chúng không cần phải giống nhau.
  • Ví dụ, P có thể là một chương trình đầy đủ và Q có thể là một hàm.

xác minh

Điều này Hãy thử trực tuyến! đoạn trích ở đây có thể xác minh xem hai chương trình có loại trừ lẫn nhau hay không. Các đầu vào được đặt trong hai đối số đầu tiên.

> <> , Điểm: 41 + 41 = 82

Chỉnh sửa: cả hai đều chứa 3. Đã sửa

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

và

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

Hãy thử trực tuyến! (hoán đổi các dòng để có đầu ra khác) Với xác minh lần này!

><>là một ngôn ngữ đặc biệt khó sử dụng ở đây, vì chỉ có một cách để xuất các ký tự, đó là lệnh o. May mắn thay, chúng ta có thể sử dụng lệnh p ut để đặt omã nguồn trong khi thực thi, giống như trong Lập trình của tôi trong câu trả lời của Thế giới nguyên sơ .

Điều này đã mất rất nhiều thử nghiệm và lỗi. Tôi bắt đầu với hai chương trình loại trừ lẫn nhau:

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

và

"r00gr40g8+X0pN+?Y0.data

Mỗi cái biến đổi chính nó và dữ liệu của nó bằng N, cái đầu tiên trừ và cái thứ hai thêm vào. Sau đó nó xuất ra điều này ngược lại. Vấn đề là dữ liệu sau mỗi chương trình là chương trình khác ngược lại, được dịch chuyển bởi N. ( Xlà số ô mà chương trình cần đặt ovà Y là ô nơi con trỏ lặp lại. ?Là nơi ođặt) .

Cả hai đều theo cùng một cấu trúc, được thể hiện theo những cách khác nhau. Họ chạy một chuỗi ký tự trên toàn bộ mã, thêm nó vào ngăn xếp. Họ tạo lại lệnh chuỗi ký tự mà họ đã sử dụng và đặt nó ở dưới cùng của ngăn xếp. Họ lặp qua chồng, thêm / bớt N cho mỗi ký tự và in chúng.

Chương trình đầu tiên sử dụng 'dưới dạng chuỗi ký tự và đơn giản d3*}để tạo giá trị 39 và đẩy nó xuống dưới cùng của ngăn xếp. Thứ hai sử dụng "như chuỗi ký tự có cùng chức năng. Nó làm rmờ ngăn xếp, xuất ghiện ký tự ở ô 0,0 và đảo ngược lại ngăn xếp. Sau đó, nó gnhận giá trị tại ô 4.0 ( g) và thêm 8 vào giá trị đó để lấy ovà đặt giá trị đó vào X.

Cả hai chương trình sử dụng một phương pháp lặp khác nhau. Chương trình đầu tiên sử dụng lệnh Skip ( !) để chỉ chạy một nửa lệnh trong khi rẽ trái, đảo ngược hướng và chạy nửa còn lại. Cái thứ hai sử dụng lệnh jump ( .) để bỏ qua ngược về điểm bắt đầu của vòng lặp tại ô Y. Cả hai đều chạy cho đến khi không còn mục nào trên stack và lỗi chương trình.

Tôi gặp phải một số vấn đề với hầu hết các giá trị thấp hơn của N, bởi vì việc chuyển một ký tự sẽ biến nó thành một ký tự khác cần thiết cho chương trình đó (và do đó không thể được sử dụng làm dữ liệu cho chương trình kia) hoặc hai ký tự từ hai chương trình sẽ chuyển sang cùng một nhân vật. Ví dụ:

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

v.v.

Cuối cùng, tôi đã lên tới 10 ( a), nơi tôi có thể tránh những vấn đề này. Có thể có một phiên bản ngắn hơn trong đó các ca làm việc được đảo ngược và chương trình đầu tiên sẽ thêm N trong khi phiên bản thứ hai trừ nó. Tuy nhiên, điều này có thể tồi tệ hơn, vì chương trình đầu tiên thường nằm ở phần dưới của thang đo ASCII, vì vậy trừ đi là tốt hơn để tránh xung đột.

Forth (gforth 64 bit nhỏ) , 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 

Hãy thử trực tuyến!

Kịch bản xác minh

Cảm ơn @Nathaniel vì ý tưởng sử dụng Forth - anh ấy đã nhắc nhở tôi trong các ý kiến ​​rằng Forth không phân biệt chữ hoa chữ thường . Sau đó là sự thay đổi tâm trạng - Tôi đã tìm ra lý do tại sao điều này sẽ không hoạt động, tiếp theo là các giải pháp cho những vấn đề này, lặp đi lặp lại. Tất cả trong khi quay chiếc xe đạp tập trong nhà của tôi như một con quay fidget quá khổ và sai lầm (bạn chỉ cần lấy một đầu của thanh tay cầm và nghiêng nó một chút).

Trước khi viết các chương trình này, tôi đã phác thảo những ký tự nào có thể được sử dụng bởi chương trình nào. Cụ thể, chương trình thứ hai chỉ có thể sử dụng chữ in hoa, chữ số thập phân, tab và dấu phẩy. Điều này có nghĩa là chương trình đầu tiên là tất cả chữ thường, nhưng tôi đã sử dụng một số chữ cái viết hoa cho các giá trị ASCII của chúng.

Vì các tab khó sử dụng, nên tôi sẽ sử dụng khoảng trắng trong phần giải thích.

Chương trình đầu tiên có dạng s" code"code- s"bắt đầu một chuỗi ký tự, sau đó được xử lý bởi bản sao thứ hai của mã - một khung quine chuẩn. Tuy nhiên, thay vì xuất ra mã nguồn của chính nó, nó sẽ tạo ra chương trình khác, trông giống như sau:

• HERE
• Đối với mỗi 8 byte trong chuỗi gốc, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Điều này sử dụng không gian dữ liệu của Forth. HEREtrả về con trỏ đến cuối vùng không gian dữ liệu hiện được phân bổ và ,nối thêm một ô chứa đầy một số vào nó. Do đó, ba điểm đầu tiên có thể được xem như một chuỗi ký tự được tạo bằng cách sử dụng s". Để kết thúc chương trình thứ hai:

• EMIT xuất ra một ký tự cho giá trị ASCII của nó, vì vậy:
  • 115 EMIT in một chữ thường s
  • 34 EMIT in ký tự "
  • 9 EMIT in một tab
• 2DUPnhân đôi hai phần tử trên cùng của ngăn xếp ( a b -- a b a b ), ở đây là con trỏ tới và độ dài của chuỗi
• TYPE in một chuỗi để xuất bản sao đầu tiên của mã
• 34 EMITin báo giá kết thúc ", và cuối cùng
• TYPE xuất bản sao thứ hai của mã

Hãy xem chương trình đầu tiên hoạt động như thế nào. Trong nhiều trường hợp, các số phải tránh, được thực hiện bằng cách sử dụng 'xphần mở rộng cú pháp gforth cho các ký tự, và đôi khi trừ đi giá trị ASCII của không gian, có thể thu được bằng cách sử dụng 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.

Để hoàn thành điều này, tôi muốn nói rằng tôi đã thử sử dụng EVALUATE, nhưng chương trình thứ hai trở nên lớn hơn cả hai chương trình được trình bày ở trên. Dù sao, đây là:

: 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

Nếu bạn quản lý để chơi golf này đủ để vượt qua s" ..."...cách tiếp cận của tôi , hãy tiếp tục và đăng nó như là câu trả lời của riêng bạn.

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

Cả hai chương trình in ra đầu ra tiêu chuẩn.

Chương trình perl đầu tiên chứa hầu hết các ký tự và dòng mới ASCII có thể in được và nó kết thúc bằng chính xác một dòng mới, nhưng hai chữ cái đại diện cho byte không phải 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]

Cái thứ hai chứa hầu hết các byte không phải ASCII, bao gồm một số ký tự điều khiển cao được thay thế bằng các ngôi sao trong bài đăng này và không có dòng mới nào cả:

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

Một hexdump của chương trình đầu tiên xxdlà:

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

Và một hexdump của chương trình thứ hai là:

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

Trong chương trình thứ hai, chuỗi được trích dẫn (dài 189 byte, được phân tách bằng dấu ngã) là toàn bộ chương trình đầu tiên ngoại trừ dòng mới cuối cùng, chỉ được mã hóa bằng cách bổ sung bitwise cho mỗi byte. Chương trình thứ hai chỉ đơn giản giải mã chuỗi bằng cách bổ sung cho từng byte mà ~toán tử thực hiện trong perl. Chương trình in chuỗi được giải mã theo sau là một dòng mới ( sayphương thức thêm một dòng mới).

Trong cấu trúc này, bộ giải mã của chương trình thứ hai chỉ sử dụng sáu ký tự ASCII khác nhau, vì vậy chương trình đầu tiên có thể thực tế tùy ý, miễn là nó chỉ chứa các ký tự ASCII và loại trừ sáu ký tự đó. Không khó để viết bất kỳ chương trình perl nào mà không sử dụng năm ký tự đó. Do đó, logic quine thực tế là trong chương trình đầu tiên.

Trong chương trình đầu tiên, logic quine sử dụng từ điển dài 11 từ @fvà lắp ráp đầu ra từ những từ đó. Những từ đầu tiên lặp lại hầu hết mã nguồn của chương trình đầu tiên. Phần còn lại của các từ là các ký tự đơn cụ thể. Ví dụ, từ 5 là một dấu ngã, là dấu phân cách cho hai chuỗi ký tự trong chương trình thứ hai. Danh sách các số giữa các dấu ngoặc là công thức để in các từ theo thứ tự nào. Đây là một phương pháp xây dựng chung khá bình thường cho các quines, điều khó khăn duy nhất trong trường hợp này là các từ trong từ điển đầu tiên được in với các byte được bổ sung theo bit.

Haskell , 306 + 624 = 930 byte

Chương trình 1: Một hàm ẩn danh lấy một đối số giả và trả về một chuỗi.

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

Hãy thử trực tuyến!

Chương trình 2: q[[40,...]]ở cuối là một hàm ẩn danh lấy một đối số giả và trả về một chuỗi.

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

Hãy thử trực tuyến!

Bộ ký tự 1 (bao gồm không gian):

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

Bộ ký tự 2 (bao gồm dòng mới):

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

Vì chỉ có tập 1 chứa các ký tự không phải ASCII, nên các byte UTF-8 của chúng cũng rời rạc.

Làm thế nào nó hoạt động

• Chương trình 1 thường được viết với các biểu thức lambda, dấu cách và dấu ngoặc đơn, sử dụng miễn phí các hàm chữ và số dựng sẵn và với dữ liệu quine dưới dạng chuỗi ký tự ở cuối.

  • Mã lõi của Chương trình 1 được chuyển thành chuỗi dữ liệu bằng chữ đơn giản bằng cách bao quanh nó bằng dấu ngoặc kép.
    • Để hỗ trợ điều này, mọi dấu gạch chéo ngược được theo sau bởi ahoặc b, tạo thành chuỗi thoát hợp lệ mà làm tròn qua show.
    • Một lợi ích nhỏ khác là a, bvà clà các chữ cái viết thường duy nhất có mã ASCII nhỏ hơn 100, lưu một chữ số trong mã hóa số được sử dụng bởi chương trình 2.
  • Mã hóa chuỗi ký tự của mã lõi của chương trình 2 bị xáo trộn nhiều hơn bằng cách sử dụng Unicode không ASCII: Mỗi ký tự có 182 điểm được thêm vào điểm mã của nó để đảm bảo không có sự trùng lặp với các ký tự gốc.
    • 182 từng là 128, cho đến khi tôi nhận ra rằng tôi có thể lạm dụng thực tế là 182 có độ dài gấp đôi chuỗi ký tự cho mã chương trình 1 để rút ngắn quá trình giải mã. (Như một phần thưởng, chương trình 2 có thể sử dụng các dòng mới.)

• Chương trình 2 thường được viết với các phương trình hàm cấp cao nhất (ngoại trừ ẩn danh cuối cùng), ký tự và số thập phân, cú pháp danh sách / phạm vi và toán tử, và với dữ liệu quine là danh sách các danh sách Ints ở cuối.

  • Mã lõi của Chương trình 1 được mã hóa dưới dạng danh sách các điểm mã của nó, với trích dẫn kép cuối cùng.
  • Mã lõi của Chương trình 2 được mã hóa dưới dạng danh sách các điểm mã của chuỗi ký tự được sử dụng trong chương trình 1, vẫn được dịch chuyển lên trên 182.

Hướng dẫn, chương trình 1

• bvà clà các giá trị của chuỗi ký tự chuỗi cho chương trình 2 và 1, tương ứng, được đưa ra làm đối số cuối cùng cho biểu thức lambda. ()là một đối số giả chỉ để đáp ứng quy tắc của PPCG rằng chương trình sẽ xác định hàm.
• foldr(\a->map pred)b(show()>>c)giải mã chuỗi bthành mã lõi của chương trình 2 bằng cách áp dụng map predcho nó một số lần bằng độ dài của show()>>c == c++c, hoặc 182.
• tail(show c)chuyển đổi chuỗi cthành mã lõi của chương trình 1, với một trích dẫn kép cuối cùng được nối thêm.
• :pure bkết hợp điều này trong một danh sách với chuỗi b.
• map(map fromEnum)$ chuyển đổi các chuỗi thành danh sách các điểm mã.
• `mappend`show(...) tuần tự hóa danh sách kết quả của danh sách và cuối cùng nối nó vào mã lõi của chương trình 2.

Hướng dẫn, chương trình 2

• Toplevel z~z=[[['@','0'..]!!4..]!!z]là một chức năng chuyển đổi mã trỏ lại thành các ký tự (cần thiết để viết vì không phải tất cả các ký tự toEnumcó sẵn.)
  • Đối số điểm mã của nó cũng được gọi z. Điểm đánh dấu sự lười biếng ~không có tác dụng ở vị trí này nhưng tránh một nhân vật không gian.
  • ['@','0'..] là một phạm vi danh sách bước lùi bắt đầu từ mã ASCII 64, sau đó nhảy xuống 16 bước mỗi bước.
  • Áp dụng !!4cho điều này cho một \NULnhân vật.
  • Bao bọc trong một [ ..]phạm vi cho một danh sách tất cả các ký tự, !!zchỉ mục.
  • Nhân vật cuối cùng được bọc trong một danh sách đơn. Điều này cho phép ánh xạ chức năng zqua các danh sách bằng cách sử dụng =<<thay vì không có sẵn mapvà <$>.
• Toplevel q[x,q]_=z=<<x++q++[34,34]++xlà một hàm xây dựng chương trình 1 từ danh sách dữ liệu quine.
  • xlà dữ liệu cho lõi của chương trình 1 (bao gồm cả trích dẫn kép cuối cùng) và bên trong qlà dữ liệu bị che _giấu cho lõi của chương trình 2. là một đối số giả khác chỉ để biến hàm ẩn danh cuối cùng thành hàm thay vì chỉ là một chuỗi.
  • x++q++[34,34]++x ghép các mảnh, bao gồm hai dấu ngoặc kép với mã ASCII 34.
  • z=<<xây dựng chương trình 1 bằng cách ánh xạ zqua phần nối để chuyển đổi từ điểm mã thành ký tự.
• Cuối cùng q[[40,...]]là một chức năng ẩn danh kết hợp qvới dữ liệu quine.

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

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Chương trình đầu tiên thực hiện như sau:

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

Điều này để lại các chuỗi 79,7806,8318,7885,7769,338,115và ỌṘnhư hai đối số của chuỗi và chúng được nối liền và in ở cuối.

Chương trình thứ hai tính toán chr( Ọ) của danh sách các số trả về OṾ⁾ọṙŒs. Ṙin “OṾ⁾ọṙŒs”(có dấu ngoặc kép) và trả về đầu vào, để lại “OṾ⁾ọṙŒs”OṾ⁾ọṙŒslà đầu ra đầy đủ.

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

"lF{3+|3d*HqlJJJQpp2

Hãy thử trực tuyến!

'5ssTMMMotK-g6.6~Io

Hãy thử trực tuyến!

Xác nhận trực tuyến!

Chúng hoạt động như thế nào

"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

Chuyển thể từ Jo King> <> trả lời . Có nhiều lệnh thay thế khác cho đầu ra và lặp lại, không cần ghoặc p, và hai phần chính trở nên ngắn hơn nhiều.

Một điểm khác biệt chính là tôi tạo ra trích dẫn của đối thủ trực tiếp ở đầu ngăn xếp. Bằng cách này, nó dễ dàng hơn một chút để giữ bất biến quote + my code + opponent code(reversed and shifted).