Su trabajo es simular un par de pulsaciones de teclas que escribe un usuario.

Entrada

Un conjunto de cadenas o cadenas con un delimitador de su elección (fuera del rango 32-126) que contiene al menos una 'pulsación de tecla'.

Esta matriz solo contendrá dos tipos de cadenas: pulsaciones de teclas pasivas (caracteres únicos) y comandos (caracteres entre paréntesis [ ]).

• Pulsaciones de teclas pasivas
  1. Códigos de caracteres ASCII [32-126]
• Comandos:
  1. [B] : retroceso (eliminar el último carácter agregado si hay uno)
  2. [C] : copie todo lo que ya se ha escrito
  3. [D] : borra todo lo que se ha escrito
  4. [P] : pegar lo que se ha copiado

Salida

La cadena producida por las pulsaciones de teclas.

Ejemplos

['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!'

Este es el código de golf , por lo que gana el código más corto en bytes.

05AB1E , 34 33 31 27 bytes

Utiliza la codificación CP-1252 .

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

Pruébalo en línea!

Explicación

õ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

Los pares de funciones evaluadas en el código anterior son:

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 

Guardado 4 bytes usando el mod 5truco de la respuesta CJam de Lynn

Vim, 76, 64, 62 , 58 pulsaciones de teclas

Gracias a Loovjo por guardar 7 pulsaciones de teclas

¿Alguien dijo simular pulsaciones de teclas? Pues bien, es una buena cosa mi idioma preferido al golf en es todo acerca de las pulsaciones de teclas que simulan!

: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>"

La entrada viene en este formato:

h
e
l
l
o

[C]
[P]

Esta es una respuesta bastante directa. Simplemente traduce cada "comando" al equivalente de pulsación de tecla vim de ese comando. Tomémoslo línea por línea.

:no s :%s/\M[

Esto ahorra una tonelada de bytes. Vim tiene una "línea de comando" incorporada donde puede crear asignaciones, cambiar configuraciones, guardar archivos, etc. Aquí estamos creando una asignación. :noes la abreviatura de lo :nnoremapque significa "Cuando estamos en modo normal, sustituya este lado izquierdo por este lado derecho". Como estamos llamando :%s/ cinco veces diferentes , esto ahorra mucho. El \Mes un buen truco. Significa que la siguiente búsqueda será "Very No Magic", lo que significa que la expresión regular [B]coincidirá con el texto literal en [B]lugar de un rango que contenga solo una B en él. Como la mayoría de los comandos sustitutos tienen corchetes, completamos el primero.

Luego, llamamos a cinco comandos sustitutos. Vale la pena señalar por qué llamé <C-v>tantas veces. Los personajes como <esc>, <C-v>, <C-r>, etc, son caracteres no imprimibles, y se deben escribir en la línea de comandos con una <C-v>.

• [B]: retroceso. Esta es bastante fácil. Simplemente sustituya cada uno [B]con Ctrl-h, que es equivalente a retroceso en vim.

• [C]: copie todo lo que ya se ha escrito. Esto se traduce a <esc>0y$A. Esto significa:

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

  Casi podríamos hacer Yen lugar de lo 0y$que significa "tirar de toda la línea", pero esto también toma una nueva línea que no queremos.

• [D]: borra todo lo que se ha escrito. Esto es <esc>"_S. Como antes, <esc>sale del modo de inserción para que podamos ejecutar comandos. Hay algunas cosas que son más convenientes aquí. Entonces hacemos

    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]: pegar lo que se ha copiado. Este también es muy sencillo. Es solo lo <C-r>"que significa Insert the contents of register '"'. "resulta ser el registro principal al que 'y' tira.

Ahora que hemos traducido todos los comandos, debemos unir todas las líneas eliminando todos los caracteres de nueva línea. Gracias a nuestro mapeo, esto es solo

s<bs>\n

El <bs>es un retroceso, (ASCII 0x08) y lo necesitamos debido a [que lo completamos.

Por ahora, hemos traducido la entrada al código vim, y solo necesitamos ejecutarla. Así que nosotros:

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~

Pruébalo en línea!

Explicación

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.

Los 1>3bmapas de "función hash"

• cadenas de un solo carácter a 0 (= 0 mod 5),
• [B]a 291 (= 1 mod 5),
• [D]a 297 (= 2 mod 5),
• [P]a 333 (= 3 mod 5),
• [C]a 294 (= 4 mod 5).

Este valor (mod 5) se utiliza como índice en una lista de fragmentos de código CJam:

• Para cadenas de un solo carácter, digamos h, "h"se devuelve el fragmento , que empuja una cadena de un solo carácter a la pila.
• Para [B], ;se devuelve el fragmento , que muestra un elemento.
• Para [D], ];se devuelve el fragmento , lo que borra la pila.
• Para [P], L~se devuelve el fragmento , que agrega variable La la pila.
• Para [C], ]:L~se devuelve el fragmento , que almacena la pila actual en la variable L.

Estos fragmentos se concatenan y ejecutan; CJam imprime implícitamente la pila final. Les inicialmente la lista vacía, por lo que el búfer de copia está inicialmente "vacío".

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

Jalea , 50 51 48 bytes

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

TryItOnline
o todos los casos de prueba

¿Cómo?

Ṿ”;;µṭ“Ṗ“ø©“ḣ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

Por ejemplo

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!"

- con mayúscula 'B'como caso de prueba, ya que antes de arreglar un error, habría regresado"I likeees!"

JavaScript (ES6), 84 80 77 76 bytes

Guardado 3 bytes gracias a @Neil, 1 más gracias a @ 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 es dos bytes más largo:

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

Fragmento de prueba

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

Incluye +1 para -p

Proporcione información sobre STDIN terminada por líneas nuevas (la última línea nueva puede omitirse, por lo que cuenta como una cadena separada por líneas nuevas):

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

da

aHez

keystrokes.pl:

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

Casi capté la respuesta de Jelly pero el demonio escapó a 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

Ideona

Una función recursiva con entrada, suna lista de las pulsaciones de teclas.

Cada llamada recursiva actualiza el texto de retorno ry, en el caso de a [C], el portapapeles, chasta que sesté vacío.

Los nuevos valores de ry cson encontrados por la indexación en un diccionario, {...}y pasaron con el desembalaje, *. Para las pulsaciones de teclas pasivas, s[0][1:2]se devolverá una cadena vacía y ''se utilizará la tecla en su lugar.

Haskell, 136133 130127 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""""

Pruébalo en Ideone.

Explicación: k realiza una recursión de cola sobre una lista de comandos. bes el búfer en el que se construye la cadena, cguarda la parte copiada.

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

Editar: para guardar algunos bytes, los comandos [B][C][D][P]ya no coinciden exactamente, sino que se comparan: ¿menos que 'C'? -> By así sucesivamente. Gracias a @nimi por guardar 3 bytes.

Mathematica, 100 bytes

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

Función anónima. Toma una lista de cadenas como entrada y devuelve una cadena como salida. Ignora cualquier mensaje generado.

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

Esto definitivamente se puede jugar un poco más, pero esta es mi respuesta inicial. Se editará después de encontrar algo para eliminar esas equalsverificaciones ... reemplazado porcharAt , pero probablemente todavía se puede jugar golf ...

Ungolfed y código de prueba:

Pruébalo aquí.

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", "!" }));
  }
}

Salida:

Hello
Hello Hello 

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

PHP, 131 bytes

17 bytes guardados por el operador ternario @IsmaelMiguel

<?$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;

Utiliza un enfoque basado en cadenas en lugar de uno basado en una matriz.

Usar como:

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: ahorró 8 bytes al modificar el orden de los?: sy hacerlos negativos para evitar tener que usar tantos corchetes;

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$

La entrada se da como una cadena con comas, que luego se convierte en una matriz.

V , 49 bytes

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

Pruébalo en línea!

Como esto contiene caracteres no imprimibles, aquí hay un 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

Esta es solo una traducción directa de mi respuesta vim para poder competir con Jelly. Desafortunadamente, todavía estoy un byte terminado, pero todavía estoy trabajando en el último. :)

De todos modos, estoy más orgulloso de esa respuesta, así que si quieres una explicación muy detallada, lee esa en su lugar.

En realidad, 56 bytes

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

Pruébalo en línea!

Explicación:

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

Versión más legible:

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

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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}

Bien formateado:

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
}

Solo quería demostrar que podía hacer esto en TCL

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

Sin golf:

(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

Resuelve este problema como un pliegue con el resultado y el portapapeles como acumulador. Lamentablemente, scala no tiene un operador condicional ternario, sino que lo usa if elsecomo una expresión.

PHP 7.1, 95 92 bytes

Nota: requiere PHP 7.1 para las compensaciones de cadena negativas.

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;

Sin compensaciones de cadena negativas (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

Corre así:

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!

Explicación

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.

Ajustes

• Guardado 3 bytes combinando el manejo de salida con el manejo de comando