Objectif:

Codez deux programmes où chacun des programmes sort les deux codes source entrelacés par caractère comme une fermeture éclair, un quine à double fente. La sortie d'un quine à double fente commence par le premier caractère du code source du premier programme. Si le code source de l'un des programmes est plus court que l'autre, le reste de la sortie doit être rempli avec le reste du code source plus long.

Règles:

1. Vous pouvez utiliser n'importe quel langage de programmation pour les deux programmes, pas nécessairement le même langage de programmation pour les deux.
2. Vos programmes ne doivent prendre aucune entrée d'un fichier, nom de fichier, réseau, l'autre programme ou quoi que ce soit d'autre.

Critères obligatoires:

• Il y a un hic, quelque part dans la sortie, le mot QUINEen majuscules doit exister, sans interruption.
• Vous devez indiquer les deux langages de programmation que vous utilisez. Si vous utilisez le même langage de programmation pour les deux, il vous suffit d'indiquer un seul langage de programmation.
• Les deux programmes doivent pouvoir s'exécuter ou être interprétés, respectivement indépendamment de l'autre programme.

Exemple:

Avoir cet exemple de code source du programme un :

"QIE"

Avoir cet exemple de code source du programme deux :

"UN"

Ensuite, la sortie Quine à double fente valide des deux programmes doit être:

""QUINE""

C'est le code-golf, le moins d'octets lorsque l'on additionne la longueur des deux codes source, et évidemment aussi la longueur de chaque sortie de programme, gagne!

CJam, 49 47 octets

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

et

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

les deux imprimés

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

Essayez-le en ligne: programme 1 , programme 2 , preuve de validité

Comment ils travaillent

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

Le programme 1 se termine ici et a une représentation sous forme de chaîne de tout son code source (que chaque caractère a répété deux fois) ainsi que la chaîne e # QUINE sur la pile.

Le programme 2 analyse également e#QUINE, ce qui est un commentaire.

Dans les deux cas, CJam imprime automatiquement les deux chaînes, ce qui entraîne la sortie susmentionnée.

Sérieusement, 46 56 42 octets

QUNX;RZtdXεj.ƒ£REIQ

Vidage hexadécimal:

51554e583b525a746458ee6a2e7f9f9c524549510a

Le deuxième programme est ce programme exact inversé. Il contient un caractère invisible, mais le nombre d'octets est correct. Les deux programmes produisent cette chaîne palindromique:

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

(Pour une raison quelconque, il affiche le caractère invisible lorsqu'il le produit dans mon terminal. Je ne comprends pas vraiment cet octet 7F.)

Comment ça fonctionne:

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

Le reste du programme n'est pas exécuté.

Puis l'autre sens:

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

À ce stade, nous exécutons maintenant le premier programme ci-dessus, donc l'exécution continue comme décrit ici.

J'exploite beaucoup le fait que plusieurs commandes ne font rien pour les chaînes ou les piles vides ici. J'exploite également le comportement inattendu tlorsqu'il n'y a qu'un seul élément sur la pile. Ne vous attendez pas à ce que ce programme fonctionne dans les futures versions de Ser sérieux.

Étant donné que la version en ligne de l'interpréteur Ser sérieux continue d'être interrompue, vous devrez télécharger l'interprète et l'exécuter sur votre propre machine pour le tester.

GolfScript, 46 octets

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

et

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

les deux imprimés

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

Essayez-le en ligne: programme 1 , programme 2 , preuve de validité

Comment ça fonctionne

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

Le code source du programme 2 analyse également QUINE\n, qui sont deux jetons non définis.

Perl, 61 + 60 = 121 octets

Programme 1:

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

Programme 2:

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

Je pensais que j'allais essayer ça dans une langue non golfique. Il s'agit essentiellement d'un constructeur de quine universel en Perl modifié pour doubler chaque caractère avant de l'imprimer et l'ajouter QUINEà la fin. Ensuite, il suffit de coller un commentaire à la fin du code pour compenser le texte ajouté.

(J'ai écrit ceci sans vraiment regarder les autres réponses. Il s'avère qu'il serait possible d'enregistrer un octet en mettant le commentaire entier dans un programme, mais je ne sais pas si je devrais simplement copier de manière flagrante des algorithmes comme ça.)