Objetivo:

Codifique dois programas em que cada um dos programas gera os dois códigos-fonte entrelaçados por caractere como um zíper, um Quine com duas fendas. A saída de um Quine com duas fendas está começando com o primeiro caractere do código-fonte do primeiro programa. Se o código fonte de um dos programas tiver um comprimento menor que o outro, o restante da saída deverá ser preenchido com o restante do código fonte mais longo.

Regras:

1. Você pode usar qualquer linguagem de programação para ambos os programas, não sendo necessária a mesma linguagem de programação para ambos.
2. Seus programas não devem receber nenhuma entrada de um arquivo, nome de arquivo, rede, outro programa ou qualquer outra coisa.

Critérios obrigatórios:

• Existe um problema, em algum lugar da saída a palavra QUINEem maiúsculas deve existir, ininterrupta.
• Você precisa indicar quais são as duas linguagens de programação que você está usando. Se você estiver usando a mesma linguagem de programação para ambos, precisará especificar apenas uma linguagem de programação.
• Ambos os programas devem poder executar ou ser interpretados, respectivamente, independentemente do outro programa.

Exemplo:

Tendo este exemplo de código-fonte do programa um :

"QIE"

Tendo este exemplo de código-fonte do programa dois :

"UN"

Em seguida, a saída Quine de abertura dupla válida de ambos os programas deve ser:

""QUINE""

Este é o código-golfe, o menor número de bytes ao somar o comprimento dos dois códigos-fonte e, obviamente, também o comprimento da saída de cada programa, ganha!

CJam, 49 47 bytes

{`:_"__~~e#QUINE"}_~

e

{`:_"__~~e#QUINE"}_~e#QUINE

ambos imprimem

{{``""__~~""++::__""ee##QQUUIINNEE""}}__~~e#QUINE

Experimente on-line: programa 1 , programa 2 , prova de validade

Como eles trabalham

{                }   e# Push a code block.
                  _~ e# Execute a copy.
 `                   e# Convert the code block into a string.
  :_                 e# Duplicate each character of the resulting string.
    "__~~e#QUINE"    e# Push this string.

O programa 1 termina aqui e possui uma representação de seqüência de caracteres de todo o código-fonte (que cada caractere repetiu duas vezes), bem como a seqüência de caracteres e # QUINE na pilha.

Programa 2 adicionalmente analisa e#QUINE, que é um comentário.

Nos dois casos, o CJam imprime as duas seqüências automaticamente, resultando na saída mencionada acima.

Sério, 46 56 42 bytes

QUNX;RZtdXεj.ƒ£REIQ

Hex Dump:

51554e583b525a746458ee6a2e7f9f9c524549510a

O segundo programa é esse programa exato invertido. Ele contém um caractere invisível, mas a contagem de bytes está correta. Ambos os programas produzem essa sequência palíndrica:

QQUINEXR;£RƒZ⌂t.djXεεXjd.t⌂ZƒR£;RXENIUQQ

(Por alguma razão, ele exibe o caractere invisível quando o envia no meu terminal. Eu realmente não entendo esse byte de 7F.)

Como funciona:

Q                     Push the source to the stack
 U                    Nop
  NX                  Push and pop lyrics to 99 bottles of beer
    ;R                Make a copy of the source reversed.
      Z               Zip them together.
       t              Completely flatten the list.
        dX            Delete the trailing newline
          εj          Join it into a string.
            .         Print it with a trailing newline.
             ⌂        (This is that 7F byte that won't show up. It halts.)

O restante do programa não é executado.

Então a outra direção:

\n                   Nop
  Q                  Push the source code.
   IE                Nops
     R               Reverse source code to get source of first program
      £              Eval it into a function
       ƒ             Call it.

Neste ponto, agora estamos executando o primeiro programa acima, portanto, a execução continua como descrito lá.

Estou explorando fortemente o fato de que vários comandos não fazem nada para seqüências de caracteres ou pilhas vazias aqui. Também estou explorando o comportamento inesperado de tquando há apenas um item na pilha. Não espere que este programa funcione em versões futuras do Seriously.

Como a versão on-line do interpretador sério continua sendo quebrada, você deverá fazer o download do interpretador e executá-lo em sua própria máquina para testá-lo.

GolfScript, 46 bytes

{`{.}%"..~~QUINE"}.~

e

{`{.}%"..~~QUINE"}.~QUINE

ambos imprimem

{{``{{..}}%%""....~~~~QQUUIINNEE""}}..~~QUINE

Experimente on-line: programa 1 , programa 2 , prova de validade

Como funciona

{`{.}%"..~~QUINE"}.~

{                }    # Push a code block.
                  .~  # Execute a copy.
 `                    # Convert the code block into a string.
  {.}%                # Duplicate each character of the resulting string.
      "..~~QUINE"     # Push that string.

O código fonte do programa 2 analisa adicionalmente QUINE\n, que são dois tokens indefinidos.

Perl, 61 + 60 = 121 bytes

Programa 1:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#QIE

Programa 2:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#UN

Pensei em tentar isso em um idioma que não fosse o golfe. Este é basicamente apenas um construtor universal de quine no Perl modificado para dobrar cada caractere antes de imprimi-lo e anexá QUINE-lo ao final. Depois, basta colocar um comentário no final do código para compensar o texto adicionado.

(Eu escrevi isso sem realmente olhar para as outras respostas. Acontece que seria possível salvar um byte colocando todo o comentário em um programa, mas não tenho certeza se eu deveria apenas copiar descaradamente algoritmos como esse.)