सीड में गोल्फिंग के लिए टिप्स

Question

आपके पास sed में गोल्फिंग के लिए क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं जो कोड-गोल्फ समस्याओं पर लागू हो सकते हैं और जो कम से कम कुछ विशिष्ट सेड के लिए विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)।

कृपया प्रति उत्तर एक टिप पोस्ट करें।

Comments

वास्तव में एक गोल्फ टिप (लेकिन अभी भी गोल्फ के लिए एक टिप) नहीं है: लाइनफीड्स केवल कई बाइट्स को अर्धविराम के रूप में उपभोग करते हैं, जिससे आप अपने कोड को छोटा और पठनीय रख सकते हैं ।

— डेनिस

कोई टिप नहीं, लेकिन एक समस्या: मेरे पास जीएनयू सेड है, फिर भी Fकमांड ने कभी काम नहीं किया। क्या किसी को पता है क्यों?

— शीशमारा ३०'१६

@ शीशमौरा Fमेरे जीएनयू सेड (डेबियन परीक्षण) पर काम करता है। यह सिर्फ -स्टड से पढ़ता है, बेशक, लेकिन यह अपेक्षित है। आपको क्या मिलता है sed -e 'F;Q' /etc/hostname?

— टोबी स्पाईट

@TobySpeight जो यह त्रुटि देता है char 1: unknown command: F:। मुझे शायद sed को अपडेट करना होगा; आपके पास क्या संस्करण है? Lकमांड भी काम नहीं करता है, लेकिन जब से यह बेकार वैसे भी -l nमौजूद है। जीएनयू सेड की साइट पर उल्लिखित अन्य सभी चीजें काम करती हैं।

— शशमौरा ३०'१६

मैंने bash, sed and dcउन सभी के लिए चैट रूम खोला, जो इन भाषाओं के बारे में बात करना चाहते हैं। चलो एक समुदाय बनाते हैं!

— शीशमारा

Answer 1

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

:    # define label ""
p    # print pattern space
b    # infinite loop! - branch to label ""

Comments

4.3 ग्नू सेड के रूप में, इस व्यवहार को हटा दिया गया था । :अब एक लेबल की आवश्यकता है।

— केविन

दरअसल, यहां भी वास्तविक Git प्रतिबद्ध है लिंक । मुझे लगता है कि PPCG के लिए यह बहुत ज्यादा नहीं बदलेगा, क्योंकि हमें GNU sed 4.2.x के लिए उत्तर पोस्ट करने की अनुमति है, लेकिन यह जानना अच्छा है, हालांकि अफसोस की बात है कि यह ट्रिक आधिकारिक तौर पर अब काम नहीं करेगी।

— शीशमारा

Answer 2

जीएनयू sed प्रलेखन का वर्णन sके रूप में कमांड "sed के स्विस सेना चाकू" । लेकिन अगर आप सब करना चाहते हैं तो एक चरित्र के सभी उदाहरणों को दूसरे के साथ बदल दें, तो yकमांड वह है जो आपको चाहिए:

y/a/b/

क्या कोई चार से छोटा है:

s/a/b/g

Comments

यह भी तेजी से रास्ता तय करता है, और जगह में y/12/21/

— चार्ट

Answer 3

विस्तारित रेगेक्स सिंटैक्स (GNU sed में) का उपयोग करने पर विचार करें। -rविकल्प स्कोरिंग में एक बाइट की लागत है, लेकिन इसका उपयोग सिर्फ एक बार की एक जोड़ी से बैकस्लैश समाप्त करने के लिए \(...\)पहले से ही खुद के लिए भुगतान किया है।

Comments

-rजीएनयू sedविशिष्ट प्रतीत होने वाले अतिरिक्त नोट के साथ ।

— मैनटवर्क

@manat - जोड़ा गया (लेकिन यह एक सामुदायिक विकी उत्तर है, इसलिए आप स्वयं को संपादित कर सकते हैं)।

— टोबी स्पाइट

बेशक। मैंने इसे केवल टिप का हिस्सा नहीं माना, केवल एक अतिरिक्त नोट।

— मैनटवर्क

और यह अपने आप के लिए भुगतान कर रखता का उपयोग करते समय +, ?, {}और |regex मैचों में, के बाद से कोई बैकस्लैश या तो जरूरत है।

— शीशमारा

-Eअगर मुझे सही तरीके से याद है तो -rकई sedकार्यान्वयन में एक अन्य के रूप में काम करता है।

— phk

Answer 4

जब बार-बार एक लूप में प्रतिस्थापित किया जा रहा है:

loop:
s/foo/bar/g
tloop

यह आमतौर पर विश्व स्तर पर बदलने के लिए अनावश्यक है, क्योंकि लूप अंततः सभी घटनाओं को बदल देगा:

# GNU sed
:
s/foo/bar/
t

ऊपर GNU एक्सटेंशन पर भी ध्यान दें: एक लेबल में एक खाली नाम हो सकता है, जिससे अधिक कीमती बाइट्स की बचत होगी। अन्य कार्यान्वयन में, एक लेबल खाली नहीं हो सकता है, और लेबल के बिना कूदना स्क्रिप्ट के अंत में प्रवाह होता है (जैसे कि n)।

Comments

खाली लेबल नाम GNU- विशिष्ट है, POSIX को स्क्रिप्ट के अंत में कूदने के लिए बिना तर्क के शाखाओं की आवश्यकता होती है (BSDs और बिजीबॉक्स में व्यवहार प्रतीत होता है, GNU sed में भी अगर आप खाली नहीं जोड़ते हैं :)

— Ninjubj

अनाम लेबल हमेशा GNU sed में एक बग होता था, एक्सटेंशन नहीं था, और 4.3 और उच्चतर संस्करण में यह बग, पछतावा, निश्चित था। देखें यहाँ ।

— शीशमारा

Answer 5

कोई अंतर्निहित अंकगणित नहीं है, लेकिन गणना एकात्मक या एक-कोडित दशमलव में की जा सकती है। निम्नलिखित कोड दशमलव के रूप में UCD को x के साथ इकाई और 0 को अंक विभाजक के रूप में परिवर्तित करता है:

s/[1-9]/0&/g
s/[5-9]/4&/g
y/8/4/
s/9/4&/g
s/4/22/g
s/[37]/2x/g
s/[26]/xx/g
s/[1-9]/x/g

और यहाँ दशमलव में रूपांतरण वापस है:

s/0x/-x/g
s/xx/2/g
y/x/1/
s/22/4/g
s/44/8/g
s/81/9/g
s/42/6/g
s/21/3/g
s/61/7/g
s/41/5/g
s/-//g

इन दोनों को "बिना किसी संख्या का उपयोग किए दो संख्याओं के गुणा" के उत्तर से लिया गया है ।

इस उत्तर से " पुरानी घुंघराले नंबरों" के लिए, इस जोड़ी के लूप की जोड़ी का उपयोग करके प्लेन पुरानी यूनरी को परिवर्तित किया जा सकता है ; , जहां इकाई है ;। मैंने उपयोग किया है vऔर xरोमन का मिलान करने के लिए 5और 10; b"बीआईएस" से आता है।

# unary to decimal
:d
/;/{
s/;;;;;/v/g
s/vv/x/g
/[;v]/!s/x\+/&0/
s/;;/b/g
s/bb/4/
s/b;/3/
s/v;/6/
s/vb/7/
s/v3/8/
s/v4/9/
y/;bvx/125;/
td
}

# Decimal to unary
:u
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
tu

Comments

... और यदि आपको इनमें से किसी एक का उपयोग करना है, तो आप निश्चित रूप से पहले से ही कोड गोल्फ खो चुके हैं, हालांकि आप अभी भी जावा उत्तर के साथ प्रतिस्पर्धी हो सकते हैं ;-) फिर भी उपयोग करने के लिए मजेदार है।

— डिजिटल ट्रामा

सादी एकरी से दशमलव में रूपांतरण दशमलव रूप X0X के बराबर इनपुट के लिए गलत उत्तर देता है, उदाहरण के लिए 108। इसके लिए जिम्मेदार रेखा है /[;v]/!s/\b/0/2, जिसे /[;v]/!s:x\+:&0:काम करने के लिए इसे बदलने की आवश्यकता है । देखें यहाँ ।

— शीशमारा

@seshoumara, आपका लिंक एक खाली पृष्ठ प्रतीत होता है। लेकिन यह पूरी तरह से प्रशंसनीय है कि मैंने उस कोड को संदर्भित उत्तर से निकालते समय एक त्रुटि की थी, इसलिए मैं बस आपके फिक्स को लागू करूंगा।

— स्पाइट

लिंक सही ढंग से लोड होता है, लेकिन मुझे "टीआईओ" के साथ एक ग्रे पेज के अलावा कुछ की उम्मीद थी और कुछ ऐसा जो उबंटू लोगो जैसा दिखता है - क्या यही इरादा है? और मैं उन उत्तर के दूसरे ( 58007 ) का उल्लेख कर रहा था , जैसा कि सादा-अनार्य नमूना उत्पन्न हुआ है।

— टोबी स्पाइट

TIO लिंक में सही कोड, साथ ही एक उदाहरण इनपुट, 108 अनुपयोगी होना चाहिए। कोड चलाने पर आपको सही परिणाम 108, और 180 नहीं, जैसा कि पहले निर्धारित कोड की अब की लाइन से देखा जाना चाहिए था। संदर्भित उत्तर को अपडेट करना पूरी तरह से आप पर निर्भर है। यह एक सामुदायिक विकि है।

— शीशमारा

Answer 6

जैसा कि man sed(GNU) में उल्लेख किया गया है , आप वाक्यविन्यास का उपयोग करके किसी भी चरित्र को नियमित अभिव्यक्तियों के परिसीमन के रूप में उपयोग कर सकते हैं

\%regexp%

जहां %किसी भी चरित्र के लिए एक प्लेसहोल्डर है।

यह जैसे कमांड के लिए उपयोगी है

/^http:\/\//

जो छोटे हैं

\%^http://%

क्या में बताया गया है जीएनयू मैनुअल sed लेकिन नहीं में man sedहै कि आप की सीमांकक बदल सकते हैं s///और y///साथ ही।

उदाहरण के लिए, कमांड

ss/ssg

पैटर्न स्थान से सभी स्लैश को निकालता है।

Answer 7

यदि इस प्रश्न पर स्पष्ट रूप से प्रतिबंध नहीं लगाया गया है, तो इस मेटा प्रश्न के लिए सर्वसम्मति यह है कि संख्यात्मक इनपुट एकात्मक हो सकता है। यह आपको इस उत्तर के अनुसार दशमलव के 86 बाइट्स को एकजुट करने के लिए बचाता है ।

Comments

क्या मैदानी सर्वसम्मति से सादा पुराने एकांगी प्रारूप का जिक्र नहीं है? मेरे पास कई उत्तर हैं जहां UCD में एक इनपुट मुझे मदद करेगा, अगर यह किसी भी तरह से है।

— शीशमारा

@ शीशमौरा का मतलब था यूरी, न कि यूसीडी

— डिजिटल ट्रॉमा

फिर दशमलव से सादी पुरानी यूनरी में रूपांतरण आपके द्वारा लिंक किए गए उत्तर के अनुसार आपको 126 बाइट बचाता है। 86 बाइट्स यूसीडी में रूपांतरण के लिए है।

— शीशमारा

Answer 8

इस टिप के उत्तर पर विस्तार करते हुए , दशमलव और सादी यूनरी संख्या प्रारूपों के बीच रूपांतरण के बारे में, मैं निम्नलिखित वैकल्पिक तरीके प्रस्तुत करता हूं, उनके फायदे और नुकसान।

सादे यूनिरी के लिए दशमलव: 102 + 1 (आर झंडा) = 103 बाइट्स। मैंने \t1 बाइट के रूप में शाब्दिक टैब के रूप में गिना ।

h
:
s:\w::2g
y:9876543210:87654321\t :
/ /!s:$:@:
/\s/!t
x;s:-?.::;x
G;s:\s::g
/\w/{s:@:&&&&&&&&&&:g;t}

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

लाभ: यह 22 बाइट्स छोटा है और अतिरिक्त के रूप में, यह इनपुट के रूप में नकारात्मक पूर्णांक के साथ काम करता है

नुकसान: यह होल्ड स्पेस को ओवरराइट कर देता है। हालाँकि, चूंकि यह अधिक संभावना है कि आपको प्रोग्राम की शुरुआत में इनपुट पूर्णांक को सही रूप में परिवर्तित करना होगा, इसलिए यह सीमा शायद ही कभी महसूस की जाती है।

दशमलव के लिए एकतरफा प्लेन: 102 + 1 (आर झंडा) = 103 बाइट्स

s:-?:&0:
/@/{:
s:\b9+:0&:
s:.9*@:/&:
h;s:.*/::
y:0123456789:1234567890:
x;s:/.*::
G;s:\n::
s:@::
/@/t}

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

लाभ: यह 14 बाइट्स छोटा है। इस बार दोनों टिप संस्करण नकारात्मक पूर्णांक के लिए इनपुट के रूप में काम करते हैं।

नुकसान: यह होल्ड स्पेस को ओवरराइट कर देता है

एक जटिल चुनौती के लिए, आपको इन स्निपेट्स को अन्य जानकारी के साथ काम करने के लिए अनुकूलित करना होगा जो कि पैटर्न स्पेस या होल्ड स्पेस में मौजूद हो सकते हैं, इसके अलावा संख्या परिवर्तित करने के लिए। यदि आप जानते हैं कि कोड केवल सकारात्मक संख्याओं के साथ काम करता है, तो कोड अधिक गोल्फ हो सकता है, या केवल शून्य ही एक वैध इनपुट / आउटपुट नहीं होने वाला है।

इस तरह के चुनौती जवाब का एक उदाहरण, जहां मैंने इन स्निपेट्स का निर्माण और उपयोग किया है, एक संख्या (1 / x) का पारस्परिक है ।

Comments

यूनिरी-टू-दशमलव के लिए आप अंतिम दो प्रतिस्थापनों को मिलाकर दो बाइट्स बचा सकते हैं s:\n|@$::g:। tio.run/##K05N@f@/2ErX3krNwIpL30G/…

— जॉर्डन

मेरी अपनी कोशिश थी दशमलव पर एकतरफा कनवर्टर करने की। यहाँ 97 बाइट्स है :) इसे ऑनलाइन आज़माएं! (यह भी आवश्यकता नहीं है -r, लेकिन नई आम सहमति के साथ, झंडे बाईटेकाउंट वैसे भी नहीं गिने जाते हैं , और यह पकड़ स्थान को गड़बड़ नहीं करता है)

— क्रिति लिथोस

असल में अगर आप से अंतिम पंक्ति को बदलने /\n/taके लिए /\n/t, आप 96 पाने के लिए 1 बाइट को बचाने

— Kritixi lithos

@Cowsquack धन्यवाद, 96 बहुत अच्छा है! अब समय नहीं है, इस सप्ताह के अंत में इसे देखेंगे।

— शेषमारा

ज़रूर, मुझे चैट पर एक पिंग भेजें :)

— क्रिति लिथोस

Answer 9

आइए tऔर Tआज्ञाओं के बारे में बात करते हैं , कि यद्यपि उन्हें मैन पेज में समझाया गया है, लेकिन इसके बारे में भूलना और बग को आकस्मिक रूप से लागू करना आसान है, खासकर जब कोड जटिल हो जाता है।

इसके लिए मैन पेज स्टेटमेंट t:

यदि s///अंतिम इनपुट लाइन को पढ़ने के बाद और अंतिम टी या टी कमांड के बाद से एक सफल प्रतिस्थापन किया गया है, तो लेबल करने के लिए शाखा।

उदाहरण दिखा रहा है कि मेरा क्या मतलब है: मान लीजिए कि आपके पास संख्याओं की एक सूची है और आप गिनना चाहते हैं कि कितने नकारात्मक हैं। नीचे आंशिक कोड:

1{x;s/.*/0/;x}                   # initialize the counter to 0 in hold space
s/-/&/                           # check if number is negative
t increment_counter              # if so, jump to 'increment_counter' code block
b                                # else, do nothing (start a next cycle)

:increment_counter
#function code here

ठीक लग रहा है, लेकिन यह नहीं है। यदि पहली संख्या सकारात्मक है, तो वह कोड अभी भी नकारात्मक होगा, क्योंकि tइनपुट की पहली पंक्ति के माध्यम से किए गए कूद को बिना परवाह किए किया जाता है, क्योंकि sजब हमने काउंटर को इनिशियलाइज़ किया तो एक सफल प्रतिस्थापन था ! सही है: /-/b increment_counter।

यदि यह आसान लग रहा था, तो आप अभी भी बेवकूफ हो सकते हैं जब कार्यों को अनुकरण करने के लिए कई कूदता है। हमारे उदाहरण increment_counterमें कोड का ब्लॉक सुनिश्चित करने के लिए बहुत सारी sकमांड का उपयोग करेगा । b mainएक ही जाल में गिरने के लिए "मुख्य" में एक और चेक के साथ वापस लौटने का कारण हो सकता है। यही कारण है कि मैं आमतौर पर कोड ब्लॉक से लौटता हूं s/.*/&/;t label। यह बदसूरत है, लेकिन उपयोगी है।

Answer 10

यदि आप GNU सेड के साथ जाते हैं s/.*//, तो पैटर्न स्पेस को क्लियर करने के बजाय , zकमांड (लोअरकेस) का उपयोग करें । निचले बाइट्स की गिनती के अलावा, इसका यह लाभ है कि यह अगले चक्र को शुरू नहीं करेगा जैसा कि कमांड dकरता है, जो कुछ स्थितियों में उपयोगी हो सकता है।

Comments

यदि आपके पास अमान्य मल्टी-बाइट अनुक्रम हैं (जो मेल नहीं खाते हैं .) तो भी लाभ हो सकता है ।

— टोबे स्पीट

Answer 11

मुझे पता है कि यह एक पुराना धागा है, लेकिन मैंने यूसीडी कन्वर्टर्स को उन अनाड़ी दशमलव को लगभग सौ बाइट्स के साथ पाया, कुछ ने होल्ड स्पेस को गड़बड़ कर दिया या विशेष दोषपूर्ण sedसंस्करणों की आवश्यकता की ।

UCD I के लिए दशमलव के लिए (68 बाइट्स; पूर्व में सबसे अच्छा 87 बाइट्स यहाँ पोस्ट किया गया)

s/$/\n9876543210/
:a
s/\([1-9]\)\(.*\n.*\)\1\(.\)/\3x\2\1\3/
ta
P;d

UCD to दशमलव है (66 बाइट्स भी; पूर्व में सबसे अच्छी पोस्ट यहाँ 96)

s/$/\n0123456789/
:a      
s/\([0-8]\)x\(.*\n.*\)\1\(.\)/\3\2\1\3/
ta      
P;d

• \nप्रतिस्थापन में पोर्टेबल नहीं है। आप इसके बजाय एक अलग वर्ण का उपयोग कर सकते हैं और दो बाइट्स बचा सकते हैं, लेकिन आपको अपेंडिक्स को हटाने के लिए अधिक बाइट्स की आवश्यकता होगी P;d; अगली टिप्पणी देखें या, यदि आपका होल्ड स्पेस खाली है, तो G;s/$/9876543210/बाइट पेनल्टी के बिना करें।
• यदि आपको आगे की प्रक्रिया की आवश्यकता है, तो आपको s/\n.*//इसके बजाय कुछ और बाइट्स की आवश्यकता होगी P;d।
• आप उन छोटे पुराने GNU sedसंस्करणों के लिए दो बाइट्स बचा सकते हैं
• नहीं, आप उन छह बैकस्लैश को नहीं बचा सकते क्योंकि विस्तारित नियमित एक्सप्रेशन बैकरेफेरेंस नहीं करते हैं

Comments

इस थ्रेड में यूसीडी और बैक कन्वर्टर्स के लिए कोई दशमलव नहीं है जो होल्ड स्पेस को गड़बड़ करते हैं या दोषपूर्ण सेड वर्जन की आवश्यकता होती है।

— शीशमारा

6 अप्रैल से आपका स्वयं का उत्तर सोने के स्थान का उपयोग करता है और केवल पुराने sedसंस्करणों के साथ चलेगा जो POSIX मानक का उल्लंघन करते हैं।

— फिलिपोस

मैं UCD रूपांतरणों के लिए दशमलव नहीं कर रहा हूँ! धागे को फिर से ध्यान से पढ़ें। UCD का अर्थ है कि 12 को 0x0xx में बदल दिया गया है (आपका उत्तर क्या है), जबकि सादा एकरी (मेरा उत्तर क्या है) का अर्थ है कि 12 को xxxxxxxxxxxx में बदल दिया गया है। मैंने प्रतीक के रूप में @ धोखा दिया है, लेकिन आपको इसका विचार है। और आगे, PPCG पर किसी को POSIX मानक का पालन करने की आवश्यकता नहीं है।

— शीशमारा

यह आप प्रसन्न हैं, शेरिफ

— Philippos

Answer 12

एक बार में पूरा इनपुट पढ़ें -z

अक्सर आपको एक बार में एक पंक्ति के बजाय एक बार पूरे इनपुट पर संचालित करने की आवश्यकता होती है। Nआदेश के लिए उपयोगी है:

:
$!{N;b}

... लेकिन आमतौर पर आप इसे छोड़ सकते हैं और -zध्वज का उपयोग कर सकते हैं ।

-zझंडा sed उपयोग NUL (बनाता है \0के बजाय अपने इनपुट लाइन विभाजक के रूप में) \nहै, इसलिए यदि आप जानते हैं कि आपके इनपुट शामिल नहीं होंगे \0, यह इनपुट के सभी पढ़ा जाएगा एक बार एक "पंक्ति" के रूप में:

$ echo 'foo
> bar
> baz' | sed -z '1y/ao/eu/'
fuu
ber
bez

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

Answer 13

एक बाइट में एक नई लाइन जोड़ें

Gआदेश एक नई पंक्ति और पैटर्न अंतरिक्ष के लिए पकड़ अंतरिक्ष की सामग्री को जोड़ देती है, इसलिए यदि आपके पकड़ अंतरिक्ष, रिक्त है बजाय इस की:

s/$/\n/

तुम यह केर सकते हो:

G

तीन बाइट्स में एक नई रूपरेखा तैयार करें

Hआदेश एक नई पंक्ति और पकड़ अंतरिक्ष के लिए पैटर्न अंतरिक्ष की सामग्री को जोड़ देती है, और xदो अदला-बदली, इसलिए यदि आपके पकड़ अंतरिक्ष, रिक्त है बजाय इस की:

s/^/\n/

तुम यह केर सकते हो:

H;x

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

H;z;x

Answer 14

Sed में, एक फ़ंक्शन के लिए निकटतम चीज जो आपके पास हो सकती है वह एक लेबल है। एक फ़ंक्शन उपयोगी है क्योंकि आप इसके कोड को कई बार निष्पादित कर सकते हैं, इस प्रकार बहुत सारे बाइट्स बचा सकते हैं। हालाँकि, आपको रिटर्न लेबल को निर्दिष्ट करने की आवश्यकता होगी और इस तरह आप अपने कोड में कई बार इस "फ़ंक्शन" को कॉल नहीं कर सकते जिस तरह से आप इसे अन्य भाषाओं में करेंगे।

मेरे द्वारा उपयोग किया जाने वाला वर्कअराउंड दो यादों में से एक ध्वज में जोड़ना है, जिसका उपयोग रिटर्न लेबल का चयन करने के लिए किया जाता है। यह सबसे अच्छा काम करता है जब फ़ंक्शन कोड को केवल एक मेमोरी स्पेस (अन्य एक) की आवश्यकता होती है।

उदाहरण दिखा रहा है कि मेरा क्या मतलब है: एक छोटे से खेल को लिखने के लिए मेरा एक प्रोजेक्ट से लिया गया

# after applying the player's move, I overwrite the pattern space with the flag "P"
s/.*/P/
b check_game_status
:continue_turn_from_player
#code

---

b calculate_bot_move
:return_bot_move
# here I call the same function 'check_game_status', but with a different flag: "B"
s/.*/B/
b check_game_status
:continue_turn_from_bot
#code (like say 'b update_screen')

---

:check_game_status   # this needs just the hold space to run
#code
/^P$/b continue_turn_from_player
/^B$/b continue_turn_from_bot

लेबल को केवल एक अक्षर पर रखा जाना चाहिए, मैंने बेहतर स्पष्टीकरण के लिए पूर्ण नामों का उपयोग किया।

Answer 15

खाली रीगेक्स पहले से सामने आए रेजेक्स के बराबर हैं

^{( एनागोल सबमिशन से इसे खोजने के लिए रिले का धन्यवाद )}

यहां एक उदाहरण है जहां हमें @एक खाली बफर में 100 एस बनाने का काम सौंपा गया है ।

s/$/@@@@@@@@@@/;s/.*/&&&&&&&&&&/ # 31 bytes
s/.*/@@@@@@@@@@/;s//&&&&&&&&&&/  # 30 bytes

दूसरा समाधान 1 बाइट छोटा है और इस तथ्य का उपयोग करता है कि खाली रेगेक्स अंतिम सामना किए गए रेगेक्स से भरे हुए हैं। यहां, दूसरे प्रतिस्थापन के लिए, अंतिम रेगेक्स था .*, इसलिए यहां खाली रेगेक्स भरा जाएगा .*। यह भी regexes के साथ काम करता है /conditionals/।

ध्यान दें कि यह पहले का सामना करना पड़ा rexx है, इसलिए निम्नलिखित भी काम करेगा।

s/.*/@@@@@@@@@@/;/@*/!s/$/@/;s//&&&&&&&&&&/

खाली रेगेक्स की @*जगह भर जाती है $क्योंकि s/$/@/कभी नहीं पहुंचता है।

Comments

हां, अच्छा जवाब। मैंने भी रेगेक्स को अधिक लंबा बना दिया है ताकि वे इस तरह से फिर से मिलान कर सकें (इस प्रकार कार्यक्रम को छोटा बना सकते हैं)।

— टोबी स्पाइट

Answer 16

अधिकतर बेकार कदम:

y|A-y|B-z|

यह केवल अनुवाद करेगा Aकरने के लिए Bऔर yकरने के लिए z(... और -करने के लिए -;) तो है, लेकिन और कुछ नहीं,

sed -e 'y|A-y|B-z|' <<<'Hello world!'

अभी लौटेंगे:

Hello world!

आप यह सुनिश्चित कर सकता है इस लोअर केस हेक्साडेसिमल मूल्यों पर इस का उपयोग करके बेकार हो जाएगा, नमूने के लिए (केवल युक्त 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, eया f।)

Comments

यह कुछ ऐसा है जो आपको कठिन तरीके से पता चला है ?! ;-)

— टोबे स्पीट

मुझे बेकार स्क्रिप्ट पसंद हैं: sed '; ;/s/b;y|A-y|B-z|;s ;s/ //; ; ;' <<<'Hello world'(यह जगह को क्यों नहीं दबाते?)

— एफ। होरी