L'obiettivo

In questa sfida, il tuo compito è quello di scrivere tre programmi che formano una sorta di sistema simile a quello di un altro. Chiamiamo i programmi A, Be C. Se uno dei programmi riceve la fonte di un altro programma come input, deve generare la fonte del terzo programma. Ad esempio, se Aviene fornito Bcome input, viene emesso C. Se i programmi sono date propria sorgente come input, essi devono uscita i tre corde "three", "mutual"e "quines"(senza virgolette). In tutti i casi, possono generare una nuova riga finale aggiuntiva. Per qualsiasi altro input, i programmi possono fare qualsiasi cosa, incluso crash.

Esempio

Ad esempio, supponiamo che i codici sorgente di A, Be Csiano aSdf, ghJke zxcV. Quindi i programmi dovrebbero comportarsi come segue.

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

Regole e punteggio

Le soluzioni A, Be Cpossono essere sia funzioni o programmi completi, ma devono essere completamente indipendenti: non è consentito codice condiviso. Si applicano scappatoie standard e regole di quine , quindi i programmi non possono accedere ai propri codici sorgente in alcun modo.

Il tuo punteggio è il conteggio dei byte combinato di A, Be C, il punteggio più basso è migliore.

CJam, 165 147 114 108 99 byte

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

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

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

Grazie a @ MartinBüttner per un suggerimento che ha contribuito a salvare 48 byte!

Provalo online nell'interprete CJam .

Verifica

$ 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

Idea

L'insieme {0, 1, 2, 3} è un gruppo sotto l'operazione ^ (OR binario esclusivo), dove ogni elemento è il proprio inverso.

Se tutti e tre i programmi sono identici ad eccezione del primo carattere (un elemento di {0, 1, 2, 3} ), possiamo distinguerli e stamparli facilmente:

• Iniziamo XORing la cifra all'inizio del codice sorgente e dell'input.

• Se il risultato è in 0 , l'origine e l'input corrispondono.

  Quindi, stampiamo una delle tre parole, selezionate da questa cifra comune.

• Se il risultato non è 0 , è l'elemento di {1, 2, 3} che non è né nell'origine né nell'input.

  Quindi, lo stampiamo, seguito dal resto dell'input.

Come funziona

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.