L'amato pesce che nuota attraverso il codice di > <> (un linguaggio di programmazione esoterico) è stato tolto dal suo ambiente naturale. Questo cambiamento lo ha reso incapace di muoversi nel modo in cui era solito: quello che era un movimento toroidale era limitato al semplice movimento da sinistra a destra. Ma i programmi> <> sono ancora scritti come se il pesce fosse in grado di attraversarli. È tuo compito, caro programmatore, scrivere un programma per linearizzare un programma> <>. E fallo nel minor numero di byte possibile; i pesci non hanno ricordi molto grandi.
Movimento in> <>
In> <>, il movimento è toroidale e un carattere alla volta. Ciò significa che il pesce (il puntatore) può "avvolgere" dalla fine di una linea all'inizio. In> <>, il pesce è anche in grado di spostarsi dall'alto verso il basso, dal basso verso l'alto e da destra a sinistra, in contrasto con il modo in cui si muovono i puntatori. Quindi questo schema di movimento sarebbe valido:
>>>^ >>>v
>>>^ v
e finirebbe con un ciclo infinito (tornando alla riga superiore una volta che passa infinitamente il fondo).
Il pesce si muove in una griglia di lunghezza uguale a max (lunghezza della fila) e altezza uguale al numero di file.
Come capisci in che modo si muove il pesce? Questi comandi cambiano il vettore di direzione del movimento (ad es. (-1,0)Significa da destra a sinistra):
Command | Direction Change
---------------------------
> | (1,0) (default)
< | (-1,0)
^ | (0,1)
v | (0,-1)
/ | (x,y) -> (y,x)
\ | (x,y) -> (-y,-x)
| | (x,y) -> (-x,y)
_ | (x,y) -> (x,-y)
# | (x,y) -> (-x,-y)
; | (0,0)
Come notato, il pesce inizia a muoversi da sinistra a destra, cioè con il vettore di direzione (1,0). Il pesce inizia ad analizzare i comandi a partire dal primo comando che vede e cambia direzione se un comando corrisponde a uno dei suddetti cambi di direzione.
Il pesce smette di muoversi quando vede un ;e termina il programma.
Ingresso
L'ingresso sarà un programma valido (ad es. Non loop continuo) fornito tramite STDIN. Se lo desideri, puoi anche leggere un file. Le linee di ciascun programma non avranno necessariamente la stessa lunghezza.
L'input è dato come una stringa, con le nuove righe che separano ogni riga nel programma.
I programmi non eseguiranno il loop, il che significa anche che termineranno sempre con a ;.
Produzione
L'output sarà il programma linearizzato. Cioè, dovresti restituire tutti i personaggi (inclusi i cambi di direzione) che il pesce vedrebbe se eseguisse il programma "normalmente". Questo è tutti i personaggi nel suo percorso verso ;.
Se l'input ha linee di lunghezza disuguale e il pesce finisce per muoversi lungo una linea più corta della lunghezza della linea più lunga, dovresti trattarlo come se il pesce si stesse muovendo su uno spazio (vedi casi di test).
Chi ha familiarità con> <> saprà che i cambi di direzione non sono l'unico modo per fare movimento in esso, ma per semplicità trattano l'input come se fossero l' unico modo per influenzare il movimento.
Regole
- Si applicano scappatoie standard
- È possibile scrivere un programma completo o una funzione
- L'input viene fornito tramite STDIN o un file come stringa contenente le righe del programma separate da newline (
\n)- Puoi prendere l'input in modo diverso, entro limiti ragionevoli (sentiti libero di chiedermi se hai in mente un tipo specifico di input). Non è possibile riempire l'input con spazi in modo che la lunghezza della linea corrisponda.
- Fare riferimento a questo meta post per quanto riguarda l'input flessibile. Per quanto riguarda la pubblicazione, il consenso generale deve essere il più flessibile possibile entro limiti ragionevoli.
- L'output è una singola stringa tramite STDOUT o restituito dalla funzione (a seconda di ciò che si sceglie di fare, vedere la regola 2)
Casi test
v >v
>abcv//;
gfed<^ih
v>abcv<defghi^//>v;
v >v
>abcv//;
gfed<^
v>abcv<defg ^//>v;
abcdef;
abcdef;
abcd|;
abcd|dcba;
abcd#;
abcd#dcba;
abcd\;
_
abcd\_\dcba;
^;
>abcde/
^jihg<
^ >abcde/ <ghij^a;
;
;