Mes fils sont tous emmêlés!

N'est-ce pas ennuyeux quand les fils s'emmêlent? Eh bien, cela m'est juste arrivé, alors j'aimerais m'aider à les démêler! Pour votre commodité, je les ai tous déconnectés de l'appareil, mais ils sont tous toujours connectés à la prise. Votre défi est de comprendre comment les démêler!

Contribution

L'entrée sera constituée d'espaces, de tuyaux et de X (les deux cas). L'entrée ressemblera à ceci:

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

Un X majuscule signifie que le fil gauche croise le fil droit et un x minuscule signifie le contraire. Les première et dernière lignes seront toujours | | | |.... Vous pouvez prendre l'entrée comme une chaîne séparée par des virgules, un tableau de chaînes, etc. Le format n'est pas strict, tant qu'il est logique et ne contient aucune information supplémentaire.

Production

Pour ce défi, non seulement j'ai besoin de savoir combien de temps je vais prendre, je dois savoir exactement quoi faire. Donc, affichez une liste de paires entières avec le caractère R ou L, insensible à la casse, représentant les deux fils à démêler et dans quel sens (R signifie de droite à gauche, et vice versa pour L). Vous devez me dire dans quel sens les décroiser; Je ne peux pas comprendre ça moi-même. La sortie est assez flexible aussi, tant que vous sortez toutes les paires entières + caractère dans le bon ordre et que vous ne sortez aucun texte non-sens supplémentaire (les crochets, les virgules, etc. sont très bien). Les fils peuvent être indexés à zéro ou un, mais l'index doit commencer par la gauche. Notez que vous devez démêler du bas, pas du haut. Le style de sortie doit être cohérent, et veuillez spécifier comment vous sortez s'il n'est pas évident. La casse du personnage ne doit pas être cohérente,

Exemple de sortie

Pour l'exemple d'entrée ci-dessus, la sortie serait quelque chose comme:

2 3 R
3 4 L
1 2 R

Le format de sortie ici est une liste de valeurs séparées par des espaces séparées par des sauts de ligne. Ceci est indexé 1.

Spécifications supplémentaires

Il est valide d'avoir X et x empilés verticalement l'un sur l'autre dans l'un ou l'autre ordre. Étant donné que je suis paresseux, je ne veux pas changer de fil inutilement, alors ne sortez rien pour ces cas; si je trouve ça, je vais juste tirer les fils doucement pour les remettre en place.

Il est également valide d'avoir plusieurs X et x empilés verticalement, et tant qu'aucun fil n'est impliqué dans d'autres croisements, je ne veux pas de mouvements supplémentaires (parce que je suis paresseux). Ainsi, si les caractères X X x X x xapparaissent dans une colonne sans aucun autre croisement, la sortie doit toujours être vide!

Dans le cas où cela n'est pas clair, R élimine X et L élimine x.

Il pourrait y avoir deux croisements de fils dans la même ligne, auquel cas l'ordre de ces deux swaps n'a pas d'importance. Vous n'obtiendrez jamais quelque chose comme | X X |(cela n'a pas de sens car cela implique que le fil du milieu est croisé sur les fils à la fois à gauche et à droite).

Il n'y a pas toujours de croisements ...

L'entrée pourrait être un seul tuyau. Cependant, l'entrée ne sera jamais vide.

La solution valide la plus courte gagne le 20 décembre!

Plus d'exemples

Comme j'ai promis:

Exemple 1

Contribution

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

Production

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

Exemple 2

Contribution

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

Production

2 3 L
1 2 R

Exemple 3

Contribution

|

La sortie est vide. Oui, vous devez gérer cette affaire.

Exemple 4

Contribution

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

La sortie est vide. Juste pour le fun :).

Exemple 5

Contribution

| |
 X 
 X 
 x 
 X 
 x 
 x 
| |

La sortie est toujours vierge ...

Befunge, 173 octets

L'entrée est lue à partir de stdin dans le format exact donné dans la description du défi, bien qu'il soit crucial que chaque ligne soit de la bonne longueur et que la ligne finale doit inclure une nouvelle ligne (c'est-à-dire pas seulement EOF à la fin de cette ligne).

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

Essayez-le en ligne!

L'idée de base de cette solution est que nous avons un "tableau" gardant une trace du nombre de torsions pour chaque fil. Ainsi, chaque fois que nous rencontrons une torsion dans une direction, nous incrémentons le comptage pour le fil associé, tandis qu'une torsion dans l'autre direction décrémentera le comptage.

En même temps que nous traitons la torsion pour un fil particulier, nous examinons également le nombre de torsions pour les fils à gauche et à droite de celui-ci. Si l'un d'eux n'est pas nul, nous devons "vider" ces torsions sur la pile, car il ne sera plus possible de les démêler par des torsions ultérieures dans la direction opposée.

Après la dernière ligne d'entrée, le flux d'entrée renvoie EOF à plusieurs reprises, et ces caractères EOF sont interprétés comme des torsions dans chaque fil, au moins à des fins de vidage. Cela force le programme à vider tous les décomptes en suspens dans le tableau, mais il ne génère aucun nouveau décompte de torsions.

Une fois le traitement de l'entrée terminé, toutes les commandes de démêlage des fils seront désormais dans la pile. Cela signifie que nous pouvons simplement les retirer dans l'ordre inverse pour afficher les instructions nécessaires pour démêler les fils de bas en haut.

Pyth - 26 25 octets

Très simple, je peux peut-être jouer au filtrage.

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

Essayez-le en ligne ici .

JavaScript (ES6), 178 octets

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

Prend l'entrée comme un tableau de chaînes représentant des lignes et renvoie un tableau de tableaux de valeurs, par exemple [[2, 3, "R"], [3, 4, "L"], [1, 2, "R"]]. L'ordre inverse aide aux éliminations.

Python 2, 244 241 octets

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

Prend l'entrée comme liste de chaînes

Exemple:

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

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

Edit: corrigé pour le cas:

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

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