Una rotazione di una stringa viene effettuata suddividendo una stringa in due pezzi e invertendo il loro ordine, ad esempio "world! Hello,"è una rotazione di "Hello, world!". È possibile creare programmi che possono essere ruotati per formare un programma diverso, ma comunque valido. Considera questo esempio in Python:

print ")import sys; sys.stdout.write("

Può essere ruotato per formare

import sys; sys.stdout.write("print ")

Che è esso stesso un programma Python valido.

La tua sfida è quella di scrivere un programma che genera una rotazione di se stesso, che quando eseguito genererà il programma originale. I punti bonus per qualsiasi voce con una durata del ciclo maggiore di due!

Questo è il golf del codice, il punteggio esatto sarà: (lunghezza del codice) / (durata del ciclo - 1).

EDIT: Abbiamo un vincitore (a meno che qualcun altro non sia in grado di battere un punteggio di 4)! Sarei comunque molto interessato a vedere altre soluzioni, siano esse contendenti o meno.

APL (158 caratteri, punteggio = 4)

'''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 

Sto usando Dyalog APL qui. Il numero di cicli può essere aumentato di uno aggiungendo 0 (0 seguito da uno spazio) alla fine dell'espressione e alla fine della stringa (prima '''). La lunghezza del ciclo è (# 0's) + 1e la lunghezza dell'espressione è 150 + 4*(cycle length)). Supponendo che continuiamo ad aggiungere zeri per sempre, il punteggio è Limit[(150 + 4*n)/(n - 1), n -> Infinity] = 4, dov'è nla durata del ciclo.

Ecco un esempio con durata del ciclo = 6:

      '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 
 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0

      0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0
 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0

      0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0
 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0

      0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0
 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0

      0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0
 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1

      0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1
'''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 0 0 0 0

192 caratteri, punteggio = 2

'''{2≠⍴⍺:¯3⌽(2×1+⍴⍺)⍴(1+⍴⍺)⍴⍺ ⋄ a←⊃2⌷⍺ ⋄ ⍵=0:¯2⌽(2×1+⍴a)⍴(1+⍴a)⍴a⋄(-4+⌊10⍟⊃⍺)⌽(2×1+⍴a)⍴(1+⍴a)⍴a}01'''{2≠⍴⍺:¯3⌽(2×1+⍴⍺)⍴(1+⍴⍺)⍴⍺⋄a←⊃2⌷⍺⋄⍵=0:¯2⌽(2×1+⍴a)⍴(1+⍴a)⍴a⋄(-4+⌊10⍟⊃⍺)⌽(2×1+⍴a)⍴(1+⍴a)⍴a}01

A seconda dell'implementazione, un punto di errore potrebbe essere quando il numero intero con prefisso sulla stringa è troppo grande. Teoricamente, tuttavia, possiamo aggiungere un ciclo aggiungendo due caratteri: 1a alla fine della stringa (prima ''') e 1a alla fine dell'intera riga.

200 caratteri, punteggio = 1

'''{a←{2=⍴⍵:⊃2⌷⍵⋄⍵}⍺⋄(⍺{⍵=9:⍬⋄⍕1+{2=⍴⍵:10×⊃⍵⋄0}⍺}⍵),(¯2⌽(2×1+⍴a)⍴(1+⍴a)⍴a),⍺{⍵=9:(⍕9),⍕⊃⍺⋄⍕⌊⍵÷10}⍵}'''{a←{2=⍴⍵:⊃2⌷⍵⋄⍵}⍺⋄(⍺{⍵=9:⍬⋄⍕1+{2=⍴⍵:10×⊃⍵⋄0}⍺}⍵),(¯2⌽(2×1+⍴a)⍴(1+⍴a)⍴a),⍺{⍵=9:(⍕9),⍕⊃⍺⋄⍕⌊⍵÷10}⍵}91

La mia implementazione APL non ha interi di precisione illimitati per impostazione predefinita, quindi l'intero viene convertito in un float quando diventa troppo grande, causando un errore nell'output. Quindi questo è il più schizzinoso, ma teoricamente (a mano o con un interprete APL diverso), dovrebbe avere un punteggio di 1. Basta aggiungere un 1alla fine dell'espressione e si ottiene un altro ciclo.

Panoramica (con un quine più corto)

Darò una panoramica della prima versione, perché penso che sia probabilmente la più facile da comprendere. Prima di affrontare quella versione, tuttavia, prenderemo in considerazione un semplice quine in APL :

1⌽22⍴11⍴'''1⌽22⍴11⍴'''

Ho scoperto che uno dei modi migliori per comprendere alcune espressioni APL è guardare l'output attraverso la cascata di operatori / funzioni. Tutti gli operatori e le funzioni in APL sono associativi a destra e hanno la stessa precedenza, quindi eccola, da destra a sinistra:

• '''1⌽22⍴11⍴''': Questa è solo una stringa letterale (un elenco di caratteri). ''è il modo APL per sfuggire alle virgolette singole. Uscita: '1⌽22⍴11⍴'.
• 11⍴'''1⌽22⍴11⍴''': Qui, risagomiamo ( ⍴) la stringa per essere di lunghezza 11. Poiché la lunghezza della stringa è inferiore a 11, viene ripetuta (ovvero 5⍴'abc'cederebbe 'abcab'). Uscita: '1⌽22⍴11⍴''. Quindi ora abbiamo due virgolette alla fine: stiamo arrivando da qualche parte!
• 22⍴11⍴'''1⌽22⍴11⍴''': Allo stesso modo, ora ridisegniamo la lunghezza del nostro output precedente 22. Uscita: '1⌽22⍴11⍴'''1⌽22⍴11⍴''. Ci siamo quasi - dobbiamo solo spostare la prima citazione singola alla fine.
• 1⌽22⍴11⍴'''1⌽22⍴11⍴''': Qui, ruotiamo ( ⌽) l'elenco di caratteri di 1. Questo sposta il primo carattere della stringa alla fine. Come altro esempio, 2⌽'abcdef'ritorna 'cdefab'. Uscita: 1⌽22⍴11⍴'''1⌽22⍴11⍴'''.

Il quine rotante

Quel quine corto è la base principale per il nostro quine rotante. Ora, con questo in mente, diamo un'occhiata al nostro quine:

'''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 

{ ... }definisce una funzione senza nome, che è dove faremo il lavoro. Si noti che le funzioni in APL accettano un argomento destro, indicato da ⍵, e un argomento sinistro opzionale, indicato da ⍺(think infix). Vogliamo alimentare questa funzione sia la nostra stringa di quine sia qualcosa che ci aiuti a creare un numero arbitrario di cicli. Per rendere le cose più facili per noi stessi (e per chiunque voglia aggiungere cicli), rendiamo la stringa quine l'argomento sinistro. L'argomentazione corretta, quindi, è dove inseriamo la nostra lista di cicli. 2 o più elementi separati da uno spazio creano un elenco, quindi in questo esempio abbiamo un elenco di 2 elementi composto da a 1e a 0.

Possiamo vedere che la funzione sembra simile alla quine di prima. Abbiamo la stessa ...⌽...⍴...⍴...forma di prima. Quindi va bene, almeno lo capiamo molto! Diamo approfondire l'ellissi, a cominciare tutto dopo l'ultima ⍴: ⊃,/(~^/¨⍺=0)/⍺.

• Come puoi vedere guardando l'esempio sopra, abbiamo il prefisso della stringa con gli 0 dal lato destro, aggiungendo uno ad ogni iterazione; ma non ci importa di quelli in questo momento. Vogliamo solo la corda!
• Innanzitutto, considera cosa c'è tra parentesi. (A proposito, si raggruppano come nella maggior parte delle altre lingue.)
  • ⍺=0restituisce un elenco, in questo caso, con la stessa forma di ⍺, in cui ogni elemento in ⍺è sostituito da un 1se è uguale a 0e un 0altro. Questo viene eseguito in modo ricorsivo; quindi se abbiamo un elenco di un elenco di un elenco di caratteri, i singoli caratteri verranno testati rispetto a 0 e verrà restituito un elenco di un elenco di un elenco di valori binari.
  • Quindi, se ⍺costituito solo dalla nostra stringa, otteniamo un elenco di 0. Altrimenti, il nostro argomento di sinistra ha alcuni 0 con prefisso (ad esempio, 0 0 0 'quinestring'), quindi è un elenco composto da 0 e un altro elenco, la nostra stringa. Quindi appare il nostro output 1 1 1 <sub-list of zeros>.
  • ^/¨⍺=0: Applichiamo la funzione derivata ^/, che riduce ( /) usando la funzione logica AND ( ^), a ciascun ¨elemento ( ) di ⍺=0. Questo per appiattire la sotto-lista di zeri in modo da poter considerare la stringa quine come un valore binario. Considerando l'esempio precedente, l'output sarebbe 1 1 1 0.
  • ~: NON binari ciascuno dei valori precedenti (ad es. Ritorno 0 0 0 1).
• (~^/¨⍺=0)/⍺: Per ogni elemento in ⍺, lo repliciamo ( /) il numero di volte dato dall'elemento corrispondente nell'argomento sinistro. Questo elimina tutti gli 0, lasciandoci solo con la nostra stringa quine.
• ⊃,/sono alcuni documenti necessari per garantire di recuperare un elenco di caratteri appiattito, riducendo il risultato con la funzione di concatenazione ( ,). Se l'input è già un elenco appiattito (ovvero, l'argomento sinistro della nostra funzione principale è solo la stringa), otteniamo un elenco di 1 elemento contenente tale elenco. Nell'altro caso, quando abbiamo un elenco costituito da un sotto-elenco per la stringa, otteniamo la stessa cosa indietro (un elenco con un sotto-elenco). Quindi scompattiamo questo ( ⊃), dandoci solo il primo elemento della lista (cioè la sotto-lista di caratteri). Questo potrebbe sembrare superfluo, ma altrimenti cercheremmo di rimodellare un elenco di 1 elemento!

Successivamente, esaminiamo la lunghezza fornita per la prima modifica, tra parentesi:

• ⍺,⍵: Concateniamo l'argomento giusto al primo argomento
• ⊃,/⍺,⍵: Come prima - appiattisci l'elenco.
• +/0=⊃,/⍺,⍵: Consente di aggiungere il numero di zeri nell'elenco riducendo ( /) utilizzando la funzione addition ( +).
• 2×+/0=⊃,/⍺,⍵: Moltiplica quel numero per due.
• z←2×+/0=⊃,/⍺,⍵: Assegna ( ←) il risultato a una variabile, z. Per ricapitolare, zora è il doppio del numero di zeri trovati negli argomenti sinistro e destro.
• 77+z←2×+/0=⊃,/⍺,⍵: Aggiungiamo quindi 77, per i caratteri nella stringa quine, ignorando tutto ciò che segue lo spazio seguente 1. Come nell'esempio iniziale di Quine, aggiungiamo 1 alla lunghezza della stringa per ottenere un'altra virgoletta singola.
• L'output di questa nuova forma, in questo esempio, è: '{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 ''

L'argomento alla nuova forma che segue è semplice e rispecchia la breve quina (2 volte la lunghezza della prima forma). Il nostro output ora è:

'{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 '''{(((3+z)×^/⍵)-5+2×+/+/¨⍺=0)⌽(2×77+z)⍴(77+z←2×+/0=⊃,/⍺,⍵)⍴⊃,/(~^/¨⍺=0)/⍺}1 0 ''

Ora per il passaggio finale, in cui calcoliamo quanto ruotare la stringa di output:

• Come puoi vedere guardando l'output precedente, vogliamo ruotarlo indietro (un importo negativo) per portare le 2 virgolette finali all'inizio. Poiché vogliamo che anche uno 0(e un altro spazio) si spostino all'inizio, vogliamo ruotarlo di altri 3 caratteri indietro.
• +/+/¨⍺=0: Somma il numero di zeri nell'argomento sinistro . Il primo (da destra) +/¨somma il conteggio di ciascun elemento (ovvero, un elenco secondario o solo un numero intero), e il secondo +/ci fornisce la somma dell'elenco risultante.
• 5+2×+/+/¨⍺=0: Moltiplica per due (per ruotare anche gli spazi) e aggiungi 5 (il risultato che abbiamo trovato prima).
• Ora, sottraggiamo il valore precedente dall'argomento sinistro -per gestire il caso quando raggiungiamo la fine del nostro ciclo:
  • (3+z)×^/⍵: E tutti gli elementi nell'argomento giusto insieme per vedere se abbiamo raggiunto il nostro fine ( 1) e moltiplicalo per 3+z.

E abbiamo finito!

GolfScript, 10046/9999 ≈ 1.0047 (punteggio asintotico 1)

OK, proverò a battere la voce APL di DC con questo:

{\''+.,{(;\'.~1'}{'1'9999*@'.~']puts:puts}if}.~

Il codice sopra non è il vero quine - ho pensato che pubblicare un one-liner da 10kB non sarebbe stata una buona idea. Piuttosto, eseguire il codice sopra riportato una volta produce il vero programma GolfScript da 10046 caratteri, che, se ripetuto come specificato nella domanda, genera 9999 rotazioni di se stesso e, infine, di nuovo se stesso.

La durata del ciclo (e del programma) può essere regolata modificando la costante 9999. Per brevità e convenienza, mostrerò come appare l'output iterato se la costante viene ridotta a 9:

111111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~
11111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~1
1111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~11
111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~111
11111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~1111
1111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~11111
111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~111111
11{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~1111111
1{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~11111111
{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~111111111
111111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~
11111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~1
1111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~11
111111{\''+.,{(;\'.~1'}{'1'9*@'.~']puts:puts}if}.~111
etc.

All'aumentare della costante 9999, il rapporto tra la durata del programma e la durata del ciclo (meno uno) tende a uno. Sono abbastanza sicuro che questa soluzione non possa essere battuta, almeno non in modo asintotico. ;-)

Come funziona?

GolfScript è un linguaggio abbastanza semplice in cui scrivere quines, dato che praticamente qualsiasi numero letterale funge da quine: ad esempio, l'output del programma GolfScript 12345- avete indovinato - 12345. Inoltre, concatenare più quine in genere produce un quine. Quindi, potrei usare un numero semplice 11111...111come la parte ripetitiva del mio quin ciclico.

Tuttavia, per far sì che le quine si muovano effettivamente, dobbiamo trasportare ed eseguire un "payload" non banale. Il quine GolfScript più semplice che mi viene in mente che posso fare è il seguente:

{PAYLOAD'.~'}.~

Quindi il mio piano era di prefissare un quine come quello con una costante numerica ripetitiva e di usare un payload che tagliava una cifra dal numero e lo spostava alla fine del programma. Se il programma rileva che non vi è alcuna costante numerica davanti ad essa (nel qual caso il valore sotto di essa nello stack sarà una stringa vuota, supponendo che non vi sia input), verrà invece anteposta una costante numerica di lunghezza fissa davanti a si.

C'è un'altra ruga, però: quando si "avvolge", il payload deve anche sopprimere l'output del numero dopo se stesso. Normalmente, quando termina un programma GolfScript, tutti i valori nello stack vengono stampati automaticamente, il che sarebbe un problema qui.

Tuttavia, risulta essere un modo (AFAIK) non documentato per evitarlo: l'interprete chiama effettivamente la funzione predefinita putsper eseguire la stampa, ridefinendo tale funzione come no-op sopprime l'output automatico. Naturalmente, questo significa anche che dobbiamo prima chiamarci putsper stampare la parte della pila che vogliamo stampare.

Il codice finale sembra piuttosto disordinato (anche per GolfScript), ma almeno funziona. Ho il sospetto che possano esserci alcuni modi intelligenti in cui non ho ancora pensato di radere alcuni caratteri dal payload, ma per questa versione mi sono concentrato principalmente sul punteggio asintotico.

HTML, meno infinito (quasi)

-2

AA

-10

AAAAAAAAAA

E così via ... Se qualcuno dice che è un imbroglio, possiamo discuterne, ma ho trovato un buco in questione :)

Quindi immagino che tutti capiscano che il codice lo fa, non ha loop, quindi il loop più lungo è 0e considerando la lunghezza del programma è n, il punteggio è n / (0 - 1)o -n, posso scrivere un programma ncon un intero positivo altrettanto grande, ma è inutile, perché tutti lo capiscono.