A tarefa

Nesse desafio, sua tarefa é escrever três programas que formam um tipo de sistema mútuo. Vamos chamar os programas A, Be C. Se um dos programas receber a fonte de outro programa como entrada, ele fornecerá a fonte do terceiro programa. Por exemplo, se Aé dado Bcomo entrada, ele gera C. Se os programas são dadas sua própria fonte como entrada, devem saída as três cordas "three", "mutual"e "quines"(sem aspas). Em todos os casos, eles podem gerar uma nova linha final à direita. Para outras entradas, os programas podem fazer qualquer coisa, incluindo falha.

Exemplo

Por exemplo, suponha que os códigos fonte de A, Be Csão aSdf, ghJke zxcV. Em seguida, os programas devem se comportar da seguinte maneira.

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

Regras e pontuação

As soluções A, Be Cpodem ser tanto funções ou programas completos, mas eles devem ser completamente independentes: não código compartilhado é permitido. Aplicam- se brechas padrão e regras de quine , para que os programas não possam acessar seus próprios códigos-fonte de forma alguma.

Sua pontuação é a contagem combinada de bytes de A, Be C, quanto menor a pontuação, melhor.

CJam, 165 147 114 108 99 bytes

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

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

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

Obrigado a @ MartinBüttner por uma sugestão que ajudou a economizar 48 bytes!

Experimente online no intérprete CJam .

Verificação

$ 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éia

O conjunto {0, 1, 2, 3} é um grupo sob a operação ^ (binário exclusivo OR), em que cada elemento é seu próprio inverso.

Se todos os três programas forem idênticos, exceto o primeiro caractere (um elemento de {0, 1, 2, 3} ), podemos distinguir e imprimi-los facilmente:

• Começamos digitando o dígito no início do código fonte e da entrada.

• Se o resultado estiver em 0 , a fonte e a entrada correspondem.

  Assim, imprimimos uma das três palavras, selecionadas por esse dígito comum.

• Se o resultado não for 0 , é o elemento {1, 2, 3} que não está na fonte nem na entrada.

  Assim, nós a imprimimos, seguidos pelo restante da entrada.

Como funciona

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.