Meus fios estão todos emaranhados!

Não é chato quando os fios se enroscam? Bem, isso aconteceu comigo, então eu gostaria de me ajudar a desembaraçá-los! Para sua conveniência, desconectei todos do dispositivo, mas eles ainda estão todos conectados à tomada. Seu desafio é descobrir como desembaraçá-los!

Entrada

A entrada consistirá em espaços, tubulações e Xs (ambos os casos). A entrada será algo como isto:

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

Um X maiúsculo significa que o fio esquerdo cruza o fio direito e um x minúsculo significa o oposto. A primeira e a última linha serão sempre | | | |.... Você pode considerar a entrada como uma sequência separada por vírgula, uma matriz de sequências, etc. O formato não é rigoroso, desde que faça sentido e não contenha nenhuma informação extra.

Resultado

Para esse desafio, não só preciso saber quanto tempo levarei, preciso saber exatamente o que fazer. Portanto, produza uma lista de pares inteiros com o caractere R ou L, sem distinção entre maiúsculas e minúsculas, representando quais dois fios se desembaraçar e de que maneira (R significa direita sobre a esquerda e vice-versa para L). Você precisa me dizer qual o caminho para descruzá-los; Eu não consigo descobrir isso sozinho. A saída também é bastante flexível, desde que você imprima todos os pares inteiros + caractere na ordem correta e você não imprima nenhum texto extra sem sentido (colchetes, vírgulas etc.). Os fios podem ser zero ou um indexado, mas o índice deve começar pela esquerda. Observe que você deve desembaraçar da parte inferior, não da parte superior. O estilo de saída deve ser consistente e especifique como você está produzindo, se não for óbvio. O caso do personagem não tem que ser consistente,

Saída de amostra

Para o exemplo de entrada acima, a saída seria algo como:

2 3 R
3 4 L
1 2 R

O formato de saída aqui é uma lista separada por nova linha de valores separados por espaço. Isso é indexado em 1.

Outras especificações

É válido ter X e x empilhados verticalmente um sobre o outro em qualquer ordem. Como sou preguiçoso, não quero trocar desnecessariamente os fios; portanto, não produza nada para esses casos; se achar isso, puxarei os fios gentilmente para endireitá-los.

Também é válido ter vários X e x empilhados verticalmente, e enquanto nenhum fio estiver envolvido em outros cruzamentos, eu não quero nenhum movimento extra (porque sou preguiçoso). Portanto, se os caracteres X X x X x xaparecerem em uma coluna sem outros cruzamentos, a saída ainda estará em branco!

Caso isso não esteja claro, R elimina X e L elimina x.

Pode haver duas passagens de fio na mesma linha; nesse caso, a ordem desses dois swaps não importa. Você nunca terá algo parecido | X X |(isso não faz sentido, porque implica que o fio do meio está sendo cruzado sobre os fios, tanto à esquerda quanto à direita).

Nem sempre há travessias ...

A entrada pode ser um único tubo. No entanto, a entrada nunca ficará em branco.

A menor solução válida vence em 20 de dezembro!

Mais exemplos

Como eu prometi:

Exemplo 1

Entrada

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

Resultado

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

Exemplo 2

Entrada

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

Resultado

2 3 L
1 2 R

Exemplo 3

Entrada

|

A saída está em branco. Sim, você tem que lidar com este caso.

Exemplo 4

Entrada

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

A saída está em branco. Apenas por diversão :).

Exemplo 5

Entrada

| |
 X 
 X 
 x 
 X 
 x 
 x 
| |

A saída ainda está em branco ...

Anterior, 173 bytes

A entrada é lida a partir de stdin no formato exato fornecido na descrição do desafio, embora seja crucial que cada linha tenha o comprimento correto e a linha final inclua uma nova linha (ou seja, não apenas EOF no final dessa linha).

$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:<

Experimente online!

A idéia básica para esta solução é que tenhamos uma "matriz" acompanhando as contagens de torção para cada fio. Portanto, toda vez que encontramos uma torção em uma direção, aumentamos a contagem do fio associado, enquanto uma torção na outra direção diminui a contagem.

Ao mesmo tempo em que processamos a torção para um fio em particular, também observamos a contagem de torções dos fios à esquerda e à direita dele. Se um deles for diferente de zero, precisamos "descarregar" essas torções na pilha, pois não será mais possível que elas sejam desvendadas pelas torções posteriores na direção oposta.

Após a última linha de entrada, o fluxo de entrada retorna EOF repetidamente, e esses caracteres EOF são interpretados como torções em todos os fios, pelo menos para fins de descarga. Isso força o programa a liberar todas as contagens pendentes na matriz, mas não gera novas contagens de torção.

Depois que terminarmos de processar a entrada, todos os comandos para desembaraçar os fios estarão na pilha. Isso significa que podemos simplesmente soltá-los na ordem inversa para produzir as instruções necessárias para desembaraçar os fios de baixo para cima.

Pitão - 26 25 bytes

Muito simples, talvez eu possa jogar golfe na filtragem.

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

Experimente online aqui .

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

Recebe a entrada como uma matriz de cadeias que representam linhas e retorna uma matriz de matrizes de valores, por exemplo [[2, 3, "R"], [3, 4, "L"], [1, 2, "R"]]. A ordem inversa ajuda nas eliminações.

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

Recebe entrada como lista de strings

Exemplo:

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

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

Editar: corrigido para o caso:

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

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