Ihre Aufgabe ist es, ein paar Tastenanschläge zu simulieren, die ein Benutzer eingibt.

Eingang

Ein String-Array oder ein String mit einem Begrenzer Ihrer Wahl (außerhalb des Bereichs 32-126), der mindestens einen 'Tastenanschlag' enthält.

Dieses Array enthält nur zwei Arten von Zeichenfolgen: passive Tastenanschläge (einzelne Zeichen) und Befehle (Zeichen in Klammern [ ]).

• Passive Tastenanschläge
  1. ASCII-Zeichencodes [32-126]
• Befehle:
  1. [B] : Rücktaste (letztes hinzugefügtes Zeichen entfernen, falls vorhanden)
  2. [C] : Kopieren Sie alles, was bereits geschrieben wurde
  3. [D] : lösche alles was geschrieben wurde
  4. [P] : Einfügen, was kopiert wurde

Ausgabe

Die von den Tastenanschlägen erzeugte Zeichenfolge.

Beispiele

['H', 'e', 'l', 'l', 'o'] -> 'Hello'
['H', 'e', 'l', 'l', 'o', ' ', '[C]', '[P]'] -> 'Hello Hello '
['[D]', 'D', '[B]'] -> ''
['H', '[C]', 'i', '[P]', '[C]', '[P]'] -> 'HiHHiH'
['e', '[C]', '[B]', 'I', ' ', 'l', 'i', 'k', '[P]', ' ', 'b', '[P]', '[P]', 's', '!'] -> I like bees!
['N', '[P]'] -> 'N'
['#', '5', '0', 'K', '0', '0', '1', '[D]', '#', 'n', 'o', 't'] -> '#not'
['H', 'o', 'w', ' ', '[D]', 'H', 'e', 'y'] -> 'Hey'
['s', 'u', 'd', '[B]', 'p', '[C]', '[D]', 'I', ' ' , 'h', 'a', 'v', 'e', ' ', '[P]', 'p', 'e', 'r', '!'] -> 'I have supper!'

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

05AB1E , 34 33 31 27 Bytes

Verwendet die CP-1252- Codierung.

õUvygiyJë"XJ¨DU\"4äyáÇ5%è.V

Probieren Sie es online!

Erläuterung

õU                                  # initialize X as the empty string
v                                   # for each y in input
 ygiyJ                              # if len(y) == 1 join y with stack
      ë                             # else
       "XJ¨DU\"                     # push this string
               4ä                   # split into 4 parts (of size [2,1,2,1])
                 yá                 # push only letters of y
                   Ç5%              # mod its ascii code by 5
                      è             # index into the string above with this
                       .V           # evaluate as 05AB1E code

Die im obigen Code bewerteten Funktionspaare sind:

DU    # [C] -> duplicate and store in X
XJ    # [P] -> push X and join with stack
¨     # [B] -> remove last char of string
\     # [D] -> remove top of stack 

4 Bytes mit dem mod 5Trick aus Lynns CJam-Antwort gespeichert

Vim, 76, 64, 62 , 58 Tastenanschläge

Vielen Dank an Loovjo für das Speichern von 7 Tastenanschlägen

Hat jemand gesagt, Tastatureingaben simulieren? Dann ist es eine gute Sache, dass es in meiner Lieblingssprache zum Golfen nur darum geht , Tastenanschläge zu simulieren!

:no s :%s/\M[
sB]/<C-v><C-h>
sC]/<C-v><esc>0y$A
sD]/<C-v><esc>"_S
sP]/<C-v><C-r>"
s<bs>\n
S<C-r>"

Die Eingabe erfolgt in folgendem Format:

h
e
l
l
o

[C]
[P]

Dies ist eine ziemlich einfache Antwort. Es übersetzt einfach jeden "Befehl" in den vim-Tastendruck, der diesem Befehl entspricht. Nehmen wir es Zeile für Zeile.

:no s :%s/\M[

Das spart eine Menge Bytes. Vim hat eine eingebaute "Befehlszeile", in der Sie Zuordnungen erstellen, Einstellungen ändern, Dateien speichern usw. Hier erstellen wir eine Zuordnung. :noist eine Abkürzung für :nnoremap"Wenn wir uns im normalen Modus befinden, ersetzen Sie diese rechte Seite durch diese linke Seite." Da wir :%s/ fünf verschiedene Zeiten anrufen , spart dies viel. Das \Mist ein schöner Trick. Dies bedeutet, dass die folgende Suche "Sehr keine Magie" lautet, was bedeutet, dass der reguläre Ausdruck [B]dem wörtlichen Text entspricht [B]und nicht einem Bereich, der nur ein B enthält. Da die Mehrzahl der Ersatzbefehle eckige Klammern enthält, füllen wir die erste aus.

Dann rufen wir fünf Ersatzbefehle auf. Es ist erwähnenswert, warum ich <C-v>so oft angerufen habe. Charaktere mögen <esc>, <C-v>, <C-r>etc. sind nicht druckbare Zeichen und muss mit einem in die Befehlszeile eingegeben werden <C-v>.

• [B]: Rücktaste. Dieser ist ziemlich einfach. Ersetzen Sie einfach jedes [B]mit Ctrl-h, was in vim der Rücktaste entspricht.

• [C]: Kopieren Sie alles, was bereits geschrieben wurde. Dies wird übersetzt in <esc>0y$A. Das heisst:

  <esc>      " Escape to normal mode
       0     " Move to the beginning of this line
        y$   " Yank to the end of the line
          A  " Re enter insert mode at the end of this line.
  

  Wir konnten fast nicht einfach Yan Stelle von 0y$dem Mittel „riss die ganze Linie“, aber das greift auch eine neue Zeile , dass wir nicht wollen.

• [D]: alles löschen, was geschrieben wurde. Das ist <esc>"_S. <esc>Beendet wie zuvor den Einfügemodus, damit wir Befehle ausführen können. Es gibt einige Dinge, die hier bequemer sind. So machen wir es

    S         " Delete this whole line and enter insert mode again
  "_          " Send it to 'the black hole register'. This is just so that we don't overwrite the main register.
  

• [P]: Füge ein, was kopiert wurde. Dieser ist auch sehr einfach. Es ist nur <C-r>"was bedeutet Insert the contents of register '"'. "Zufällig ist es das Hauptregister, zu dem 'y' gehört.

Nachdem wir alle Befehle übersetzt haben, müssen wir alle Zeilen miteinander verbinden, indem wir alle Zeilenumbrüche entfernen. Dank unseres Mappings ist dies gerecht

s<bs>\n

Das <bs>ist ein Backspace (ASCII 0x08) und wir brauchen es, weil [wir es ausgefüllt haben.

Inzwischen haben wir die Eingabe in VIM-Code übersetzt und müssen ihn nur noch ausführen. Also wir:

S           " Delete this whole line and enter insert mode
 <C-r>"     " Insert the keystrokes of register '"' as if they were typed by the user

CJam , 33 Bytes

q~{_[`';"];""L~""]:L~"]\1>3b=}%s~

Probieren Sie es online!

Erläuterung

q~                                  Read an evaluate input list.
  {                          }%     Map over each string in it:
   _                                 Duplicate the string, say S.
    [`';"];""L~""]:L~"]              Replace it the following list:
                                      [repr(S) '; "];" "L~" "]:L~"]
                       \             Bring S on top of the stack.
                        1>           Chop off the first char.
                          3b         Base-3 conversion.
                            =        Modular index into the list.
                               s~   Concatenate and run as CJam code.

Die "Hash-Funktion" 1>3bKarten

• Einzelzeichenketten bis 0 (= 0 mod 5),
• [B]bis 291 (= 1 mod 5),
• [D]bis 297 (= 2 mod 5),
• [P]bis 333 (= 3 mod 5),
• [C]bis 294 (= 4 mod 5).

Dieser Wert (Mod 5) wird als Index für eine Liste von CJam-Codeausschnitten verwendet:

• Bei Einzelzeichenfolgen hwird beispielsweise das Snippet "h"zurückgegeben, wodurch eine Einzelzeichenfolge auf den Stapel verschoben wird.
• Für [B]wird das Snippet ;zurückgegeben, das ein Element öffnet.
• Für [D]wird das Snippet ];zurückgegeben, wodurch der Stapel gelöscht wird.
• Für [P]wird das Snippet L~zurückgegeben, das Variable Lan den Stapel anfügt .
• Für [C]wird das Snippet ]:L~zurückgegeben, das den aktuellen Stack in der Variablen speichert L.

Diese Snippets werden verkettet und ausgeführt. Der letzte Stapel wird implizit von CJam gedruckt. LIst anfangs die leere Liste, so ist der Kopierpuffer anfangs "leer".

Python 2, 96 95 93 Bytes

r=c=""
for o in input():c=[c,r][x=="[C]"];r=[r+c,r[:-1],r,"",r+o][ord(o[1:2]or"E")%5]
print r

Jelly , 50 51 48 Bytes

Ṿ”;;µṭ“Ṗ“ø©“ḣ0“;®”
L>1a2ị$i@“BCDP0”ịÇ
Ç€“⁶Ṗ©”;FV

TryItOnline
Oder alle Testfälle

Wie?

Ṿ”;;µṭ“Ṗ“ø©“ḣ0“;®” - Link 1, CreateCodeLookupValueList: keystroke
      “Ṗ“ø©“ḣ0“;®” - list of strings, ["Ṗ","ø©","ḣ0"";®"] - these are Jelly code for:
                         Ṗ  : pop (i.e. delete last entry)
                         ø© : niladic separation and copy to register (i.e. copy)
                         ḣ0 : head to 0 (i.e. delete all entries)
                         ;® : concatenate with value of register (i.e. paste)
    µ              - monadic chain separation
Ṿ                  - uneval - make a Jelly code version of the keystroke
                                               e.g. "I" -> "“I”"
 ”;                - string literal ";"                      |
   ;               - concatenate e.g. ";I"                   v
     ṭ             - tack, to make the list ["Ṗ","ø©",";®","“I”"] 
                             a keystroke - a command will evaluate to a string like
                             "“[C]”" but wont be accessed)

L>1a2ị$i@“BCDP0”ịÇ - Link 2, ConvertAKeystokeToJellyCodeString: keystroke
L>1                - length greater than 1? (i.e. isCommand?)
      $            - last two links as a monad
   a               - and
    2ị             - index 2 of the keystroke (0 due to and for a passive keystroke)
         “BCDP0”   - Literal string "BCP0"
       i@          - find first matching index of, with reversed arguments
                ị  - index into
                 Ç - call last link (1) as a monad (get code to replace this keystroke)

Ç€“⁶Ṗ©”;FV - Main link: list of keystrokes
Ç€         - call last link (2) as a monad (convert to Jelly code)
  “⁶Ṗ©”    - literal string "⁶Ṗ©" - setup the register with an empty string:
                 ⁶ :literal " ";
                 Ṗ : pop the space to give an empty string;
                 © : places it into the register
       ;   - concatenate (put that at the front)
        F  - flatten list (lists and strings are equivalent in Jelly)
         V - evaluate the string

Beispielsweise

The input:
    ['e', '[C]', '[B]', 'I', ' ', 'l', 'i', 'k', '[P]', ' ', 'B', '[P]', '[P]', 's', '!']
Becomes the Jelly code:
    "⁶Ṗ©;“e”ø©Ṗ;“I”;“ ”;“l”;“i”;“k”;®;“ ”;“B”;®;®;“s”;“!”"
Which then evaluates to
    "I like Bees!"

- mit einem Kapital 'B'als Testfall, da es zurückgekehrt wäre, bevor ich einen Fehler behoben habe"I likeees!"

JavaScript (ES6), 84 80 77 76 Byte

3 Bytes dank @Neil gespeichert, 1 dank @ edc65

x=>x.reduce((s,[c,z])=>z<'C'?s.slice(0,-1):z<'D'?t=s:z<'P'?"":s+=z?t:c,t="")

.map ist zwei Bytes länger:

x=>x.map(([c,z])=>s=z<'C'?s.slice(0,-1):z<'D'?t=s:z<'P'?"":s+=z?t:c,s=t="")&&s

Testschnipsel

f=x=>x.reduce((s,[c,z])=>z<'C'?s.slice(0,-1):z<'D'?t=s:z<'P'?"":s+=z?t:c,t="")

console.log(f(['e', '[C]', '[B]', 'I', ' ', 'l', 'i', 'k', '[P]', ' ', 'b', '[P]', '[P]', 's', '!']))

<button onclick="console.log(f(I.value.split('\n')))">Run</button>
<br><textarea id=I rows=10>H
e
l
l
o
 
[C]
[P]</textarea><br>

Perl, 53 50 Bytes

Beinhaltet +1 für -p

Geben Sie eine Eingabe in STDIN ein, die durch Zeilenumbrüche abgeschlossen wird (die letzte Zeile kann weggelassen werden, sodass sie als durch Zeilenumbrüche getrennte Zeichenfolge gilt):

keystrokes.pl
H
e
[C]
[D]
a
b
[B]
[P]
z
^D

gibt

aHez

keystrokes.pl:

#!/usr/bin/perl -p
$\.=/^.$/?$&:/P/?$a:(/C/?$a=$\:chop($\x=/B/))x0}{

Fast erwischt die Gelee-Antwort, aber der Unhold entkam auf 48 Bytes ...

Python 120 119 116 Bytes

f=lambda s,r='',c='':f(s[1:],*{'B':(r[:-1],c),'C':(r,r),'D':('',c),'P':(r+c,c),'':(r+s[0],c)}[s[0][1:2]])if s else r

Ideone

Eine rekursive Funktion mit Eingabe, seine Liste der Tastenanschläge.

Jeder rekursive Aufruf aktualisiert den Rückgabetext rund im Fall von a [C]die Zwischenablage, cbis sleer ist.

Die neuen Werte von rund cwerden durch Indizieren in ein Wörterbuch gefunden {...}und beim Entpacken übergeben *. Für die passiven Tastenanschläge s[0][1:2]wird eine leere Zeichenfolge zurückgegeben und der Schlüssel ''wird stattdessen verwendet.

Haskell, 136 133 130 127 Bytes

k c b(('[':m:_):i)|m<'C'=k c[q|b>"",q<-init b]i|m<'D'=k b b i|m<'P'=k c""i|1<3=k c(b++c)i
k c b(s:i)=k c(b++s)i
k c b[]=b
k""""

Probieren Sie es auf Ideone.

Erläuterung: k Führt eine Endrekursion über eine Liste von Befehlen durch. bIst der Puffer, in dem der String aufgebaut ist, cspeichert der kopierte Teil.

k c b ("[B]":i) = k c (take(length b - 1)b) i -- remove last element of buffer
k c b ("[C]":i) = k b b i                     -- set copy to buffer
k c b ("[D]":i) = k c "" i                    -- clear the buffer
k c b ("[P]":i) = k c (b++c) i                -- append content of copy to the buffer
k c b (s:i)     = k c (b++s) i                -- append char to the buffer
k c b []        = b                           -- command list is empty, return buffer
f = k "" ""                                   -- initialise copy and buffer with empty strings

Bearbeiten: Um einige Bytes zu speichern, werden die Befehle [B][C][D][P]nicht mehr genau verglichen, sondern: kleiner als 'C'? -> Bund so weiter. Vielen Dank an @nimi für das Speichern von 3 Bytes.

Mathematica, 100 Bytes

""<>Fold[Switch[#2,"[B]",Most@#~Check~{},"[C]",a=#,"[D]",{},"[P]",#~Join~a,_,Append@##]&,a={};{},#]&

Anonyme Funktion. Nimmt eine Liste von Zeichenfolgen als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück. Ignorieren Sie alle generierten Nachrichten.

Java 7, 207 203 Bytes

String c(String[]a){String r="",c=r;for(String s:a){int k=s.length(),l=r.length(),z;if(k>1){z=s.charAt(1);r=z<67?l>0?r.substring(0,l-1):"":z<68?r:z<69?"":z<81?r+c:r+s;c=z==67?r:c;}r+=k<2?s:"";}return r;}

Dies kann auf jeden Fall noch etwas mehr Golf gespielt werden, aber dies ist meine erste Antwort. Wird bearbeiten , nachdem ich etwas , diese zu entfernen gefunden equals-Checks .. ersetzt mit charAt, kann aber wahrscheinlich noch golfed werden ..

Ungolfed & Testcode:

Probieren Sie es hier aus.

class M{
  static String c(final String[] a) {
    String r = "",
           c = r;
    for(String s : a){
      int k = s.length(),
          l = r.length(),
          z;
      if(k > 1){
        z = s.charAt(1);
        r = z < 67
             ? l > 0
                ? r.substring(0, l-1)
                : ""
             : z < 68
                ? r
                : z < 69
                   ? ""
                   : z < 81
                      ? r + c
                      : r + s;
        c = z == 67
             ? r
             : c;
      }
      r += k < 2
            ? s
            : "";
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(new String[]{ "H", "e", "l", "l", "o" }));
    System.out.println(c(new String[]{ "H", "e", "l", "l", "o", " ", "[C]", "[P]" }));
    System.out.println(c(new String[]{ "[D]", "D", "[B]" }));
    System.out.println(c(new String[]{ "H", "[C]", "i", "[P]", "[C]", "[P]" }));
    System.out.println(c(new String[]{ "e", "[C]", "[B]", "I", " ", "l", "i", "k", "[P]", " ", "b", "[P]", "[P]", "s", "!" }));
    System.out.println(c(new String[]{ "N", "[P]" }));
    System.out.println(c(new String[]{ "#", "5", "0", "K", "0", "0", "1", "[D]", "#", "n", "o", "t" }));
    System.out.println(c(new String[]{ "H", "o", "w", " ", "[D]", "H", "e", "y" }));
    System.out.println(c(new String[]{ "s", "u", "d", "[B]", "p", "[C]", "[D]", "I", " ", "h", "a", "v", "e", " ", "[P]", "p", "e", "r", "!" }));
  }
}

Ausgabe:

Hello
Hello Hello 

HiHHiH
I like bees!
N
#not
Hey
I have supper!

PHP, 131 Bytes

17 Bytes werden durch den ternären Operator @IsmaelMiguel gespeichert

<?$c=[];foreach($_GET[a]as$v)($t=$v[1])!=P?$t!=C?$t!=B?$t!=D?$o[]=$v:$o=[]:array_pop($o):$c=$o:$o=array_merge($o,$c);echo join($o);

PHP, 108 Bytes

for(;null!==$s=$argv[++$i];)($g=$s[1])!=B?$g!=C?$g!=D?$o.=$g!=P?$s:$c:$o='':$c=$o:$o=substr($o,0,-1);echo$o;

Verwendet einen stringbasierten Ansatz anstatt eines arraybasierten.

Verwenden Sie wie:

php -r "for(;null!==$s=$argv[++$i];)($g=$s[1])!=B?$g!=C?$g!=D?$o.=$g!=P?$s:$c:$o='':$c=$o:$o=substr($o,0,-1);echo$o;" a b "[C]" "[B]" "[P]" "[C]" "[D]" j "[P]"

edit: 8 Bytes wurden gespeichert, indem die Reihenfolge der?: s geändert und negativ gemacht wurde, um zu vermeiden, dass so viele Klammern verwendet werden müssen.

SpecBAS - 216 Bytes

1 s$,t$="": INPUT a$: DIM b$(SPLIT a$,NOT ",")
2 FOR EACH l$ IN b$()
3 CASE l$
4 WHEN "[B]": s$=s$( TO LEN s$-1)
5 WHEN "[C]": t$=s$
6 WHEN "[D]": s$=""
7 WHEN "[P]": s$=s$+t$
8 OTHERWISE : s$=s$+l$
9 END CASE
10 NEXT l$: ?s$

Die Eingabe erfolgt als Zeichenfolge mit Kommas, die dann in ein Array umgewandelt wird.

V , 49 Bytes

íÛBÝ/
íÛCÝ/0y$A
íÛDÝ/"_S
íÛPÝ/"
íî
0éiD@"

Probieren Sie es online!

Da dies nicht druckbare Zeichen enthält, ist hier ein Hexdump:

0000000: eddb 42dd 2f16 080a eddb 43dd 2f16 1b30  ..B./.....C./..0
0000010: 7924 410a eddb 44dd 2f16 1b22 5f53 0aed  y$A...D./.."_S..
0000020: db50 dd2f 1612 220a edee 0a30 e969 4440  .P./.."....0.iD@
0000030: 22

Dies ist nur eine direkte Übersetzung meiner Antwort, damit ich mit Jelly mithalten kann. Leider bin ich immer noch ein Byte vorüber, aber ich arbeite immer noch an dem letzten. :)

Auf diese Antwort bin ich sowieso stolzer. Wenn Sie also eine sehr ausführliche Erklärung wünschen, lesen Sie diese stattdessen.

Eigentlich 56 Bytes

''j"'[B]"'XaÆ"'[C]""k;╗i"aÆ"'[P]""╜i"aÆ"'[D]"'éaÆ''+ƒkΣR

Probieren Sie es online!

Erläuterung:

''j"'[B]"'XaÆ"'[C]""k;╗i"aÆ"'[P]""╜i"aÆ"'[D]"'éaÆ''+ƒkΣR
''j                                                       insert an apostrophe between every pair of commands
   "'[B]"'XaÆ"'[C]""k;╗i"aÆ"'[P]""╜i"aÆ"'[D]"'éaÆ         replace:
   "'[B]"'XaÆ                                               "'[B]" with "X"
             "'[C]""k;╗i"aÆ                                 "'[C]" with "k;╗i"
                           "'[P]""╜i"aÆ                     "'[P]" with "╜i"
                                       "'[D]"'éaÆ           "'[D]" with "é"
                                                 ''+      prepend an apostrophe
                                                          now the input has been converted to the equivalent Actually program ("'<character>" pushes the character, "X" removes the last character, "k;╗i" saves the current stack state to a register, and "╜i" pushes the saved stack state)
                                                    ƒ     execute the code
                                                     kΣ   concatenate the characters
                                                       R  reverse the string

Java, 181

String v(String[]a){String r="",c=r;for(String s:a){try{int p=s.charAt(1)%5;r=p<1?r+c:p>2?"":p==1?r.length()<2?"":r.split(".$")[0]:r;c=p==2?r:c;}catch(Exception e){r+=s;}}return r;}

Mehr lesbare Version:

String v(String[]a){
    String r="",c=r;
    for(String s:a){
        try{
            int p=s.charAt(1)%5;
            r= p<1
                 ? r+c
                 : p>2
                    ? ""
                    :p==1
                        ? r.length()<2
                                     ?""
                                     :r.split(".$")[0]
                        :r;
            c=p==2?r:c;
        }catch(Exception e){
            r+=s;
        }
    }return r;
}

MATL , 46 Bytes

vXKx"@gtnq?2)XJ66=?3L)}J67=?XK}J68=?vx}K]]]]&h

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

v                % Push empty array
XK               % Copy to clipboard K. This initiallizes it as empty
x                % Delete
"                % Implicitly input cell array. For each
  @g             % Push current cell's contents
  t              % Duplicate elements
  n              % Number of elements
  q?             % If more then 1
    2)           % Get second char. Copy to clipboard J
    66=?         % If it ss 'B'
      3L)        % Remove last element from string built up to now
    }            % Else
      J67=?      % If it was a 'C'
        XK       % Copy string built up to now into clipboard K
      }          % Else
        J68=?    % If was a 'D'
          vx     % Delete stack. This deletes string built up to now, if any
        }        % Else: it was a 'P'
          K      % Paste from clipboard K
        ]        % End if
      ]          % End if
    ]            % End if
  ]              % End if
  &h             % Horizontally concatenate stack
                 % Implicitly end for
                 % Implicitly display

TCL, 186 Bytes

proc t w {foreach "B C P N D r Q" [list {[string range $r 0 end-1]} {[set Q $r]} {$r$Q} {$r$g}] break;foreach g $w {eval "set c \$[string index ${g}N 1]";eval "set r \"$c\""};return $r}

Schön formatiert:

proc t w {
    foreach "B C P N D r Q" [list {[string range $r 0 end-1]} {[set Q $r]} {$r$Q} {$r$g}] break;
    foreach g $w {
        eval "set c \$[string index ${g}N 1]"
        eval "set r \"$c\""
    }
    return $r
}

Ich wollte nur beweisen, dass ich das in TCL kann

Scala, 158 Bytes

(i:Seq[String])=>(("","")/:i){case((a,c),k)=>if(k.size<2)(a+k,c)else
if(k=="[B]")(a dropRight 1,c)else
if(k=="[C]")(a,a)else
if(k=="[D]")("",c)else(a+c,c)}._1

Ungolfed:

(i:Seq[String]) => i.foldLeft(("", "")){
  case ((res,clipboard),key) =>
    if (k.size == 1) (res+key,clipboard)
    else if (k=="[B]") (res dropRight 1, clipboard)
    else if (k=="[C]") (res, res)
    else if (k=="[D]") ("", clipboard)else(acc+clipboard,clipboard)
}._1

Löst dieses Problem als Falte mit dem Ergebnis und der Zwischenablage als Akkumulator. Leider hat scala keinen ternären bedingten Operator, sondern wird if elseals Ausdruck verwendet.

PHP 7.1, 95 92 Bytes

Hinweis: Benötigt PHP 7.1 für negative String-Offsets.

for(;n|$i=$argv[++$x];)($l=$i[1])?$l^r?$l^s?$l^t?$o.=$c:$o="":$c=$o:$o[-1]="":$o.=$i;echo$o;

Ohne negative String-Offsets (101 Bytes):

php -r 'for(;n|$i=$argv[++$x];)($l=$i[1])?$l^r?$l^s?$l^t?$o.=$c:$o="":$c=$o:$o=substr($o,0,-1):$o.=$i;echo$o;' e [C] [B] I ' ' l i k [P] ' ' b [P] [P] s ! 2>/dev/null;echo

Laufen Sie wie folgt:

php -nr 'for(;n|$i=$argv[++$x];)($l=$i[1])?$l^r?$l^s?$l^t?$o.=$c:$o="":$c=$o:$o[-1]="":$o.=$i;echo$o;' e [C] [B] I ' ' l i k [P] ' ' b [P] [P] s !;echo
> I like bees!

Erläuterung

for(
  ;
  n|$i=$argv[++$x];   # Iterates over the input until null.
)
  ($l=$i[1])?         # Check if this item is a command, if so set to $l
    $l^r?             # If the command is not B
      $l^s?           # If the command is not C
        $l^t?         # If the command is not D
          $o.=$c      # Then it's P, so paste the clipboard ($c)
        :$o=""        #      It's D, so delete output
      :$c=$o          #      It's C, so copy output to clipboard
    :$o[-1]=""        #      It's B, so remove the last output char
  :$o.=$i;            # No command, add the current item to the output.

echo$o;               # Print the output.

Optimierungen

• Einsparung von 3 Bytes durch Kombination des Output-Handlings mit dem Command-Handling