Obbiettivo:

Codifica due programmi in cui ciascuno dei programmi genera entrambi i codici sorgente interlacciati per carattere come una cerniera, un Quine a doppia fenditura. L'output di un quine a doppia fessura inizia con il primo carattere del codice sorgente del primo programma. Se il codice sorgente di uno dei programmi è più corto dell'altro, il resto dell'output deve essere riempito con il resto del codice sorgente più lungo.

Regole:

1. È possibile utilizzare qualsiasi linguaggio di programmazione per entrambi i programmi, non necessario lo stesso linguaggio di programmazione per entrambi.
2. I tuoi programmi non dovrebbero ricevere alcun input da un file, nome file, rete, altro programma o altro.

Criteri obbligatori:

• C'è un problema, da qualche parte nell'output QUINEdeve esistere la parola in maiuscolo, ininterrotta.
• Devi indicare quali due linguaggi di programmazione stai utilizzando. Se si utilizza lo stesso linguaggio di programmazione per entrambi, è necessario indicare solo un linguaggio di programmazione.
• Entrambi i programmi dovrebbero essere in grado di eseguire, o essere interpretati, rispettivamente indipendenti dall'altro programma.

Esempio:

Con questo codice sorgente di esempio del programma uno :

"QIE"

Con questo codice sorgente di esempio del programma due :

"UN"

Quindi l'output Quine a doppia fenditura valido da entrambi i programmi deve essere:

""QUINE""

Questo è code-golf, il minimo di byte quando si somma la lunghezza di entrambi i codici sorgente, e ovviamente anche la lunghezza di ciascun programma in uscita, vince!

CJam, 49 47 byte

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

e

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

entrambi stampano

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

Provalo online: programma 1 , programma 2 , prova di validità

Come funzionano

{                }   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.

Il programma 1 termina qui e ha una rappresentazione in formato stringa dell'intero codice sorgente (che ogni carattere ha ripetuto due volte) nonché la stringa e # QUINE nello stack.

Il programma 2 analizza inoltre e#QUINE, che è un commento.

In entrambi i casi, CJam stampa automaticamente le due stringhe, generando l'output di cui sopra.

Scherzi a parte, 46 56 42 byte

QUNX;RZtdXεj.ƒ£REIQ

Dump esadecimale:

51554e583b525a746458ee6a2e7f9f9c524549510a

Il secondo programma è esattamente questo programma invertito. Contiene un carattere invisibile, ma il conteggio dei byte è corretto. Entrambi i programmi producono questa stringa palindromica:

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

(Per qualche motivo mostra il carattere invisibile quando lo emette nel mio terminale. Non capisco davvero quel byte 7F.)

Come funziona:

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

Il resto del programma non viene eseguito.

Quindi l'altra direzione:

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

A questo punto, stiamo eseguendo il primo programma sopra, quindi l'esecuzione continua come descritto qui.

Sto sfruttando pesantemente il fatto che diversi comandi non fanno nulla per stringhe o pile vuote qui. Sto anche sfruttando il comportamento inaspettato di tquando c'è solo un oggetto nello stack. Non aspettarti che questo programma funzioni nelle versioni future di Seriously.

Poiché la versione online dell'interprete Seriously continua a non funzionare, dovrai scaricare l'interprete ed eseguirlo sul tuo computer per testarlo.

GolfScript, 46 byte

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

e

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

entrambi stampano

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

Provalo online: programma 1 , programma 2 , prova di validità

Come funziona

{`{.}%"..~~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.

Viene inoltre analizzato il codice sorgente del programma 2 QUINE\n, che sono due token non definiti.

Perl, 61 + 60 = 121 byte

Programma 1:

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

Programma 2:

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

Ho pensato di provarlo in un linguaggio non golfistico. Questo è fondamentalmente solo un costruttore universale di quine in Perl modificato per raddoppiare ogni carattere prima di stamparlo e aggiungerlo QUINEalla fine. Quindi dobbiamo solo inserire un commento alla fine del codice per compensare il testo aggiunto.

(Ho scritto questo senza davvero guardare le altre risposte. Si scopre che sarebbe possibile salvare un byte inserendo l'intero commento in un programma, ma non sono sicuro se dovrei semplicemente copiare palesemente algoritmi del genere.)