पर्ल 6 में गोल्फ के लिए टिप्स

Question

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

कृपया ध्यान दें कि पर्ल 6 पर्ल 5 नहीं है, इसलिए यह प्रश्न डुप्लिकेट नहीं है। पर्ल 5 गोल्फ के लिए ज्यादातर टिप्स सिर्फ पर्ल 6 पर लागू नहीं होते हैं।

Answer 1

subशाब्दिक अर्थ से बचें । कई मामलों में, आप बस {}कोड ब्लॉक के लिए उपयोग कर सकते हैं। उदाहरण के लिए, निम्नलिखित कोड न लिखें।

sub ($a){$a*2}

इसके बजाय, ब्लॉक सिंटैक्स का उपयोग करें। यह भी आप उपयोग करना की सुविधा देता है $_, @_और %_प्लेसहोल्डर चरों, यदि आप केवल एक ही चर की जरूरत है। यदि आपको अधिक आवश्यकता है, तो आप उपयोग कर सकते हैं $^a, $^bचर, और इसी तरह।

{$_*2}

इसके अलावा, कुछ दुर्लभ मामलों में, जो भी कोड का उपयोग करना संभव है (विशेषकर जब आपके पास सरल अभिव्यक्तियाँ हों)। *प्लेसहोल्डर तर्क बदल देता है।

* *2

Answer 2

पर्ल 6 में एक बहुत ही विचित्र विशेषता है, जहाँ यह सभी यूनिकोड पात्रों को एनडी , एनएल , और  नो में तर्कसंगत संख्या के रूप में इस्तेमाल करने की अनुमति देता है। इनमें से कुछ ASCII में अपने संख्यात्मक मूल्यों को लिखने से कम हैं:

• ¼(2 बाइट्स) .25या 1/4(3 बाइट्स) से छोटा है ।
• ¾(2 बाइट्स) .75या 3/4(3 बाइट्स) से छोटा है ।
• ৴(3 बाइट्स) 1/16(4 बाइट्स) से छोटा है ।
• 𐦼(4 बाइट्स) 11/12(5 बाइट्स) से छोटा है ।
• 𒐲(4 बाइट्स) 216e3(5 बाइट्स) से छोटा है ।
• 𒐳(4 बाइट्स) 432e3(5 बाइट्स) से छोटा है ।

Comments

इसके लिए अनुवर्ती कार्रवाई के रूप में, आप यूनिकोड घातांक का उपयोग भी कर सकते हैं, यहां तक ​​कि कई अंकों और / या माइनस के साथ: say (3² + 4², 2²⁰, 5⁻²)=>> (25 1048576 0.04)। यूनिकोड की पूरी सूची आप इस तरह से दुरुपयोग कर सकते हैं: docs.perl6.org/language/unicode_texas ।

— Ramillies

Answer 3

इनपुट पढ़ने के लिए कार्यों को जानें। पर्ल 6 में कई दिलचस्प कार्य हैं जो आसानी से एआरजीवी, या एसटीडीआईएन से इनपुट पढ़ सकते हैं (यदि एआरजीवी पर कुछ भी निर्दिष्ट नहीं किया गया था), जो सही तरीके से उपयोग किए जाने पर आपके कोड को छोटा कर सकता है। यदि आप उन्हें फ़ाइलहैंड विधि कहते हैं, तो आप उन्हें विशेष फ़ाइलहैंडल पर काम करने के लिए बाध्य कर सकते हैं (यदि आप उदाहरण के लिए पढ़ा जा सकता है STDIN, लेकिन आपको ARGV पर तर्क पढ़ना होगा)।

get

इस फ़ंक्शन को एक पंक्ति मिलती है, और स्वचालित रूप से इसे काटता है, इसलिए आपको नहीं करना है। यह उपयोगी है यदि आपको केवल एक पंक्ति पढ़ने की आवश्यकता है।

lines

यह फ़ंक्शन फ़ाइल या STDIN से सभी लाइनें प्राप्त करता है। यह एक आलसी सूची है, इसलिए यदि आप इसका उपयोग करते हैं for, तो यह केवल वही पढ़ेगा जो आपको चाहिए। उदाहरण के लिए।

say "<$_>"for lines

slurp

यह पूरी फ़ाइल या STDIN पढ़ेगा, और परिणाम को एक स्ट्रिंग के रूप में लौटाएगा।

Comments

यह बग तय हो गया - पता नहीं कब, लेकिन say "<$_>" for linesअब काम करता है

— बिल्ली

Answer 4

चेतावनी : पाठ की दीवार। यह बहुत सारी छोटी-छोटी तरकीबें हैं जिन्हें मैंने समय के साथ इकट्ठा किया।

अनाम ब्लॉक के रूप में अपने समाधान लिखें

यह पहले से ही उल्लेख किया गया था, लेकिन मैं इसे दोहराना चाहूंगा। TIO में, आप my $f =हेडर, ब्लॉक को उचित कोड में लिख सकते हैं और पाद को a से शुरू कर सकते हैं ;। ऐसा लगता है कि काम पूरा करने के लिए यह सबसे छोटा तरीका है (क्योंकि आपको किसी इनपुट को पढ़ने की परवाह करने की आवश्यकता नहीं है, यह आपको तर्क में दिया गया है)।

एक और अच्छा तरीका उपयोग कर रहा है -nया -pस्विच, लेकिन मैं इसे TIO में काम करने के लिए एक तरह से नहीं मिला।

तर्क पास करने के लिए कोलोन सिंटैक्स का उपयोग करें

इसके बजाय, है thing.method(foo,bar) , आप कर सकते हैं thing.method:foo,barऔर 1 चरित्र को बचा सकते हैं । दुर्भाग्य से, आप स्पष्ट कारणों के लिए परिणाम पर दूसरी विधि नहीं कह सकते हैं, इसलिए यह केवल ब्लॉक में अंतिम विधि के लिए उपयोग करने के लिए समझ में आता है।

उपयोग $_जितना हो सके उतना

कभी-कभी इसकी वजह से कई अलग-अलग तर्कों की तुलना में एकल सूची तर्क लेना बेहतर होता है। एक्सेस करते समय $_, आप केवल डॉट के साथ शुरू करके इस पर तरीके कह सकते हैं: उदा.sort इसके बराबर है $_.sort।

हालांकि, यह ध्यान रखें कि प्रत्येक ब्लॉक अपने स्वयं के हो जाता है $_ , इसलिए बाहरी ब्लॉक के पैरामीटर आंतरिक लोगों में नहीं फैलेंगे। यदि आप एक आंतरिक ब्लॉक से मुख्य समारोह के मापदंडों का उपयोग करने की जरूरत है, ...

का प्रयोग करें ^चर यदि आप उपयोग नहीं कर सकते$_

^इस तरह के बीच में, सतर्क और चर नाम डालें $^a:। ये केवल एक ब्लॉक के अंदर काम करते हैं। संकलक पहले गिना करता है कि आपके पास ब्लॉक में इनमें से कितने हैं, उन्हें शाब्दिक रूप से क्रमबद्ध करें, और फिर पहले तर्क को पहले एक, दूसरे को दूसरे और इसी तरह से असाइन करें। ^केवल चर की पहली घटना में उपयोग किए जाने की आवश्यकता है। तो {$^a - $^b}2 स्केलर लेता है और उन्हें घटाता है। केवल एक चीज जो मायने रखती है वह है वर्णमाला क्रम, इसलिए {-$^b + $^a}वही काम करता है।

यदि आपको कभी भी नुकीले ब्लॉक सिंटैक्स (जैसे ->$a,$b {$a.map:{$_+$b}}) का उपयोग करने का मन करता है , तो आप उस ब्लॉक के शुरू में फर्जी स्टेटमेंट लिखना बेहतर समझते हैं , जिसका उपयोग ^आप प्रत्येक मुख्य ब्लॉक (जैसे {$^b;$^a.map:{$_+$b}}) में नहीं करने जा रहे हैं (नोट) गोल्फ के लिए यह बेहतर तरीका है{$^a.map(*+$^b)} । मैं सिर्फ इस अवधारणा को दिखाना चाहता था।]

ऑपरेटर डॉक्स को ध्यान से पढ़ें

ऑपरेटर बहुत शक्तिशाली होते हैं और अक्सर वे काम करने का सबसे छोटा तरीका होते हैं। विशेष रूप से मेटा ऑपरेटरों (ऑपरेटरों कि एक तर्क के रूप ऑपरेटरों लेने के लिए) [], [\], X, <</ >>और Zआपका ध्यान के लायक हैं। मत भूलो कि एक मेटा-ऑप एक तर्क के रूप में एक और मेटा-ऑप ले सकता है (जैसे कि XZ%%मैं यहां उपयोग करने में कामयाब रहा )। आप >>एक विधि कॉल के लिए भी उपयोग कर सकते हैं , जो नक्शे की तुलना में बहुत सस्ता हो सकता है ( @list>>.methodबजाय @list.map(*.method), लेकिन सावधान रहें, वे समान नहीं हैं! )। और, अंत में, इससे पहले कि आप एक बाइनरी का उपयोग करें << >>, ध्यान रखें कि Zअक्सर बहुत कम पात्रों में एक ही काम करेंगे।

यदि आप एक-दूसरे पर बहुत सारे मेटा-ऑप्स छिपाते हैं, तो आप वर्ग कोष्ठक का उपयोग करके पूर्वता निर्दिष्ट कर सकते हैं []। जब आप इतने सारे संचालकों को ढेर कर देंगे तो यह आपको बचाएगा। (यह बहुत बार नहीं होता है।)

अंत में, आप, बूल, इंट या Str के लिए मजबूर चीजों की जरूरत है तरीकों का उपयोग नहीं करते .Bool, .Intऔर .Str, बल्कि ऑपरेटरों ?, +और ~। या इससे भी बेहतर, उन्हें इंट और इतने पर मजबूर करने के लिए उन्हें एक अंकगणितीय अभिव्यक्ति में डाल दें। किसी सूची की लंबाई पाने का सबसे छोटा तरीका है +@list। यदि आप किसी सूची की लंबाई की शक्ति की 2 गणना करना चाहते हैं, तो बस कहें 2**@listऔर यह द राइट थिंग करेगा।

मुक्त राज्य चर का उपयोग करें $, @और%

प्रत्येक ब्लॉक में, $(या @या %) की प्रत्येक घटना एक चमकदार नई स्केलर (या सरणी, या हैश) राज्य चर को संदर्भित करती है (एक चर जिसका मूल्य ब्लॉक में कॉल पर रहता है)। यदि आपको एक स्टेट वैरिएबल की आवश्यकता है जिसे केवल स्रोत कोड में एक बार संदर्भित करने की आवश्यकता है , तो ये तीन आपके बड़े दोस्त हैं। (सबसे अधिक बार $।) उदाहरण के लिए, रिवर्स मैथ साइकल चुनौती में, इसका इस्तेमाल ऑपरेटरों को एक सरणी से चक्रीय रूप से चुनने के लिए किया जा सकता है, जिसे अनुक्रमित किया गया था $++%6।

map, grepएट अल के उप रूपों का उपयोग करें ।

इसका मतलब है कि: बल्कि कर map {my block},listसे list.map({my block})। यहां तक ​​कि अगर आप उपयोग करने का प्रबंधन करते हैं list.map:{my block}, तो ये दोनों दृष्टिकोण समान संख्या में बाइट्स पर निकलते हैं। और अक्सर, आपको विधि को कॉल करते समय सूची को छोटा करना होगा, लेकिन उप को कॉल करते समय नहीं। इसलिए उप दृष्टिकोण हमेशा बेहतर होता है या कम से कम विधि एक के समान होता है।

यहाँ एकमात्र अपवाद तब है जब वह वस्तु जो mapपेड, grepपेड वगैरह होनी है , अंदर है $_। फिर .map:{}स्पष्ट रूप से धड़कता है map {},$_।

उपयोग जंक्शनों ( &और |) के बजाय &&और ||।

जाहिर है, वे 1 बाइट कम हैं। दूसरी ओर, उन्हें एक बूलियन संदर्भ में मजबूर होकर ढह जाना चाहिए। यह हमेशा एक के साथ किया जा सकता है ?। यहां आपको एक मेटा-ऑप के बारे में पता होना चाहिए !opजो बूल संदर्भ को मजबूर करता है, opपरिणाम का उपयोग करता है और नकारात्मक करता है ।

यदि आपके पास एक सूची है और आप इसे एक जंक्शन में बदलना चाहते हैं, तो उपयोग न करें [&]और [|]। इसके बजाय का उपयोग करें .anyऔर .all। ऐसा भी है .noneजो जंक्शन ऑप्स द्वारा इतनी आसानी से नकल नहीं किया जा सकता है।

Comments

मुझे लगता है कि &&और ||अभी भी कम सर्किटिंग लिए उपयोगी होते हैं?

— एएससीआईआई-केवल

@ ASCII- केवल: हाँ, निश्चित रूप से वे हैं।

— रामलीज

Answer 5

चरों के लिए उपयोग किए जाने वाले स्थान को कम करें

इसके कुछ हिस्से हैं।

व्हाट्सएप को हटा दें

का उपयोग myकर घोषित चर आमतौर पर myऔर चर नाम के बीच की जगह के बिना घोषित किया जा सकता है । my @aके बराबर है my@a।

सतर्क-कम चर का उपयोग करें

आप चर नाम का उपयोग करने से पहले सर्जन को हटाने के लिए एक बैकस्लैश का उपयोग करके चर घोषित कर सकते हैं, जैसे:

my \a=1;

(दुर्भाग्य से आप स्थान नहीं हटा सकते :()

यह तब उपयोगी है जब आप बाद में उन्हें केवल नंगे चर नाम से संदर्भित कर सकते हैं।

 a=5;
 a.say

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

का उपयोग करें $!और$/

ये पूर्व-घोषित चर आमतौर पर अपवाद और रेगेक्स मैचों के लिए क्रमशः उपयोग किए जाते हैं, लेकिन इसका उपयोग करने की आवश्यकता नहीं होती है my।

$!=1;
$/=5;

विशेष $/रूप से एक सरणी के रूप में उपयोग कर रहा है और सरणी के $उस तत्व तक पहुंचने के लिए एक नंबर के बाद शॉर्टकट का उपयोग कर रहा है $/;

$/=100..200;
say $5;  #105
say $99; #199

Answer 6

के ...बजाय का उपयोग करेंfirst

आमतौर पर, यदि आप पहली संख्या को खोजना चाहते हैं जो किसी शर्त से मेल खाती है &f, तो आप इसका प्रतिनिधित्व कर सकते हैं जैसे:

first &f,1..*

हालाँकि, इसके बजाय आप ...ऑपरेटर का उपयोग कर सकते हैं :

+(1...&f)

यदि आप से शुरू करना है 0, तो आप के -1बजाय बाद में हो सकता है +।

यदि आप किसी सूची में पहले तत्व का सूचकांक चाहते हैं @aजिसकी स्थिति &fसामान्य है, तो आप निम्न कार्य करते हैं:

first &f,@a,:k

बजाय:

(@a...&f)-1

(या इसके विपरीत अगर आप 0 अनुक्रमित करना चाहते हैं)। उसी तरह, आप पहले सभी तत्वों को प्राप्त कर सकते हैं जो स्थिति को पास करते हैं।

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