Immagina un percorso fatto di <e >che termina in un @, ad es
><>@
Un camminatore inizia nella cella più a sinistra. Attraverserà il percorso come segue:
- Se il camminatore è su una
@cella, ha raggiunto l'obiettivo e il gioco è fatto. - Se il deambulatore si trova su una
>cella, l'intero percorso sposta ciclicamente di un passo verso destra , portando con sé il deambulatore . - Se il deambulatore si trova su una
<cella, l'intero percorso si sposta di un passo a sinistra, ciclicamente, portando con sé il deambulatore . - Successivamente, il camminatore fa un singolo passo. Se è alle due estremità del percorso, si allontana dalla fine. Altrimenti continua a muoversi nella direzione in cui si è spostato sull'ultimo gradino (ignorando la rotazione), camminando inizialmente a destra.
Esaminiamo l'esempio sopra. La posizione del camminatore è contrassegnata con ^:
><>@ --rotate--> @><>
^ ^
step right (first step):
@><> --rotate--> ><>@
^ ^
step right:
><>@ --rotate--> @><>
^ ^
step left (dead end):
@><> --rotate--> ><>@
^ ^
step left:
><>@ --rotate--> @><>
^ ^
step left:
@><> Goal reached!
^
Il walker ha visitato 6 celle nel processo (inclusa la cella di partenza e la @e contando ogni cella tutte le volte che è stata visitata).
Ecco un piccolo esempio, in cui il deambulatore viene trasportato attraverso i bordi mediante una rotazione:
>>@ --rotate--> @>>
^ ^
step right (first step):
@>> --rotate--> >@>
^ ^
step right (dead end):
>@> Goal reached!
^
Questa volta il camminatore ha visitato 3 celle.
Possiamo facilmente trasformarlo in una sequenza intera:
- Ti viene dato un numero intero positivo N , ad es
9. - Si calcola la rappresentazione binaria di questo numero intero, ad es
1001. - Poi girare
1in>e0in<e aggiungere un@:><<>@. - Associamo a N il numero di celle visitate dal walker nel numero costruito in questo modo.
I primi elementi della sequenza risultante sono:
2, 3, 3, 4, 6, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6,
6, 10, 6, 10, 8, 8, 6, 10, 8, 8, 6, 6, 6, 6, 7, 7
Questo può sembrare abbastanza arbitrario, ma la sequenza risultante in realtà risulta avere molta struttura:
Per riferimento, puoi trovare i primi 2048 numeri della sequenza in questo pastebin .
La sfida
Hai indovinato: devi calcolare la sequenza sopra. Puoi farlo in tre modi:
- È possibile produrre una sequenza infinita (mentre la memoria lo consente), emettendo continuamente valori (separati da caratteri non numerici) o utilizzando una forma di generatore infinito in linguaggi che li supportano. Se stampi un flusso infinito su STDOUT, non devi stampare i numeri uno per uno, ma assicurati che ogni numero venga stampato dopo un periodo di tempo limitato (e in ordine). Se usi questa opzione, non dovresti prendere alcun input.
- Si può prendere un numero intero N come input e produrre la N esimo termine della sequenza.
- Si può prendere un numero intero N come input e prodotti tutto fino alla N esimo termine della sequenza, come elenco o stringa utilizzando un separatore univoca.
Dato che non voglio penalizzare le lingue che non possono essere facilmente convertite tra le basi, invece dell'intero N puoi invece prendere la rappresentazione binaria di N , usando 0s e 1s come al solito (come un elenco o una stringa), con il maggior numero -significante prima di tutto.
È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).
Si applicano le regole standard del code-golf .
sfondo
Questo in realtà calcola il numero di "tick" che un interprete diretto del mio linguaggio di programmazione esoterico Labyrinth avrebbe bisogno di interpretare il "percorso" come codice sorgente. In tal caso, il "walker" è semplicemente il puntatore dell'istruzione (che ha una posizione e una direzione), il @comando termina il programma <e >sono comandi di modifica del codice sorgente.