Q u i n e R e l a y!

Quine Relay!

Un relè quine dell'ordine è una serie di programmi in lingue distinte in modo tale che ciascun programma emetta e emette . $n$ $P_1\dots P_n$ $P_i$ $P_{i+1}$ $P_n$ $P_1$

Ad esempio, un relè 2-quine può essere visto qui:

Rubino → Perl 6:

Questo programma Ruby :

$><<"print ("
p (DATA.read*2).chars.map(&:ord)
$><<".map: &chr).join"

__END__
$><<"print ("
p (DATA.read*2).chars.map(&:ord)
$><<".map: &chr).join"

__END__

genera questo programma Perl 6 :

print ([36, 62, 60, 60, 34, 112, 114, 105, 110, 116, 32, 40, 34, 10, 112, 32, 40, 68, 65, 84, 65, 46, 114, 101, 97, 100, 42, 50, 41, 46, 99, 104, 97, 114, 115, 46, 109, 97, 112, 40, 38, 58, 111, 114, 100, 41, 10, 36, 62, 60, 60, 34, 46, 109, 97, 112, 58, 32, 38, 99, 104, 114, 41, 46, 106, 111, 105, 110, 34, 10, 10, 95, 95, 69, 78, 68, 95, 95, 10, 36, 62, 60, 60, 34, 112, 114, 105, 110, 116, 32, 40, 34, 10, 112, 32, 40, 68, 65, 84, 65, 46, 114, 101, 97, 100, 42, 50, 41, 46, 99, 104, 97, 114, 115, 46, 109, 97, 112, 40, 38, 58, 111, 114, 100, 41, 10, 36, 62, 60, 60, 34, 46, 109, 97, 112, 58, 32, 38, 99, 104, 114, 41, 46, 106, 111, 105, 110, 34, 10, 10, 95, 95, 69, 78, 68, 95, 95, 10]
.map: &chr).join

che a sua volta genera il programma Ruby originale.

La sfida

La prima risposta sarà un relè quine ordine : un quine normale. Può essere in qualsiasi lingua. $1$

La risposta successiva sceglierà una lingua diversa e creerà un inoltro ordine quine usando queste due lingue. $2$

E così via. La risposta -th creerà un kine relé di ordine usando le precedenti lingue e una nuova, diversa lingua. $k$ $k$ $k - 1$

vincente

Se, dopo 2 settimane, non sono state aggiunte altre risposte, il vincitore è la persona che ha risposto con il quine relay di ordine più elevato.

Più regole

Nessuna persona può rispondere due volte di seguito.
Nessuna persona può rispondere entro un'ora dal post più recente.
Le lingue che differiscono per versione sono considerate distinte. Pertanto, Python 2 e Python 3 possono entrambi essere parte della catena.
Le lingue che differiscono per compilatore o interprete non sono considerate distinte. Quindi, Python 3 (Cython) e Python 3 sono considerati intercambiabili ma non distinti.
Ogni risposta può ordinare le lingue in qualsiasi modo. Se la terza risposta ha un ordine di Ruby → Perl 6 → JavaScript, non sei limitato ad aggiungere una lingua fino alla fine. Se stavi aggiungendo Java al mix, allora potresti scrivere JavaScript → Ruby → Java → Perl 6 se lo desideri.

Formato per le risposte

n. Lingua ₁ → Lingua ₂ →… → Lingua _n

Lingua ₁
language 1 code
Lingua ₂
language 2 code
Lingua ₃
language 3 code
...

Lingua _n
language n code

Sentiti libero di aggiungere spiegazioni ovunque nelle tue risposte.

quine answer-chaining

— Conor O'Brien
fonte

Dovresti aggiungere qualcosa come un minimo di 2 caratteri per evitare catene quine degenerate come la stringa vuota. Inoltre, qualcosa che impedisce alle lingue che di default riecheggiano il loro input. In alternativa, è possibile raggrupparli in uno solo richiedendo che tutti gli output nella catena siano univoci.

— Yonatan N,

@YonatanN In realtà, una volta aggiunte abbastanza lingue, sarebbe difficile riuscire a farlo ... sarebbe interessante vedere qualcuno provare. Anche se penso che finora tutti abbiano quine vuote.

— Ørjan Johansen,

@ ØrjanJohansen a partire da ora, qualcuno può eliminare la domanda utilizzando un linguaggio di tipo Bubblegum e un input vuoto.

— Yonatan N,

@YonatanN Hm, sì, immagino ci siano troppi modi per abusarne. (Anche questo genere di cose è il motivo per cui altre domande concatenate danno la vittoria alla seconda ultima risposta.)

— Ørjan Johansen

@YonatanN Quines a 0 o 1 carattere di solito non soddisfano la nostra definizione standard di quine

— Conor O'Brien

Risposte:

10. Javascript → Foo → Brainfuck → Wumpus → Gol> <> → RAD →> <> → Python 2 → Brain-Flak → 4

Modifica: per la prossima risposta, ho chiarito come il Python generi un po 'di più Brain-Flak qui , ma non posso preoccuparmi di aggiornare i collegamenti.

Aggiunto Gol> <>. È poco rpHdopo il codice Wumpus. Ho anche ottimizzato un po 'il codice di Brainfuck e Brain-Flak. Verifica!

JavaScript (Node.js)

(f=_=>{q=(c=String.fromCharCode)(39);Q=c(34);b=c(96);x=0;console.log(Q+[...`${Q}99+&;75*1-l2:8-&o@rpH${q}${q+q}rpp>o<def n(x):global l;r=p+p+f+F+P+q+(p+P)*(l-x)+Q+P if x<l else p+p+f+F+P+(p+P)*(x-l)+P;l=x;return r;''a''p=chr(40);P=chr(41);q=chr(91);Q=chr(93);f=chr(123);F=chr(125);l=4;print p+p+p+p+p+p+P+p+P+p+P+P+f+F+P+f+F+p+P+P+f+F+P+f+F+P,str().join(map(n,map(lambda x:ord(x)-48,str().join(map(lambda c:${b}600${b}+(str(c-99).zfill(2)+${b}99500${b}.zfill(10) if c>99 else str(c).zfill(2)+${b}500${b}),[`+[...`(f=${f})()`].map(c=>c.charCodeAt())+`]))[::-1]+${b}99996${b}))),${[...'pppppppPpPPfFpPPfFpPPfFpPPfFPppPpPPfFpPP'].join`+`}${q}`].map(s=>c(43).repeat(Math.max(-x+s.charCodeAt(),0))+c(45).repeat(Math.max(x-(x=s.charCodeAt()),0))+c(46)).join(c()).match(/.{1,253}/g).join(c(10)+Q))})()

Q u i n e R e l a y!

Quine Relay!

Rubino → Perl 6:

La sfida

vincente

Più regole

Formato per le risposte

n. Lingua 1 → Lingua 2 →… → Lingua n

Lingua 1

Lingua 2

Lingua 3

Lingua n

10. Javascript → Foo → Brainfuck → Wumpus → Gol> <> → RAD →> <> → Python 2 → Brain-Flak → 4

3. JavaScript → Python 2 → Foo

JavaScript

Python 2

foo

1. Foo

foo

2. Python 2 → Foo

5.> <> → JavaScript → brainfuck → Python 2 → Foo

> <>

JavaScript

brainfuck

Python 2

foo

9. JavaScript → Foo → Brainfuck → Wumpus → RAD →> <> → Python 2 → Brain-Flak → 4

JavaScript

foo

brainfuck

Wumpus

RAD

> <>

Python 2

Brain-Flak

4

4.> <> → JavaScript → Python 2 → Foo

6.> <> → JavaScript → brainfuck → Python 2 → Brain-Flak → Foo

7.> <> → JavaScript → RAD → Brainfuck → Python 2 → Brain-Flak → Foo

> <>

JavaScript

RAD

brainfuck

Python 2

Brain-Flak

foo

8.> <> → Wumpus → JavaScript → RAD → brainfuck → Python 2 → Brain-Flak → Foo

n. Lingua ₁ → Lingua ₂ →… → Lingua _n

Lingua ₁

Lingua ₂

Lingua ₃

Lingua _n