I miei fili sono tutti aggrovigliati!

Non è fastidioso quando i fili si aggrovigliano? Bene, mi è appena successo, quindi mi piacerebbe aiutarmi a districarli! Per comodità, li ho scollegati tutti dal dispositivo, ma sono ancora tutti collegati alla presa. La tua sfida è capire come districarli!

Ingresso

L'input sarà costituito da spazi, pipe e X (entrambi i casi). L'input sarà simile a questo:

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

Una X maiuscola indica che il filo sinistro attraversa il filo destro e una x minuscola indica il contrario. La prima e l'ultima riga saranno sempre | | | |.... Puoi prendere l'input come una stringa separata da virgola, una matrice di stringhe, ecc. Il formato non è rigoroso, purché abbia senso e non contenga ulteriori informazioni.

Produzione

Per questa sfida, non solo devo sapere quanto tempo impiegherò, ma devo sapere esattamente cosa fare. Quindi, genera un elenco di coppie di numeri interi con il carattere R o L, senza distinzione tra maiuscole e minuscole, che rappresentano i due fili da districare e in che modo (R significa destra su sinistra e viceversa per L). Devi dirmi in che modo separarli; Non riesco a capirlo da solo. Anche l'output è piuttosto flessibile, a patto che tu emetta tutte le coppie di numeri interi + carattere nell'ordine corretto e non produci alcun testo senza senso extra (parentesi, virgole, ecc. Vanno bene). I fili possono essere zero o uno indicizzato, ma l'indice deve iniziare da sinistra. Nota che devi districare dal basso, non dall'alto. Lo stile di output deve essere coerente e si prega di specificare come si sta producendo se non è ovvio. Il caso del personaggio non deve essere coerente,

Uscita campione

Per l'input di esempio sopra, l'output sarebbe simile a:

2 3 R
3 4 L
1 2 R

Il formato di output qui è un elenco separato da righe di valori separati da spazi. Questo è 1-indicizzato.

Ulteriori specifiche

È valido avere X e x sovrapposti verticalmente l'uno sull'altro in entrambi gli ordini. Dato che sono pigro, non voglio cambiare i fili inutilmente, quindi non emettere nulla per questi casi; se lo trovo, tirerò delicatamente i fili per metterli dritti.

È anche valido avere più X e x impilati verticalmente e fintanto che nessuno dei fili è coinvolto in altri incroci, non voglio mosse extra (perché sono pigro). Pertanto, se i personaggi vengono X X x X x xvisualizzati in una colonna senza altri incroci, l'output dovrebbe essere ancora vuoto!

Nel caso ciò non sia chiaro, R elimina X e L elimina x.

Potrebbero esserci due incroci di filo nella stessa riga, nel qual caso l'ordine di questi due swap non ha importanza. Non otterrai mai qualcosa del genere | X X |(questo non ha senso perché implica che il filo intermedio viene attraversato sui fili sia a sinistra che a destra).

Non ci sono sempre incroci ...

L'ingresso potrebbe essere una singola pipe. Tuttavia, l'input non sarà mai vuoto.

La soluzione valida più breve vince il 20 dicembre!

Altri esempi

Come ho promesso:

Esempio 1

Ingresso

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

Produzione

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

Esempio 2

Ingresso

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

Produzione

2 3 L
1 2 R

Esempio 3

Ingresso

|

L'output è vuoto. Sì, devi occuparti di questo caso.

Esempio 4

Ingresso

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

L'output è vuoto. Solo per divertimento :).

Esempio 5

Ingresso

| |
 X 
 X 
 x 
 X 
 x 
 x 
| |

L'output è ancora vuoto ...

Befunge, 173 byte

L'input viene letto dallo stdin nel formato esatto indicato nella descrizione della sfida, anche se è fondamentale che ogni riga abbia la lunghezza corretta e che l'ultima riga debba includere una nuova riga (cioè non solo EOF alla fine di quella riga).

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

Provalo online!

L'idea di base di questa soluzione è che abbiamo un "array" che tiene traccia dei conteggi di torsione per ciascun filo. Quindi ogni volta che incontriamo una torsione in una direzione aumentiamo il conteggio per il filo associato, mentre una torsione nell'altra direzione diminuirà il conteggio.

Mentre elaboriamo la torsione per un particolare filo, osserviamo anche il conteggio della torsione per i fili a sinistra e a destra di esso. Se uno di loro è diverso da zero, dobbiamo "svuotare" i colpi di scena sulla pila, poiché non sarà più possibile per loro essere svelati da colpi di scena successivi nella direzione opposta.

Dopo l'ultima riga di input, il flusso di input restituisce EOF ripetutamente e questi caratteri EOF vengono interpretati come colpi di scena in ogni filo, almeno ai fini del flushing. Ciò forza il programma a cancellare tutti i conteggi in sospeso nell'array, ma non genererà nuovi conteggi di torsione.

Una volta terminata l'elaborazione dell'input, tutti i comandi per districare i fili saranno ora in pila. Ciò significa che possiamo semplicemente espellerli in ordine inverso per emettere le istruzioni necessarie per districare i fili dal basso verso l'alto.

Pyth - 26 25 byte

Molto semplice, forse posso golf il filtraggio.

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

Provalo online qui .

JavaScript (ES6), 178 byte

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

Prende l'input come una matrice di stringhe che rappresentano linee e restituisce una matrice di matrici di valori, ad es [[2, 3, "R"], [3, 4, "L"], [1, 2, "R"]]. L'ordinamento inverso aiuta con le eliminazioni.

Python 2, 244 241 byte

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

Accetta input come elenco di stringhe

Esempio:

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

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

Modifica: risolto per caso:

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

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