¡Mis cables están enredados!

¿No es molesto cuando los cables se enredan? Bueno, eso me pasó a mí, ¡así que me gustaría ayudarme a desenredarlos! Para su comodidad, los desconecté a todos del dispositivo, pero todavía están conectados a la toma de corriente. ¡Tu desafío es descubrir cómo desenredarlos!

Entrada

La entrada consistirá en espacios, tuberías y X (ambos casos). La entrada se verá más o menos así:

| | | |
 X  | |
| |  x 
|  X  |
| | | |

Una X mayúscula significa que el cable izquierdo cruza sobre el cable derecho, y una x minúscula significa lo contrario. La primera y la última línea siempre serán | | | |.... Puede tomar la entrada como una cadena separada por comas, una matriz de cadenas, etc. El formato no es estricto, siempre que tenga sentido y no contenga ninguna información adicional.

Salida

Para este desafío, no solo necesito saber cuánto tiempo tardaré, sino también saber exactamente qué hacer. Por lo tanto, genere una lista de pares enteros con el carácter R o L, sin distinción entre mayúsculas y minúsculas, que represente qué dos cables desenredar y de qué manera (R significa derecha sobre izquierda y viceversa para L). Tienes que decirme de qué manera descruzarlos; No puedo entender eso yo mismo. La salida también es bastante flexible, siempre que envíe todos los pares enteros + caracteres en el orden correcto y no envíe ningún texto sin sentido adicional (los corchetes, las comas, etc. están bien). Los cables pueden ser cero o uno indexado, pero el índice debe comenzar desde la izquierda. Tenga en cuenta que debe desenredar desde la parte inferior, no desde la parte superior. El estilo de salida debe ser coherente y, por favor, especifique cómo va a salir si no es obvio. El caso del personaje no tiene que ser consistente,

Salida de muestra

Para el ejemplo de entrada anterior, el resultado sería algo como:

2 3 R
3 4 L
1 2 R

El formato de salida aquí es una lista separada por nueva línea de valores separados por espacios. Esto es 1 indexado.

Especificaciones adicionales

Es válido tener X y x apiladas verticalmente una sobre la otra en cualquier orden. Como soy flojo, no quiero cambiar los cables innecesariamente, así que no envíe nada para estos casos; si encuentro eso, simplemente tiraré de los cables suavemente para que queden rectos.

También es válido tener múltiples X y x apiladas verticalmente, y mientras ninguno de los cables esté involucrado en otros cruces, no quiero ningún movimiento adicional (porque soy flojo). Por lo tanto, si los caracteres X X x X x xaparecen en una columna sin ningún otro cruce, ¡el resultado debería estar en blanco!

En caso de que esto no esté claro, R elimina X y L elimina x.

Podría haber dos cruces de cables en la misma fila, en cuyo caso no importa el orden de estos dos intercambios. Nunca obtendrá algo como | X X |esto (esto no tiene sentido porque implica que el cable del medio se está cruzando sobre los cables tanto a la izquierda como a la derecha).

No siempre hay cruces ...

La entrada podría ser una sola tubería. Sin embargo, la entrada nunca estará en blanco.

¡La solución válida más corta gana el 20 de diciembre!

Más ejemplos

Como lo prometí:

Ejemplo 1

Entrada

| | | | | |
| |  X   x 
 X  |  x  |
|  x  |  X 
 X   X  | |
| | | | | |

Salida

1 2 R
3 4 R
2 3 L
5 6 R
1 2 R
4 5 L
3 4 R
5 6 L

Ejemplo 2

Entrada

| | |
 X  |
|  x 
| | |
|  X 
|  x 
| | |

Salida

2 3 L
1 2 R

Ejemplo 3

Entrada

|

La salida está en blanco. Sí, tienes que lidiar con este caso.

Ejemplo 4

Entrada

| |
 X 
 x 
 X 
 x 
 X 
 x 
 X 
 x 
 X 
 x 
| |

La salida está en blanco. Solo por diversión :).

Ejemplo 5

Entrada

| |
 X 
 X 
 x 
 X 
 x 
 x 
| |

La salida sigue en blanco ...

Befunge, 173 bytes

La entrada se lee desde stdin en el formato exacto dado en la descripción del desafío, aunque es crucial que cada línea tenga la longitud correcta y la línea final debe incluir una nueva línea (es decir, no solo EOF al final de esa línea).

$1>>05p~$~:55+-#v_
$_^#`"N":+1g50$<>:2+3%1-05g6g+0v>!#:v#
vg50-1*2p51:-1_^#:<*2!!-*84p6g5<
 +#,.#$"R"\#\-#+5<^g51$_:0`6*\25g\v@_:#!.#:1#,
>+::25p6g\48*\6p48 *-:!^!:--1*2`0:<

Pruébalo en línea!

La idea básica para esta solución es que tenemos una "matriz" que realiza un seguimiento de los recuentos de torsión para cada cable. Entonces, cada vez que nos encontramos con un giro en una dirección, incrementamos el conteo para el cable asociado, mientras que un giro en la otra dirección disminuirá el conteo.

Al mismo tiempo que procesamos el giro para un cable en particular, también observamos el recuento de giro para los cables a la izquierda y a la derecha del mismo. Si alguno de ellos no es cero, necesitamos "enjuagar" esos giros en la pila, ya que ya no será posible que se desenreden por giros posteriores en la dirección opuesta.

Después de la última línea de entrada, la secuencia de entrada devuelve EOF repetidamente, y estos caracteres EOF se interpretan como giros en cada cable, al menos con el propósito de enjuagar. Esto obliga al programa a eliminar cualquier recuento pendiente en la matriz, pero no generará ningún recuento de giro nuevo.

Una vez que hayamos terminado de procesar la entrada, todos los comandos para desenredar los cables estarán ahora en la pila. Esto significa que simplemente podemos sacarlos en orden inverso para generar las instrucciones necesarias para desenredar los cables de abajo hacia arriba.

Pyth - 26 25 bytes

Muy sencillo, tal vez pueda jugar golf al filtrado.

fhhT_m+hB/xrdZ\x2@"RL"}\x

Pruébelo en línea aquí .

JavaScript (ES6), 178 bytes

f=([t,...a],r=[])=>a[0]?t.replace(/x/gi,(c,i)=>(c=c<'x'?'R':'L',i=++i/2,r.reduce((f,[j,,d],n)=>f||i<j+2&&j<i+2&&(j-i|c==d||r.splice(n,1)&&2),0)<2?r=[[i,i+1,c],...r]:r))&&f(a,r):r

Toma datos como una matriz de cadenas que representan líneas y devuelve una matriz de matrices de valores, por ejemplo [[2, 3, "R"], [3, 4, "L"], [1, 2, "R"]]. El orden inverso ayuda con las eliminaciones.

Python 2, 244 241 bytes

m=[]
for l in input():
 for i in range(len(l)):
  c=l[i];a=i/2+1;L,R=[a,a+1,'LR'[c>'v']],[a,a+1,'RL'[c>'v']];x=m.index(L)if L in m else-1;M=zip(*m[:x+1])
  if c in'xX':
   if x>=0and(a in M[1]or a+1in M[0])<1:del m[x]
   else:m=[R]+m
print m

Toma entrada como lista de cadenas

Ejemplo:

Entrada: ['| | | |', ' X | |', '| | x ', '| X |', ' x | |']

Salida: [[1, 2, 'L'], [2, 3, 'R'], [3, 4, 'L'], [1, 2, 'R']]

Editar: Corregido por caso:

Entrada: ['| | |', ' X |', ' X |', ' x |', '| X', ' X |', ' x |', ' x |', '| | |']

Salida: [[1, 2, 'L'], [2, 3, 'R'], [1, 2, 'R']]