ความท้าทายของคุณง่าย เขียนโปรแกรมสองโปรแกรมที่ไม่มีตัวอักษรที่ให้ผลลัพธ์ซึ่งกันและกัน

ตัวอย่าง

สองโปรแกรมPและQเป็น quines ที่ไม่เกิดร่วมกันหาก:

1. Pเอาท์พุทQ
2. Qเอาท์พุทP
3. ไม่มีอักขระcซึ่งเป็นของทั้งPและQ
4. แต่ละโปรแกรมPและQเป็นquines ที่เหมาะสม
   1. ข้อหานี้ quines ว่างเปล่าและ quines อ่านได้ว่าเป็นของตัวเอง (หรืออื่น ๆ ) รหัสที่มาเป็นที่ไม่ถูกต้อง

กฎเพิ่มเติม

• ความยาวรวมที่สั้นที่สุดของโปรแกรมเหล่านี้ชนะ นั่นคือขนาด ( P ) + ขนาด ( Q ) คือคะแนนของคุณและคะแนนต่ำสุดชนะ
• ทั้งสองโปรแกรมเป็นภาษาเดียวกัน
• แต่ละโปรแกรมอาจเป็นโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบและไม่จำเป็นต้องเหมือนกัน
  • ตัวอย่างเช่นPอาจเป็นโปรแกรมเต็มรูปแบบและQอาจเป็นฟังก์ชัน

การตรวจสอบ

นี้ลองออนไลน์! ข้อมูลโค้ดที่นี่สามารถตรวจสอบได้ว่าโปรแกรมสองโปรแกรมนั้นมีลักษณะเฉพาะตัวหรือไม่ อินพุตถูกใส่ในสองอาร์กิวเมนต์แรก

> <> , คะแนน: 41 + 41 = 82

แก้ไข: ทั้งคู่มี 3. แก้ไข

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

และ

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

ลองออนไลน์! (สลับบรรทัดเพื่อรับเอาต์พุตอื่น) ด้วยการตรวจสอบในครั้งนี้!

><>oเป็นภาษาที่ยากโดยเฉพาะอย่างยิ่งที่จะใช้ที่นี่เป็นมีเพียงวิธีหนึ่งที่จะตัวละครที่ออกคำสั่ง โชคดีที่เราสามารถใช้คำสั่งp ut เพื่อวางoในซอร์สโค้ดระหว่างการดำเนินการเช่นในการเขียนโปรแกรมของฉันในคำตอบPristine World

หนึ่งนี้เอามากของการทดลองและข้อผิดพลาด ฉันเริ่มด้วยโปรแกรมที่ไม่เหมือนกันสองโปรแกรม:

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

และ

"r00gr40g8+X0pN+?Y0.data

แต่ละคนแปลงตัวเองและข้อมูลโดย N การลบครั้งแรกและการเพิ่มครั้งที่สอง จากนั้นผลลัพธ์จะเป็นแบบย้อนกลับ ประเด็นก็คือข้อมูลหลังจากแต่ละโปรแกรมเป็นโปรแกรมอื่นในทางกลับกันเลื่อนโดย N ( Xคือจำนวนเซลล์ที่โปรแกรมต้องใส่oและ Y คือเซลล์ที่ตัวชี้ลูปกลับไป?เป็นที่oวาง) .

ทั้งสองปฏิบัติตามโครงสร้างเดียวกันแสดงในรูปแบบที่แตกต่างกัน พวกเขาใช้สตริงตัวอักษรมากกว่ารหัสทั้งหมดเพิ่มลงในสแต็ก พวกเขาสร้างคำสั่งตัวอักษรสตริงที่พวกเขาใช้และวางไว้ที่ด้านล่างของสแต็ค พวกมันวนไปมาบนสแต็กโดยเพิ่ม / ลบ N ไปที่อักขระแต่ละตัวแล้วพิมพ์ออกมา

โปรแกรมแรกใช้'เป็นตัวอักษรสตริงและง่ายd3*}ในการสร้างค่า 39 และผลักดันมันไปที่ด้านล่างของสแต็ค ที่สองใช้"เป็นตัวอักษรสตริงที่มีฟังก์ชั่นเดียวกัน มันจะrสแต็กซ้อนgets อักขระที่เซลล์ 0,0 และย้อนกลับสแต็กอีกครั้ง จากนั้นจึงgป้อนค่าที่เซลล์ 4,0 ( g) และบวก 8 เข้าไปเพื่อรับoและวางที่ X

ทั้งสองโปรแกรมใช้วิธีการวนลูปที่แตกต่างกัน โปรแกรมแรกใช้คำสั่ง skip ( !) เพื่อเรียกใช้คำแนะนำเพียงครึ่งเดียวในขณะที่ไปทางซ้ายกลับทิศทางและทำงานอีกครึ่งหนึ่ง ตัวที่สองใช้คำสั่ง jump ( .) เพื่อข้ามไปด้านหลังจนถึงจุดเริ่มต้นของลูปที่เซลล์ Y การรันทั้งสองนี้จนกว่าจะไม่มีรายการเพิ่มเติมในสแต็กและข้อผิดพลาดของโปรแกรม

ฉันพบปัญหาจำนวนหนึ่งด้วยค่าที่ต่ำกว่าของ N ส่วนใหญ่เนื่องจากการเปลี่ยนอักขระหนึ่งตัวจะเปลี่ยนเป็นอักขระอื่นที่จำเป็นสำหรับโปรแกรมนั้น (ดังนั้นจึงไม่สามารถใช้เป็นข้อมูลสำหรับโปรแกรมอื่น) หรือสองตัวอักษรจาก สองโปรแกรมจะเปลี่ยนเป็นอักขระตัวเดียวกัน ตัวอย่างเช่น:

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

เป็นต้น

ในที่สุดฉันถึง 10 ( a) ซึ่งฉันสามารถหลีกเลี่ยงปัญหาเหล่านี้ได้ อาจมีเวอร์ชั่นที่สั้นกว่าซึ่งการเลื่อนจะถูกย้อนกลับและโปรแกรมแรกจะเพิ่ม N ในขณะที่โปรแกรมที่สองลบออก สิ่งนี้อาจแย่กว่านั้นเนื่องจากโปรแกรมแรกโดยทั่วไปจะอยู่ในระดับล่างสุดของระดับ ASCII ดังนั้นการลบจะดีกว่าเพื่อหลีกเลี่ยงความขัดแย้ง

Forth (gforth 64-bit little-endian น้อย) , 428 + 637 = 1,065ไบต์

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 

ลองออนไลน์!

สคริปต์ยืนยัน

ขอบคุณ@Nathanielสำหรับแนวคิดของการใช้ Forth - เขาเตือนฉันในความคิดเห็นที่Forth ไม่ได้ตรงตามตัวพิมพ์ใหญ่ -เล็ก อารมณ์แปรปรวนมาแล้ว - ฉันค้นหาเหตุผลว่าทำไมสิ่งนี้ถึงไม่ได้ผลตามมาด้วยการแก้ไขปัญหาเหล่านี้ซ้ำแล้วซ้ำอีก ทั้งหมดในขณะที่ปั่นจักรยานฝึกในร่มของฉันเหมือนสปินเนอร์อยู่ไม่สุขที่มีขนาดใหญ่และขาดรูปร่าง

ก่อนที่จะเขียนโปรแกรมเหล่านี้ฉันร่างแบบอักษรที่สามารถใช้กับโปรแกรมใดได้บ้าง โดยเฉพาะโปรแกรมที่สองสามารถใช้ตัวอักษรตัวพิมพ์ใหญ่ตัวเลขทศนิยมแท็บและเครื่องหมายจุลภาคเท่านั้น นี่หมายความว่าโปรแกรมแรกเป็นตัวพิมพ์เล็กทั้งหมด แต่ฉันใช้ตัวอักษรตัวพิมพ์ใหญ่บางตัวสำหรับค่า ASCII

เนื่องจากแท็บไม่สะดวกฉันจะใช้ช่องว่างในคำอธิบายแทน

โปรแกรมแรกเป็นรูปแบบs" code"code- s"เริ่มต้นตัวอักษรสตริงซึ่งจะถูกประมวลผลโดยสำเนาที่สองของรหัส - กรอบมาตรฐาน quine อย่างไรก็ตามแทนที่จะส่งออกซอร์สโค้ดของมันเองมันจะสร้างโปรแกรมอื่นซึ่งมีลักษณะดังนี้:

• HERE
• สำหรับแต่ละ 8 ไบต์ในสตริงต้นฉบับ 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

สิ่งนี้ใช้พื้นที่ข้อมูลของ Forth HEREส่งกลับตัวชี้ไปยังจุดสิ้นสุดของพื้นที่พื้นที่ข้อมูลที่จัดสรรในปัจจุบันและ,ผนวกเซลล์ที่เต็มไปด้วยตัวเลข ดังนั้นครั้งแรกที่สามจุด bullet s"สามารถมองเห็นได้เช่นตัวอักษรสตริงสร้างขึ้นโดยใช้ วิธีปิดโปรแกรมที่สองให้เสร็จสิ้น:

• EMIT เอาต์พุตอักขระที่กำหนดค่า ASCII ดังนั้น:
  • 115 EMIT พิมพ์ตัวพิมพ์เล็ก s
  • 34 EMIT พิมพ์อักขระเครื่องหมายคำพูด "
  • 9 EMIT พิมพ์แท็บ
• 2DUPทำซ้ำองค์ประกอบสองอันดับแรกบนสแต็( a b -- a b a b )กนี่คือตัวชี้ไปและความยาวของสตริง
• TYPE พิมพ์สตริงเพื่อส่งออกสำเนาแรกของรหัส
• 34 EMITพิมพ์ใบเสนอราคาปิด"และในที่สุด
• TYPE ส่งออกสำเนาที่สองของรหัส

มาดูกันว่าโปรแกรมแรกทำงานอย่างไร ในหลายกรณีจำเป็นต้องหลีกเลี่ยงตัวเลขซึ่งทำได้โดยใช้'xส่วนขยายไวยากรณ์ gforth สำหรับตัวอักษรและบางครั้งก็ลบค่า ASCII ของพื้นที่ซึ่งสามารถรับได้โดยใช้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.

ในการจบการทำงานนี้ฉันอยากจะบอกว่าฉันพยายามใช้EVALUATEแต่โปรแกรมที่สองมีขนาดใหญ่กว่าโปรแกรมทั้งสองที่แสดงไว้ด้านบน อย่างไรก็ตามนี่คือ:

: 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

หากคุณจัดการตีกอล์ฟให้มากพอที่จะก้าวข้ามs" ..."...แนวทางของฉันไปข้างหน้าและโพสต์มันเป็นคำตอบของคุณเอง

Perl, (311 + 630 = 941 ไบต์) 190 + 198 = 388 ไบต์

ทั้งสองโปรแกรมพิมพ์ไปที่เอาต์พุตมาตรฐาน

โปรแกรม perl แรกประกอบด้วยอักขระ ASCII ส่วนใหญ่ที่พิมพ์ได้และขึ้นบรรทัดใหม่และลงท้ายด้วยบรรทัดใหม่หนึ่งบรรทัด แต่ตัวอักษรสองตัวÿแสดงถึงไบต์ที่ไม่ใช่ ASCII:

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

ส่วนที่สองประกอบด้วยไบต์ที่ไม่ใช่ ASCII ส่วนใหญ่รวมถึงอักขระควบคุมจำนวนมากที่ถูกแทนที่ด้วยดาวในโพสต์นี้และไม่มีการขึ้นบรรทัดใหม่เลย:

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

เลขฐานสิบหกของโปรแกรมแรกที่มีxxdคือ:

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

และเลขฐานสิบหกของโปรแกรมที่สองคือ:

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

ในโปรแกรมที่สองสตริงที่ยกมา (189 ไบต์ยาวคั่นด้วย tildes) เป็นโปรแกรมแรกทั้งหมดยกเว้นการขึ้นบรรทัดใหม่สุดท้ายเท่านั้นเข้ารหัสโดย bitwise การเติมเต็มแต่ละไบต์ โปรแกรมที่สองเพียงแค่ถอดรหัสสตริงโดยเติมเต็มแต่ละไบต์ซึ่ง~ผู้ประกอบการทำใน Perl โปรแกรมจะพิมพ์สตริงถอดรหัสตามด้วยการขึ้นบรรทัดใหม่ ( sayวิธีการเพิ่มบรรทัดใหม่)

ในการสร้างนี้ตัวถอดรหัสของโปรแกรมที่สองใช้อักขระ ASCII ที่แตกต่างกันเพียงหกตัวเท่านั้นดังนั้นโปรแกรมแรกสามารถใช้งานได้ตามอำเภอใจตราบใดที่มีเพียงอักขระ ASCII เท่านั้นและไม่รวมอักขระหกตัวเหล่านั้น มันไม่ยากที่จะเขียนโปรแกรม Perl โดยไม่ต้องใช้ตัวละครทั้งห้า ตรรกะ quine จริงจึงอยู่ในโปรแกรมแรก

ในโปรแกรมแรกตรรกะ quine ใช้พจนานุกรมความยาว 11 คำ@fและรวบรวมผลลัพธ์จากคำเหล่านั้น คำแรกทำซ้ำซอร์สโค้ดส่วนใหญ่ของโปรแกรมแรก คำที่เหลือเป็นอักขระเดี่ยวที่เฉพาะเจาะจง ตัวอย่างเช่นคำ 5 คือเครื่องหมายตัวหนอนซึ่งเป็นตัวคั่นสำหรับสองสตริงตัวอักษรในโปรแกรมที่สอง รายการตัวเลขระหว่างวงเล็บคือสูตรสำหรับคำที่จะพิมพ์ตามลำดับ นี่เป็นวิธีการก่อสร้างทั่วไปที่ค่อนข้างธรรมดาสำหรับการควอเตอร์เพียงบิดอย่างเดียวในกรณีนี้คือคำในพจนานุกรมแรกจะถูกพิมพ์ด้วยไบต์ของ bitwise ที่สมบูรณ์

Haskell , 306 + 624 = 930 ไบต์

โปรแกรม 1: ฟังก์ชั่นนิรนามที่รับอาร์กิวเมนต์ดัมมี่และส่งคืนสตริง

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

ลองออนไลน์!

โปรแกรม 2: q[[40,...]]ในตอนท้ายเป็นฟังก์ชั่นนิรนามที่รับอาร์กิวเมนต์ดัมมี่และส่งคืนสตริง

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

ลองออนไลน์!

ชุดอักขระ 1 (รวมช่องว่าง):

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

ชุดอักขระ 2 (รวมบรรทัดใหม่):

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

เนื่องจากชุดที่ 1 มีอักขระที่ไม่ใช่ ASCII เท่านั้นไบต์ UTF-8 ของพวกเขาจึงไม่รวมกัน

มันทำงานอย่างไร

• โดยทั่วไปแล้วโปรแกรมที่ 1 จะเขียนด้วยนิพจน์แลมบ์ดาช่องว่างและวงเล็บการใช้ฟังก์ชันตัวอักษรและตัวเลขในตัวฟรีและมีข้อมูลควินินเป็นตัวอักษรสตริงในตอนท้าย

  • รหัสหลักของโปรแกรม 1 จะถูกแปลงเป็นข้อมูลตัวอักษรแบบสตริงโดยล้อมรอบด้วยเครื่องหมายคำพูด
    • ในการสนับสนุนสิ่งนี้แบ็กสแลชทุกครั้งจะถูกตามด้วยaหรือbซึ่งเป็นรูปแบบการหลบหนีที่ถูกต้องซึ่งผ่านshowไปมา
    • อีกประโยชน์เล็ก ๆ ก็คือว่าa, bและcเป็นคนเดียวที่ต่ำกว่าตัวอักษรกรณีที่มีรหัส ASCII น้อยกว่า 100 บาทประหยัดในการเข้ารหัสตัวเลขที่ใช้โดยโปรแกรม 2
  • การเข้ารหัสตัวอักษรสตริงของรหัสหลักของโปรแกรม 2 นั้นดูสับสนมากขึ้นโดยใช้ non-ASCII Unicode: อักขระทุกตัวมีการเพิ่ม 182 ลงในจุดโค้ดเพื่อให้แน่ใจว่าไม่มีการทับซ้อนกับอักขระดั้งเดิม
    • 182 เคยเป็น 128 จนกระทั่งฉันรู้ว่าฉันสามารถใช้ความจริงที่ว่า 182 เป็นสองเท่าของความยาวของตัวอักษรสตริงสำหรับโค้ดของโปรแกรม 1 เพื่อลดการถอดรหัส (เป็นโบนัสโปรแกรม 2 สามารถใช้การขึ้นบรรทัดใหม่ได้)

• โดยทั่วไปโปรแกรม 2 จะเขียนด้วยสมการฟังก์ชันระดับบนสุด (ยกเว้นนิรนามสุดท้าย) ตัวอักษรตัวอักษรและตัวเลขทศนิยมไวยากรณ์รายการ / ช่วงและตัวดำเนินการและมีข้อมูล quine เป็นรายการของInts ที่สิ้นสุด

  • รหัสหลักของโปรแกรม 1 ถูกเข้ารหัสเป็นรายการของรหัสคะแนนพร้อมด้วยเครื่องหมายคำพูดคู่สุดท้าย
  • รหัสหลักของโปรแกรม 2 ถูกเข้ารหัสเป็นรายการของรหัสจุดของตัวอักษรสตริงที่ใช้ในโปรแกรม 1 ซึ่งยังคงเพิ่มขึ้น 182

เกมส์โปรแกรม 1

• bและcเป็นค่าของตัวอักษรสตริงสำหรับโปรแกรม 2 และ 1 ตามลำดับซึ่งกำหนดให้เป็นอาร์กิวเมนต์สุดท้ายของนิพจน์แลมบ์ดา ()เป็นอาร์กิวเมนต์ดัมมี่เพียงเพื่อตอบสนองกฎ PPCG ที่โปรแกรมควรกำหนดฟังก์ชั่น
• foldr(\a->map pred)b(show()>>c)ถอดรหัสสตริงbรหัสหลักของโปรแกรมที่ 2 โดยการใช้map predไปจำนวนครั้งเท่ากับความยาวของหรือshow()>>c == c++c182
• tail(show c)แปลงสตริงcให้เป็นรหัสแกนหลักของโปรแกรม 1 โดยมีเครื่องหมายอัญประกาศคู่สุดท้ายต่อท้าย
• :pure bbรวมนี้ในรายการกับสตริง
• map(map fromEnum)$ แปลงสตริงเป็นรายการของรหัสจุด
• `mappend`show(...) เรียงลำดับรายการผลลัพธ์ที่เกิดขึ้นเป็นลำดับและท้ายที่สุดจะผนวกเข้ากับรหัสหลักของโปรแกรม 2

เกมส์โปรแกรม 2

• ระดับบนสุดz~z=[[['@','0'..]!!4..]!!z]เป็นฟังก์ชั่นการแปลงรหัสชี้กลับไปที่ตัวอักษร (จำเป็นต้องเขียนเนื่องจากไม่มีอักขระทั้งหมดในtoEnum)
  • zอาร์กิวเมนต์จุดรหัสของมันจะถูกเรียกว่า เครื่องหมายความเกียจคร้าน~ไม่มีผลในตำแหน่งนี้ แต่หลีกเลี่ยงอักขระเว้นวรรค
  • ['@','0'..] เป็นช่วงรายการก้าวถอยหลังเริ่มต้นที่รหัส ASCII 64 จากนั้นกระโดดลง 16 ขั้นในแต่ละขั้นตอน
  • การนำ!!4ไปใช้กับสิ่งนี้จะทำให้\NULตัวละคร
  • การตัดคำที่อยู่ใน[ ..]ช่วงให้รายการของตัวละครทั้งหมดซึ่ง!!zดัชนี
  • ในที่สุดตัวละครจะถูกห่อหุ้มด้วยรายการซิงเกิล นี้จะช่วยให้การทำแผนที่การทำงานzมากกว่ารายการที่ใช้=<<แทนการใช้งานไม่ได้และmap<$>
• ระดับบนสุดq[x,q]_=z=<<x++q++[34,34]++xเป็นฟังก์ชั่นการสร้างโปรแกรม 1 จากรายการข้อมูลควิน
  • xเป็นข้อมูลสำหรับแกนหลักของโปรแกรม 1 (รวมถึงเครื่องหมายคำพูดคู่สุดท้าย) และข้อมูลภายในqคือข้อมูลที่ทำให้งงงวยสำหรับแกนหลักของโปรแกรม 2 _เป็นอาร์กิวเมนต์ดัมมี่อื่นเพียงอย่างเดียวที่จะทำให้ฟังก์ชั่นนิรนามสุดท้ายเป็นเพียงฟังก์ชัน
  • x++q++[34,34]++x เชื่อมต่อชิ้นส่วนรวมถึงเครื่องหมายคำพูดคู่สองตัวพร้อมรหัส ASCII 34
  • z=<<สร้างโปรแกรม 1 โดยการแมปzผ่านการต่อข้อมูลเพื่อแปลงจากจุดโค้ดเป็นอักขระ
• สุดท้ายq[[40,...]]คือฟังก์ชั่นที่ไม่ระบุชื่อรวมqกับข้อมูลควิน

เยลลี่ , _{128 90 87 86 85 79} 16 + 32 = 48 ไบต์

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

ลองออนไลน์!

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

ลองออนไลน์!

โปรแกรมแรกทำสิ่งต่อไปนี้:

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

สิ่งนี้ทำให้สตริง79,7806,8318,7885,7769,338,115และỌṘเป็นสองอาร์กิวเมนต์ของโซ่และพวกเขาจะถูกรวมเข้าด้วยกันและพิมพ์ในตอนท้าย

โปรแกรมที่สองคำนวณchr( Ọ) OṾ⁾ọṙŒsจากรายการตัวเลขซึ่งผลตอบแทน Ṙพิมพ์“OṾ⁾ọṙŒs”(พร้อมเครื่องหมายคำพูด) และส่งคืนอินพุตโดยปล่อย“OṾ⁾ọṙŒs”OṾ⁾ọṙŒsเป็นเอาต์พุตแบบเต็ม

Gol> <> , _{23 +23 = 46 22 + 22 = 44} 20 + 20 = 40 ไบต์

"lF{3+|3d*HqlJJJQpp2

ลองออนไลน์!

'5ssTMMMotK-g6.6~Io

ลองออนไลน์!

ยืนยันออนไลน์!

พวกเขาทำงานอย่างไร

"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

ที่ดัดแปลงมาจาก> <> คำตอบโจของพระบาทสมเด็จพระเจ้าอยู่หัว การมีคำสั่งทางเลือกอื่น ๆ อีกมากมายสำหรับเอาท์พุทและทำซ้ำไม่จำเป็นต้องมีgหรือpและเนื้อหาหลักทั้งสองก็สั้นกว่ามาก

ความแตกต่างที่สำคัญอีกอย่างคือฉันสร้างใบเสนอราคาของคู่ต่อสู้โดยตรงที่ด้านบนของสแต็ค ด้วยวิธีนี้มันง่ายกว่าเล็กน้อยในการรักษาค่าคงที่quote + my code + opponent code(reversed and shifted)ไว้