Supponiamo di avere 2 lingue Ae B. Una stringa sè una semiquina in Ae Bse soddisfa le seguenti condizioni:

1. sè un quine in lingua A.
2. sè un poliglotta in Ae B.
3. L'output di esecuzione scome Bprogramma è una stringa diversa s', che è un quine in B.

L'obiettivo di questa sfida è scrivere una semiquina in due lingue distinte. Si tratta di code-golf , quindi vince il codice più breve, con la prima risposta utilizzata come tiebreaker.

Regole per Quines

Sono accettate solo vere quine. Cioè, è necessario stampare l'intero codice sorgente su STDOUT, senza :

• leggendo il codice sorgente, direttamente o indirettamente.
• basandosi su un ambiente REPL che semplicemente valuta e stampa ogni espressione che gli dai da mangiare.
• basandosi su funzionalità linguistiche che in alcuni casi stampano semplicemente l'origine.
• usando messaggi di errore o STDERR per scrivere tutto o parte del quine. (È possibile scrivere elementi su STDERR o produrre avvisi / errori non fatali purché STDOUT sia un quine valido e i messaggi di errore non ne facciano parte.)

Inoltre, il codice sorgente non deve essere costituito esclusivamente da valori letterali (siano essi valori letterali stringa, valori letterali numerici, ecc.) E / o NOP. Ad esempio, `12è un poliglotta in Jelly e Pyth, ma in Jelly è un NOP e un valore letterale numerico, quindi non è valido.

Qualsiasi output non sopprimibile (come avvisi sul copyright, messaggi di avvio / arresto o un feed di riga finale) può essere ignorato nell'output per motivi di validità del quine.

Regole per poliglotti

Le due lingue utilizzate devono essere nettamente diverse. In particolare:

• Non devono essere versioni diverse della stessa lingua (ad esempio Python 2 vs. Python 3).
• Non devono essere dialetti diversi della stessa lingua (ad es. Pascal vs. Delphi).
• Una lingua potrebbe non essere un sottoinsieme dell'altra (ad es. C vs. C ++ ¹ ).
• Una lingua potrebbe non essere una derivata banale dell'altra (ad esempio Matlab vs Octave ² , brainfuck vs boolfuck vs TinyBF vs ShadyAsFuck vs tutte le altre banali derivate brainfuck).

Regole varie

• Non è possibile accettare input da STDIN (o da qualsiasi altra fonte). Se la lingua scelta deve accettare input, l'input deve essere vuoto (stringa vuota, reindirizzato da /dev/null, ecc.) Oppure l'output del programma non deve dipendere dall'input.
• Per questa sfida, è necessario scrivere un programma completo. Non è necessario richiedere codice aggiuntivo per eseguire la soluzione (come assegnare e chiamare una funzione lambda definita nella soluzione).

^{1: Sì, so che C non è in realtà un sottoinsieme di C ++. È abbastanza vicino per essere considerato uno ai fini dei poliglotti, quindi lo conto per questa sfida.}

^{2: Come il punto 1 sopra, sebbene Octave non sia tecnicamente compatibile al 100% con Matlab, è stato progettato per essere compatibile ed è abbastanza vicino da consentire a un poliglotta Matlab / Octave di banalizzare la sfida.}

GolfScript + Fission , 19 18 byte

{".~
'!+OR"
2<}.~

L'avanzamento finale è necessario.

Questa è una vera quine in GolfScript. Provalo online!

In Fissione stampa

'!+OR"

che è una vera quina in Fissione . Provalo online!

Spiegazione

In GolfScript, qualsiasi forma

{...}.~

è un quine fintanto che ...lascia una stringa con ".~"nello stack. Il .duplica il blocco, in modo tale che ci sia una copia che viene stampato alla fine, e le ~esegue, in modo che possiamo usare il suo contenuto per stampare la .~stessa. In questo caso, il blocco spinge la stringa

".~
'!+OR"

e poi lo tronca ai primi due caratteri con 2<.

Il programma Fission funziona davvero esattamente come il quine stesso , poiché la prima e la terza riga sono completamente ignorate dal programma.

Ruby + (JavaScript o Python 3), 76 byte

Questa è un'altra sfida che può essere risolta usando la mia nuova lingua preferita, il sottoinsieme quasi comune di Ruby, JavaScript e Python 3; e dato che non abbiamo ancora risposte in lingue exoteriche, e a molte persone piace vedere soluzioni in lingue non golfistiche, ho pensato che avrei contribuito. Ancora meglio, la stessa risposta risolve la sfida in vari modi contemporaneamente.

Ecco s:

s="'";d='"';n='print("s="+d+s+d+";d="+s+d+s+";n="+s+n+s+";eval(n)")';eval(n)

Questa è una quinta in Ruby. Non è un quine in JavaScript o Python 3; se lo esegui in una di quelle lingue, il suo output s'ha una nuova riga finale, quindi è diverso:

s = "'", " '; n =' di stampa (" s = "+ d + s + d +"; d =' d = "+ s + d s + +"; n = "+ s + n + s +" ; eval (n) ") '; eval (n)

Tuttavia, s'è un quine poliglotta in JavaScript e Python 3! (Come al solito per me, sto usando l'implementazione di JavaScript di Rhino, sia per comodità (in quanto viene eseguito dalla riga di comando piuttosto che necessitare di un browser), sia perché ha una strana libreria standard in cui printscrive nell'output standard.) Entrambe le lingue producono s'come risultato dell'esecuzione di entrambi i programmi.

Come bonus, questo programma risolve anche il problema al contrario. Se decidi di eseguire s'in Ruby, stamperà di snuovo il programma originale . Come tale, s'è una risposta valida (ma leggermente più lunga, a 77 byte) alla domanda.

A questo punto, sto quasi iniziando a pensare "le differenze nel fatto che l'output finisca o meno con una nuova riga sufficiente per considerare due programmi diversi" dovrebbero essere considerate una scappatoia standard, dato che questo sembra essere un secondo insieme di lingue (oltre al noto GolfScript / CJam) in cui è possibile eseguire il trucco.

Vitsy (modalità provvisoria) e Y, 9 byte, non competitivi.

' Ugrd3*Z

In Vitsy, questo è un quine. In Y, questo stampa Ugrd3*Z'; quando viene eseguito, questo stampa Ugrd3*Z', che è un quine in Y. Y, tuttavia, postdatizza la domanda.

Cosa vede Vitsy:

 ' Ugrd3*Z
 '         Heyyyy a string! Let's do this!
  ........ Capturing a string! Oh, not done? Hm, let's go back to the start.
 '         There we go.
           (space) ...
   U       (no op)
    g      use count, disabled in safe mode
     r     reverse stack
      d3*  push a '
         Z print it all!

Cosa vede Y:

' Ugrd3*Z
'         Push a space.
  U       Wrap around and capture.
   g      Print that. (Nothing else is printed.)

CJam + GolfScript, 9 byte

"0$p"
0$p

Questa è una quinta in CJam. In GolfScript, si genera con una nuova riga finale, che è un quine in GolfScript.

Non sono sicuro che CJam debba essere considerato una derivata banale di GolfScript. Ma penso che siano abbastanza diversi e almeno non banali.