Escriba un programa o función que incluya una cadena de una sola línea no vacía de caracteres ascii imprimibles excluyendo el espacio:

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Puede suponer que la entrada es válida.

Según la entrada, dibuje una nueva cadena organizada en una cuadrícula textual de espacios y nuevas líneas siguiendo las reglas de gráficos de tortuga , donde la tortuga siempre ocupa un espacio de cuadrícula y solo puede mirar hacia las direcciones cardinales.

Imprima el primer carácter de la cadena de entrada en la cuadrícula de texto. La tortuga comienza aquí mirando hacia la derecha. Itere sobre el resto de los caracteres en la cadena de entrada (solo se detiene si la tortuga se atasca), repitiendo este proceso:

1. Si los 4 espacios de la cuadrícula directamente adyacentes a la tortuga están todos llenos (es decir, ninguno de ellos es un espacio), deja de iterar. La tortuga está atascada y la cuadrícula está lo más completa posible.

2. Mire el carácter actual en la entrada en comparación con el carácter anterior:

   • Si el personaje actual es léxico antes que el anterior, gire la tortuga un cuarto de vuelta a la izquierda.

   • Si el personaje actual es léxico después del anterior, gire la tortuga un cuarto de vuelta a la derecha.

   • Si el personaje actual es igual al anterior, no rote la tortuga.

3. Si el espacio de la cuadrícula que enfrenta la tortuga ahora no está vacío (es decir, no es un espacio), gire repetidamente la tortuga un cuarto de vuelta hacia la izquierda hasta que esté frente a un espacio de cuadrícula vacío.

4. Mueve la tortuga un paso de la cuadrícula hacia adelante en la dirección que está mirando e imprime el personaje actual en la cuadrícula en la nueva ubicación de la tortuga.

Imprima o devuelva la cadena de cuadrícula de texto resultante sin filas o columnas extrañas de espacios en blanco. Las líneas pueden tener espacios finales hasta la columna más a la derecha con un no espacio, pero no más allá. Opcionalmente, se permite una nueva línea final.

El código más corto en bytes gana.

Ejemplo

Aquí están todos los pasos de la entrada spattuuxze. Los ^V<>caracteres muestran la dirección se enfrenta a la tortuga, son no parte de la entrada o salida.

s>

^
p
s

<ap
  s

^
t
ap
 s

^
t
t
ap
 s

tu>
t
ap
 s

tuu>
t
ap
 s

tuu
t x
apV
 s

tuu
<zx
ap
 s

En este punto, la tortuga está atascada, por lo que enunca se imprime y el resultado final es:

tuu
tzx
ap
 s

A continuación se muestra un resultado similar pero no válido, ya que tiene una columna de espacios en blanco innecesaria:

 tuu
 tzx
 ap
  s

Casos de prueba

spattuuxze

tuu
tzx
ap
 s

spattuuxxze

tuu
t x
apx
 sze

1111111

1111111

ABCDEFGHIJKLMNOP

PEFG
ODAH
NCBI
MLKJ

`_^]\[ZYXWVUTSR

 ^_RS
\]`UT
[ZWV
 YX

Woo!

W
o
o!

woo!

!o
 o
 w

Wheeee

W
heeee

banana

  a
 an
an
b

Turtle

T
ure
 tl

turTle

  e
tTl
ur

^{(Dígame de inmediato si alguno de estos parece incorrecto).}

Groovy (357 bytes)

No se utilizaron libs de tortugas externas y no se dañaron tortugas.

R={s->s[0]?[0,-1*s[0]]:[s[1],0]}
L={s->s[0]?[0,s[0]]:[-1*s[1],0]}
def y(s){l=s.length()*2;z(new String[l][l],[l/4,l/4],s,null,[0,1])}
def z(g,l,w,p,h){if(w.length() && !g[(int)(l[0]+h[0])][(int)(l[1]+h[1])]){c=w.getAt(0);w=w.substring(1);if(p && p<c){h=R(h)}else if(p>c){h=L(h)};g[(int)l[0]+h[0]][(int)l[1]+h[1]]=c;z(g,[l[0]+h[0],l[1]+h[1]],w,c,h)}else{g}}

Pruébelo aquí: https://groovyconsole.appspot.com/edit/5115774872059904

Intentos previos

Groovy (397 bytes)

rotR={s->s[0]!=0?[0,-1*s[0]]:[s[1],0]}
rotL={s->s[0]!=0?[0,s[0]]:[-1*s[1],0]}
def y(s){z(new String[s.length()][s.length()],[s.length()/2,s.length()/2],s,null,[0,1])}
def z(g,l,w,p,h){if(w.length() && !g[(int)(l[0]+h[0])][(int)(l[1]+h[1])]){c=w.getAt(0);w=w.substring(1);if(p && p<c){h=rotR(h)}else if(p > c){h=rotL(h)};g[(int)l[0]+h[0]][(int)l[1]+h[1]]=c;z(g,[l[0]+h[0],l[1]+h[1]],w,c,h)}else{g}}

https://groovyconsole.appspot.com/script/5179465747398656

Java, 408406 bytes

String f(String I){int l=I.length(),x=l,y=x,z=x,t=y,Z=x,T=y,d=1,i=1,a;char[][]g=new char[l*2][l*2];int[]D={-1,0,1,0};for(char c,p=g[x][y]=I.charAt(0);i<l;p=c){c=I.charAt(i++);d=((c<p?d-1:c>p?d+1:d)+4)%4;for(a=0;g[x+D[d]][y+D[3-d]]>0&&a++<4;)d=(d+3)%4;if(a>3)break;g[x+=D[d]][y+=D[3-d]]=c;z=z<x?z:x;Z=Z>x?Z:x;t=t<y?t:y;T=T>y?T:y;}for(I="";z<=Z;z++,I+="\n")for(a=t;a<=T;a++)I+=g[z][a]<1?32:g[z][a];return I;}

La función obtiene la entrada como cadena y devuelve el resultado como una cadena.

Internamente, utiliza una matriz de caracteres 2D para almacenar las letras y mantiene las columnas y filas mínimas y máximas utilizadas para devolver la matriz secundaria que se utilizó.

Por lo tanto, en la Cadena de resultados no hay columnas iniciales de espacios en blanco, pero hay espacios en blanco finales hasta la columna más a la derecha con un carácter sin espacio. Se agrega una nueva línea al final.

Cualquier sugerencia para jugar más al golf es bienvenida :-)

Python3, 419 414 bytes

Z=input();l=r=c=M=R=C=N=len(Z);t=(r*2)+1;A=[0]*t;J=range
for i in J(t):A[i]=[" "]*t
A[r][c]=Z[0];i=1;Q=[1,0,-1,0];d=q=0
while i<l:
 if Z[i]<Z[i-1]:d+=3
 elif Z[i]>Z[i-1]:d+=1
 while A[r+Q[(d-1)%4]][c+Q[d%4]]!=" "and q<4:d+=3;q+=1
 if q>3:break
 r+=Q[(d-1)%4];c+=Q[d%4];R=min(R,r);C=min(C,c);M=max(M,r);N=max(N,c);A[r][c]=Z[i];i+=1;q=0
for i in J(R,M+1):
 for j in J(C,N+1):print(A[i][j],end="")
 print()