व्यंग भरी ^ एच ^ एच ^ एच ^ एच ^ एच ^ Hspaces

47

कुछ टर्मिनलों पर, बैकस्पेस दबाने ^Hपर पिछले वर्ण को हटाने के लिए नियंत्रण कोड उत्पन्न होता है । इसने एक झगड़ालू मुहावरे को जन्म दिया, जहां कॉमेडी प्रभाव के लिए संपादन किए जाते हैं :

इस मूर्ख के लिए अच्छा बनो ^ H ^ H ^ H ^ Hgentleman, वह कॉर्पोरेट मुख्यालय से दौरा कर रहा है।

एक या अधिक के साथ एक स्ट्रिंग को देखते हुए ^H, प्रत्येक पर बैकस्पेसिंग के परिणाम को आउटपुट करें ^H। इनपुट केवल मुद्रण योग्य वर्ण (ASCII 32-126) का उपयोग करेगा, और ^केवल के रूप में दिखाई देगा ^H। खाली पाठ पर बैकस्पेस कभी नहीं होगा।

आप यह नहीं मान सकते हैं कि आउटपुट वातावरण नियंत्रण कोड का समर्थन करता है, विशेष रूप से बैकस्पेस कोड \x08।

>> Horse^H^H^H^H^HCow
Cow

>> Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ.
Be nice to this gentleman, he's visiting from corporate HQ.

>> 123^H45^H^H^H78^H
17

>> Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma
Digital Trauma

लीडरबोर्ड

यहां मार्टिन ब्यूटनर के सौजन्य से एक उप-भाषा लीडरबोर्ड है ।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

code-golf  string 
— XNOR
स्रोत
4
है AAA^HB^H^Hमान्य है?
— नाथन मेरिल
@NathanMerrill हाँ, और इसका परिणाम है A।
— xnor
3
मुझे संदेह है कि रेटिना यहां अच्छा करेगी।
— क्लाउडीयू
1
@Fatalize: "खाली पाठ पर बैकस्पेस कभी नहीं होगा।"
— माल्टीसेन
16
@ मेरी टाइडल टग मुझे वापस लाने के लिए आती है
— डिजिटल ट्रॉमा

जवाबों:

69

GNU sed, 11 बाइट्स

:;s/.^H//;t

परीक्षण उत्पादन:

$ echo "Horse^H^H^H^H^HCow
Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ.
123^H45^H^H^H78^H
Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma" | sed ':;s/.^H//;t'
Cow
Be nice to this gentleman, he's visiting from corporate HQ.
17
Digital Trauma
$
— डिजिटल आघात
स्रोत
5
देखो किसने दिखाया! यह मारिया टाइडल टग ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एच ^ एचडीजीटल ट्रॉमा!
— एलेक्स ए।
@AlexA। क्या मुझे एक चुटकुला याद आ रहा है?
— user253751
@ मिनीबिस: प्रश्न पर डिजिटल ट्रॉमा की टिप्पणी देखें ।
— एलेक्स ए।
sed -r ':;s/(^|.)\^H//;t'- यह अतिरिक्त 6 बाइट्स की कीमत पर काम करता है
— arager
@aragaer यह क्यों आवश्यक है? ओपी कहता है " खाली पाठ पर बैकस्पेस कभी नहीं होगा "। मुझे लगता है ^Hकि स्ट्रिंग की शुरुआत खाली पाठ पर एक बैकस्पेस है।
— डिजिटल ट्रॉमा
19

अजगर, 11 बाइट्स

.U+PbZcz"^H

प्रदर्शन।

.U+PbZcz"^H
               Implicit: z = input()
      cz"^H    z.split("^H")
.U             reduce, with the first element of the list as the initial value.
   Pb          Remove the last character of what we have so far.
  +  Z         And add on the next segment.
               Print implicitly.
— isaacg
स्रोत
17

गीमा, 6 बाइट्स

?#\^H=

नमूना रन:

bash-4.3$ gema -p '?#\^H=' <<< 'pizza is alright^H^H^H^H^H^Hwesome'
pizza is awesome

सीडब्ल्यू, क्योंकि मूर्ख बनाम सज्जन उदाहरण बहुत लंबा लगता है। (एक दिन के बाद मार दिया। हो सकता है कि दुभाषिया में गड़बड़ हो। यहां अन्य सभी उदाहरण सेकंड के अंशों में संसाधित किए गए हैं।) गामा का पुनरावर्ती पैटर्न पुनरावृत्ति स्तर से प्रभावित नहीं होता है, लेकिन गैर-मिलान की मात्रा प्रसंस्करण समय में तेजी से वृद्धि करती है। ।

— मैनेटवर्क को प्रकट करता है
स्रोत
क्या भाषा का कोई लिंक है?
— जीथब
ज़रूर। gema.sourceforge.net (BTW, Gema प्रोजेक्ट 2003-10-27 दर्ज किया गया था, जबकि GitHub 2008-04-10 था। यह वहां नहीं मिलने का एक कारण हो सकता है।)
— manatwork
मेरा मानना ​​है कि पुनरावृत्ति की गहराई गैर-मिलान स्ट्रिंग की लंबाई के बराबर है, क्योंकि यह बार-बार फिर से फिर से \^Hउठेगी, जब तक कि एक बार में एक वर्ण से मेल खाते हुए मच तक नहीं ?।
— isaacg
15

सी, 52 बाइट्स

j;f(char*s){for(j=0;*s=s[j];s[j]==94?s--,j+=3:s++);}

हम एक फ़ंक्शन को परिभाषित करते हैं fजो इनपुट के रूप में स्ट्रिंग को एक पॉइंटर लेता है। फ़ंक्शन कॉल के बाद, उस पॉइंटर में एक संशोधित स्ट्रिंग शामिल होगी।

एक साधारण परीक्षण:

int main(int argc, char** argv) {
    char buf[300] = "Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma";
    f(buf);
    printf(buf);
    return 0;
}

उपरोक्त प्रिंट:

Digital Trauma
— BrainSteel
स्रोत
1
यह वास्तव में चतुर था। एक दो बातें जिन पर मैंने गौर किया: ग्लोबल्स पहले से ही शून्य से शुरू होते हैं, इसलिए jआपके forलूप में init की कोई आवश्यकता नहीं है (बेशक तब यह एकल उपयोग है, लेकिन मुझे नियमों में इसके बारे में कुछ भी नहीं दिखता है :))। आप वेतन वृद्धि के साथ असाइनमेंट को भी जोड़ सकते हैं: j;f(char*s){for(;s[j]==94?*s--=s[j],j+=3:s++);}(47 बाइट्स)
— कोल कैमरून
— भूमिगत
@undergroundmonorail ख़तरा, मैं सिर्फ यह देखने के लिए दोहरी जाँच कर रहा था कि क्या मैं चूक गया। मैं अभी भी गोल्फ को कोड करने के लिए नया हूँ, लेकिन मुझे याद है कि भविष्य के लिए :)। जानकारी के लिए धन्यवाद!
— कोल कैमरून
1
@ColeCameron जिसमें एक अप्रयुक्त संशोधन और पहुंच (UB) है, और दुर्भाग्य से मेरे संकलक / मशीन पर तत्काल EXC_BAD_ACCESS का कारण बनता है।
— 14
1
@ क्वेंटिन मैंने वह कोशिश की, लेकिन कॉमा इन s--, j+=3एंड ऑपरेटर मिसाल के कारण, यह सही काम नहीं करता है।
— ब्रेनसैट
14

हास्केल, 47 बाइट्स

h(a,_:_:b)=f$init a++b;h(x,_)=x
f=h.span(/='^')

एक कार्य को परिभाषित करता है f :: String -> String। यह काम किस प्रकार करता है:

    f "ab^Hc^Hd"
=== h ("ab", "^Hc^Hd")   (find ^H)
=== f ("a" ++ "c^Hd")    (backspace)
=== f "ac^Hd"            (join)
=== h ("ac", "^Hd")      (find ^H)
=== f ("a", "d")         (backspace)
=== f "ad"               (join)
=== h ("ad", "")         (find ^H)
=== "ad"                 (no ^H: base case)
— लिन
स्रोत
1
मुझे लगता है कि आप में से दो मामलों को स्वैप करके एक बाइट को बचा सकता है hऔर कर रही h(x,_)=xरिक्त स्ट्रिंग मामले के लिए।
— जर्गबेल
12

CJam, 14 13 बाइट्स

q"^H"/{W\ts}*

यह काम किस प्रकार करता है

q                   e# Read the entire input
 "^H"/              e# Split it on occurrences of string "^H"
      {    }*       e# Reduce on the split array
       W\t          e# This is the tricky part. We know that if there are two parts that we
                    e# are reducing on, they must be separated by "^H". Which in turn means
                    e# that from the first part, last characters needs to be deleted
                    e# So we simply put the second part in place of the last character of the
                    e# first part.
          s         e# Doing the above makes it a mixed array of character and string.
                    e# So we convert it to a single string, ready to be served as first part
                    e# in next reduce iteration

अद्यतन: 1 बाइट jimmy23013 के लिए धन्यवाद बचाया

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
2
1 बाइट छोटी W\ts:।
— jimmy23013
11

रेटिना, 13 बाइट्स

रेटिना

+`.\^H(.*)
$1

दो लाइनों को अपनी फ़ाइलों पर जाना चाहिए लेकिन आप -sध्वज के साथ एक फ़ाइल के रूप में कोड चला सकते हैं ।

प्रत्येक चरण में हम .\^Hस्ट्रिंग में पहला मैच हटाते हैं । +जब तक कोई विलोपन नहीं होता है हम इसे ( संशोधक के साथ ) दोहराते हैं ।

— randomra
स्रोत
बस एक जिज्ञासा: क्यों की कैप्चरिंग (.*), जैसा कि लगता है कि यह सिर्फ अपरिवर्तित है?
— मैनटवर्क
1
@manatwork इस तरह से हम केवल पहले .\^Hको एक चरण में पकड़ते हैं । अन्यथा पहले चरण के बाद abc^H^H^Hपरिणाम होगा ab^।
— रैंडम जूल
4
प्रतिस्थापन की सीमा को अभी तक लागू नहीं करने के लिए माफी (जो शायद कुछ ऐसा ही करने की अनुमति देगा +1`.\^H)। ;)
— मार्टिन एंडर
10

जावास्क्रिप्ट ( ईएस 6 ), 39 बाइट्स

f=s=>(t=s.replace(/.\^H/,''))!=s?f(t):t

// TEST

Out=x=>O.innerHTML+=x+'\n'

Test=_=>(Out(I.value + "\n-> " + f(I.value)),I.value='')

;["Horse^H^H^H^H^HCow"
,"Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."
,"123^H45^H^H^H78^H"
,"Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma"]
.forEach(t => Out(t + "\n-> " + f(t)))
#I { width:400px }
<pre id=O></pre>
<input id=I><button onclick='Test()'>-></button>
स्निपेट का विस्तार करें

— edc65
स्रोत
10

पर्ल, 20 16 15 बाइट्स

(14 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

s/.\^H//&&redo

नमूना रन:

bash-4.3$ perl -pe 's/.\^H//&&redo' <<< "Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."
Be nice to this gentleman, he's visiting from corporate HQ.
— आदमी काम पर है
स्रोत
1
4 पात्रों को बचाएं:1while s/.\^H//
— केविन रीड
वाह! यह बढ़िया है @KevinReid। धन्यवाद।
— मैनटवर्क
1
एक और:s/.\^H//&&redo
— डेनिस
धन्यवाद, @ डेनिस। redoकिसी तरह अपने कौशल सेट में अपना रास्ता नहीं बनाया। उसको बदलना पड़ेगा।
— मैनटवर्क
2
ध्यान दें कि @ डेनिस का संस्करण केवल काम करेगा (जैसा कि इरादा है) यदि यह लूप या { }ब्लॉक के अंदर एकमात्र स्टेटमेंट है । (इसके साथ काम करने का कारण यह perl -pहै कि -pस्विच स्वचालित रूप से आपके कोड को whileलूप के अंदर लपेटता है ।) केविन का संस्करण किसी भी सेटिंग में काम करता है।
— इल्मरी करोनें
9

जूलिया, ५ Jul ४२ 41 बाइट्स

सहेजे गए 16 बाइट्स मैनटवर्क के लिए और 1 ग्लेन ओ के लिए धन्यवाद!

f(s)='^'∈s?f(replace(s,r".\^H","",1)):s

यह एक पुनरावर्ती फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

यह ^Hइनपुट के होते हुए खाली स्ट्रिंग के साथ एक समय में एक घटना की जगह लेता है ^।

उदाहरण:

julia> f("123^H45^H^H^H78^H")
"17"

julia> f("pizza is alright^H^H^H^H^H^Hwesome")
"pizza is awesome"
— एलेक्स ए।
स्रोत
यह पहली बार है जब मैंने जूलिया को जंगल में देखा है। अच्छा!
— ओगडाय
8

REGXY, 10 बाइट्स

REGXY , एक रेगेक्स प्रतिस्थापन आधारित भाषा का उपयोग करता है । किसी भी वर्ण की जगह ^ H कुछ भी नहीं है। दूसरी पंक्ति तब निष्पादित होती है जो पिछली पंक्ति के लिए एक संकेतक है, प्रतिस्थापन को दोहराता है जब तक कि यह मेल नहीं खाता।

/.\^H//
//

यह ऊपर दिए गए लिंक में नमूना दुभाषिया के साथ सही ढंग से संकलित और निष्पादित करता है, लेकिन समाधान शायद थोड़ा सा अजीब है क्योंकि यह भाषा विनिर्देश की अस्पष्टता में एक धारणा पर निर्भर करता है। युक्ति बताती है कि प्रत्येक लाइन पर (/ से पहले) एक लेबल के रूप में कार्य करता है, लेकिन धारणा यह है कि एक अशक्त लेबल-पॉइंटर एक शून्य लेबल (या दूसरे शब्दों में) के साथ फ़ाइल में पहले कमांड पर वापस इंगित करेगा। वह 'शून्य' एक वैध लेबल है)। एक कम चुटीला समाधान होगा:

a/.\^H//
b//a

जिसकी मात्रा 13 बाइट्स तक है।

— Jarmex
स्रोत
7

पायथन 3, 53 बाइट्स

o=""
for x in input().split("^H"):o=o[:-1]+x
print(o)

लेकिन व्यक्तिगत रूप से मुझे यह वर्डियर संस्करण बेहतर लगता है:

H=input().split("^H")
print(eval("("*~-len(H)+")[:-1]+".join(map(repr,H))))

दिलचस्प बात यह है कि

'B''a''c''k''h''a''n''d''e''d'[:-1][:-1][:-1][:-1][:-1][:-1]

वास्तव में काम करता है और देता है 'Back', इसलिए मैंने तब मैप करने की कोशिश की ^H -> [:-1]और किसी अन्य चर c -> 'c'ने eval, लेकिन दुर्भाग्य से आपके पास बिना किसी तार के बाद नहीं हो सकता है +, इसलिए यह विफल रहता है:

'B''a''c''k''h''a''n''d''e''d'[:-1][:-1][:-1][:-1][:-1][:-1]'s''p''a''c''e''s'
— Sp3000
स्रोत
अरे ... यह बहुत साफ है।
— एलेक्स वान एलवाईई
+=पाश में काम करता है
— कैलक्यूलेटरफ़लाइन
@CatsAreFluffy यह o=o[:-1]+x, नहींo=o+x
— Sp3000
उफ़, चूक गए। क्या कुछ o[:-2]=xकाम पसंद है ?
— कैलक्यूलेटरफेलीन
@CatsAreFluffy आप कर सकते हैं आवंटित नहीं करने के लिएstr
— Sp3000
7

हास्केल, 52 47 बाइट्स

import Data.Lists
foldl1((++).init).splitOn"^H"

उपयोग उदाहरण:

> map (foldl1((++).init).splitOn"^H") ["Horse^H^H^H^H^HCow", "123^H45^H^H^H78^H", "Digital Trauma^H^H^H^H^H^H^H^H^H^H^H^H^H^HMaria Tidal Tug^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HDigital Trauma"]
["Cow","17","Digital Trauma"]

यह काम किस प्रकार करता है:

                  splitOn"^H"     -- split on substring "^H", e.g "Horse^H^H^H^H^HCow" -> ["Horse","","","","","Cow"]
                 .                -- then
foldl1(         )                 -- fold from left by
            init                  --   first dropping the last char from the left argument
       (++).                      --   second concatenating left and right argument
— nimi
स्रोत
6

रूबी, 27 24 20 बाइट्स

(19 अक्षर कोड + 1 वर्ण कमांड लाइन विकल्प।)

$_=$`+$'while/.\^H/

करने के लिए धन्यवाद:

  • वैश्विक चर (-4 वर्ण) का उपयोग करने के सुझाव के लिए वेंटरो

नमूना रन:

bash-4.3$ ruby -pe '$_=$`+$'"'"'while/.\^H/' <<< "Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."
Be nice to this gentleman, he's visiting from corporate HQ.
— आदमी काम पर है
स्रोत
+1 मैंने सोचा कि जब तक मैंने यह नहीं देखा तब तक मैं एक रूबी का जवाब दूंगा - मुझे पूरा यकीन है कि यह उतना ही छोटा है जितना कि यह मिलने वाला है। के महान उपयोग []!
— डानिएरो
शुरुआत में एक और संस्करण था: loop{$_[/.\^H/]=""}rescue""यह एक अच्छाई है क्योंकि यह रूबी के अपवाद की शीतलता को दर्शाता है।
— मैनेटवर्क
Haha, यह एक महान है :)
— daniero
1
देर से बेहतर कभी नहीं: $_=$`+$'while~/.\^H/20 के लिए (यदि आप regexp literal in conditionचेतावनी के बारे में परवाह नहीं करते हैं, तो आप टिल्ड को भी छोड़ सकते हैं )।
— वेंटरो
1
@manatwork: तकनीकी रूप से यह सभी रूबी संस्करणों में दिखाई देता है> = 1.9 (regex और स्ट्रिंग शाब्दिक स्थितियों को 1.8 के बाद घटाया गया था), मुझे लगता है कि आपके rubyबस अभी भी 1.8 की चूक है, जबकि irbरूबी 2.1.5 का उपयोग करता है।
— वेंटरो
4

अजगर 2, 50

यह lambdaवहाँ एक दूसरे में एक सा अजीब है , लेकिन लगता है कि अब तक का सबसे अच्छा पायथन है।

lambda s:reduce(lambda a,b:a[:-1]+b,s.split('^H'))
— feersum
स्रोत
3

पायथ - 19 बाइट्स

वास्तव में इसके साथ वास्तव में अच्छी तरह से काम करता है, लेकिन यह एक समय में केवल एक चार करता है इसलिए मुझे ^Hलाइनब्रेक के साथ प्रतिस्थापित करने के लिए वास्तविक अहंकार के रूप में लगभग चार चार्ट खर्च करने थे । ऐसा करने के लिए बेहतर तरीके की तलाश है।

u?+GHnHbPGjbcz"^H"k

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

— Maltysen
स्रोत
3

TeaScript , 7 बाइट्स [प्रतिस्पर्धा नहीं]

इस चुनौती के लागू होने के बाद TeaScript के रूप में प्रतिस्पर्धा नहीं की गई थी। यह यहाँ संदर्भ के रूप में है।

xW/.\^H

यह नए टीस्क्रिप्ट 3 का उपयोग करता है, और पात्रों को हटाने के लिए पुनरावर्ती की जगह लेता है

— Downgoat
स्रोत
1
किसी कारण के लिए यह लीडरबोर्ड पर 8859 बाइट्स के कारण आईएसओ 8859 लिंक के रूप में गिना जाता है ...
— ev3commander
regerence? xD
— बिल्ली
2

K5, 64 बाइट्स

K वास्तव में इस तरह के काम के लिए डिज़ाइन नहीं किया गया है ...

{[s]$[2>#s;s;`=t:*&{"^H"~2#x_s}'1+!-2+#s;s;,/2#2!|(0,t,3+t)_s]}/
— kirbyfan64sos
स्रोत
2

गोल्फलुआ, 36 बाइट्स

\f(s)@o!=s o=s;s=s:g(".^H","",1)$~s$

नमूना रन:

Lua 5.2.2  Copyright (C) 1994-2013 Lua.org, PUC-Rio
> \f(s)@o!=s o=s;s=s:g(".^H","",1)$~s$
> w(f("Be nice to this fool^H^H^H^Hgentleman, he's visiting from corporate HQ."))
Be nice to this gentleman, he's visiting from corporate HQ.
— आदमी काम पर है
स्रोत
2

जावास्क्रिप्ट, 62 बाइट्स

सबसे छोटा नहीं है, लेकिन ठीक काम करता है।

t=prompt();while(t.match(R=/.\^H/))t=t.replace(R,'');alert(t);
स्निपेट का विस्तार करें

यह शायद बहुत छोटा किया जा सकता है!

— इस्माइल मिगुएल
स्रोत
1
कम से कम एक नहीं है और या तो काम नहीं करता है (परीक्षण के किसी भी मामले की कोशिश करें)।
— Regexp
@ edc65 टिप के लिए धन्यवाद। मैंने कुछ चीजों की कोशिश की और उन्होंने काम किया। इसलिए मैंने इस तरह पोस्ट किया
— इस्माइल मिगुएल
2

आर, 54 52 बाइट्स

f=function(s)ifelse(s==(r=sub(".\\^H","",s)),r,f(r))

मेरे जूलिया जवाब के रूप में एक ही मूल विचार । यह एक पुनरावर्ती फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। यदि इनपुट ^Hहटाए जाने की एक घटना के साथ खुद के बराबर है, तो उसे वापस कर दें, अन्यथा फ़ंक्शन को फिर से कॉल करें।

आप इसे ऑनलाइन आज़मा सकते हैं !

— एलेक्स ए।
स्रोत
2

ईसीएमएस्क्रिप्ट 6, 57 बाइट्स

s=>{while(~s.indexOf`^H`)s=s.replace(/.\^H/,'');return s}

यह शायद गोल्फ है, बस एक रास्ता शायद नहीं लगता है

— Downgoat
स्रोत
2
कैसे के बारे में s=>{while(s!=(s=s.replace(/.\^H/,""));return s}?
— LRN
या, यदि whileऔर returnबहुत लंबा है, तो यह पुनरावर्ती हो सकता है:var f=s=>s==(s=s.replace(/.\^H/))?s:f(s)
— lrn
@ एलएम आपको प्रतिस्थापित करने के लिए दूसरा पैरामीटर जोड़ना चाहिए। तो आपके पास मेरा जवाब है :)
— edc65
सच। और खाली स्ट्रिंग तर्क की जरूरत है, मैंने गलत संस्करण कॉपी किया होगा :(
— lrn
~s.indexOf`^H`बन सकते हैं/\^H/.test(s)
— नहीं कि चार्ल्स
2

(दृश्य) फॉक्सप्रो किसी भी संस्करण में 80 बाइट्स

PARA t
DO WHILE AT('^H',t)>0
t = STRT(t,SUBS(t,AT('^H',t)-1,3))
ENDDO
RETU t

^ H ढूँढने और एक वर्ण का बैकअप लेने के लिए स्ट्रिंग अनुवाद को खाली करना।

— क्रिस
स्रोत
2

जूलिया, 41 39 बाइट्स

s->foldl((t,v)->chop(t)v,split(s,"^H"))

यह क्या कर रहा है ^ एच को एक सीमांकक के रूप में उपयोग कर रहा है, और फिर प्रत्येक स्ट्रिंग पर अंतिम चरित्र को हटा रहा है और फिर अंतिम चरित्र को हटाने से पहले अगले स्ट्रिंग को समाप्‍त कर रहा है। अन्य जूलिया जवाब के विपरीत, यह एक पुनरावर्ती कार्य नहीं है।

नोट: मैंने फ़ंक्शन का नाम परिभाषा से हटा दिया है। मूल रूप से, यह f(s)=बजाय कहा s->, और आप इसे के रूप में इस्तेमाल किया f("AAA^HB^H^H")... लेकिन मैं इसे "गुमनाम" होने की अनुमति देकर दो बाइट्स बचा रहा हूं, और खुद को इसके नाम के रूप में उपयोग करता हूं। आप इसे इस तरह उपयोग करते हैं:

(s->foldl((t,v)->chop(t)v,split(s,"^H")))("AAA^HB^H^H")

(आप इसके रूप में एक चर भी असाइन कर सकते हैं f=s->foldl((t,v)->chop(t)v,split(s,"^H")), फिर f("AAA^HB^H^H")काम करेंगे)

— ग्लेन हे
स्रोत
2

आरएस, 8 बाइट्स

तकनीकी रूप से, यह गणना नहीं करता है, क्योंकि यह इस सवाल के पोस्ट किए जाने के बाद मैंने एक विशेषता पर निर्भर करता है। हालांकि, मुझे लगता है कि यह बहुत साफ है।

+?1.\^H/

लाइव डेमो और परीक्षण के मामले ।

— kirbyfan64sos
स्रोत
क्या नई सुविधा एक सीमा प्रतिस्थापन है?
— xnor
@ एक्सनॉर यस: द ?1।
— kirbyfan64sos
@ ऑप्टिमाइज़र क्यों? तुम वैसे भी गीता से हार रहे हो। : O
— kirbyfan64sos
हाँ :(। टिप्पणी पोस्ट करने के बाद देखा gema
— ऑप्टिमाइज़र
1

पायथन 2, 74 + 2 = 76 बाइट्स

मैंने अब तक कुछ तरीकों की कोशिश की है, यह सबसे अच्छा है जो मैं अब तक के साथ आने में सक्षम हूं।

n=input();o='';c=0
for l in n:d=l=='^';o=[o+l*(1-c),o[:-1]][d];c=d
print o
— Kade
स्रोत
4
वे 2 अतिरिक्त बाइट्स कहाँ से आ रहे हैं?
— xnor
@xnor इनपुट को काम करने के लिए उद्धरणों से घिरा होना चाहिए। मैं उस पोस्ट में डालना भूल गया।
— केड
1
मुझे लगता है कि सामान्य अधिवेशन कड़े तर्कों को मुक्त करने के लिए उद्धरण में लेने की अनुमति देता है, लेकिन मैं पूरी तरह से निश्चित नहीं हूं।
— xnor
1

कण्ठमाला, 84 बाइट्स

R Z S T="",Y=$L(Z,"^H") F I=1:1:Y{S T=T_$P(Z,"^H",I) S:I<Y T=$E(T,1,$L(T)-1)} W !,T

इसे संभवतः एक फ़ंक्शन के रूप में छोटा किया जा सकता है (1 बाइट मैं त्वरित परीक्षण में सहेजने में सक्षम था), लेकिन मैं एक-लाइनर पहलू की तरह काम कर रहा हूं ... :-)

ब्रेसिज़ कण्ठमाला के स्वाद से आते हैं जो कि मैं सबसे ज्यादा वाकिफ हूं।

— zmerch
स्रोत
1

जावा - 123 बाइट्स

मैं व्यक्तिगत रूप से इस g---1हिस्से को सबसे ज्यादा पसंद करता हूं ।

String f(char[] a){String b="";for(int g=-1;++g<a.length;b=(a[g++]=='^'?b.substring(0,b.length()-1):b+a[g---1]));return b;}

विस्तारित (थोड़ा):

  String f(char[] a) {
      String b = "";
      for (int g = -1;
           ++g < a.length;
           b = (a[g++]=='^' 
                ? b.substring(0, b.length() - 1) 
                : b + a[g---1])
      );
      return b;
  }
— खिंचाव पागल
स्रोत
1

बैच - 138 बाइट्स

@!! 2>nul||cmd/q/v/c%0 %1&&exit/b
set s=%1&for /F %%a in ('"prompt $H&echo on&for %%b in (1)do rem"')do set D=%%a
echo %s:^H=!D! !D!%

पहली पंक्ति लंबी बाइट पर कुछ बाइट्स को बचाने का एक तरीका है @echo off&setLocal enableDelayedExpansion(जो गूंज को बंद कर देता है और चर के विलंबित विस्तार को सक्षम करता है, यदि आप सोच रहे थे)। मैंने इसे टिप्स इन गोल्फिंग फॉर बैच में समझाया ।

दूसरी पंक्ति एक चर क्षेत्र में बैकस्पेस नियंत्रण वर्ण को बचाने के लिए एक साफ छोटी चाल है। यह बहुत आसान है, और मैं इसका श्रेय लेने का नाटक नहीं कर सकता। यह यहाँ समझाया गया है । मूल रूप से एक बैकस्पेस वर्ण उत्पन्न करने के लिए संकेत कमांड का उपयोग करता है और इसे एक चर में कैप्चर करता है - इस मामले में!D! ।

अंतिम पंक्ति फिर सरल स्ट्रिंग हेरफेर करती है - के ^Hसाथ बदलें !D!<SPACE>!D!।

C:\>bsp.bat "testing^H^H^H test"
"test test"

दुर्भाग्य से यह मामलों की तरह टूट जाता है "AAA^HB^H^H"- जहां इसे उत्पादन करना चाहिए "A", यह इसके बजाय उत्पादन करता है "A"B। जो कुछ गड़बड़ है। मुझे यह देखना होगा कि बैच स्ट्रिंग हेरफेर कुछ और गहराई में कैसे काम करता है।

C:\>bsp.bat "AAA^HB^H^H"
"A"B

यहाँ पर कुछ सहायक लोगों के लिए धन्यवाद - मुझे अब एहसास हुआ कि मैं केवल बैकस्पेस चरित्र (0x08) को बचा रहा था, और इसलिए केवल पात्रों को अधिलेखित कर रहा था। यह अब निम्नलिखित जैसे उदाहरणों के साथ काम करता है:

C:\>bsp.bat "AAA^HB^H^H"
"A"
— unclemeat
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.