Программа A выводит код программы B при запуске, а B выводит источник A.

Требования:

• Только один язык в обеих программах
• Программы разные. Одна программа, которая выводит сама себя, не подходит.
• Обе программы не пусты или имеют длину не менее 1 байта. Конечные переводы строк как в источнике, так и в выводе игнорируются
• стандартный ввод закрыт Не читайте ничего (поэтому вы не можете прочитать источник и манипулировать им). Вывод идет в стандартный вывод.
  Изменить: стандартный подключен к /dev/null. Вы можете заказать его, если будет уточнено.
• Не используйте randomфункции.

Дополнительно:

• Дайте объяснения, если это возможно

Оценка - это общая длина . Трейлинг новой строки не считается, если он не влияет на программу.

CJam , 13 + 13 = 26 байт

{sYZe\"_~"}_~

Попробуйте онлайн!

Выходы

{sZYe\"_~"}_~

объяснение

{       e# Standard quine framework, leaves a copy of the block on the stack
        e# for the block itself to process.
  s     e# Stringify the block.
  YZe\  e# Swap the characters at indices 2 and 3, which are Y and Z themselves.
  "_~"  e# Push the "_~" to complete the quine.
}_~

Поскольку e\во втором и третьем операндах коммутативно, другая программа делает то же самое, обмениваясь Zи Yвозвращаясь в исходный порядок.

CJam ,11 + 13 = 24 11 + 12 = 23 байта

"N^_p"
N^_p

Попробуйте онлайн!

Выходы:

"N^_p
"
N^_p

Вывод имеет 13 байтов, но:

Трейлинг новой строки не считается, если он не влияет на программу.

Поэтому я изменил пробел на новую строку, чтобы воспользоваться этим.

Это основано на самом коротком CJam собственно квине:

"_p"
_p

И это N^- xor строки с новой строкой, которая добавляет новую строку, если новой строки нет, и удаляет ее, если есть, для строки, каждый символ которой уникален.

Я думаю, что видел эту квинну в вопросе о квине, но не смог ее найти.

RProgN 2 , 3 + 3 = 6 байт

Первая программа:

0
1

Попробуйте онлайн!

Вторая программа:

1
0

Попробуйте онлайн!

-2 спасибо Мартину Эндеру .

С 95 + 95 = 190 байт

Спасибо @immibis за сохранение 16 * 2 байтов!

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Попробуйте онлайн!

Выходы:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=0^1;printf(s,34,s,34,i);}

Попробуйте онлайн!

Какие выводы:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Javascript, 67 + 67 = 134 байта

1-я программа:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=0))

2-я программа:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=1))

Это основано на ответе Германа Лауэнштейна на Tri-interquine

Javascript (Invalid-reads source code), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 байт

сэкономил 20 байтов благодаря Tushar, 6 байтов благодаря Craig Ayre и сэкономил 16 байтов благодаря kamoroso94

1-я программа:

f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()

2-я программа:

f=_=>alert(("f="+f).replace(1,a=>+!+a)+";f()");f()

Меняет местами 1 с 0 и наоборот. Они оба делают одно и то же, просто производя различный вывод из-за их исходного кода.

Python 2, 63 + 63 = 126 байт

Попробуйте онлайн

Первая программа:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

выходы:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Вторая программа:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Выходы:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

JavaScript ( JsShell ), 35 + 34 = 69 байт

1:

(f=x=>print(`(f=${f})(${-x})`))(-1)

2:

(f=x=>print(`(f=${f})(${-x})`))(1)

Mathematica, 43 + 44 = 87 байт

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -1 1]

а также

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -(-1)]

asmutils sh, 16 + 16 байт, злоупотребляя правилом "stdin is closed".

#!/bin/sh
tr x y

Поскольку stdin закрыт, и sh откроет свой скрипт для первого доступного дескриптора (вместо того, чтобы перемещать его в дескриптор с высоким номером, как это делают современные оболочки), tr заканчивает чтение из копии скрипта, даже не открыв его.

Этот запрос может быть полезен, но вставить его сложно.

Кроме того, в этой оригинальной версии используется некая безумная ошибка в древнем ядре, которое я использовал в те дни. (Я не знаю, что случилось с этим ядром - позже я узнал, что у него также есть разные старшие и младшие номера для устройств.) Если вы исправите изменения ABI, которые сломались, так как interquine все равно не будет работать. Я забываю, имеет ли asmutils sh exec или нет, но если это так, то это современная версия:

exec dd skip=0 | tr x y

Это злоупотребляет преднамеренной ошибкой в ​​asmutils dd; у него есть оптимизация производительности, которую он вызывает llseek для пропуска, если может, но чтобы сохранить байт, он передает SEEK_SET, а не SEEK_CUR. Это приводит к сборке мусора на stderr, но перехват на stdout. Asmutils dd не имеет возможности подавить спам stderr.

Недогрузка , 32 + 32 = 64 байта

(a~a*(:^)*S)(~(a)~a*^a(:^)**S):^

Попробуйте онлайн!

(~(a)~a*^a(:^)**S)(a~a*(:^)*S):^

Попробуйте онлайн!

Common Lisp, 58 символов

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

... или 24 символа, если вы не возражаете, предполагая, *print-circle*что глобально установлено T:

#1=(print '(write '#1#))

Печатное представление кода читается как циклическая структура, где #1#указатель на обратную ячейку минует следующую #1=. Мы цитируем программы так, чтобы они не выполнялись. Поскольку *print-circle*это T, REPL заботится о том, чтобы выдавать такие переменные считывателя во время печати; это то, что печатает и возвращает приведенный выше код:

#1=(write '(print '#1#)) 

Когда мы оцениваем приведенный выше код, он печатает:

#1=(print '(write '#1#))

Если вы хотите придерживаться значения по умолчанию для *print-circle*- NIL в соответствующей реализации, то вам придется временно перепривязать переменную:

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

Внутри тела LET мы печатаем вещи *print-circle*как T. Таким образом, мы получаем:

#1=(write
    '(let ((*print-circle* t))
       (print '#1#))
    :circle t) 

Как видите, новая программа не перепривязывается *print-circle*, но, поскольку мы используем writeфункцию низкоуровневого вызова print, мы можем передавать дополнительные аргументы, такие как :circle. Затем код работает как положено:

#1=(let ((*print-circle* t))
     (print '(write '#1# :circle t)))

Тем не менее, вы должны выполнить вышеупомянутые программы в качестве сценария, а не внутри РЕПЛ, потому что даже если вы печатаете вещи, заботясь о кольцевых структур, так writeи printтакже возвращает значение , которое печатается; и в REPL по умолчанию значение также печатается, но вне динамического контекста, где *print-circle*T.

> <> , 16 + 16 = 32 байта

":1-}80.r   !#o#

а также

#o#!   r.08}-1:"

Попробуйте онлайн!

Это работает с использованием перехода в программе, при первом переходе программы будет пропущен обратный стек (если он перевернет стек, это будет quine). Вторая программа не пропускает обратное, но если она уже полностью изменена потоком программы, то она создаст оригинал.

Этот код закончится ошибкой.

RProgN 2 , 7 + 7 = 14 байт

Я хотел показать лучшее использование RProgN, а не просто злоупотреблять заказами на печать ...

1
«\1\-

а также...

0
«\1\-

Разъяснения

1   # Push the constant, 1. (Or 0, depending on the program)

«\1\-
«       # Define a function from this to the matching », in this case there isn't any, so define it from this to the end of the program, then continue processing.
 \      # Flip the defined function under the constant.
  1\-   # Get 1 - Constant.

Поскольку это печатает стопку вверх дном, сначала печатается новая константа, а затем печатается строковая версия функции.

Попробуйте онлайн!

LOGO , 65 + 66 = 131 байт

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] 1]

а также

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] -1]

Python 3, 74 + 74 = 148 байт

a='a=%r;b=%r;print(b%%(b,a))';b='b=%r;a=%r;print(a%%(a,b))';print(b%(b,a))

а также

b='b=%r;a=%r;print(a%%(a,b))';a='a=%r;b=%r;print(b%%(b,a))';print(a%(a,b))

я тоже не понимаю

> <> , 12 + 12 = 24 байта

'3d*!|o|!-c:

а также

':c-!|o|!*d3

Попробуйте онлайн!

Обе программы используют строковый литерал для добавления кода в стек, а затем создают 'команду различными методами. При печати стопки он сдвигает код назад, но 'остается впереди. Есть несколько вариантов, которые производят '; 3d*, d3*, 00g, :c-Когда в паре с 3d*и :9-когда в паре с 00g.

Слишком похожее решение для публикации в Befunge-98 за 13 * 2 байта

"2+ck, @,kc+2

Stax , 18 + 20 = 38 байт

"Vn|^34bL"Vn|^34bL

Запускать и отлаживать онлайн!

"Vn|^34bL
"Vn|^34bL

Запускать и отлаживать онлайн!

объяснение

Добавлено для полноты. Порт ответа CJam от @ jimmy23013. Переключает переводы строки, используя set xor.

Javascript (ES6), 36 + 36 = 72 байта

Программа 1:

f=n=>('f='+f).replace(/4|5/g,n=>n^1)

Программа 2:

f=n=>('f='+f).replace(/5|4/g,n=>n^1)

Эти программы работают клонирование себя и заменить 5с 4и 4с5

console.log((
    f=n=>('f='+f).replace(/4|5/g,n=>n^1)
)())
console.log((
    f=n=>('f='+f).replace(/5|4/g,n=>n^1)
)())

Кляйн , 26 24 байта

<:3+@+3<:"

Попробуйте онлайн!

объяснение

Это работает так же, как мой Klein Quine , где он печатает источник задом наперед, а затем a ", последний из которых сходит с рук, будучи палиндромным, поэтому все, что нам нужно сделать, это сделать его непалиндромным, не нарушая его функциональность. Путем переключения <и :мы смогли сделать это, не мешая функционалу.

Пари / GP , 36 + 36 = 72 байта

(f=(x)->print1("(f="f")("1-x")"))(1)

Попробуйте онлайн!

(f=(x)->print1("(f="f")("1-x")"))(0)

Попробуйте онлайн!