Einführung

Ich bin ein großer Fan der SBU-Herausforderungen (Short But Unique), die ständig bei PPCG auftauchen. Das CUSRS ist ein System zur Umgestaltung von Zeichenfolgen. Eine CUSRS-Funktion verwendet 2 Parameter und gibt 1 Zeichenfolge aus.

Herausforderung

Erstellen Sie ein Programm, eine Funktion, ein Lambda oder eine akzeptable Alternative, um Folgendes zu tun:

Gegeben String inputund String refactor(als Beispiele), refactor inputVerwendung refactorwie folgt:

Der refactorString hat das Format ((\+|\-)\w* *)+(Regex), zum Beispiel:

+Code -Golf -lf +al

Jeder Abschnitt ist eine Refactoring-Aktion, die ausgeführt werden muss input. Jedes Programm hat auch einen Zeiger.

+ Fügt das Suffix (ohne Pluszeichen) an der aktuellen Position des Zeigers im String ein und setzt den Zeiger dann auf 0 zurück.

Jede Operation sollte auf den inputString angewendet und das Ergebnis zurückgegeben werden.

Beispiel:

input:
Golf +Code //pointer location: 0

output:
CodeGolf //pointer location: 0

-Inkrementiert den Zeiger durch den String, bis er das Suffix findet. Das Suffix wird aus dem String entfernt und der Zeiger bleibt auf der linken Seite des entfernten Textes. Wenn kein Suffix gefunden wird, bewegt sich der Zeiger einfach zum Ende des Strings und bleibt dort.

input:
Golf -lf //pointer location 0

output:
Go //pointer location 2

Beispiele

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"

Beispielcode

Das Beispiel ist Java, es wird überhaupt nicht gespielt.

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;
}

Regeln

• Standardschlupflöcher gelten
• Der kürzeste Code in Bytes gewinnt

APL, 91 90 Bytes

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

Dies nimmt die Zeichenfolge als rechtes Argument und die Befehle als linkes Argument wie folgt:

      '+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 Bytes

" "%(: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 181 168 165 Bytes)

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)

Beispiel, das zeigt, wie sich der Zeiger zum Ende bewegt, wenn er keinen Teilstring findet:

Input: HelloThere -x +Friend
Output: HelloThereFriend

Besonderer Dank geht an Artyer, der mir 13 Bytes erspart hat.

Ein weiteres Dankeschön an Artyer, der mir über den begParameter von weitere 3 Bytes erspart hat index.

Alte Antwort:

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)

Beispiel für die Funktionsweise des Zeigers (alle Beispiele im Q funktionieren, auch wenn Sie den Zeiger nicht berücksichtigen und ihn beim ersten Auftreten einfach ersetzen):

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

Bearbeiten: Seit 2 Minuten ist meine Antwort nach einem Kommentar des Fragestellers ungültig.

aaa -b + b würde zu aaab führen, da der Zeiger bis zum Ende gehen würde.

Edit2: Behoben.

JavaScript (ES6), 117 Byte

(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

Erläuterung: Anstatt einen umständlichen Zeiger zu verwenden, behalte ich die linke Hälfte der Zeichenfolge in tund die rechte Hälfte in s. Darüber hinaus splitund joinsind eine bequeme Möglichkeit, die Entfernung durchzuführen.