La tâche

Dans ce défi, votre tâche consiste à écrire trois programmes qui forment une sorte de système de type quine mutuel. Appelons les programmes A, Bet C. Si l'un des programmes reçoit la source d'un autre programme en entrée, il doit sortir la source du troisième programme. Par exemple, si Aest donné Ben entrée, il sort C. Si les programmes sont donnés leur propre source en entrée, ils doivent sortir les trois chaînes "three", "mutual"et "quines"(sans les guillemets). Dans tous les cas, ils peuvent générer une nouvelle ligne de fin supplémentaire. Pour toute autre entrée, les programmes peuvent faire n'importe quoi, y compris planter.

Exemple

Par exemple, supposons que les codes source de A, Bet Csont aSdf, ghJket zxcV. Ensuite, les programmes doivent se comporter comme suit.

Source Input  Output
--------------------
aSdf   aSdf   three
aSdf   ghJk   zxcV
aSdf   zxcV   ghJk
ghJk   aSdf   zxcV
ghJk   ghJk   mutual
ghJk   zxcV   aSdf
zxcV   aSdf   ghJk
zxcV   ghJk   aSdf
zxcV   zxcV   quines

Règles et notation

Les solutions A, Bet Cpeuvent être soit des fonctions soit des programmes complets, mais elles doivent être totalement indépendantes: aucun code partagé n'est autorisé. Les failles standard et les règles de quine s'appliquent, de sorte que les programmes ne peuvent en aucun cas accéder à leurs propres codes source.

Votre score est le nombre d'octets combinés de A, Bet Cun score inférieur étant meilleur.

CJAM, 165 147 114 108 99 octets

2 _ri^_q+@"quinesmutualthree"6/=?

1 _ri^_q+@"quinesmutualthree"6/=?

3 _ri^_q+@"quinesmutualthree"6/=?

Merci à @ MartinBüttner pour une suggestion qui a permis d'économiser 48 octets!

Essayez-le en ligne dans l' interpréteur CJam .

Vérification

$ cat A
2 _ri^_q+@"quinesmutualthree"6/=?
$ cat B
1 _ri^_q+@"quinesmutualthree"6/=?
$ cat C
3 _ri^_q+@"quinesmutualthree"6/=?
$ 

$ cjam A < A
three
$ cjam A < B
3 _ri^_q+@"quinesmutualthree"6/=?
$ cjam A < C
1 _ri^_q+@"quinesmutualthree"6/=?
$ 

$ cjam B < A
3 _ri^_q+@"quinesmutualthree"6/=?
$ cjam B < B
mutual
$ cjam B < C
2 _ri^_q+@"quinesmutualthree"6/=?
$ 

$ cjam C < A
1 _ri^_q+@"quinesmutualthree"6/=?
$ cjam C < B
2 _ri^_q+@"quinesmutualthree"6/=?
$ cjam C < C
quines

Idée

L'ensemble {0, 1, 2, 3} est un groupe sous l'opération ^ (OU binaire exclusif), où chaque élément est son propre inverse.

Si les trois programmes sont identiques à l'exception du premier caractère (un élément de {0, 1, 2, 3} ), nous pouvons les distinguer et les imprimer facilement:

• Nous commençons par XORing le chiffre au début du code source et de l'entrée.

• Si le résultat est à 0 , la source et l'entrée correspondent.

  Ainsi, nous imprimons l'un des trois mots, sélectionnés par ce chiffre commun.

• Si le résultat n'est pas 0 , c'est l'élément de {1, 2, 3} qui n'est ni dans la source ni dans l'entrée.

  Ainsi, nous l'imprimons, suivi du reste de l'entrée.

Comment ça marche

2                                  e# Push the number N on the stack.
  _                                e# Push a copy.
    r                              e# Read a token from STDIN, i.e., the input up
                                   e# to and excluding the next whitespace char.
     i                             e# Cast to integer.
      ^                            e# XOR it with the copy of N. Result: X
       _                           e# Push a copy of the result.
        q+                         e# Append the rest of the input.
          @                        e# Rotate N on top of the stack.
           "quinesmutualthree"6/   e# Push ["quines" "mutual" "three"].
                                =  e# Select the word at index N.
                                 ? e# If X is non-zero, select the modified input;
                                   e# otherwise, select the word.