Ваша задача проста. Напишите две программы, которые не разделяют символы, которые выводят друг друга.

пример

Две программы P и Q являются взаимоисключающими квинусами, если:

1. P выходы Q
2. Q выходы P
3. Нет символа c, который принадлежит как P, так и Q
4. Каждая программа P и Q являются собственными
   1. Это считает пустые квины и квины, считывающие их собственный (или другой) исходный код недействительными .

Больше правил

• Самая короткая общая длина этих программ побеждает. То есть размер ( 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в исходный код во время выполнения, как в моем ответе « Программирование в нетронутом мире» .

Этот занял много проб и ошибок. Я начал с двух взаимоисключающих программ:

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

а также

"r00gr40g8+X0pN+?Y0.data

Каждый преобразует себя и свои данные на N, первое вычитая, а второе прибавляя. Затем он выводит это в обратном порядке. Дело в том , что данные после каждой программы является другой программой в обратном направлении, сдвинуто на N. ( Xэто числом клеток , где потребность программы ставить oи Y является ячейкой , где указатель возвращается к началу цикла. ?То , где oставится) ,

Оба имеют одинаковую структуру, представленную по-разному. Они запускают строковый литерал по всему коду, добавляя его в стек. Они воссоздают используемую ими строковую литеральную команду и помещают ее в конец стека. Они зацикливаются на стеке, добавляя / вычитая N для каждого символа и печатая их.

Первая программа использует 'как строковый литерал, так и простой, d3*}чтобы создать значение 39 и поместить его в конец стека. Второй использует "строковый литерал с той же функцией. Он rпересекает стек, gпомещает символ в ячейку 0,0 и снова переворачивает стек. Затем он gпомещает значение в ячейку 4,0 ( g), добавляет к нему 8 и получает его oв X.

Обе программы используют разные методы зацикливания. Первая программа использует команду пропуска ( !), чтобы выполнить только половину инструкций при движении влево, меняет направление и запускает вторую половину. Второй использует команду jump ( .), чтобы перейти назад к началу цикла в ячейке Y. Оба они выполняются до тех пор, пока в стеке не останется больше элементов и ошибок программы.

Я столкнулся с рядом проблем с большинством более низких значений N, потому что смещение одного символа превратило бы его в другой символ, необходимый для этой программы (и, следовательно, не может использоваться в качестве данных для другой программы) или в два символа из две программы переместятся в один и тот же персонаж. Например:

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

и т.п.

В конце концов я добрался до 10 ( a), где я смог избежать этих проблем. Возможно, существует более короткая версия, в которой сдвиги меняются местами, и первая программа добавляет N, а вторая вычитает его. Это может быть хуже, хотя, поскольку первая программа обычно находится в нижней части шкалы ASCII, поэтому вычитание лучше, чтобы избежать конфликтов.

Forth (64-битный little-endian gforth) , 428 + 637 = 1065 байтов

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

Это использует пространство данных Форта. HEREвозвращает указатель на конец выделенной в данный момент области пространства данных и ,добавляет к ней ячейку, заполненную номером. Таким образом, первые три пункта маркера можно увидеть как строковый литерал, созданный с использованием 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-байт \ 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]

Второй содержит в основном не-ASCII байты, в том числе несколько высокоуровневых символов, которые заменены звездами в этом посте, и никаких новых строк вообще:

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

Hexdump первой программы с 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].

И hexdump второй программы:

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 байт, разделенная тильдами) представляет собой всю первую программу, за исключением последнего перевода строки, кодируется только побитовым дополнением каждого байта. Вторая программа просто декодирует строку, дополняя каждый байт, что ~оператор делает в perl. Программа печатает декодированную строку, за которой следует новая строка ( sayметод добавляет новую строку ).

В этой конструкции декодер второй программы использует только шесть различных символов ASCII, поэтому первая программа может быть практически произвольной, если она содержит только символы ASCII и исключает эти шесть символов. Нетрудно написать любую Perl-программу без использования этих пяти символов. Фактическая логика Куайна, таким образом, находится в первой программе.

В первой программе логика quine использует словарь из 11 слов @fи собирает выходные данные из этих слов. Первые слова повторяют большую часть исходного кода первой программы. Остальные слова - это отдельные символы. Например, слово 5 - это тильда, которая является разделителем двух строкового литерала во второй программе. Список чисел в скобках - это рецепт, для которого нужно печатать слова в каком порядке. Это довольно обычный общий метод построения для квинов, единственный поворот в этом случае состоит в том, что первые слова словаря печатаются с побитовым добавлением байтов.

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 обычно написана с лямбда-выражениями, пробелами и круглыми скобками, свободным использованием встроенных буквенно-цифровых функций, а также с данными quine в качестве строковых литералов в конце.

  • Собственный основной код программы 1 превращается в строковые литеральные данные, просто заключая их в кавычки.
    • Чтобы поддержать это, за каждой обратной косой чертой следует aили b, которые образуют допустимые escape-последовательности, проходящие в обратном направлении show.
    • Еще одна крошечной преимущество заключается в том a, bи cявляются только строчными буквами , чья ASCII кода меньше , чем 100, сэкономив цифры в числовом кодировке , используемой программой 2.
  • Строковое литеральное кодирование основного кода программы 2 более запутанно с использованием не-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++cили 182.
• tail(show c)преобразует строку cв основной код программы 1 с добавлением окончательной двойной кавычки.
• :pure bобъединяет это в списке со строкой b.
• 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 из списка данных Quine.
  • 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).