Produrre un programma A in modo tale che eseguirlo nella lingua A produca il programma B e che esegua il programma A nella lingua B produca il programma C.

Il programma B, quando eseguito nella lingua B, produce il programma A, e l'esecuzione del programma B nella lingua A produce il programma C.

Il programma C, quando eseguito nella lingua A o nella lingua B , stampa "Lingua errata!".

Program | Language | Result
--------|----------|----------
A       | A        | Program B
B       | B        | Program A
A       | B        | Program C
B       | A        | Program C
C       | A        | "Wrong language!" 
C       | B        | "Wrong language!" 

La tua risposta dovrebbe usare questo modello:

Lingua A / Lingua B, {a byte} + {b byte} = {byte totali} byte

Programma A:

a code

Programma B:

b code

Programma C:

c code 

Fonte:

# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Nessuno di questi programmi dovrebbe ricevere input.
• Versioni diverse della stessa lingua contano come lingue diverse. (anche se questo è scoraggiato perché porta a soluzioni noiose)
• Le lingue A e B devono essere distinte.
• Non devi leggere il tuo codice sorgente da un file. I programmi potrebbero non essere vuoti
• Si applicano scappatoie standard.

suggerimenti

• C ++ e [Python / Bash / altri #linguaggi commentati] sono buone combo perché puoi definire macro che una lingua può ignorare

Questo è code-golf , quindi vince la somma più piccola dei byte che contano i programmi A e B.

Befunge-98 (PyFunge) / > <> , 123 + 123 = 266 250 246 byte

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Provalo in Befunge-98! , Provalo in> <>!

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Provalo in> <>! , Provalo in Befunge-98!

"a0!#.pek,@f[>o<!egaugnal gnorW

Provalo in Befunge-98! Provalo in> <>!

Come funziona:

La seconda riga in entrambi i programmi è identica e ha la stessa funzione per entrambe le lingue. Quando inserito a sinistra dal<<<< , stampa l'intera seconda riga. Quando si entra a destra di quelli, stampare il programma C.

Quando la prima riga viene eseguita nella lingua sbagliata, entra nella sezione di produzione del programma C. Altrimenti, stampa la riga superiore all'indietro con la "parte anteriore ed entra nella sezione di produzione della seconda riga.

Prima linea

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00

><>:
" Wrapping string literal over the first line
 81!#.  Jumps the pointer to the Program C producer

Befunge-98:
" Wrapping string literal
 81!#.  Pushes 8,0 (! inverts number, # skips over .)
      #v Skip over the exit
        p00g Pops the excess 8,0 and space and gets the " from 0,0
            >:#,_ Classic print until stack is empty
       v         j+4< Skips back to the exit and goes to the second line

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18

><>:
" Wrapping string literal
 00g!# Gets the " from 0,0
      o!v5l1=. Print until the stack is empty and jump to the second line

Befunge-98:

" Wrapping string literal
 00g Gets the " from 0,0
    !#o!v Skip the instruction o and go to Program C producer

Seconda linea:

g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# $$00gff+k,@,k*9aa$$ #o#!a"

><>: Second line producer
g00<<<<< Get the " from cell 0,0
        ......      " Wrapping string literal over the stack
               #o#!a  Print newline and the stack and exit
Program C producer:
       >0!#[        Clear stack
            f8+1!#. Jump to cell 22,1
                   .....'...'   Push program C to the stack
                             00g Get " from cell 0,0
                                !#o# Print stack until empty

Befunge-98: Second line producer

g00<<<<< Get the " from cell 0,0
        ......              " Wrapping string literal
                       #o#!a  Skip over instruction o
                     $$       Pop the excess characters
                  90a Push a newline and 90
               @,k      Execute , instruction (print) 90+1 times, printing second line

Program C producer:
        >0!#[ Push 1 and skip [
             f8+1!#. Push 22, 0 and skip .
                    48*k'...' Execute ' instruction 32 times, pushing program C
                         ...'00g!#o# Push 0 and skip the instruction o
                                     \! Convert excess values to two 0s
                                       g Get " from cell 0,0
                                          ff+ Push 30
                                             k, Execute , 30+1 times, printing program C
                                               @ Exit program

Programma C

"a0!#.pek,@f[>o<!egaugnal gnorW

><>:
" Wrapping string literal
 a0!#. Jump to cell 10,0
           f[ Create a new stack with only the top 15 elements
             >o< Print stack

Befunge-98:
" Wrapping string literal
 a0!#. Push 10,1
      p Pop 10,1 and excess space
       ek,@ Push 14 and execute , 14+1 times and exit the program

JavaScript (ES6) / Python 3, 264 + 258 = 522 byte

Programma A:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;print(c);'''
console.log(b,...[a,b,c].map(uneval))//'''

Programma B:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;'''
print=_=>console.log(c)//'''
print(a%(a,b,c))

Programma C:

1//2;alert=print
alert('Wrong language!')

Probabilmente golfable ...

Spiegazione JavaScript

Programma A:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;print(c);'''

// Print the Python program (b), replacing the "%s"s with the raw forms of a, b, and c:
console.log(b,...[a,b,c].map(uneval))//'''

Programma B:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;'''

// Define a function `print` which prints `c` (the "Wrong language!" program):
print=_=>console.log(c)//'''

// Call `print`, ignoring the argument (which is NaN):
print(a%(a,b,c))

Programma C:

// Ignore this line:
1//2;alert=print

// Alert "Wrong language!":
alert('Wrong language!')

Spiegazione Python

Programma A:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Print `c` (the "Wrong language!" program):
1//2;print(c);

# Ignore this part:
'''
console.log(b,...[a,b,c].map(uneval))//'''

Programma B:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Ignore this part:
1//2;'''
print=_=>console.log(c)//'''

# Print the JS program (a), replacing the "%r"s with the raw forms of a, b, and c:
print(a%(a,b,c))

Programma C:

# Set `alert` to the function `print`:
1//2;alert=print

# Call this function on "Wrong language!":
alert('Wrong language!')

Python 3 + JavaScript (Rhino), 171 + 171 = 342 byte

Programma A (emette il programma B in Python 3, il programma C in JavaScript; nota la nuova riga finale):

s="'";d='"';r=['print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")','print("print("+d+"Wrong language!"+d+")")'];eval(r[([11]+[0])[1]])

Programma B (emette il programma A in JavaScript, il programma C in Python; nota la nuova riga finale):

s="'";d='"';r=['print("print("+d+"Wrong language!"+d+")")','print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")'];eval(r[([11]+[0])[1]])

Programma C (genera "Lingua errata!" In entrambe le lingue; ha anche una nuova riga finale, che non conta nel punteggio):

print("Wrong language!")

Nota che sto usando un dialetto insolito di JavaScript qui. Le persone normalmente usano le implementazioni del browser, ma quelle hanno problemi con l'output, facendolo in modo strano (usando alert). Sto usando il pacchetto Ubuntu rhinoche è un'implementazione JavaScript "offline" con un diverso set di librerie implementate in un browser tipico (è inteso come un linguaggio di script incorporabile); ciò è notevole in quanto fornisce printun'istruzione nello stesso stile di, ad esempio, Python 3.

Questo è un "vero poliglotta", nel senso che entrambe le lingue eseguono gli stessi calcoli, nello stesso ordine, dando loro lo stesso significato. Entrambi hanno lo stesso AST (ed è abbastanza banale creare un quine poliglotta JavaScript Python 3 + riducendo questo programma). Non esiste un codice specifico per una lingua, che mi aiuta a ridurre la lunghezza. Per inciso, devi usare Python 3 in modo da poter usare i punti e virgola per separare le istruzioni (se hai usato le nuove linee dovresti sfuggire alle nuove linee).

Il programma inizia definendo le stringhe se dche contengono rispettivamente una virgoletta singola e una virgoletta doppia. Questo rende possibile l'output delle virgolette senza doverle menzionare più avanti nel codice sorgente, evitando problemi con l'escaping (che spesso sembrano essere un problema con le quines; il motivo principale per cui rispondo a così tanti problemi con Quine è che le sue stringhe nidificano) .

Il cuore del programma è l'array rche contiene il corpo principale dei due programmi utilizzati dalla sfida; uno dei programmi (quello che viene prima nel programma A e il secondo nel programma B) è un quasi-quine che genera semplicemente il programma originale concatenando insieme pezzi (presi principalmente da rse stesso, con alcuni letterali di stringa), e il altro programma di stampa C. Al fine di rendere il programma non un vero quine (il che renderebbe impossibile rilevare che stavamo eseguendo nella lingua sbagliata), gli elementi di rsono stampati in ordine inverso; r[0]nel programma A è r[1]nel programma B e viceversa.

Infine, tutto ciò che è necessario è evalutilizzare l'elemento corretto di r. Questo si ottiene usando l'espressione ([11]+[0])[1]che produce un valore diverso in Python 3 e in JavaScript. Entrambe le lingue lo analizzano in modo identico, ma hanno idee diverse su ciò che l'aggiunta fa agli elenchi:

• Quando Python 3 si aggiunge [11]a [0], ottiene [11, 0](concatenando gli elenchi), e quindi prendendo il secondo elemento dell'elenco ( [1]) ci dà l'intero 0.

• Quando JavaScript aggiunge [11]a [0], si ottiene "110"(concatenando le rappresentazioni di stringa di liste), e poi con il secondo carattere della stringa ( [1]) ci dà la stringa "1", che JavaScript è molto felice di usare come un indice in una lista.

Pertanto, Python 3 esegue il primo elemento di rentrambi i programmi (producendo il quasi-quine quando si esegue il programma A e stampa il programma C quando si esegue il programma B); JavaScript esegue il secondo elemento, quindi tratta il programma A e il programma B in modo opposto.

Per inciso, se si esegue il programma A in Ruby, verrà stampato il programma B tranne senza una nuova riga finale. Se si esegue il programma B in Ruby, verrà stampato il programma C tranne che senza una nuova riga finale. In altre parole, questa soluzione funziona quasi completamente con un diverso set di lingue, scambiando Python 3 con Ruby (l'unica ragione per cui non elimino la nuova riga dal programma B per ottenere un punteggio di 341 è che l'incoerenza della nuova riga nel programma C squalificherà la presentazione).

(Stavo lavorando su un "vero poliglotta" come questo per un motivo diverso, che ora ho pubblicato come una sfida, e ho capito che le tecniche potevano essere adattate anche a questo.)

C / Python, 733 byte + 733 byte = 1466 byte

Programma A:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}
print(c%(13,34,34))

Programma B:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(c,13,34,34);};
print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))

Programma C:

#define print(a) main(){puts(a);}
print("Wrong language!")

Ho usato il tuo suggerimento di usare C / C ++ con Python. Suppongo che non sia molto conciso, ma comunque idoneo.

Python 2 / Retina, 550 + 645 = 1373 1254 1221 1195 byte

Non sono sicuro che le parti unichre replacepossano essere giocate di più. Ho provato ad usare Python 3, ma molto si perde aggiungendo parentesi e gestendole. Ho provato a impostarlo R=unicode.replacee usarlo, ma l'output viene incasinato.

Si noti che Retina ha una nuova riga finale nel suo output di default, e questo non è incluso nei programmi. Se qualcuno dice che devo rimuoverlo, ciò può essere fatto in modo banale. Inoltre, il codice Python funziona su repl.it, ma non è garantito che funzioni su Ideone.com.

Si noti inoltre che le nuove righe iniziali e finali sono significative nel codice seguente.

Programma A (Python 2): 638 587 566 550 byte (UTF-8)

Python 2 , Retina

U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶\n#1 #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Programma B (Retina): 735 667 655 645 byte (ISO 8859-1)

Retina , Python 2

#U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|·#¸print"Wrong language!"¸#?.*t|"¸·#{2}|^.·\n#1   #\n\n#T ³-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

Programma C:

Python 2 , Retina

Questo in realtà può essere abbreviato usando #!`W.*!invece le ultime due righe, ma questo rende A e B più lunghi, perché avere `una linea in cui non ce n'era uno significa che devo gestirla diversamente (perché il primo backtick in una linea in Retina è un delimitatore di configurazione).

print"Wrong language!"
#?.*t|"

Spiegazione:

Programma C:

                        # Retina: replace nothing with the Python code string
print"Wrong language!"  # >> code is executed if run in Python
#?.*t|"                 # Comment w/ '?' for Retina to skip, then replace up to the 't',
                        #    as well as any quotation marks, with nothing

Ho scritto il Programma C per la prima volta durante il mio primo tentativo e l'ho tenuto praticamente lo stesso. In Python, stampa la stringa e ignora il commento. In Retina, non sostituisce nulla con print"Wrong language!"e quindi rimuove le parti intorno Wrong language!.

Per comprendere meglio i programmi complessi, diamo un'occhiata alle versioni semplificate:

Programma A (semplificato):

print"\n#PYTHON\n#1`#\n\n#T`²-¹`_o`[^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n"#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Quando ho ricominciato da zero, ho usato il PYTHON bit come segnaposto per il codice che dovrebbe stampare il Programma A. Questa versione più semplice ha reso più facile spiegare come sarebbero stati stampati sia il Programma B che il Programma C.

Il printtutto dentro è ciò che stampa il Programma B, ma prima vediamo come viene stampato il Programma C, perché è semplice. Dopo il print"..."è #|. Questo trucco ha salvato CARICHI di difficoltà che ho riscontrato nel mio primo tentativo. Ciò consente a Retina di non sostituire nulla con la 2a linea, che sarà il Programma C, tranne che c'è un #davanti. Le ultime 2 righe lo rimuovono per prime #. Ero solito #{2}impedire al palco di rimuovere tutte le occorrenze di #. Non posso usare#1`# come ho usato nel Programma B, perché causa problemi ad avere quel backtick nella prima riga del Programma A.

Il che mi porta alla mia prossima attività, stampando il Programma B. Potresti aver notato un'altra differenza rispetto al codice reale. Non ci sono backtick nel codice reale, poiché li ho sostituiti con le schede. Ho dovuto sostituire un carattere, perché qualsiasi backtick renderebbe il codice precedente una stringa di configurazione in Retina, causando l'invalidità della sintassi. Ho scelto le schede perché sono visibili e il punto di codice è una singola cifra ( 9). Il codice stampa il Programma B come mostrato nella versione semplificata di seguito.

Programma B:

#PYTHON
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

Le prime due righe non sostituiranno nulla con il codice Python, ma con un #davanti e alcuni caratteri leggermente diversi. Questa parte è stata omessa per chiarezza. La fase successiva lo rimuove per prima #. Quindi, utilizzo una fase di traslitterazione (T)#T`²-¹`_o`[^¹] per annullare alcune delle replaceoperazioni osservate nel programma completo A. L'utilizzo di questa fase è un modo per produrre una vera e propria lesione ¶in Retina, che altrimenti potrebbe essere impossibile.¹ Sostituisce ·con ¶e ³con ². Le occorrenze ¹rimarranno invariate perché ignorate [^¹].

Programma A:

Newline e tab sono stati aggiunti per la leggibilità.

U=unichr;s=U(39)*3;

_=u'''
    \n#U=unichr;s=U(39)*3;

    _=u%s.replace(U(9),U(96));

    print _%%(s+_+s)
    .replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
    .replace(U(183),U(184)).replace(U(182),U(183))#|

    ¶#·print"Wrong language!"·#?.*t|"·
    ¶#{2}|^.
    ¶

    \n#1    #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''

.replace(U(9),U(96));

print _%(s+_+s)
.replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
.replace(U(183),U(184)).replace(U(182),U(183))#|

#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Ciò segue la struttura generale del seguente quine Python:

_='_=%r;print _%%_';print _%_

Quando aggiungi cose prima o dopo, devi anche inserirle nella stringa.

U=unichr;_='U=unichr;_=%r;print(_%%_).replace('','')';print(_%_).replace('','')

Volevo usare una stringa a tre virgolette per semplificare l'inclusione delle virgolette (evitando l'uso di barre rovesciate). s=U(39)*3;è la stringa''' . Ho anche usato %sinvece di %r, al fine di evitare alcuni problemi con newline o altri personaggi sfuggiti a barre rovesciate.

U=unichr;s=U(39)*3;_='''U=unichr;s=U(39)*3;_=%s;print(s+_%%_+s).replace('','')''';print(s+_%_+s).replace('','')

Quindi adesso i rimpiazzi. La prima sostituzione .replace(U(9),U(96));è lì per sostituire le schede con i backtick che vediamo nel Programma B. Questa sostituzione è fatta prima della formattazione delle stringhe, perché le schede devono rimanere tab nel Programma A. Le altre sostituzioni sono semplicemente per evitare di usare determinati caratteri nel 2 ° linea del programma B:

.replace(U(10),U(92)+'n')   # Replace newlines with a backslash and 'n', for B to print A.
.replace(U(96),U(9))        # Replace backticks with tabs for the first part of B.
.replace(U(178),U(179))     # Replace '²' with '³', which will be undone with B's T stage
.replace(U(183),U(184))     # Replace '·' with '¸', which will be undone with B's T stage
.replace(U(182),U(183))     # Replace '¶' with '·', which will be undone with B's T stage

Queste ultime tre sostituzioni anticipano la fase di traslitterazione nel Programma B, al fine di impedire che quei personaggi vengano rimossi o traslitterati quando non dovrebbero esserlo.

L'unica altra parte del codice è il codice del Programma B che viene essenzialmente copiato carattere per carattere, ad eccezione delle modifiche dovute alle sostituzioni.

¹ Grazie a Martin per il suo suggerimento su come produrre un letterale ¶in Retina. Ha reso tutto molto più semplice.

Befunge / Python, 381 + 485 259 + 345 229 + 304 = 533 byte

Programma A: prova in Befunge | Prova in Python

#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''

Programma B: prova in Python | Prova in Befunge

#>55+"]:5+5+["50g"!egaugnal gnorW"50g"'<:#>!#,_@<'tnirp">:#,_@
print """#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''"""

Programma C: prova in Befunge | Prova in Python

print'<@_,#!>#:<'"Wrong language!"[+5+5:]

Spiegazione

Programma C: Questo si basa sul fatto che Befunge-93 ignora le istruzioni non supportate, quindi mentre l' pinnocuo scrivere uno zero a 0; 0, il resto printviene ignorato fino <all'istruzione che inverte la direzione. Quindi, scorrendo da destra a sinistra, +5+5inserisce un 10 (avanzamento riga) nello stack seguito dalla stringa di messaggio, quindi viene eseguita una sequenza di output standard per scrivere la stringa. In Python sta solo stampando due letterali di stringhe concatenati insieme, ma il primo (contenente il codice Befunge) è separato dal riferimento dell'array alla fine ([+5+5:] ).

Programma B: La prima riga è una sequenza Befunge abbastanza semplice per stampare il Programma C. L'unica cosa interessante è il modo in cui genera caratteri di citazione usando 50g(cioè leggendo il carattere dalla memoria) che è più efficiente del calcolo del codice ASCII. Il #>(un ponte sopra l'istruzione direction) è essenzialmente un nop che impedisce al codice di essere visto da Python poiché #è il carattere di commento di Python. L'interpretazione di Python inizia alla seconda riga e sta semplicemente stampando una stringa multilinea contenente il codice sorgente del Programma A.

Programma A: In Python le prime tre righe vengono nuovamente ignorate perché iniziano con# , mentre l'ultima riga stampa semplicemente il Programma C. Il codice Befunge scorre avanti e indietro attraverso le prime tre righe, costruendo la sorgente per il Programma B nello stack in ordine inverso. Inizia con tre virgolette, quindi una sequenza che crea una copia del sorgente del Programma A, e infine quella che è essenzialmente una stringa codificata con l'apertura print """e la prima riga del codice Befunge. È solo questione di scriverlo con una sequenza di output standard.

Alcuni punti controversi:

1. Mi è stato detto che un quine usando il gcomando non è considerato un quine corretto per quanto riguarda questa comunità. Non sono sicuro che questa regola si applicherebbe anche a questa sfida, ma in tal caso, questa risposta potrebbe non essere considerata una soluzione adeguata.

2. Mentre ho detto che Befunge-93 ignora le istruzioni non supportate, ciò non è tecnicamente definito nelle specifiche e sarà necessario utilizzare l' -qopzione (silenziosa) della riga di comando nell'interprete di riferimento per evitare avvisi nel Programma C. La maggior parte degli altri interpreti va bene, però, ma alcuni di quelli sfacciati potrebbero potenzialmente andare in crash. Si noti inoltre che Befunge-98 riflette su istruzioni non supportate, quindi un interprete 98 eseguirà un ciclo indefinitamente.

Perl / JavaScript, 176 byte + 176 byte = 352 byte

Non pensare di poter condividere 52 byte dal meccanismo sottostante per la generosità, ma mi è piaciuto costruirlo. Penso che ciò che ho prodotto soddisfi i criteri ...

Programma A:

$P=1;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Programma B:

$P=2;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Programma C:

$P=0;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Spiegazione

Utilizza la mia polyquine Perl / JavaScript come base ma imposta un'ulteriore variabile $Pche controlla quale programma generare. Utilizza il controllo che +[]è vero in Perl, ma falsa in JavaScript.