25

Este desafío tiene lugar en una cuadrícula.

+----------+
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
+----------+

Este es de 10 x 10, pero puede tener cualquier forma rectangular.

Hay cuatro direcciones en esta cuadrícula. Arriba, abajo, izquierda y derecha.

La tarea es dibujar un camino que comience con una dirección de mayúscula inicial. En este ejemplo, irá directamente hacia arriba desde la U.

+----------+
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|   U      |
+----------+

El camino irá hacia arriba y estará compuesto por caracteres de punto y coma (.), Hasta que llegue a una pared, cuando terminará con un asterisco (*).

+----------+
|   *      |
|   .      |
|   .      |
|   .      |
|   .      |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

Además del inicio de ruta, también hay cambiadores de dirección, representados por una dirección inicial en minúscula.

+----------+
|          |
|          |
|          |
|   r.....*|
|   .      |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

Además, una mayúscula X es un obstáculo que terminará el camino.

+----------+
|          |
|          |
|          |
|          |
|   r...*X |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

Reglas

La entrada es una cadena que consta de un cuadro (que consta de |, - y + caracteres) que contiene caracteres que indican el inicio de la ruta, los cambiadores de dirección y los obstáculos.
Su código debe agregar caracteres de punto final para seguir la ruta descrita por los cambios de inicio y dirección, y un asterisco cuando / si la ruta se encuentra con una pared u obstáculo.
Puede haber múltiples rutas de inicio.
El código seguirá terminando sin error si la ruta describe un bucle.
Si una ruta se encuentra con un inicio de ruta, actuará como un cambiador de dirección.
Es código de golf, código de bajo byte y sin lagunas estándar, por favor.
Siempre prefiero enlaces a un intérprete en línea.

Casos de prueba

1: simple

+----------+
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|   U      |
+----------+


+----------+
|   *      |
|   .      |
|   .      |
|   .      |
|   .      |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

2: giro a la derecha

+----------+
|          |
|          |
|          |
|   r      |
|          |
|          |
|          |
|          |
|   U      |
+----------+


+----------+
|          |
|          |
|          |
|   r.....*|
|   .      |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

3: encrucijada

+----------+
|          |
|          |
|          |
|   r  d   |
|          |
| u    l   |
|          |
|          |
|   U      |
+----------+


+----------+
| *        |
| .        |
| .        |
| . r..d   |
| . .  .   |
| u....l   |
|   .      |
|   .      |
|   U      |
+----------+

4: 4 caminos cruzados

+----------+
|      D   |
|          |
|          |
|R         |
|          |
|         L|
|          |
|          |
|   U      |
+----------+


+----------+
|   *  D   |
|   .  .   |
|   .  .   |
|R........*|
|   .  .   |
|*........L|
|   .  .   |
|   .  .   |
|   U  *   |
+----------+

5: primer bucle

+----------+
|          |
|          |
|          |
|   r  d   |
|          |
|   u  l   |
|          |
|          |
|   U      |
+----------+

+----------+
|          |
|          |
|          |
|   r..d   |
|   .  .   |
|   u..l   |
|   .      |
|   .      |
|   U      |
+----------+

6: Arrancador como cambiador

+----------+
|          |
|          |
|          |
|   L      |
|          |
|          |
|          |
|          |
|   U      |
+----------+


+----------+
|          |
|          |
|          |
|*..L      |
|   .      |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

7: bucle recto

+----------+
|          |
|          |
|          |
|          |
|   r  l   |
|          |
|          |
|          |
|   U      |
+----------+


+----------+
|          |
|          |
|          |
|          |
|   r..l   |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

8: nudo apretado

+----------+
|          |
|          |
|          |
|  d  l    |
|   r u    |
|  r u     |
|          |
|          |
|   U      |
+----------+


+----------+
|    *     |
|    .     |
|    .     |
|  d..l    |
|  .r.u    |
|  r.u     |
|   .      |
|   .      |
|   U      |
+----------+

9: un obstáculo

+----------+
|          |
|          |
|          |
|          |
|   r    X |
|          |
|          |
|          |
|   U      |
+----------+


+----------+
|          |
|          |
|          |
|          |
|   r...*X |
|   .      |
|   .      |
|   .      |
|   U      |
+----------+

10: forma de S

+----------+
|r     d   |
|          |
|  XXXXXXXX|
| d      l |
|ul        |
|XXXXXXX   |
|          |
|R       u |
|          |
+----------+


+----------+
|r.....d   |
|.     *   |
|. XXXXXXXX|
|.d......l |
|ul      . |
|XXXXXXX . |
|        . |
|R.......u |
|          |
+----------+

11: nudo de 4 vías

+----------+
|      D   |
|          |
|   r      |
|R    d    |
|          |
|    u    L|
|      l   |
|          |
|   U      |
+----------+


+----------+
|    * D   |
|    . .   |
|   r.....*|
|R....d.   |
|   ....   |
|   .u....L|
|*.....l   |
|   . .    |
|   U *    |
+----------+

12: Cruces ocupados

+----------+
|rrrrr rrrd|
| rlrl     |
|ul rrd    |
|ruX X     |
|udl ll    |
|ull       |
|rlr       |
|rdr  d    |
|Uruull    |
+----------+


+----------+
|rrrrr.rrrd|
|.rlrl    .|
|ul rrd   .|
|ruX.X.   .|
|udl.ll   .|
|ull.     .|
|rlr.     .|
|rdr..d   .|
|Uruull   *|
+----------+

13: Comienza en Edge

+----------+
|   U      |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
+----------+

+----------+
|   U      |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
+----------+

14: Cruzando caminos muertos

+----------+
|          |
|          |
|          |
|      R   |
|          |
|          |
|          |
|          |
|         U|
+----------+


+----------+
|         *|
|         .|
|         .|
|      R..*|
|         .|
|         .|
|         .|
|         .|
|         U|
+----------+

code-golf AJFaraday
fuente

@TFeld Añadido, ¡gracias!

AJFaraday

1

Parece que todos los cambiadores de dirección siempre se alcanzan en sus casos de prueba, lo que podría permitir simplificar el algoritmo. Sugeriría agregar un caso de prueba donde no sea cierto.

Arnauld

@Arnauld Estoy bastante seguro de que hay algunos cambiadores de dirección no utilizados en el caso 12.

AJFaraday

1

caso_prueba sugerido

TSH

3

Se afirma que la cuadrícula puede tener cualquier forma rectangular, pero todos los casos de prueba parecen ser idénticos en tamaño y forma.

Gastropner

9

JavaScript (ES6), 191 183 181 bytes

Gracias a @tsh por ayudar a corregir un error

Toma la entrada como una matriz de caracteres. Salidas modificando la entrada.

f=(a,X,Y,d,n=0)=>a.map((r,y)=>r.map((v,x)=>(a+0)[i=' .*dlurDLUR'.indexOf(v),n]?X?X-x+~-d%2|Y-y+(d-2)%2?0:~i?f(a,x,y,i>2?i&3:d,n+1,r[x]=i?v:'.'):n?a[Y][X]='*':0:i>6&&f(a,x,y,i&3):0))

Pruébalo en línea!

Comentado

f = ( a,                           // a[]  = input matrix
      X, Y,                        // X, Y = coordinates of the previous cell
      d,                           // d    = current direction (0 .. 3)
      n = 0                        // n    = number of iterations for the current path
    ) =>                           //
  a.map((r, y) =>                  // for each row r[] a position y in a[]:
    r.map((v, x) =>                //   for each character v at position x in r[]:
      (a + 0)[                     //
        i = ' .*dlurDLUR'          //     i = index of the character
            .indexOf(v),           //     blocking characters '-', '|' and 'X' gives -1
        n                          //     by testing (a + 0)[n], we allow each cell to be
      ]                            //     visited twice (once horizontally, once vertically)
      ?                            //     if it is set:
        X ?                        //       if this is not the 1st iteration:
          X - x + ~-d % 2 |        //         if x - X is not equal to dx[d]
          Y - y + (d - 2) % 2 ?    //         or y - Y is not equal to dy[d]:
            0                      //           ignore this cell
          :                        //         else:
            ~i ?                   //           if this is not a blocking character:
              f(                   //             do a recursive call:
                a,                 //               pass a[] unchanged
                x, y,              //               pass the coordinates of this cell
                i > 2 ? i & 3 : d, //               update d if v is a direction char.
                n + 1,             //               increment n
                r[x] = i ? v : '.' //               if v is a space, set r[x] to '.'
              )                    //             end of recursive call
            :                      //           else (this is a blocking character):
              n ?                  //             if this is not the 1st iteration:
                a[Y][X] = '*'      //               set the previous cell to '*'
              :                    //             else:
                0                  //               do nothing
        :                          //       else (1st iteration):
          i > 6 &&                 //         if v is a capital letter:
            f(a, x, y, i & 3)      //           do a recursive call with this direction
      :                            //     else ((a + 0)[n] is not set):
        0                          //       we must be in an infinite loop: abort
    )                              //   end of inner map()
  )                                // end of outer map()

Arnauld
fuente

por cierto, [...""+a].mappodría crear una matriz con al menos 2x de longitud de a. No estoy seguro si ayuda.

tsh

(a+0)[n]guarda un byte, aunque nahora debe inicializarse.

Arnauld

8

Python 2 , 283 279 293 288 279 bytes

e=enumerate
def f(M):
 s=[(x,y,c)for y,l in e(M)for x,c in e(l)if'A'<c<'X'];v=set(s)
 for x,y,C in s:
	d=ord(C)%87%5;q=d>1;X,Y=x-d+q*3,y+~-d-q;c=M[Y][X];N=(X,Y,[C,c]['a'<c<'x'])
	if'!'>c:M[Y][X]='.'
	if(c in'-|X')*('/'>M[y][x]):M[y][x]='*'
	if(c in'udlr. *')>({N}<v):v|={N};s+=N,

Pruébalo en línea!

Toma una lista de listas.

Salidas modificando la matriz de entrada.

TFeld
fuente

6

Perl 5, 203 188 166 bytes

$l='\K[ a-z](?=';$t='([-|X])?';$s=$_;/
/;$n='.'x"@-";{$_|=s/(?|R[.*]*$l$t)|$t${l}[.*]*L)|D$n(?:[.*]$n)*$l$n$t)|$t$n$l$n([.*]$n)*U))/$&eq$"?$1?'*':'.':uc$&/es?redo:$s}

TIO

Cómo funciona

$s=$_para guardar entradas $spara restaurar los cambiadores de minúsculas $_|=$sporque bit a bit o con espacio no cambiará .y *las letras minúsculas urldse restaurarán con bit a bit u operación.
/\n/;$n='.'x"@-"para obtener "ancho" y $npara coincidir con cualquier carácter "ancho" veces
$l='\K[ a-z](?=';$t='([-|X])?'para reducir la longitud de la expresión regular; $lpara que coincida con una letra minúscula urldo un espacio en una ruta, $tpara que coincida con un terminador.

Después del reemplazo: (?| R[.*]*\K[ a-z](?=([-|X])?) | ([-|X])?\K[ a-z](?=[.*]*L) | D$n(?:[.*]$n)*\K[ a-z](?=$n([-|X])?) | ([-|X])?$n\K[ a-z](?=$n([.*]$n)*U) )

cambia /ea eval, de /smodo que .(dentro $n) coincida también con un carácter de nueva línea
$&eq$"?$1?'*':'.':uc$&si coincide es un espacio, si termiator coincide de *otra .manera mayúscula.

Nahuel Fouilleul
fuente

1

@Arnauld, funciona si ingresa un caso de prueba a la vez.

Shaggy

Sí, publiqué rápidamente y no pude comprobar que se solucionó restableciendo $sen el pie de página. $sse usa para guardar la entrada y

volver a escribir

4

Limpio , 409 bytes

import StdEnv,Data.List
q=flatlines
$m=foldl(zipWith\a b|a=='*'||b=='*'='*'=max a b)(q m)[q(foldl(\m(_,y,x)=[[if(b<>x||a<>y)if(k=='*')'.'k'*'\\k<-r&b<-[0..]]\\r<-m&a<-[0..]])m(last(takeWhile(not o hasDup)(inits(f 0y 0x)))))\\l<-m&y<-[0..],c<-l&x<-[0..]|isUpper c]
where f a y b x=let(u,v)=(a+y,b+x)in(case toLower((m!!u)!!v)of' '=[((a,b),u,v):f a u b v];'r'=f 0u 1v;'l'=f 0u -1v;'u'=f -1u 0v;'d'=f 1u 0v;_=[])

Pruébalo en línea!

Οurous
fuente

3

Python 2 , 250 bytes

def f(G,e=enumerate):
 for i,k in e(G):
	for j,l in e(k):
	 v=X=x=y=m,=l,
	 while(m in'-X|')<(l in'DLRU')>(X in v):v+=X,;y,x=zip((1,0,0,-1,y),(0,-1,1,0,x))['DLRU dlru'.find(m)%5];G[i][j]=(m,'.*'[G[i+y][j+x]in'-X|'])[m<'!'];i+=y;j+=x;X=x,i,j;m=G[i][j]

Pruébalo en línea!

Toma una lista de listas de cadenas 1-char, según lo permitido explícitamente por el OP.

Cambia la lista en su lugar.

Para una E / S más fácil, use esto .

Erik el Outgolfer
fuente

Dibuja un camino hecho por cambiadores de dirección

Reglas

Casos de prueba

1: simple

2: giro a la derecha

3: encrucijada

4: 4 caminos cruzados

5: primer bucle

6: Arrancador como cambiador

7: bucle recto

8: nudo apretado

9: un obstáculo

10: forma de S

11: nudo de 4 vías

12: Cruces ocupados

13: Comienza en Edge

14: Cruzando caminos muertos

Respuestas:

JavaScript (ES6), 191 183 181 bytes

Comentado

Python 2 , 283 279 293 288 279 bytes

Perl 5, 203 188 166 bytes

Limpio , 409 bytes

Python 2 , 250 bytes