Chaque fois que vous effectuez un mouvement sur un Rubik's Cube, il y a un mouvement inverse qui annule le premier mouvement. Pour cette raison, chaque algorithme (ensemble de mouvements) a un algorithme inverse qui annule le premier algorithme.

Le but de ce défi est de trouver l'inverse d'un algorithme donné.

Spécification:

L'entrée se compose d'un tableau de mouvements individuels. Chaque mouvement est une chaîne de longueur 1 ou 2. Bien sûr, vous pouvez utiliser le format d'entrée le plus logique dans votre langue. Chaque mouvement se compose de la structure Xou X'ou X2, où Xest une lettre majuscule ou minuscule.

Pour inverser X, remplacez-le simplement par X'. De même, X'devient X. X2d'autre part ne change pas.

Pour créer la sortie, inversez chaque déplacement, puis inversez le tableau.

Exemples (chaînes séparées par des espaces):

R => R'

D U' => U D'

S T A C K => K' C' A' T' S'

A2 B2 => B2 A2

Notation:

Il s'agit de code-golf, donc le moins d'octets est gagnant. Les échappatoires standard ne sont pas autorisées.

Python 2 , 71 57 54 53 octets

-15 octets grâce aux ovs! -3 octets grâce à Rod.

lambda l:[i.strip("'")+" '"[len(i):]for i in l[::-1]]

Essayez-le en ligne!

E / S de chaîne, 70 octets

lambda s:' '.join(i.strip("'")+"'"*(len(i)<2)for i in s.split()[::-1])

Essayez-le en ligne!

V , 13 10 octets

æGÇä/á'Ó''

Essayez-le en ligne!

3 octets économisés grâce à @nmjmcman soulignant ma fonctionnalité préférée. Explication:

æG          " Revere the order of every line
  Ç         " On every line not containing...
   ä/       " a digit:
     á'     "   Append an '
       Ó    "   Remove every instance on this line
        ''  "     Of two single quotes

Retina 0.8.2 , 27 26 octets

\w
$&'
''

'2'
2
O$^`.'?2?

Essayez-le en ligne! Le lien inclut des cas de test. Explication: La première étape ajoute une apostrophe après chaque alphanumérique. Il en résulte des doubles apostrophes (avec ou sans 2 inclus) qui doivent être éliminées. La dernière étape inverse les mouvements.

JavaScript (ES6), 45 octets

s=>s.map(([a,b])=>b?+b?a+b:a:a+"'").reverse()

La solution la plus courte consiste à prendre Array IO. Utilisation simple et appropriée de la destruction d'arguments.

La sortie de chaîne est de +8 octets pour .join` `.

Entrée chaîne, sortie tableau: 69 octets

(s,k=[])=>s.replace(/\S\S?/g,([a,b])=>k.unshift(b?+b?a+b:a:a+"'"))&&k

f=

(s,k=[])=>s.replace(/\S\S?/g,([a,b])=>k.unshift(b?+b?a+b:a:a+"'"))&&k

;

console.log(["R", "D U'", "S T A C K", "A2 B2"].map(e => `${e} => ${f(e)}`));

<textarea oninput="out.value=(f(this.value)||[]).join` `" placeholder="input here"></textarea>
<textarea id="out" readonly></textarea>

Gelée , 11 octets

ḟ;ċ?”'ḣ2µ€Ṛ

Un lien monadique prenant un retour d'une liste de listes de caractères (un "tableau" de "chaînes").

Essayez-le en ligne! (Le pied de page évite d'écraser la sortie, affichant la liste divisée avec des espaces.)

Comment?

ḟ;ċ?”'ḣ2µ€Ṛ - Link: list of lists of characters             e.g. ["F'", "D2" , "R"]
        µ€  - perform the chain to the left for €ach turn instruction:
    ”'      -   literal "'" character
   ?        -   if:
  ċ         -     count (number of "'" in the instruction) i.e.:  1   , 0    , 0
ḟ           -   then: filter out                                  "F"
 ;          -   else: concatenate                                       "D2'", "R'"
      ḣ2    -   head to index 2                                   "F" , "D2" , "R'"
          Ṛ - reverse                                            ["R'", "D2" , "F"]

JavaScript (ES6), 46 octets

Prend l'entrée comme un tableau de mouvements.

a=>a.map(m=>m[1]?+m[1]?m:m[0]:m+"'").reverse()

Essaye-le

Entrez une liste de mouvements séparés par des virgules.

o.innerText=(f=
a=>a.map(m=>m[1]?+m[1]?m:m[0]:m+"'").reverse()
)((i.value="S,T,A,C,K").split`,`);oninput=_=>o.innerText=f(i.value.split`,`)

<input id=i><pre id=o>

Explication

a=>

Fonction anonyme prenant le tableau de mouvements comme argument via un paramètre a.

a.map(m=>                       )

Mappez sur le tableau, en passant chaque chaîne à travers une fonction, où mest la chaîne actuelle.

 m[1]?

Vérifiez si la chaîne contient un deuxième deuxième caractère ( "'"ou "2").

+m[1]?

S'il essaie de convertir cette chaîne de caractères en un entier. Si la chaîne est "2", elle devient 2, ce qui est vrai. Si la chaîne est "'", elle devient NaN, ce qui est falsey.

m

Si le test précédent est véridique, revenez simplement m.

:m[0]

Sinon, retournez le premier caractère de m.

:m+"'"

Si la chaîne ne contient pas de second caractère, renvoyez-le mavec un '.

.reverse()

Inversez le tableau modifié.

Python ,  51  48 octets

lambda a:[(v+"'")[:2-("'"in v)]for v in a[::-1]]

Une fonction sans nom prenant et renvoyant des listes de chaînes.

Essayez-le en ligne!

Inverse la liste d'entrée avec a[::-1]; ajoute un 'à chaque entrée avec v+"'"; dirige chacun de 1 ou 2 caractères selon que l'original a 'ou non un in [:2-("'"in v)].

Python 3 , 91 89 72 70 69 65 octets

lambda s:[i[0]+(len(i)-2and"'"or"2"*("2"==i[1]))for i in s[::-1]]

Essayez-le en ligne! (Avec des cas de test)

Apparemment, vous n'avez pas besoin de prendre l'entrée et la sortie comme des chaînes, donc une solution de 69 octets est possible

Haskell , 43 octets

map f.reverse
f[x]=x:"'"
f[x,c]=x:[c|c>'1']

Essayez-le en ligne! Déclare une fonction anonyme map f.reverse. Lier à get utiliser comme g["S","T","A","C","K"].

PHP , 81 octets

<?foreach(array_reverse($_GET)as$v)$r[]=$v[1]?$v[1]<2?$v[0]:$v:"$v'";print_r($r);

Essayez-le en ligne!

05AB1E , 13 octets

RεÐ1èQ''si«ëK

Essayez-le en ligne!

Explication

RεÐ1èQ''si«ëK
R             # Reverse input array
 ε            # Map over each element...
  Ð1èQ         # Is the second char in the element the first one? (Uses the fact that in python indexing loops)
      ''       # Push '
        s      # Swap top items of stack
         i     # If the question above is true...
          «     # Concatenate
           ë   # Else
            K   # Push element without '  

J, 25 octets

J gère bien celui-ci, autre que la séquence d'échappement malheureuse nécessaire pour représenter une seule citation:

|.,&''''`}:@.(''''={:)&.>

Nous devons représenter la liste à l'aide de données encadrées, car il s'agit d'un mélange d'éléments à un et deux caractères, d'où:

• &.> - "under unbox", ce qui signifie déballer chaque élément, effectuer l'opération qui suit (c'est-à-dire, les symboles expliqués ci-dessous) puis réemballer une fois terminé
• (''''={:) "si le 2ème caractère est un guillemet simple" ....
• @. (Verbe de l'ordre du jour de J, une sorte de déclaration ternaire généralisée ou une déclaration de cas) "puis effectuez le 2e point de la liste de l'ordre du jour, sinon effectuez le premier"
• }: (le 2e point de la liste de l’ordre du jour), "supprimer le dernier caractère", c’est-à-dire la citation unique
• `(Le verbe de cravate de J) Vous pouvez penser à cela comme le séparateur de point de l'ordre du jour
• ,&'''' (premier point de la liste de l'ordre du jour) "ajouter une seule citation à la fin"
• |. "sens inverse"

Essayez-le en ligne!

R , 51 octets

function(u)sub("((2)|')'","\\2",paste0(rev(u),"'"))

Essayez-le en ligne!

Rubis , 44 octets

->a{a.reverse.map{|i|i[1]?i.tr(?',''):i+?'}}

Essayez-le en ligne!

Java 8, 141 128 126 octets

a->new StringBuffer(a.replaceAll("(.)","$1'").replace("'''","").replaceAll("(.)'","'$1").replaceAll("'(.)'2","2$1")).reverse()

Prend l'entrée comme simple Stringsans espaces (ie RUR'URU2R'U).

Explication:

Essayez-le en ligne.

a->new StringBuffer(           // Method with String parameter and StringBuffer return-type
  a.replaceAll("(.)","$1'")    //1  Add an apostrophe after every character
   .replace("'''","")          //2  Remove all occurrences of three adjacent apostrophes
   .replaceAll("(.)'","'$1")   //3  Reverse letter+apostrophe to apostrophe+letter
   .replaceAll("'(.)'2","2$1") //4  Reverse letter+2 to 2+letter and remove aphostrophes
  ).reverse()                  //5 Reverse everything

Exemple des étapes ci-dessus, avec comme entrée donnée: RUR'URU2R'U

1. RUR'URU2R'U → R'U'R'''U'R'U'2'R'''U'
2. R'U'R'''U'R'U'2'R'''U' → R'U'RU'R'U'2'RU'
3. R'U'RU'R'U'2'RU' → 'R'UR'U'R'U'2R'U
4. 'R'UR'U'R'U'2R'U → 'R'UR'U'R2UR'U
5. 'R'UR'U'R2UR'U → U'RU2R'U'RU'R'