Röda में गोल्फ के लिए युक्तियाँ

Question

Röda एक स्ट्रीम-आधारित स्क्रिप्टिंग भाषा है जो फर्ग्यूसक द्वारा बनाई गई है ।

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

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

Comments

क्या आप मुझे गोल्फ में हरा पाने के लिए टिप्स लेने की कोशिश कर रहे हैं? : P (मुझे शायद पायथन पेज के लिए टिप्स देखना चाहिए)

— HyperNeutrino

वाह, PCG.SE का एक प्रश्न जो हॉट नेटवर्क प्रश्नों में शामिल है और यह एक प्रोग्रामिंग पहेली / चुनौती नहीं है! :)

— पेड्रो ए

@ हिपरनेत्रो श ... ....

— user41805

Answer 1

अंडरस्कोर का उपयोग करें

यह शायद सबसे महत्वपूर्ण टिप है। लगभग हर गोल्फ वाला रोडा कार्यक्रम अंडरस्कोर का उपयोग करता है।

अंडरस्कोर सिंटेक्स forछोरों के लिए सिंटैक्टिक चीनी है। कोड की निम्नलिखित पंक्तियाँ समतुल्य हैं:

ls""|fileLength x for x|sort|pull
ls""|fileLength _|sort|pull

प्रत्येक अंडरस्कोर एक अदृश्य forलूप में एक नया चर जोड़ता है जो कथन के आसपास है। लूप प्रत्येक चर / अंडरस्कोर के लिए स्ट्रीम से एक मान खींचता है और फिर दोहराता है, जब तक कि कोई मूल्य नहीं छोड़ दिए जाते हैं।

अंडरस्कोर को बयानों में कहीं भी इस्तेमाल किया जा सकता है:

a[x:y+1]=[1]*(1+y-x) /* Sets range x..y (inclusive) */
seq x,y|a[_]=1       /* 6 bytes less */

यदि आपको एक से अधिक समान अंडरस्कोर मान का उल्लेख करना चाहिए, या रिवर्स ऑर्डर में मूल्यों का उपयोग करना चाहिए, तो आप अंडरस्कोर के बाद एक नंबर डाल सकते हैं:

a|[_^_1]  /* maps x to x^x */
a|[_2-_1] /* maps each pair (x,y) to y-x, eg. [1,2,4,8] -> [1, 4] */

Answer 2

कुछ अर्धविराम / न्यूलाइन्स वैकल्पिक हैं

Röda कोड लिखते समय, आमतौर पर सभी कथनों को अलग करने के लिए newlines या अर्धविराम का उपयोग करने की सिफारिश की जाती है। हालांकि, जब गोल्फिंग, यह जानना लायक है कि सभी अर्धविराम वास्तव में आवश्यक नहीं हैं।

यहाँ उन स्थानों की अधूरी सूची है जहाँ अर्धविराम / न्यूलाइन्स वैकल्पिक हैं । उनमें से अधिकांश के लिए लागू नहीं है जब निम्न कथन एक ऑपरेटर (के साथ शुरू होता है (, [, +, आदि)।

• असाइनमेंट के बाद
• फ़ंक्शन कॉल के बाद, जब कम से कम एक तर्क (जैसे। f x) या जब कोष्ठक का उपयोग किया जाता है (जैसे। f()) ।
• हर जगह, अगली पंक्ति / बयान के साथ शुरू होगा अगर |, ), ]या}

यदि अगला कथन किसी ऑपरेटर के साथ शुरू होता है, तो अर्धविराम / न्यूलाइन वैकल्पिक है यदि

• स्टेटमेंट एक फंक्शन कॉल है और कोष्ठक का उपयोग किया जाता है, जैसे {f(x)[y]}कि समान है {f(x);[y]}। यह केवल कथन के संदर्भ में काम करता है, न कि जब फ़ंक्शन कॉल एक अभिव्यक्ति है।
• कथन एक असाइनमेंट है और कोष्ठक का उपयोग किया जाता है, उदाहरण के x=(y)[z]लिए समान है x=(y);[z](जो कि समान नहीं है x=((y)[z]))।

और यहाँ कुछ ऐसे स्थान हैं जहाँ पर नई सुचना की आवश्यकता है :

• बाद ++और --।
• के बाद [...]।

असाइनमेंट्स को पुनर्गठित करके बाइट्स को सहेजना अक्सर संभव होता है। उदाहरण के लिए:

a=0;b=""c=[""]
b=""c=[b]a=0

x=f()y=i;z=a[0]
x=f()z=a[0]y=i

Answer 3

प्रत्यय नियंत्रण संरचनाओं का उपयोग करें

यह लगभग कभी भी इष्टतम नहीं है कि आप प्रत्यय कथनों का उपयोग न करें, क्योंकि आप इसके {...}स्थान पर उपयोग कर सकते हैं do...end।

कुछ उदाहरण:

x|unless[not(_ in y)]do[0]else[1]done
x|[0]unless[not(_ in y)]else[1]

if[p<0]do c+=p;a-=p done
{c+=p;a-=p}if[p<0]

Comments

क्या आप इसके if[_ in y]बजाय कर सकते हैं ?

— user41805

@KritiiLithos नहीं, क्योंकि मैं चाहता हूं कि हालत OR, न हो। वर्तमान में यह जाँच करता है कि इसमें कम से कम एक मूल्य xभी है या नहीं y, लेकिन आपकी स्थिति यह जाँच करेगी कि क्या सभी मान xभी अंदर हैं y। (उदाहरण यहाँ से कॉपी किया गया था )।

— fergusq

Answer 4

इनपुट के लिए स्ट्रीम का उपयोग करें

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

अधिकांश मामलों में सरणी तत्वों को स्ट्रीम में धकेल कर और फिर forलूप (या अंडरस्कोर) का उपयोग करके इसे पुनरावृत्त किया जाता है । चूंकि तत्व वैसे भी धारा से पुनरावृत्त होते हैं, इसलिए उन्हें परिभाषित नहीं किया जाना चाहिए कि वे शुरू से ही वहां क्यों हों ?

उदाहरण के लिए, इनपुट में संख्याओं के वर्गों की राशि की गणना करने के लिए:

{|a|a|[_^2]|sum} /* Removing a redundant argument */
{[_^2]|sum}      /* saves 5 bytes */

Answer 5

कोष्ठक कथन के संदर्भ में वैकल्पिक हैं। यह तब भी लागू होता है जब तर्क ऑपरेटर से शुरू होता है। उदाहरण के लिए, [a()|sqrt-_]से छोटा है [a()|sqrt(-_)]। के बाद कोष्ठक aअनिवार्य हैं, जैसा aकि अभिव्यक्ति के संदर्भ में है, बयान के संदर्भ में नहीं।

हालाँकि, लिखना [a()|sqrt(_+1)*2]संभव नहीं है, और पार्सर की मदद के लिए अतिरिक्त कोष्ठक की आवश्यकता है [a()|sqrt((_+1)*2)]:। अक्सर इस तरह की अभिव्यक्ति को फिर से लिखना संभव है, ताकि यह एक कोष्ठक के साथ शुरू न हो:[a()|sqrt 2*(_+1)]

Comments

क्या कोष्ठक की आवश्यकता के बिना कार्यों के लिए कई मापदंडों को पारित करना संभव है?

— user41805

@ कृतिलिथोस हां। उदाहरण के लिए। [a()|atan2 _,_]अनुमति दी जाएगी।

— फर्ग्यूस्क

Answer 6

के ,बजाय / बयानों ..में उपयोग करें[]push

संबंधित: इसके बजाय का उपयोग करें,and

pushसमारोह (और साथ ही printसमारोह) तर्कों के किसी भी संख्या लेते हैं, और कोई सीमांकक के साथ उनमें से हर एक आउटपुट कर सकते हैं।

तो इसका मतलब कुछ इस तरह है

["a"..b]        /*8 bytes (string "a" concatenated with variable b)*/

बस में छोटा किया जा सकता है

["a",b]         /*7 bytes*/

1 बाइट की बचत।

Answer 7

[]/ push>print

कभी भी printबयानों का उपयोग न करें । []पुश स्टेटमेंट हमेशा गोल्फर होते हैं। के बीच का अंतर printऔर pushहै कि पूर्व आउटपुट एक अनुगामी न्यू लाइन, जबकि दूसरा नहीं करता है। हालाँकि, इसे दरकिनार किया जा सकता है।

print"a"              /* 8 bytes */
["a                   /* 6 bytes; uses a literal newline */
"]

print"a",b            /* 10 bytes */
[`a$b                 /* 8 bytes; uses a literal newline and `` strings */
`]

Answer 8

``तार का उपयोग करना

में ""तार, आप उन्हें का उपयोग करने के कुछ वर्णों से बचने के लिए होगा। उदाहरण के लिए, बैकस्लैश को प्रिंट करने के लिए, आपके पास एक स्ट्रिंग होना चाहिए "\\"। बैकस्लैश से बचने के लिए एक जोड़ा बाइट है। हालांकि, अगर आप का उपयोग करें ``, आप नहीं इस चरित्र से बचने के लिए किया है और एक बाइट बचा सकता है।

print"\\"     /* 9 bytes */
print`\`      /* 8 bytes */

---

सिर्फ इतना ही नहीं, आप ``स्ट्रिंग का उपयोग करके चर और भाव को अंदर कर सकते हैं $variableNameया ${expression}, एक विशेषता जो ""स्ट्रिंग में मौजूद नहीं है ।

_{हम इन उदाहरणों में अनुगामी न्यूलाइन के साथ "a"चर के मान के साथ संकलित स्ट्रिंग का आउटपुट कर रहे bहैं।}

["a",b,"      /* 11
"]               bytes   */
[`a$b         /* 8
`]               bytes; encodes b in the string using $b */

Answer 9

के ,बजाय का उपयोग करेंand

रोदा में स्थितियां धाराएँ हैं, और इसमें कई मूल्य शामिल हो सकते हैं। ये मूल्य एक बूलियन मान के साथ कम हो जाते हैं and।

इसका मतलब है कि आप की जगह ले सकता andसाथ ,स्ट्रीम में एक से अधिक मान पुश करने के लिए की स्थिति में:

x if[a and b]
x if[a,b]

खाली हालत सत्य है

ऐसी स्थिति होना भी संभव है जिसमें कोई मूल्य न हो, जो सत्य है।

x while true
x while[]

Answer 10

फॉर्म में रिप्लेसमेंट लिस्ट लिखें *"...;..."/";"

replaceसामान्य रूप से कार्य तर्कों के रूप स्ट्रिंग की एक सूची लेता है। हालाँकि, यदि यह सूची बहुत लंबी है, तो बस रिजेक्स / रिप्लेसमेंट जोड़े को एक स्ट्रिंग में स्टोर करना फायदेमंद है और फिर स्ट्रिंग को विभाजित करें और स्टार ऑपरेटर का उपयोग करें:

replace"a","b","c","d"
replace*"a;b;c;d"/";"