Quine di ordini

10

Scrivere un programma che, se eseguito in lingue diverse, genera una permutazione di byte diversa del codice in ciascuna lingua. Il codice sorgente esatto viene conteggiato come una permutazione.

Qui "lingua diversa" può essere una versione diversa (Py 2 e Py 3) o flag standard diversi. È un output diverso che impone una versione diversa.

Per il programma si applicano regole quine appropriate in ciascuna lingua. Il tuo punteggio viene calcolato come (Language count)^6/(Code length in bytes), con un punteggio più alto è migliore.

Campione:

Se il codice è AABin servizio in tre diverse lingue rendimenti ABA, AABe AAB, quindi il suo punteggio è 2^6/3(solo uno dei due AABconteggio). Va bene se non ha ABAsenso.

code-challenge  quine  polyglot 
— l4m2
fonte
1
Cosa conta come una lingua diversa?
— Laikoni,
4
Quale definizione di quine corretta si applica? ( Martin , o ais523 , o forse qualche altra definizione in questi meta thread?) Le regole di quine appropriate si applicano solo alle interpretazioni del programma che sono effettivamente quines? (Per quello che vale, non credo che questa sfida sia migliorata molto applicando le regole del quine.)
— Lynn,
Per chiarire, lavorando sul tuo esempio - se il mio codice viene AABstampato AABin lingua-1 e ABAin lingua-2, presumo che debba essere un quine appropriato se visto come un programma lingua-1, e non ci sono ulteriori restrizioni che implicano la sua interpretazione come un programma lingua-2. È giusto?
— Lynn,
1
La lunghezza del codice è contata in caratteri o byte? Cosa dovremmo fare con codifiche di caratteri diverse?
— dylnan,
1
Che dire di byte contro caratteri?
— dylnan,

Risposte:

10

Befunge-98 , > <> , Gol> <> , fissione , Wumpus , Cardinale , cera d'api e Alice Punteggio: 8 6 /88 = 2978,909

"65*4+059*$!#.39*0jp2+'Wk,@ ''5&.'\d&o@o&88#+\@ol?!,'.'0.6'!+Ox,++tttt=++%-$#}.6~.F4*`*R

Provalo in Befunge! Provalo in> <>! Provalo in Gol> <>! Provalo in Fission! Provalo in Wumpus! Provalo in Cardinale! Provalo in cera d'api! Provalo in Alice!

Verifica!

Molti linguaggi 2D, tutti abusando di stringhe letterali avvolgenti. Le differenze nelle uscite sono quindi:

> <>, Gol> <> e Befunge-98 stampano tutti il ​​codice all'indietro (tranne per "), con gli ultimi tre caratteri in posizioni diverse R*", O"*e "R*rispettivamente. Anche la cera d'api ha il codice al contrario, ma gli ultimi tre caratteri sono intervallati nella prima sezione dell'output. Alice è per lo più a ritroso, ad eccezione di tutti i caratteri del escape ( ', \e ") si è trasferito al fronte, invece.

Wumpus è l'unica vera quina, Fission inserisce la "fine del codice anziché l'inizio, e Cardinale mette "tra il 0e il 5vicino all'inizio.

Prova di diverse permutazioni

spiegazioni:

Befunge-98:

"  Wrapping string literal pushes all other characters + a space to the stack
 65*4+  Push " to the stack
      059*$!#.39*0j   Push 1,27 to the stack
                   p  Pops the top three values of the stack (27,1,34)
                    2+  Adds 2 to the space to make "
                      'Wk,@  Prints the top 88 characters of the stack and terminates

> <> e Gol> <>:

Ad essere sincero, non ho fatto molto qui. L'unica differenza tra l'esecuzione di queste due lingue è il @comando, che ruota i primi tre valori dello stack in modi diversi per ciascuna lingua.

"  Wrapping string literal pushes all other characters to the stack
 65*4+  Push 34 (") to the stack
      059*$!#.  Jump to cell 45,0
                                   \@  Rotate the top three values of the stack 
                                     ol?!,'.'0.  Output the whole stack, ending in a divide by 0/stack underflow error

fissione:

 "............R  Spawn a pointer going right

 "  Switch to printing mode and print every other character
 "  Switch off printing mode
  6  Teleport to other 6
 "........6'!+O   Print the "

Wumpus:

"  Bouncing string literal
 65*4+  Push a (")
      059*$!#.   Push 0 and jump to cell 0,45
                                        \  Reflect off mirror
                                       +   Add 0 to top of stack
                                 @o&88#    Print the top 88 characters of the stack

Cardinale:

                                 %   Spawn two pointer going left/right (up/down despawn immediately)
                                  -$  Right pointer jumps to cell -1,0
                      x,++tttt=++     Left pointer prints "
"  While right pointer switches to print mode and prints the code

Cera d'api:

 "................*`*   Spawn pointers going in every direction
                        Every other * also spawns pointers, but they do nothing
                   `    Turn on print mode for two of the pointers going in different directions
                        This prints everything but the `
          #}.6~.F4*     Print a `

Alice:

"  Wrapping string literal pushes all other characters to the stack
   Except 's and mirrors
 65*4+  Push " to the stack
      059*$!#.  Does nothing
              39*0j  Jumps to cell 39,0
                         ''5&.    Push ' and duplicate it 5 times
                              '\  Push \
                                d&o@  Print the whole stack
— Jo King
fonte
6

Perl 5 , Rubino , JavaScript (Chrome), PHP , Python 2 , Python 3 , 1206 byte, segnare 6 6 /1206 = 38,6865671641791

q=1//2;s=+0;s|0;"/.__id__;#";_="""q=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%"))""";R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q="""|;#<?ob_end_clean();
eval($_='"$t"?0?[$q=37 .chr+113 .chr+38 .chr,$p=(96 .chr+39 .chr)*4,$n=10 .chr,$s=39 .chr*12,$S=34 .chr*3]:eval("printf=console.log;c=String.fromCharCode;$q=c(96);$p=c(37,113,38,39).repeat(4);$n=c(10);$s=c(39).repeat(12);$S=c(34,34,34)"):[]?[$q=q(!g)^PA,$p=HARHARHARHAR^od2od2od2od2,$n=R^X,$s=bbbbbbbbbbbb^EEEEEEEEEEEE,$S=hhh^JJJ]:[$q=O^h,$p=str_repeat(RHa3^w9GS,4),$n=R^X,$s=str_repeat(b^E,12),$S=HHH^jjj];//#');printf($x='q=1//2;s=+0;s|0;"/.__id__;#";_=%7$sq=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%8$s"))%7$s;R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q=%7$s|;#<?ob_end_clean();%5$seval($_=%3$s%1$s%3$s);printf($x=%3$s%2$s%3$s,$_,$x,$q,$p,$n,$s,$S,"%8$s",![]||([]+[])?$n:"");//#%4$s%6$s%7$s;print(_.format(Q,_,q[0:-12]+R,"%8$s"))%9$s',$_,$x,$q,$p,$n,$s,$S,"%",![]||([]+[])?$n:"");//#`q&%`q&%`q&%`q&%''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))

Convalida online Perl, Ruby, PHP, Python 2 e Python 3!

Nota : l'esecuzione del programma sopra nella console di Inspector in Chrome (che sembra supportare argomenti posizionali console.log) restituisce il programma corretto.

Spiegazione

Questo è risultato molto più lungo di quanto sperassi e ho anche reso la mia vita un po 'più difficile, quindi è probabile che continuerò a armeggiare. Vorrei aggiungere anche più lingue, ma devo trovare qualcosa a cui non dispiace un $sigillo ...

Questo è più o meno un formato Quine standard in cui il calcolo del preventivo da usare è un po 'diverso per ogni lingua: in Ruby %q&viene utilizzato, usi PHP ', JavaScript (Node.js) fa uso di `e Perl 5 utilizza q(... ). Poiché cambiano solo le virgolette, il resto del programma è ancora eseguibile e sintassi valida in ogni lingua. Python 2 e 3 sono racchiusi nel programma precedente usando """per Python 2 e '''per Python 3.

I programmi Perl e Ruby risultanti non sono quines standard, vengono aggiunti ulteriori q/ %qi ogni iterazione, ma il primo programma ritorna correttamente.

I risultati sono:

  • Perl 5:
    eval($_=q&... q&);printf($x=q&... q&,... );//#'%`'%`'%`'%`''''''''''''"""...
  • Ruby:
    eval($_=%q&... %q&);printf($x=%q&... %q&,... );//#`'`'`'`'''''''''''''"""...
  • JavaScript (Chrome):
    eval($_=`... `);printf($x=`... `,... );//#%q&'%q&'%q&'%q&'''''''''''''"""...
  • PHP:
    eval($_='... ');printf($x='... ',... );//#`q&%`q&%`q&%`q&%''''''''''''"""...
  • Python 2:
    ... _="""... """;... q="""...''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))
  • Python 3:
    ... _='''... ''';... q='''...""""""""""""''';print(_.format(Q,_,q[0:-12]+R,"%"))

Ho rielaborato molto questo, spero di non aver perso nulla chiave qui. Ho ancora molta strada da fare per essere vicino al punteggio di Jo King ...

— Dom Hastings
fonte
2

Gelatina , e M , 2 6 /14 = 4.57

1Ɗṙ@“1Ɗṙ@ȮṾ”ȮṾ

Provalo in Jelly!

Provalo in M!

Ɗṙ@ȮṾ1“Ɗṙ@ȮṾ1” in gelatina

1Ɗṙ@ȮṾ“1Ɗṙ@ȮṾ” in M

— dylnan
fonte
Non sono sicuro che quello a carbone
— contenga
@ H.PWiz Stavo per aggiungere un commento dicendo questo. Chiederò a OP
— dylnan il
@ l4m2 consideri il programma Charcoal un vero e proprio quine? In caso contrario lo eliminerò.
— dylnan,
Immagino sia come Quinein PHP?
— l4m2
@ l4m2 Non sono sicuro, non conosco PHP. Funziona per la maggior parte del testo ASCII, credo
— Dylnan,
2

Python 2 e Python 3 , 2 6 /61 = 1.05

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

Provalo in Python 2!

Provalo in Python 3!

Risparmiato 12 byte grazie a Jo King.

Stampe Python 2

s=')]1-2*)0>2/1(::[s%%s(tnirp;r%=s';print(s%s[::(1/2>0)*2-1])

Stampe Python 3

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

Questo utilizza il fatto che 1/2è .5in Python 3 e 0in Python 2.

— dylnan
fonte
1

Bash / GolfScript, 72 byte, segnare 2 6 /72 = 8/9 (~ 0,888 ...)

.~0 () 
{ 
    declare "-f" @* ".~0" " ()
 "+@n.;
    echo '.~0;'
}
.~0;

Contiene un singolo spazio finale sulle prime due righe.

Provalo online in Bash.
Provalo online su GolfScript.

Semplicemente la modifica della risposta di @ jimmy23013 per la sfida " Scrivi una poliammina " . La modifica che è stata effettuata è stata la rimozione dello spazio finale dopo la terza riga e il passaggio \n"+@n.;a \n "+@n;.

Bash stamperà le righe 1 e 2 in questo modo:

.~0 ()    <- Trailing space
{         <- Trailing space

E GolfScript stamperà le linee 1 e 2 in questo modo:

.~0 ()   <- No trailing space
 {       <- Both leading and trailing space

Qui il programma di base, l'output di Bash e l'output di GolfScript rispettivamente con le nuove righe sostituite con \n:

.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 ()\n { \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;

      ^^^ Note the difference here
— Kevin Cruijssen
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.