introduction

Je suis un grand fan des défis SBU (Short But Unique) qui surgissent tout le temps sur PPCG. Le CUSRS est un système conçu pour refactoriser les chaînes, une fonction CUSRS prend 2 paramètres et génère 1 chaîne.

Défi

Produisez un programme, une fonction, un lambda ou une alternative acceptable pour effectuer les opérations suivantes:

Étant donné String inputet String refactor(à titre d'exemples), refactoriser en inpututilisant refactorcomme suit:

La refactorchaîne sera au format ((\+|\-)\w* *)+(regex), par exemple:

+Code -Golf -lf +al

Chaque section est une action de refactorisation à effectuer input. Chaque programme a également un pointeur.

+ Insère son suffixe (sans le signe plus) à l'emplacement actuel du pointeur dans la chaîne, puis réinitialise le pointeur à 0.

Chaque opération doit être appliquée à la inputchaîne et le résultat doit être renvoyé.

Exemple:

input:
Golf +Code //pointer location: 0

output:
CodeGolf //pointer location: 0

-Incrémente le pointeur dans la chaîne jusqu'à ce qu'il trouve le suffixe. Le suffixe sera supprimé de la chaîne et le pointeur sera laissé sur le côté gauche du texte supprimé. Si aucun suffixe n'est trouvé, le pointeur progressera simplement jusqu'à la fin de la chaîne et y restera.

input:
Golf -lf //pointer location 0

output:
Go //pointer location 2

Exemples

input:
"Simple" "-impl +nip -e +er"

output:
"Sniper"

input:
"Function" "-F +Conj"

output:
"Conjunction"

input:
"Goal" "+Code -al +lf"

output:
"CodeGolf"

input:
"Chocolate" "Chocolate"

output:
"Chocolate" //Nothing happens...

input:
"Hello" "-lo+p        +Please" //Spaces are irrelevant

output:
"PleaseHelp"

input:
"Mississippi" "-s-s-i-ppi+ng" //Operations can be in any order

output:
"Missing"

input:
"abcb" "-c -b +d"

output:
"abd"

input:
"1+1=2" "-1+22-=2+=23"

outut:
"22+1=23"

Exemple de code

L'exemple est Java, ce n'est pas du tout du golf.

public static String refactor(String input, String swap) {
    int pointer = 0;
    String[] commands = swap.replace(" ", "").split("(?=[-+])");

    for (String s : commands) {
        if (s.startsWith("+")) {
            input = input.substring(0, pointer) + s.substring(1) + input.substring(pointer, input.length());
            pointer = 0;
        } else {
            if (s.startsWith("-")) {
                String remove = s.substring(1);
                for (int i = pointer; i < input.length(); i++) {
                    if (input.substring(i, i + remove.length() > input.length() ? input.length() : i + remove.length()).equals(remove)) {
                        pointer = i;
                        input = input.substring(0, i) + input.substring(i + remove.length(), input.length());
                        break;
                    }
                }
            }
        }
    }

    return input;
}

Règles

• Les échappatoires standard s'appliquent
• Le code le plus court, en octets, gagne

APL, 91 90 octets

{s l←⍵0⋄s⊣{g←1↓⍵⋄'+'=⊃⍵:+s∘←(l↑s),g,l↓s⋄l∘←¯1+1⍳⍨g⍷s⋄+s∘←(l↑s),s↓⍨l+⍴g}¨{1↓¨⍵⊂⍨⍵=⊃⍵}' ',⍺}

Cela prend la chaîne comme argument de droite et les commandes comme argument de gauche, comme ceci:

      '+Code -al +lf' {s l←⍵0⋄s⊣{g←1↓⍵⋄'+'=⊃⍵:+s∘←(l↑s),g,l↓s⋄l∘←¯1+1⍳⍨g⍷s⋄+s∘←(l↑s),s↓⍨l+⍴g}¨{1↓¨⍵⊂⍨⍵=⊃⍵}' ',⍺} 'Goal'
CodeGolf

GolfScript, 97 octets

" "%(:s;0:p;{("-"0=={.s p>\?.-1={;;s,:p;}{:p;,:l;s p<s p l+>+:s;}if}{s p<\+s p>+:s;0:p;}if}/"\n"s

Test: golfscript.tryitonline.net

Python 3 ( 164 194 186 186 181 168 165 octets)

p=0
w,*x=input().split()
for i in x:
 if '-'>i:w,p=w[:p]+i[1:]+w[p:],0
 else:
  try:p=w.index(i[1:],p)
  except:p=len(w)
  w=w[:p]+w[p:].replace(i[1:],'',1)
print(w)

Exemple montrant le pointeur se déplaçant vers la fin s'il ne trouve pas de sous-chaîne:

Input: HelloThere -x +Friend
Output: HelloThereFriend

Un merci spécial à Artyer pour m'avoir sauvé 13 octets.

Un autre merci à Artyer de m'avoir sauvé encore 3 octets via le begparamètre de index.

Ancienne réponse:

p=0
x=input().split()
w=x[0]
for i in x[1:]:
 if i[0]=='+':
  w=w[:p]+i[1:]+w[p:]
  p=0
 else:
  p=w[p:].index(i[1:])+p
  w=w[:p]+w[p:].replace(i[1:],'',1)
print(w)

Exemple illustrant le fonctionnement du pointeur (tous les exemples du travail Q fonctionnent même si vous ne tenez pas compte du pointeur et ne le remplacez qu'à la première occurrence):

Input: HelloThereCowboy -r -e -y +ySays +Oh
Output: OhHelloTheCowboySays

Edit: Depuis 2 minutes ma réponse est désormais invalide selon un commentaire du demandeur.

aaa -b + b résulterait de aaab car le pointeur irait jusqu'à la fin.

Edit2: fixe.

JavaScript (ES6), 117 octets

(s,r,t='')=>r.match(/\S\w*/g).map(r=>(q=r.slice(1),r<'-'?(s=t+q+s.t=''):([b,...a]=s.split(q),t+=b,s=a.join(q))))&&t+s

Explication: Au lieu d'utiliser un pointeur encombrant, je garde la moitié gauche de la chaîne tet la moitié droite dedans s. En outre, splitet joinconstituent un moyen pratique d'effectuer la suppression.