Votre travail consiste à simuler deux frappes de touche saisies par un utilisateur.

Contribution

Un tableau de chaînes ou une chaîne avec un délimiteur de votre choix (en dehors de la plage 32-126) contenant au moins une «touche».

Ce tableau ne contiendra que deux types de chaînes: les frappes au clavier passives (un seul caractère) et les commandes (le caractère entre parenthèses [ ]).

• Frappes passives
  1. Codes de caractères ASCII [32-126]
• Commandes:
  1. [B] : backspace (supprime le dernier caractère ajouté s'il y en a un)
  2. [C] : copier tout ce qui a déjà été écrit
  3. [D] : efface tout ce qui a été écrit
  4. [P] : coller ce qui a été copié

Sortie

La chaîne produite par les frappes.

Exemples

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

C'est du code-golf , donc le code le plus court en octets gagne!

05AB1E , 34 33 31 27 octets

Utilise le codage CP-1252 .

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

Essayez-le en ligne!

Explication

õ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

Les paires de fonctions évaluées dans le code ci-dessus sont:

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 

Sauvegardé 4 octets en utilisant le mod 5truc de Lynn's CJam answer

Vim, 76, 64, 62 , 58 frappes

Merci à Loovjo pour avoir économisé 7 frappes de touche

Est-ce que quelqu'un a dit simuler des frappes? Eh bien, c’est une bonne chose que ma langue préférée pour jouer au golf consiste à simuler les frappes au clavier!

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

L'entrée se présente sous ce format:

h
e
l
l
o

[C]
[P]

C'est une réponse assez simple. Cela traduit simplement chaque "commande" en l'équivalent de frappe de vim de cette commande. Prenons-le ligne par ligne.

:no s :%s/\M[

Cela économise une tonne d'octets. Vim a une "ligne de commande" intégrée dans laquelle vous pouvez créer des mappages, modifier les paramètres, enregistrer des fichiers, etc. Nous créons ici un mappage. :noest l'abréviation de :nnoremapce qui signifie "Lorsque nous sommes en mode normal, remplace ce côté gauche par ce côté droit". Comme nous appelons :%s/ cinq fois , cela économise beaucoup. Le \Mest un bon tour. Cela signifie que la recherche suivante sera "Very No Magic", ce qui signifie que l'expression régulière [B]correspondra au texte littéral [B]plutôt qu'à une plage contenant uniquement un B dans celui-ci. Étant donné que la majorité des commandes de remplacement comportent des crochets, nous complétons le premier.

Ensuite, nous appelons cinq commandes de substitution. Il faut savoir pourquoi j'ai appelé <C-v>tant de fois. Des personnages comme <esc>, <C-v>, <C-r>, etc. sont des caractères non imprimables, et doivent être tapés dans la ligne de commande avec <C-v>.

• [B]: retour arrière. Celui-ci est assez simple. Il suffit de substituer chacun [B]avec Ctrl-h, ce qui équivaut à un retour arrière dans vim.

• [C]: copie tout ce qui a déjà été écrit. Ceci est traduit en <esc>0y$A. Ça signifie:

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

  Nous pourrions presque simplement faire Yà la place de 0y$ce qui signifie "tirer la ligne entière", mais cela saisit également une nouvelle ligne que nous ne voulons pas.

• [D]: efface tout ce qui a été écrit. C'est <esc>"_S. Comme précédemment, <esc>quitte le mode insertion pour pouvoir exécuter des commandes. Certaines choses sont plus pratiques ici. Donc nous faisons

    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]: coller ce qui a été copié. Celui-ci est également très simple. C'est juste <C-r>"ce qui veut dire Insert the contents of register '"'. "se trouve être le registre principal que «y» tire.

Maintenant que nous avons traduit toutes les commandes, nous devons joindre toutes les lignes en supprimant tous les caractères de nouvelle ligne. Grâce à notre cartographie, c'est juste

s<bs>\n

Le <bs>est un backspace, (ASCII 0x08) et nous en avons besoin à cause du fichier [rempli.

À ce jour, nous avons traduit l'entrée en code vim et nous devons juste l'exécuter. Alors on:

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 octets

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

Essayez-le en ligne!

Explication

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.

Les 1>3bcartes «fonction de hachage»

• Chaînes de caractères uniques à 0 (= 0 mod 5),
• [B]à 291 (= 1 mod 5),
• [D]à 297 (= 2 mod 5),
• [P]à 333 (= 3 mod 5),
• [C]à 294 (= 4 mod 5).

Cette valeur (mod 5) est utilisée comme index dans une liste d'extraits de code CJam:

• Par exemple h, pour les chaînes à caractère unique , l'extrait "h"est renvoyé, ce qui pousse une chaîne à caractère unique vers la pile.
• Pour [B], l'extrait ;est renvoyé, ce qui fait apparaître un élément.
• Pour [D], l'extrait ];est renvoyé, ce qui efface la pile.
• Pour [P], l'extrait L~est retourné, ce qui ajoute une variable Là la pile.
• Pour [C], l'extrait ]:L~est renvoyé, ce qui stocke la pile actuelle dans la variable L.

Ces extraits sont concaténés et exécutés; la pile finale est imprimée implicitement par CJam. Lest initialement la liste vide, donc le tampon de copie est initialement "vide".

Python 2, 96 95 93 octets

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

Gelée , 50 51 48 octets

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

TryItOnline
Ou tous les cas de test

Comment?

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

Par exemple

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

- avec une majuscule 'B'comme cas de test, car avant que je corrige un bug, il serait retourné"I likeees!"

JavaScript (ES6), 84 80 77 76 octets

3 octets sauvés grâce à @Neil, 1 plus grâce à @ 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 est deux octets plus long:

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

Extrait de test

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 octets

Inclut +1 pour -p

Donne une entrée sur STDIN terminée par des nouvelles lignes (la dernière nouvelle ligne peut être omise, elle compte donc comme une chaîne séparée par des nouvelles lignes):

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

donne

aHez

keystrokes.pl:

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

J'ai presque attrapé la réponse, mais le démon s'est échappé à 48 octets ...

Python 120 119 116 octets

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

Une fonction récursive avec entrée,, sune liste des touches.

Chaque appel récursif met à jour le texte de retour ret, dans le cas d'un [C]clipboard, cjusqu'à ce qu'il ssoit vide.

Les nouvelles valeurs ret csont par indexation dans trouvent un dictionnaire, {...}et passé avec le déballage, *. Pour les frappes passives s[0][1:2], une chaîne vide sera retournée et la clé ''sera utilisée à la place.

Haskell, 136 133 130 127 octets

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

Essayez-le sur Ideone.

Explanation: k effectue une récursion sur une liste de commandes. best la mémoire tampon dans laquelle la chaîne est construite, cenregistre la partie copiée.

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

Edit: Pour sauvegarder quelques octets, les commandes [B][C][D][P]ne sont plus exactement identiques mais comparées: moins que 'C'? -> Bet ainsi de suite. Merci à @nimi pour la sauvegarde de 3 octets.

Mathematica, 100 octets

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

Fonction anonyme. Prend une liste de chaînes en entrée et retourne une chaîne en sortie. Ignorer les messages générés.

Java 7, 207 203 octets

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

Cela peut certainement être joué davantage, mais c’est ma première réponse. Je vais éditer après avoir trouvé quelque chose à supprimer ces equals-checks .. remplacé par charAt, mais peut probablement encore être joué au golf ..

Non testé et code de test:

Essayez ici.

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

Sortie:

Hello
Hello Hello 

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

PHP, 131 octets

17 octets sauvegardés par l'opérateur ternaire @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 octets

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;

Utilise une approche basée sur les chaînes plutôt que sur les tableaux.

Utilisez comme:

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: sauvegardé 8 octets en modifiant l'ordre des?: s en les rendant négatifs pour éviter d'avoir à utiliser autant de crochets;

SpecBAS - 216 octets

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$

L'entrée est donnée sous forme de chaîne avec des virgules, qui sont ensuite transformées en tableau.

V , 49 octets

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

Essayez-le en ligne!

Puisque cela contient des caractères non imprimables, voici 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

Ceci est juste une traduction directe de ma réponse vim afin que je puisse rivaliser avec Jelly. Malheureusement, je suis toujours un octet de plus, mais je travaille toujours sur le dernier. :)

De toute façon, je suis plus fier de cette réponse, alors si vous voulez une explication très détaillée, lisez plutôt celle-là.

En fait, 56 octets

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

Essayez-le en ligne!

Explication:

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

Version plus lisible:

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 octets

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

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}

Joliment formaté:

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
}

Je voulais juste prouver que je pouvais le faire dans TCL

Scala, 158 octets

(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

Résout ce problème en tant que pli avec le résultat et le presse-papiers en tant qu'accumulateur. Malheureusement, scala n'a pas d'opérateur conditionnel ternaire, mais utilise plutôt if elseune expression.

PHP 7.1, 95 92 octets

Remarque: nécessite PHP 7.1 pour les décalages de chaîne négatifs.

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;

Sans décalage de chaîne négatif (101 octets):

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

Courez comme ça:

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!

Explication

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.

Tweaks

• 3 octets enregistrés en combinant le traitement de sortie avec le traitement de commande