Ogni volta che fai una mossa su un cubo di Rubik, c'è una mossa inversa che annulla la prima mossa. Per questo motivo, ogni algoritmo (serie di mosse) ha un algoritmo inverso che annulla il primo algoritmo.

L'obiettivo di questa sfida è trovare il contrario di un determinato algoritmo.

Specifica:

L'input è costituito da una matrice di mosse individuali. Ogni mossa è una stringa di lunghezza 1 o 2. Naturalmente, puoi usare qualunque formato di input abbia più senso nella tua lingua. Ogni mossa consiste nella struttura Xo X'o X2, doveX è una lettera maiuscola o minuscola.

Per invertire X, basta sostituirlo con X'. Allo stesso modo, X'diventa X.X2d'altra parte non viene modificato.

Per creare l'output, invertire ogni spostamento, quindi invertire l'array.

Esempi (stringhe separate da spazi):

R => R'

D U' => U D'

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

A2 B2 => B2 A2

punteggio:

Questo è code-golf, quindi vince il minor numero di byte. Non sono ammesse scappatoie standard.

Python 2 , 71 57 54 53 byte

-15 byte grazie agli ovs! -3 byte grazie a Rod.

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

Provalo online!

I / O stringa, 70 byte

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

Provalo online!

V , 13 10 byte

æGÇä/á'Ó''

Provalo online!

3 byte salvati grazie a @nmjmcman sottolineando la mia funzione preferita. Spiegazione:

æ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 byte

\w
$&'
''

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

Provalo online! Il link include casi di test. Spiegazione: Il primo stadio aggiunge un apostrofo dopo ogni alfanumerico. Ciò si traduce in apostrofi doppi (con o senza un 2 inclusivo) che devono essere rimossi. La fase finale inverte le mosse.

JavaScript (ES6), 45 byte

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

La soluzione più breve è prendere Array IO. Uso semplice e appropriato della distruzione degli argomenti.

L'output della stringa è +8 byte per .join` `.

Input stringa, output array: 69 byte

(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>

Gelatina , 11 byte

ḟ;ċ?”'ḣ2µ€Ṛ

Un collegamento monadico che restituisce un elenco di elenchi di caratteri (un "array" di "stringhe").

Provalo online!(Il piè di pagina evita di distruggere l'output, visualizzando l'elenco diviso con spazi.)

Come?

ḟ;ċ?”'ḣ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 byte

Accetta input come una matrice di mosse.

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

Provalo

Inserisci un elenco di mosse separato da virgole.

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>

Spiegazione

a=>

Funzione anonima che accetta l'array di mosse come argomento tramite parametro a.

a.map(m=>                       )

Mappa sull'array, passando ogni stringa attraverso una funzione, dove si mtrova la stringa corrente.

 m[1]?

Controlla se la stringa contiene un secondo secondo carattere ( "'"o "2").

+m[1]?

In tal caso, prova a trasmettere quella stringa di caratteri a un numero intero. Se la stringa è "2", diventa 2, il che è vero. Se la stringa è "'", diventa NaN, il che è falso.

m

Se il test precedente è veritiero, torna semplicemente m.

:m[0]

Altrimenti, restituisce il primo carattere di m.

:m+"'"

Se la stringa non contiene un secondo carattere, restituire maggiunto con a '.

.reverse()

Invertire l'array modificato.

Python ,  51  48 byte

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

Una funzione senza nome che accetta e restituisce elenchi di stringhe.

Provalo online!

Inverte l'elenco di input con a[::-1]; accoda 'a ogni voce con v+"'"; testa ciascuno a 1 o 2 caratteri a seconda che l'originale avesse 'o meno un [:2-("'"in v)].

Python 3 , 91 89 72 70 69 65 byte

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

Provalo online! (Con testcase)

Apparentemente non è necessario prendere input e output come stringhe, quindi è possibile una soluzione da 69 byte

Haskell , 43 byte

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

Provalo online! Dichiara una funzione anonima map f.reverse. Associare ge utilizzare come g["S","T","A","C","K"].

PHP , 81 byte

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

Provalo online!

05AB1E , 13 byte

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

Provalo online!

Spiegazione

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 byte

J lo gestisce bene, a parte la sfortunata sequenza di escape necessaria per rappresentare una singola citazione:

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

Dobbiamo rappresentare l'elenco usando i dati inscatolati, poiché è un mix di elementi a uno e due caratteri, quindi:

• &.> - "under unbox", che significa unbox ogni elemento, esegui l'operazione che segue (cioè i simboli spiegati di seguito) e poi rebox al termine
• (''''={:) "se il 2 ° carattere è una virgoletta singola" ....
• @. (Il verbo dell'agenda di J, una specie di dichiarazione ternaria generalizzata o un'istruzione case) "quindi esegui il secondo punto nell'elenco dell'agenda, altrimenti esegui il primo"
• }: (il secondo punto nell'elenco dell'agenda), "rimuovi l'ultimo carattere", ovvero la virgoletta singola
• `(Verbo di congiunzione di J) Puoi pensare a questo come al separatore di punti dell'ordine del giorno
• ,&'''' (primo punto nella lista dell'agenda) "aggiungi una sola citazione alla fine"
• |. "inverso"

Provalo online!

R , 51 byte

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

Provalo online!

Rubino , 44 byte

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

Provalo online!

Java 8, 141 128 126 byte

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

Accetta input come singolo Stringsenza spazi (ad esRUR'URU2R'U .).

Spiegazione:

Provalo online.

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

Esempio dei passaggi precedenti, con input dato: 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'