33

आपका काम किस्ट्रोक्स के एक जोड़े का अनुकरण करना है जो एक उपयोगकर्ता प्रकार है।

इनपुट

कम से कम एक 'कीस्ट्रोक' युक्त अपनी पसंद के सीमांकक (सीमा 32-126 के बाहर) के साथ एक स्ट्रिंग सरणी या स्ट्रिंग।

इस सरणी में केवल दो प्रकार के स्ट्रिंग होंगे: निष्क्रिय कीस्ट्रोक (एकल वर्ण) और कमांड (कोष्ठक के भीतर वर्ण [ ])।

निष्क्रिय कीस्ट्रोक्स
1. ASCII वर्ण कोड [32-126]
आदेश:
1. [B] : बैकस्पेस (यदि कोई है तो अंतिम वर्ण हटा दें)
2. [C] : जो पहले से ही लिखा गया है, उसकी नकल करें
3. [D] : जो लिखा गया है, उसे हटा दें
4. [P] : जो कॉपी किया गया है उसे पेस्ट करें

उत्पादन

कीस्ट्रोक्स द्वारा निर्मित स्ट्रिंग।

उदाहरण

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

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है!

code-golf string

— डैनियल
स्रोत

FYI करें मुझे अपने कोड में एक बग मिला, क्या मैं मधुमक्खियों के लिए एक राजधानी बी के साथ एक परीक्षण का मामला सुझा सकता हूं :)

— जोनाथन एलन

एक उदाहरण भी होना चाहिए [D]जहां यह केवल एक ही उपयोग नहीं किया जाता है, इसलिए कोड सिर्फ split('[D]')[1]या कुछ नहीं होगा ।

— mbomb007

@ mbomb007, मैंने परीक्षण मामलों (# 8, # 9)

— डैनियल

और मुझे लगता है कि mbomb007 कई विलोपन के साथ एक परीक्षण के मामले के लिए पूछ रहा था।

— मार्टिन एंडर

@MartinEnder, ओह, मैंने सोचा था कि वह एक चाहता था जहाँ अन्य आदेश हैं[D]

— डैनियल

7

05AB1E , 34 33 31 27 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

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

इसे ऑनलाइन आज़माएं!

व्याख्या

õ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

उपरोक्त कोड में मूल्यांकन किए गए कार्यों के जोड़े हैं:

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

लिन के CJam उत्तरmod 5 से चाल का उपयोग करके 4 बाइट्स सहेजे गए

— Emigna
स्रोत

34

विम, 76, 64, 62 , 58 कीस्ट्रोक्स

7 कीस्ट्रोक्स को बचाने के लिए लोजोवो का धन्यवाद

क्या किसी ने कहा कि कीस्ट्रोक्स अनुकरण? तो फिर, यह एक अच्छी बात है कि गोल्फ में मेरी पसंदीदा भाषा किस्ट्रोक्स के अनुकरण के बारे में है !

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

इनपुट इस प्रारूप में आता है:

h
e
l
l
o

[C]
[P]

यह एक बहुत ही सीधा सा जवाब है। यह सिर्फ प्रत्येक "कमांड" को उस कमांड के समतुल्य विम किस्ट्रोके में अनुवाद करता है। चलो इसे लाइन से लाइन लेते हैं।

:no s :%s/\M[

इससे बाइट्स का एक टन बच जाता है । विम में एक अंतर्निहित "कमांड लाइन" है जहां आप मैपिंग बना सकते हैं, सेटिंग्स बदल सकते हैं, फाइलें बचा सकते हैं, आदि। यहां हम मैपिंग बना रहे हैं। जिसके :noलिए संक्षिप्त :nnoremapअर्थ है "जब हम सामान्य मोड में होते हैं, तो इस दाहिने हाथ की ओर के लिए इस बाएं हाथ को स्थान दें।" चूंकि हम :%s/ पांच अलग-अलग समय पर कॉल कर रहे हैं , इससे बहुत बचत होती है। \Mएक अच्छा चाल है। इसका अर्थ है कि निम्नलिखित खोज "वेरी नो मैजिक" होगी, जिसका अर्थ है कि रेगेक्स [B]शाब्दिक पाठ से मेल खाएगा, [B]न कि इसमें केवल एक बी से युक्त रेंज के बजाय। चूंकि अधिकांश स्थानापन्न आदेशों में एक कोष्ठक होता है, हम पहले एक में भरते हैं।

फिर, हम पांच स्थानापन्न कमांड कहते हैं। यह ध्यान देने योग्य है कि मैंने <C-v>कई बार क्यों बुलाया । वर्ण की तरह <esc>, <C-v>, <C-r>, आदि अमुद्रणीय वर्ण हैं, और एक साथ कमांड लाइन में टाइप किया जाना चाहिए <C-v>।

[बी]: बैकस्पेस। यह एक बहुत आसान है। बस प्रत्येक के [B]साथ स्थानापन्न करें Ctrl-h, जो कि विम में बैकस्पेस के बराबर है।
[सी]: पहले से ही लिखे गए सभी को कॉपी करें। इसका अनुवाद है <esc>0y$A। इसका मतलब है की:
```
<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.
```
हम सकता है लगभग बस कर Yजगह की में 0y$जो अर्थ है "पूरी लाइन झटका", लेकिन यह भी एक नई पंक्ति है कि हम नहीं चाहते पकड़ लेता है।
[डी]: जो कुछ भी लिखा गया है उसे हटा दें। यह वह जगह है <esc>"_S। पहले की तरह, <esc>इन्सर्ट मोड से बाहर निकलें ताकि हम कमांड चला सकें। कुछ चीजें हैं जो यहां अधिक सुविधाजनक हैं। तो हम करते हैं
```
  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.
```
[पी]: जो कॉपी किया गया है उसे पेस्ट करें। यह भी बहुत सीधा है। इसका <C-r>"मतलब सिर्फ इतना है Insert the contents of register '"'। "मुख्य रजिस्टर होता है जो 'y' के लिए होता है।

अब जब हमने सभी कमांडों का अनुवाद कर लिया है, तो हमें सभी नई लाइनों के सभी अक्षरों को हटाकर एक साथ जुड़ना चाहिए। हमारे मानचित्रण के लिए धन्यवाद, यह सिर्फ है

s<bs>\n

<bs>एक बैकस्पेस, (ASCII 0x08) है और हम इसकी वजह से जरूरत [हम में भर दिया।

अब तक, हमने इनपुट को vim कोड में अनुवादित किया है, और हमें इसे चलाने की आवश्यकता है। सो हम्:

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

— DJMcMayhem
स्रोत

<C-r>प्रलेखित का इन्सर्ट मोड प्रभाव कहाँ है ?

— नील

1

@ सामान्य रूप से, आप किसी विशिष्ट मोड के लिए एक कुंजी पा सकते हैं :h mode_keystroke। इस मामले में, यह होगा:h i_ctrl-r

— DJMcMayhem

@ ललोवो ओह क्षमा करें, मैं उल्लेख करना भूल गया। इनपुट कई लाइनों पर होने की उम्मीद है ताकि मुझे कॉमा, या /gध्वज के बारे में चिंता करने की ज़रूरत न हो । मैं उन विवरण में जोड़ देंगे।

— DJMcMayhem

2

इसके अलावा, क्या करता 0ii<esc>D@"है?

— लवजो

1

मैपिंग, एह? :) विस्तृत विवरण के लिए धन्यवाद, मैं हमेशा कुछ नया सीखता हूं!

— ईसाई रोंडेउ

9

CJam , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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.

"हैश फ़ंक्शन" 1>3bनक्शे

एकल-वर्ण तार 0 (= 0 mod 5),
[B]से 291 (= 1 मॉड 5),
[D]से 297 (= 2 मॉड 5),
[P]से 333 (= 3 मॉड 5),
[C]से 294 (= 4 मॉड 5)।

यह मान (mod 5) CJam कोड स्निपेट्स की सूची में एक सूचकांक के रूप में उपयोग किया जाता है:

एकल-वर्ण स्ट्रिंग्स के लिए, कहते हैं h, स्निपेट "h"वापस आ गया है, जो एकल-वर्ण स्ट्रिंग को स्टैक पर धकेलता है।
के लिए [B], स्निपेट ;लौटाया जाता है, जो एक तत्व को पॉप करता है।
के लिए [D], स्निपेट ];लौटाया जाता है, जो स्टैक को साफ करता है।
के लिए [P], स्निपेट L~लौटाया जाता है, जो Lस्टैक पर चर को जोड़ता है ।
के लिए [C], स्निपेट ]:L~लौटाया जाता है, जो चर में वर्तमान स्टैक को संग्रहीत करता है L।

इन स्निपेट्स को संक्षिप्त और निष्पादित किया जाता है; अंतिम स्टैक CJam द्वारा स्पष्ट रूप से मुद्रित किया जाता है। Lशुरू में खाली सूची है, इसलिए प्रतिलिपि बफर शुरू में "खाली" है।

— लिन
स्रोत

8

पायथन 2, 96 95 93 बाइट्स

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

— orlp
स्रोत

क्या आप किसी स्थान को बचाने or"E"की परिभाषा को स्थानांतरित कर सकते हैं x?

— xnor

@xnor मुझे विश्वास है।

— orlp

1

वास्तव में, ऐसा लगता है कि परिभाषित xकरना इसके लायक नहीं है। x=="C"बस हो सकता है o=="[C]"।

— xnor

7

जेली , 50 51 48 बाइट्स

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

TryItOnline
या सभी परीक्षण मामलों

कैसे?

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

उदाहरण के लिए

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

- 'B'एक परीक्षण मामले के रूप में एक राजधानी के साथ , इससे पहले कि मैं एक बग तय करता वह वापस आ गया होता"I likeees!"

— जोनाथन एलन
स्रोत

1

मुझे यकीन नहीं है कि यह एक वैध परीक्षण मामला है, लेकिन मैंने एक अत्यधिक जटिल स्ट्रिंग के साथ प्रयास किया और यह विफल प्रतीत होता है ['e', 'e', 'e', '[B]', '[C]', '[B]', '[D]', 'I', ' ', 'l', 'i', 'k', '[P]', '[B]', ' ', 'b', '[P]', 's', '!']:।

— डोम हेस्टिंग्स

आह - हाँ मैंने इस किनारे के मामले को याद किया, पूरी स्ट्रिंग को हटाने से पहले एक प्रतिलिपि है और जो कोड मैंने लिखा है वह इसे अनदेखा करता है। मैं इसे थोड़ी देर बाद देखूंगा, मुझे सूचित करने के लिए धन्यवाद।

— जोनाथन एलन

ठीक है, मैंने तय किया कि यह वास्तव में बाइट्स भी बचाता है!

— जोनाथन एलन

7

जावास्क्रिप्ट (ईएस 6), 84 80 77 76 बाइट्स

सहेजे गए 3 बाइट्स @Neil की बदौलत, @ edc65 को 1 और धन्यवाद

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

.map अब दो बाइट्स हैं:

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

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

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>

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

अंतर यह है कि आप reduceउपयोग करके संस्करण पर 3 बाइट्स बचा सकते हैं (s,[c,z])।

— नील

@ नील अच्छा लगा! यह .mapसंस्करण पर एक बाइट भी बचाता है।

— ETHproductions

x=>x.reduce((s,[c,z])=>z<'C'?s.slice(0,-1):z<'D'?t=s:z<'P'?'':s+=z?t:c,t='')1 बाइट कम। उत्सुकता से अपरिभाषित <कोई भी झूठा है

— edc65

x=>x.reduce((s,[c,z])=>z<'C'?s.slice(0,-1):z<'D'?t=s:z<'P'?"":z?t:s+c,t="")एक और चरित्र बचाता है। यदि z सत्य है, तो पेस्ट करें, अन्यथा आउटपुट में चार जोड़ें।

— ग्रैक्स 32

@Grax को पेस्ट करते समय आपको वर्तमान आउटपुट में जोड़ना होता है, इसलिए z?s+t:s+cयह 1 बाइट से अधिक हैs+=z?t:c

— edc65

5

पर्ल, 53 50 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट को नईलाइन्स द्वारा समाप्त किया गया है (अंतिम नई पंक्ति को छोड़ा जा सकता है, इसलिए यह सुर्खियों में विभाजित स्ट्रिंग के रूप में गिना जाता है):

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

देता है

aHez

keystrokes.pl:

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

लगभग जेली का उत्तर पकड़ा गया, लेकिन 48 बाइट से बच गए ...

— टन हास्पेल
स्रोत

4

अजगर 120 119 116 बाइट्स

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

इनपुट के साथ एक पुनरावर्ती कार्य s, कुंजी-स्ट्रोक की एक सूची।

प्रत्येक पुनरावर्ती कॉल वापसी पाठ को अद्यतन करता है, rऔर, [C]क्लिपबोर्ड के मामले में , खाली cहोने तक s।

के नए मूल्यों rऔर c, एक शब्दकोश में अनुक्रमण द्वारा पाए जाते हैं {...}, और खोल के साथ पारित कर दिया *। निष्क्रिय कीस्ट्रोक्स के लिए s[0][1:2]एक खाली स्ट्रिंग वापस आ जाएगी और ''इसके बजाय कुंजी का उपयोग किया जाएगा।

— जोनाथन एलन
स्रोत

मैं पूछ सकते हैं क्यों आप के रूप में लैम्ब्डा परिभाषित lambda s,r='',c=''के बजाय lambda s,r,c=''?

— एल। स्टीयर

विनिर्देश यह है कि हम वर्णों का इनपुट सरणी (यहां s) लेते हैं, इसलिए फ़ंक्शन को किसी अन्य इनपुट के साथ काम करने की आवश्यकता है।

— जोनाथन एलन

मेरी क्षमायाचना, पढ़ने की असफलता।

— एल। स्टीयर

4

हास्केल, 136 133 130 127 बाइट्स

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

Ideone पर इसे आज़माएं।

स्पष्टीकरण: k आदेशों की सूची पर एक पूंछ पुनरावृत्ति करता है। bवह बफर है जिसमें स्ट्रिंग का निर्माण किया गया है, cप्रतिलिपि किए गए भाग को बचाता है।

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

संपादित करें: कुछ बाइट्स को बचाने के लिए कमांड [B][C][D][P]अब ठीक से मेल नहीं खाते हैं लेकिन तुलना की जाती है: से कम 'C'? -> Bऔर इतने पर। 3 बाइट बचाने के लिए @nimi को धन्यवाद ।

— Laikoni
स्रोत

@ रिमी init bएक अपवाद फेंकता है यदि bखाली सूची है।

— लकोनी

@ नमि यह चतुर है, धन्यवाद! अनाम फ़ंक्शन के लिए जैसा कि मैंने किसी भी तरह से यह ध्यान में रखा था कि अनाम फ़ंक्शन केवल तभी स्वीकार्य होते हैं जब वे एकमात्र कथन होते हैं और कोई अन्य सहायक फ़ंक्शन नहीं होते हैं। हालाँकि मेटा की खोज से ऐसा कुछ नहीं हुआ, इसलिए मुझे लगता है कि यह ठीक है।

— लैकोनी 18

2

यहाँ यह है । यह उन कार्यों के लिए सहायक कार्यों की घोषणा करने की अनुमति देता है जो कार्यों का मूल्यांकन करते हैं।

— १६:१५

3

गणितज्ञ, 100 बाइट्स

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

अनाम फ़ंक्शन। इनपुट के रूप में स्ट्रिंग्स की एक सूची लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है। उत्पन्न किसी भी संदेश को अनदेखा करें।

— LegionMammal978
स्रोत

2

जावा 7, 207 203 बाइट्स

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

यह निश्चित रूप से कुछ और गोल्फ हो सकता है, लेकिन यह मेरा प्रारंभिक उत्तर है। संपादित करने के बाद मैंने उन equals-चेक को हटाने के लिए कुछ पाया .. के साथ प्रतिस्थापित किया charAt, लेकिन शायद अभी भी गोल्फ हो सकता है।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

Hello
Hello Hello 

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

— केविन क्रूज़सेन
स्रोत

2

PHP, 131 बाइट्स

17 बाइट्स @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);

— जार्ग हुल्सरमन
स्रोत

1

147 बाइट्स:

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

। (आपकी पूरी if()श्रृंखला को ट्रेनी संचालन की श्रृंखला के साथ बदल दिया गया)।

— इस्माइल मिगेल

@IsmaelMiguel धन्यवाद। मुझे ऑपरेटर का उपयोग करने की कोई इच्छा नहीं थी

— Jörg Hülsermann

मैं देख सकता हूं क्यों। यह बहुत बदसूरत लग रहा है और ... यह वास्तव में कुछ है जो आंख को नुकसान पहुंचाता है।

— इस्माईल मिगुएल

1

PHP, 108 बाइट्स

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;

सरणी आधारित एक के बजाय एक स्ट्रिंग आधारित दृष्टिकोण का उपयोग करता है।

उपयोग की तरह:

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

संपादित करें: 8 बाइट्स के आदेश को fiddling द्वारा बचाया ;: एस और इतने सारे कोष्ठक का उपयोग करने से बचने के लिए उन्हें नकारात्मक बनाने;

— user59178
स्रोत

$s=$argv[++$i]इसके बजाय null!==$s=$argv[++$i]अगर आप PHP> 7 का उपयोग करते हैं , तो आप $s=$argv[++$i]??0नोटिस को छोड़ने के लिए लिख सकते हैं

— Jörg Hülsermann

1

यह नोटिस को छोड़ने के लिए नहीं है बल्कि आपको यह '0'देखने के लिए प्रवेश करने की अनुमति देता है कि कैसे '0'गलत है। ऐसे कई अन्य नोटिस हैं, जो विशेष रूप से समय की बर्बादी की तरह प्रतीत हो रहे हैं।

— 15:59 बजे user59178

1

SpecBAS - 216 बाइट्स

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$

इनपुट कॉमा के साथ एक स्ट्रिंग के रूप में दिया जाता है, जिसे बाद में सरणी में बदल दिया जाता है।

— ब्रायन
स्रोत

1

वी , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

चूँकि इसमें अनपेक्षित वर्ण हैं, यहाँ एक हेक्सडंप है:

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

यह मेरे विम जवाब का केवल सीधा अनुवाद है ताकि मैं जेली के साथ प्रतिस्पर्धा कर सकूं। दुर्भाग्य से, मैं अभी भी एक बाइट कर रहा हूं, लेकिन मैं अभी भी आखिरी काम कर रहा हूं। :)

मुझे उस उत्तर पर वैसे भी अधिक गर्व है, इसलिए यदि आप एक विस्तृत विवरण चाहते हैं, तो इसके बजाय इसे पढ़ें।

— DJMcMayhem
स्रोत

1

दरअसल, 56 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

— मेगो
स्रोत

1

जावा, 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;}

अधिक पठनीय संस्करण:

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

— dpa97
स्रोत

आप अपने प्रयास को कैच में बदलकर कुछ बाइट (1 या 2) बचा सकते हैंif(s.length()>1){...}else

— AxelH

और बदल p==1मेंp<2

— AxelH

1

MATL , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

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

— लुइस मेंडो
स्रोत

1

टीसीएल, 186 बाइट्स

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}

अच्छी तरह से स्वरूपित:

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
}

मैं सिर्फ यह साबित करना चाहता था कि मैं टीसीएल में ऐसा कर सकता हूं

— Grax32
स्रोत

आप बाइट्स बचा सकते हैं: foreachद्वारा प्रतिस्थापित lmap; returnद्वारा set x। यह मैं एक त्वरित नज़र पर कह सकता हूं।

— सेरगिओल

1

स्काला, 158 बाइट्स

(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

इस समस्या को परिणाम के साथ गुना और संचायक के रूप में क्लिपबोर्ड को हल करता है। अफसोस की बात है कि स्केला में एक टर्नरी सशर्त संचालक नहीं है, लेकिन इसके बजाय if elseएक अभिव्यक्ति के रूप में उपयोग करता है ।

— corvus_192
स्रोत

1

PHP 7.1, 95 92 बाइट्स

नोट: नकारात्मक स्ट्रिंग ऑफसेट के लिए PHP 7.1 की आवश्यकता है।

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;

बिना नकारात्मक स्ट्रिंग ऑफसेट (101 बाइट्स):

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

इस तरह से चलाएं:

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!

व्याख्या

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.

बदलाव

कमांड हैंडलिंग के साथ आउटपुट हैंडलिंग के संयोजन से 3 बाइट्स सहेजे गए

— aross
स्रोत

विस्तार से समझाया गया एक PHP प्रविष्टि :)

— Emigna

कीस्ट्रोक्स का अनुकरण करें

05AB1E , 34 33 31 27 बाइट्स

विम, 76, 64, 62 , 58 कीस्ट्रोक्स

CJam , 33 बाइट्स

व्याख्या

पायथन 2, 96 95 93 बाइट्स

जेली , 50 51 48 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 84 80 77 76 बाइट्स

टेस्ट स्निपेट

पर्ल, 53 50 बाइट्स

अजगर 120 119 116 बाइट्स

हास्केल, 136 133 130 127 बाइट्स

गणितज्ञ, 100 बाइट्स

जावा 7, 207 203 बाइट्स

PHP, 131 बाइट्स

PHP, 108 बाइट्स

SpecBAS - 216 बाइट्स

वी , 49 बाइट्स

दरअसल, 56 बाइट्स

जावा, 181

MATL , 46 बाइट्स

व्याख्या

टीसीएल, 186 बाइट्स

स्काला, 158 बाइट्स

PHP 7.1, 95 92 बाइट्स

व्याख्या

बदलाव