Tipicamente, i poliglotti sono costruiti in modo tale che ogni lingua possa ignorare parti del codice presenti per altre lingue, avvolgendole in stringhe letterali, usando la sintassi dei commenti o altri trucchi simili.

Il tuo obiettivo è scrivere un poliglotta in cui l'output per ogni lingua è il codice del poliglotta che produce quell'output. In particolare, l'output deve essere costruito dal codice poliglotta con solo eliminazioni e deve essere un quine nella lingua data.

Regole

• Sono consentiti solo i quines appropriati (nessuna lettura del codice sorgente, nessun input di input, output deve essere su STDOUT o alternativa più vicina se STDOUT non è un'opzione e i programmi devono consistere in più di semplici letterali che sono stampati in modo implicito).
• Poiché lingue diverse possono utilizzare codifiche diverse, i byte grezzi sono ciò che conta qui. Ad esempio, se la lingua A utilizza UTF-8 e la lingua B utilizza CP437, il codice (esadecimale) C3 88 46 47sarebbe ÈFGper la lingua A e ÈFGper la lingua B.
• Tutti gli output devono essere distinti (di nuovo, confrontando i byte grezzi). Questo evita complicazioni nel tentativo di limitare le versioni in lingue minori: se due lingue usano la stessa parte del codice per fare la stessa cosa, non puoi rivendicarle entrambe.
  • Se hai due lingue A e B in modo tale che XYsia un risultato valido in entrambi, ma YZanche valido in B, puoi scegliere XYcome output per A e YZcome output per B, quindi puoi rivendicare entrambi nel tuo punteggio ( ma non puoi richiedere XYentrambe le lingue a causa della regola sopra).
• Tutte le uscite devono essere il più corte possibile. Ad esempio, se il tuo codice fosse print('foo')#something, per Python 3 (ignorando il fatto che l'output non è corretto), il codice che avresti bisogno di produrre sarebbe print('foo'), e print('foo')#non sarebbe permesso. Se ci sono più stringhe di uguale (minima) lunghezza che producono un output corretto, puoi sceglierne una qualsiasi.
• I contributi devono essere poliglotti in almeno 2 lingue.
• Il tuo punteggio sarà dato da (number of programming languages with distinct outputs)**3/(total byte size of polyglot). Vince il punteggio più alto. Nel caso in cui due invii raggiungano lo stesso punteggio, vincerà quello che ha raggiunto per primo quel punteggio.

GolfScript + CJam + Fission 2 + Jelly , 4 lingue, 24 byte, punteggio 2.667

Cominciamo con il dump esadecimale:

00000000:  3322 3024 700a 2721 2b4f 5222 0a3c 3024 700a 6523 7fff cccc

Per GolfScript, CJam e Fission 2, interpretiamo questo in alcune codifiche a byte singolo compatibili ASCII come ISO 8859-1 (la codifica esatta non ha molta importanza, perché i linguaggi definiscono comunque solo operatori per i caratteri ASCII):

3"0$p
'!+OR"
<0$p
e#<DEL>ÿÌÌ

Dov'è <DEL>il personaggio di controllo 0x7f.

In Jelly, si presume che questo si trovi nella codepage di Jelly, dove invece appare così:

3"0$p½'!+OR"½<0$p½e#¶”ṘṘ

GolfScript

L' eultima riga è una variabile sconosciuta e #commenta il resto della riga, quindi questo viene stampato

"0$p"
0$p

con un avanzamento riga finale. Questa è la versione poliglotta GolfScript / CJam della quine standard:

".p"
.p

Prova il poliglotta. | Prova il quine.

CJam

Qui, e#commenta l'ultima riga, in modo quasi identico, questo stampa

"0$p"
0$p

senza avanzamento riga finale.

Prova il poliglotta | Prova il quine.

scissione

Fissione vede solo la seconda riga che è la quinta Fissione standard, quindi stampa

'!+OR"

Non posso fornire un collegamento online per il poliglotta qui, perché TIO invia il file a Fission come UTF-8, ma Fission legge il byte di origine byte per byte, il che rende l'ultima riga troppo lunga. Tuttavia, l'ho provato localmente con un file con codifica ISO 8859-1 (in cui l'ultima riga ha la stessa lunghezza della seconda), per confermare che funziona.

Prova il quine.

Gelatina

Il pilcrow è un alias per gli avanzamenti di riga in Jelly, quindi la fonte è equivalente a:

3"0$p½'!+OR"½<0$p½e#
”ṘṘ

Tutti tranne l'ultima riga di un programma Jelly sono "collegamenti helper" (ovvero funzioni) che possono essere ignorati a meno che non vengano chiamati, a condizione che siano sintatticamente validi. Questo è in realtà il motivo per cui 3viene prima nei programmi CJam e GolfScript, perché altrimenti "non può essere analizzato in Jelly.

Altrimenti, poiché la funzione non viene chiamata, il programma equivale solo alla sua seconda riga, che è lo standard Jelly Quine.

Prova il poliglotta. | Prova il quine.

> <> + Python, 2 lingue, 51 46 byte, punteggio ~ = 0,16 0,17

Dal momento che non ci sono ancora risposte, inizierò con una semplice

#.09;!?lo}*2+2f"
_='_=%r;print _%%_';print _%_

Provalo per > <> e Python

Per> <> la prima riga è un quine (# riflette, "mette l'intera riga in pila, quindi spingiamo 34 (charcode per") e stampiamo tutto), l'esecuzione non si sposta mai da essa, quindi ignora efficacemente il resto di il codice.

Per Python la prima riga è un commento, mentre la seconda è un quine (approccio standard in Python, usando la sostituzione di stringa con la stessa stringa di entrambi gli argomenti).

JavaScript + Python 2 + Japt, 3 lingue, 132 byte, punteggio ~ = 0,205

A="`i96d)p2`i96d)p2";1//2;A=1
S="S=%s;console.log(S,uneval(S))";A//2;S="S=%r;print S%%S";"""
console.log(S,uneval(S))//""";print S%S

Questo stampa

S="S=%s;console.log(S,uneval(S))";console.log(S,uneval(S))

in JavaScript (solo in Firefox),

S='S=%r;print S%%S';print S%S

in Python 2 e

`i96d)p2`i96d)p2

in Japt. ( Provalo online! )

JavaScript

Questo è ciò che vede JavaScript:

A="`i96d)p2`i96d)p2";1
S="S=%s;console.log(S,uneval(S))";A
console.log(S,uneval(S))

La prima riga è no-op perché Anon viene utilizzata in alcun modo. La seconda riga si imposta Ssulla stringa S=%s;console.log(S,uneval(S))e la terza la stampa dopo aver sostituito la %scon la unevalrappresentazione ed di S(justS racchiusa tra virgolette). Il risultato è un quine in JavaScript.

Pitone

Questo è fondamentalmente ciò che vede Python:

A="`i96d)p2`i96d)p2";1//2;A=1
S="S=%s;console.log(S,uneval(S))";A//2;S="S=%r;print S%%S"
print S%S

La prima riga è praticamente no-op; l'unica parte importante è A=1la fine. Questo si trasforma Ain un numero in modo che la divisione intera A//2sulla seconda riga non generi un errore.

La seconda riga è per lo più allo stesso modo, tranne che Sper la stringa S=%r;print S%%S. La terza riga viene stampata Sdopo aver sostituito la %rcon la rappresentazione grezza di S(appena Sracchiusa tra virgolette singole). Il risultato è un quine in Python 2.

Japt

Questo è il codice JavaScript che vede l'interprete Japt:

A="`i96d)p2`i96d)p2";1//2;A=1
S="S=%s;console.log(S,uneval(S))";A//2;S="S=%r;print S%%S";"","\nconsole.log(S,uneval(S))//","";.p("r".i("n".t(),S%S))

Come puoi vedere, è quasi uguale alla risposta JavaScript, con un'eccezione principale: le ultime due righe sono combinate. Di conseguenza, questo è ciò che l'interprete vede effettivamente:

A="`i96d)p2`i96d)p2";1
S="S=%s;console.log(S,uneval(S))";A

La prima riga è impostata Asul quinto Japt e la seconda Ssu parte del quinto JS. In Japt, tuttavia, solo l'ultima espressione viene inviata all'output; questo è A, quindi l'output è `i96d)p2`i96d)p2.

Jolf +> <>, punteggio = 2 ** 3/15 = 0,533 ....

"r0:g>o<
"Q«Q«

Lavorando per aggiungere un'altra lingua a questo.

> <>, Python 2 e 3, 3 lingue, 107 byte, punteggio = 27/107 ~ = 0,252

#o<}-1:"
a=1/1is 1;b="(_%(_,b))"[a:-a|9];_='a=1/1is 1;b="(_%%(_,b))"[a:-a|9];_=%r;print %s';print (_%(_,b))

Provalo online: Python 2 , Python 3 , > <>

L'output di Python 3 è esattamente la seconda riga e l'output di Python 2 è questo quine . L'output> <> è la prima riga.

Spiegazione

Questo programma si basa sul classico quine di Python 2:

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

Innanzitutto, per renderlo compatibile con Python 2 e Python 3, ho cambiato l' printistruzione in una chiamata di funzione e ho aggiunto uno spazio aggiuntivo che sarà utile in seguito:

_='_=%r;print (_%%_)';print (_%_)

Successivamente, ho bisogno di un modo per distinguere Python 2 da Python 3. Uno dei modi più semplici è quello di sfruttare il fatto che /è integer divisione in Python 2, ma divisione galleggiante in Python 3. Così, le seguenti Esamina codice ad Truein Python 2, ma Falsein Python 3:

1/1is 1

Per rendere distinti gli output tra le due lingue, avevo bisogno di rimuovere selettivamente la prima e l'ultima parentesi nella printchiamata (ecco perché avevo bisogno di spazio in precedenza - senza spazio, non sarebbe una printdichiarazione valida in Python 2) . Quindi, avevo bisogno di modificare l'imbracatura di Quine in questo modo:

a=1/1is 1;b="(_%(_,b))"[a:-a|9];_='a=1/1is 1;b="(_%%(_,b))"[a:-a|9];_=%r;print %s';print (_%(_,b))

Quell'espressione viene a:-a|9valutata 0:9in Python 2 e 1:-1in Python 3. Pertanto, bè "(_%(_,b))"in Python 3, ma in Python 2 il primo e l'ultimo carattere vengono scartati, lasciando _%(_,b). E con quella modifica, il poliglotta era valido per questa sfida.

Come suggerito dal pellicano Teal, il> <> quine #o<}-1:"potrebbe essere aggiunto abbastanza facilmente, grazie al fatto che #inizia un commento a riga singola in Python. Semplicemente anteponendolo e una nuova riga aggiunge un'altra lingua e aumenta il punteggio di quasi dieci volte.

Python 2 + Retina, 2 lingue, 55 byte, punteggio = 2 ^ 3/55 ≈ 0.145

Ho usato $ninvece di ¶mantenerli entrambi ASCII validi.

S='S=%r;print S%%S';print S%S#|
#$n\(*S1`$n\(*S1`
#\`#

Python , Retina

Pitone:

S='S=%r;print S%%S';print S%S

Retina:

\(*S1`
\(*S1`

> <> + Pyke + Python 2, 81 byte, punteggio = 3 ** 3/81 ~ 0.333

"""r00gol?!;60.
a=%r;print a%%a"""#);"34.Cp\D\Es"DEp00/
a=__doc__[-15:]
print a%a

Ho provato a fare qualcosa di diverso con tutte le lingue.

> <> vede:

"""r00gol?!;60.

Questa è una leggera modifica dello standard> <> quine per utilizzare una stringa tra virgolette all'inizio. Ciò consente alle triple virgolette finali di Python di trovarsi su una riga diversa.

Provalo online!

Pyke vede:

"34.Cp\D\Es"DEp00/

Non avevo mai creato un quine in Pyke prima e quindi ho dovuto pensarne uno. Ho usato le tecniche tradizionali di quining per creare una stringa e quindi valutarla con se stessa come input. Nota per farlo funzionare senza impatto visivo, gli avvisi dovranno essere disabilitati. Errori fuori con una divisione per 0 errore nel passaggio di generazione.

Provalo qui! O solo la parte quine.

Python vede:

Tutto. Python usa tutto il codice per produrre il suo quine. Ho deciso di incorporare la parte quine nel docstring (anche se alla fine salverebbe i byte da rimuovere ma penso che sia bello). È una modifica della tecnica di quining standard.

Provalo online!