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

47

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

code-golf  tips  perl 
— कमांडो
स्रोत

जवाबों:

26

TMTOWTDI

यह सबसे महत्वपूर्ण पर्ल गोल्फ टिप है जिसे आपको जानना आवश्यक है। जब भी आप अपने कार्य को पूरा करने के लिए आपके पास कुछ वर्णों के लंबे-लंबे अनुक्रम देख रहे हों, तो अपने आप से पूछें कि क्या किसी अन्य सुविधा का उपयोग करके समान प्रभाव प्राप्त करने का कोई अन्य तरीका नहीं है। वहाँ आमतौर पर है। यहाँ सिर्फ एक मुट्ठी भर हैं:

  • ~~एक स्केलर संदर्भ लागू करता है और 4 चार्ट से छोटा होता है scalar।

  • y///clengthकी लंबाई प्राप्त करने की तुलना में एक चार छोटा है $_।

  • में चार्ट पर पुनरावृति करने की आवश्यकता है $_? बदलें split//के साथ /./gs। (या उपयोग करें /./gयदि आप भी newlines को छोड़ना चाहते हैं।) यह अन्य चर के साथ काम करता है: के split//,$xसाथ बदलें $x=~/./gs।

  • प्रत्येक पर्ल बिल्डिन कुछ देता है। printरिटर्न 1, उदाहरण के लिए, सफल I / O इंगित करने के लिए। यदि आपको $_एक सच्चे मूल्य को शुरू करने की आवश्यकता है , उदाहरण के लिए, $_=print$fooआपको एक पत्थर से दो पक्षियों को मारने की अनुमति मिलती है।

  • पर्ल में लगभग हर कथन को एक अभिव्यक्ति के रूप में लिखा जा सकता है, जिससे इसे व्यापक संदर्भों में उपयोग किया जा सकता है। कई कथन कॉमा के साथ मिलकर कई भाव बन सकते हैं। टेस्ट शॉर्ट-सर्किट ऑपरेटरों के साथ किया जा सकता है ?: && ||के साथ, और यह भी andऔर or, जो एक ही काम करते हैं लेकिन पूर्वता के साथ (काम सहित) अन्य सभी ऑपरेटरों की तुलना में कम। लूप्स के माध्यम से mapया किया जा सकता है grep। यहां तक ​​कि कीवर्ड जैसे next, lastऔर returnअभिव्यक्ति के संदर्भ में उपयोग किए जा सकते हैं, भले ही वे वापस न आएं! इस प्रकार के परिवर्तनों को ध्यान में रखते हुए, आपको उन कोड ब्लॉक को अभिव्यक्ति के साथ बदलने का अवसर मिलता है, जिन्हें एक विस्तृत विविधता के संदर्भों में भरा जा सकता है।

— रोटी का डिब्बा
स्रोत
$_=print""से छोटा है $_=print$foo।
— ASCIIThenANSI
5
विचार यह है कि आपको पहले से ही प्रिंट करने की आवश्यकता है $foo। अन्यथा, $_=1की तुलना में बहुत कम है $_=print""और समान प्रभाव है।
— ब्रेडबॉक्स
3
तीसरे के लिए क्या आप का मतलब है चेरों के ऊपर चलना $x? अन्यथा आप बस /./gsऔर कर सकते थे /./g।
— redbmk
25

दुर्व्यवहार पर्ल के विशेष चर!

  • पिछले एक जवाब में बताया गया है $/और $"करने के लिए डिफ़ॉल्ट रूप से प्रारंभ कर रहे हैं "\n"और " "क्रमश:।

  • $,और $\दोनों undefडिफ़ॉल्ट रूप से सेट हैं , और 3 चार्ट छोटे हैं।

  • $\मान पर सेट करने के कारण इसे हर पर जोड़ा जाएगा print। उदाहरण के लिए: perl -ple '$\="=".hex.$/'एक हेक्स-टू-दशमलव कनवर्टर है।

  • यदि आप कमांड-लाइन से फाइल नहीं पढ़ रहे हैं, तो आप -iस्ट्रिंग को इनपुट करने के लिए एक अतिरिक्त चैनल के रूप में कमांड-लाइन स्विच का उपयोग कर सकते हैं । इसके मूल्य में संग्रहीत किया जाएगा $^I।

  • $=जो कुछ भी उसे सौंपा गया है वह पूर्णांक होने के लिए बाध्य करता है। चलाने की कोशिश करें perl -ple '$_=$==$_'और इसे विभिन्न आवेषण दें। इसी तरह, $-इसका मान एक गैर-नकारात्मक पूर्णांक बनने के लिए मजबूर करता है (यानी एक अग्रणी डैश को गैर-संख्यात्मक वर्ण के रूप में माना जाता है)।

  • आप $.एक बूलियन ध्वज के रूप में उपयोग कर सकते हैं जो while(<>)लूप के प्रत्येक पुनरावृत्ति पर एक सच्चे (नॉनजेरो) मान पर स्वचालित रूप से रीसेट हो जाता है ।

— रोटी का डिब्बा
स्रोत
20

-n और बेजोड़ घुंघराले कोष्ठक

यह सर्वविदित है कि कमांड लाइन स्विच -nका उपयोग स्क्रिप्ट को हर पंक्ति के लिए एक बार निष्पादित करने के लिए किया जा सकता है।

perl --help कहते हैं:

  -n                assume "while (<>) { ... }" loop around program

यह स्पष्ट रूप से नहीं कहता है कि पर्ल केवल कार्यक्रम के चारों ओर एक लूप नहीं लेता है; यह सचमुच इसके while (<>) { ... }चारों ओर लपेटता है।

इस तरह, निम्नलिखित कमांड एक दूसरे के बराबर हैं:

 perl -e 'while(<>){code}morecode'
 perl -ne 'code;END{morecode}'
 perl -ne 'code}{morecode'

-p और बेजोड़ घुंघराले कोष्ठक

उपरोक्त के समान, प्रोग्राम के चारों ओर -pस्विच लपेटता है while (<>) { ... ; print }।

बेजोड़ घुंघराले ब्रैकेट का उपयोग करके, इनपुट के सभी लाइनों के लिए perl -p 'code}{morecode'निष्पादित करने codeके बाद केवल एक बार प्रिंट करेगा , उसके बाद morecode।

निष्पादित $_होने के बाद अपरिभाषित होने के बाद morecode;print, आउटपुट रिकॉर्ड विभाजक $\को वास्तविक आउटपुट प्रिंट करने के लिए दुरुपयोग किया जा सकता है।

उदाहरण के लिए

perl -pe '$\+=$_}{'

STDIN से प्रति पंक्ति एक संख्या पढ़ता है और उनकी राशि प्रिंट करता है।

— डेनिस
स्रोत
मैं मान रहा हूँ कि आप #!perl -nइसे पहली पंक्ति के साथ पूरा कर सकते हैं , है ना?
— ASCIIThenANSI
@ASCIIThenANSI: हां, यह सही है। (देर से जवाब के लिए क्षमा करें।)
— डेनिस
1
क्रेडिट देने के कारण जहां क्रेडिट होता है, मुझे लगता है कि मैंने @primo के पर्ल उत्तरों में से एक में पहली बार इन तीन ट्रिक्स (बेजोड़ घुंघराले कोष्ठक, -pऔर $\​) के संयोजन को देखा । उसके जवाब पढ़ने के लिए अपने आप में एक अच्छा पर्ल टिप है।
— डेनिस
1
}for(...){ब्रेसिज़ के बीच में एक को फेंकना अक्सर काफी आसान होता है, जैसे कि codegolf.stackexchange.com/a/25632
— primo
-N के साथ संयोजन के रूप में उपयोगी एक चीज मुझे मिली है = = डिफ़ॉल्ट मान असाइनमेंट ऑपरेटर। लूप से पहले एक मूल्य निर्दिष्ट करने में सक्षम नहीं होने के आसपास हो जाता है।
— १०
18

$_स्केलर संदर्भ को खत्म करने के लिए उपयोग करें । यह विशेष चर है जिसे अधिकांश फ़ंक्शन द्वारा डिफ़ॉल्ट के रूप में उपयोग किया जाता है, और बस मापदंडों को छोड़ना इस चर को संदर्भित करने के लिए एक शॉर्टकट है।

परिवर्तित करने से $nकरने के लिए $_, आप बदल सकते हैं $n=<>;chop$n;print$nकरने के लिए$_=<>;chop;print

यहां, printफ़ंक्शन $_डिफ़ॉल्ट रूप से सामग्री को प्रिंट chopकरता है , और काम भी करता है $_।

— PhiNotPi
स्रोत
है $_=<>;आवश्यक है, नहीं करता है <>;में लाइन पढ़ $_स्वचालित रूप से?
— सूंदर
नहीं, मुझे ऐसा नहीं लगता। मैंने कार्यक्रमों $_=<>;printऔर की तुलना की <>;print। पहले वाला मुझे दोहराता है कि मैं क्या टाइप करता हूं, जबकि दूसरा नहीं।
— PhiNotPi
ओह, धन्यवाद, पता चला है कि केवल मामलों में होता है print while(<>)। नहीं यकीन है कि अगर यह एक विशेष मामला है या इसके पीछे कुछ सुसंगत तर्क है, न <>की में भाग perlopहै और न ही whileके हिस्से के perlsynइस व्यवहार का उल्लेख करने लगते हैं।
— सूंदर
1
@sundar while(<>)एक विशेष मामला है, जिसे perlsyn, I / O ऑपरेटर्स में प्रलेखित किया गया है: 'अगर और केवल अगर इनपुट सिंबल "जबकि" स्टेटमेंट के अंदर एक ही चीज है (भले ही "for (;)" के रूप में प्रच्छन्न हो) लूप), मान स्वचालित रूप से वैश्विक चर $ _ को सौंपा गया है, जो कुछ भी पहले था उसे नष्ट कर रहा है। "
— kernigh
17

पर्ल के विशेष चर का उपयोग करें, जहाँ आप कभी भी कर सकते हैं, जैसे:

  • के $"बजाय का उपयोग करें" "
  • के $/बजाय का उपयोग करें"\n"

उन्हें एक गारंटीकृत एक-वर्ण लंबे पहचानकर्ता होने का अतिरिक्त लाभ है, जो लेक्सर की मदद से है। इससे निम्न कीवर्ड के लिए इसे गोंद करना संभव हो जाता है, जैसे:print$.for@_

सभी विशेष चर की सूची यहां उपलब्ध है: विशेष चर

— 3aw5TZetdf
स्रोत
15

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

@i=qw(unique value);

इसके बजाय नंगे पासवर्ड का उपयोग करें।

@i=(unique,value);

या यदि आप नंगे पासवर्ड का उपयोग नहीं कर सकते हैं, तो globसिंटैक्स का उपयोग करें ।

@i=<unique value>;

glob दिलचस्प प्रभावों के लिए सिंटैक्स का उपयोग भी किया जा सकता है।

@i=<item{1,2,3}>;
— कोनराड बोरोस्की
स्रोत
12

कंपाउंड स्टेटमेंट के बजाय स्टेटमेंट मॉडिफायर का इस्तेमाल करें।

कंपाउंड स्टेटमेंट में तर्क के लिए कोष्ठक की आवश्यकता होती है और ब्लॉक के लिए ब्रेसिज़ की आवश्यकता होती है, जबकि स्टेटमेंट संशोधकों की न तो आवश्यकता होती है।

की तुलना करें:

  • $a++,$b++while$n-- बनाम while($n--){$a++;$b++}
  • chop$,if$c बनाम if($c){chop$,}

ध्यान दें कि अंतिम उदाहरण के साथ संबंध है $c&&chop$,, लेकिन अधिकांश मल्टी-स्टेटमेंट ऑपरेशन के लिए वास्तव में चमकना शुरू होता है। मूल रूप से कुछ भी है कि ऑपरेटर पूर्वता खो देता है &&।

— जेबी
स्रोत
11

नहीं है use strict। (इस पर मुझे उद्धृत न करें, PCG.SE संदर्भ थोड़े मायने रखता है) और, इससे भी महत्वपूर्ण बात, कोड को कड़ाई के तहत नहीं। सामान्य संदिग्ध:

  • myयदि आप इसे टाल सकते हैं तो -Darelare वैरिएबल न करें । केवल चर जो वास्तव में ज़रूरत myहोती है, वे हैं जिन्हें आप lexically scoped चाहते हैं। यह मुश्किल से उनमें से कोई है जब गोल्फ, जहाँ आपको गुंजाइश सुरक्षा की आवश्यकता नहीं है और पूरी तरह से पुनरावर्तन को नियंत्रित करने की प्रवृत्ति है।
  • एक-शब्द तार को उद्धृत न करें: ( उदाहरण )। सुनिश्चित करें कि आपके पास समान नाम के साथ कोई फ़ंक्शन नहीं है, हालांकि।
— जेबी
स्रोत
5
print helloकाम नहीं करेगा। इसका असल में मतलब print hello $_(प्रिंट $_टू फाइलहैंडल hello) है।
— कोनराड बोरोस्की
@GlitchMr धन्यवाद! (और अब मैं स्तब्ध हूं, क्योंकि मेरी बात अभी भी मान्य है, बस साथ नहीं है print, और अब मुझे एक अच्छा और छोटा उदाहरण नहीं मिल सकता है)
— जेबी
@JB यहाँ एक अच्छा उदाहरण है: codegolf.stackexchange.com/a/8746/3348
— ardnew
11

मुझे यकीन है कि इनमें से कुछ के औपचारिक नाम हैं और मुझे उनके बारे में अभी जानकारी नहीं है।

  • यदि आपके पास एक लूप है (या लूप के लिए जिसे आप थोड़ी देर के लूप में बना सकते हैं) आप कमांड के बाद "जबकि" को परिभाषित कर सकते हैं: print $n++ while ($n < 10)
  • यदि आपको STDIN से सब कुछ एक स्ट्रिंग में पढ़ने की आवश्यकता है: $var = join('',<>)
  • जैसा कि CeilingSpy ने बताया, $ n के बजाय $ / का उपयोग करना कुछ स्थितियों में तेज है: print ('X'*10) . "\n";से अधिक लंबा हैprint ('X'*10) . $/;
  • पर्ल का sayकार्य इससे छोटा है print, लेकिन आपको कोड को -Eइसके स्थान पर चलाना होगा-e
  • लाइक a..zया यहां तक ​​कि उपयोग करें aa..zz। यदि स्ट्रिंग के रूप में आवश्यक हो, तो उपयोग करें join।
  • बढ़ते तार: $z = 'z'; print ++$z;प्रदर्शित करेगाaa

यही सब मैं अभी सोच सकता हूं। मैं बाद में कुछ और जोड़ सकता हूं।

— श्री लामा
स्रोत
1
क्या करना print ('X'*10) . $/;चाहिए? मेरे लिए यह प्रिंट 0और कोई नई रेखा नहीं है। एक बात के लिए, कोष्ठक एक फंक्शन-स्टाइल कॉल तर्क बन जाता है print, जो की तुलना में सख्त होता है .। और क्या आपका मतलब या कुछ के xबजाय था *?
— aschepler
पोस्टफ़िक्स में किसी भी कोष्ठक की आवश्यकता नहीं है while, join'',<>;उनके बिना भी काम करता है।
— कोरोबा
10

चर नामों के रूप में गैर-शब्द वर्णों का उपयोग करें

$%इसके बजाय का उपयोग करके $aआप चर नाम को एक के ठीक बगल में रख सकते हैं if, forया इसके whileरूप में निर्माण कर सकते हैं:

@r=(1,2,3,4,5);$%=4; print$_*$%for@r

कई का उपयोग किया जा सकता है, लेकिन डॉक्स और @ ब्रेडबॉक्स के उत्तर की जांच करें जिनके लिए जादू प्रभाव हैं!

जब आप स्टेटमेंट संशोधक का उपयोग नहीं कर सकते हैं तो मैप का उपयोग करें

यदि आप @ जेबी के उत्तर के अनुसार स्टेटमेंट मॉडिफायर का उपयोग नहीं कर सकते हैं , तो नक्शा एक बाइट को बचा सकता है:

for(@c){} बनाम map{}@c;

और उपयोगी है यदि आप नेस्टेड पुनरावृत्तियों करना चाहते हैं क्योंकि आप के forअंदर पोस्टफ़िक्स लूप डाल सकते हैं map।

सभी जादू नियमित अभिव्यक्ति चर का उपयोग करें

पर्ल में 'मैच से पहले टेक्स्ट' और 'मैच के बाद टेक्स्ट' के लिए मैजिक वैरिएबल्स हैं, इसलिए कम से कम दो के साथ दो समूहों में विभाजित करना संभव है:

($x,$y)=split/,/,$_;
($x,$y)=/(.+),(.+)/;
/,/; # $x=$`, $y=$'
# Note: you will need to save the variables if you'll be using more regex matches!

यह भी एक प्रतिस्थापन के रूप में अच्छी तरह से काम कर सकता है substr:

$s=substr$_,1;
/./;# $s=$'

$s=substr$_,4;
/.{4}/;# $s=$'

यदि आपको मैच की सामग्री की आवश्यकता है, तो $&इसका उपयोग किया जा सकता है, जैसे:

# assume input like '10 PRINT "Hello, World!"'
($n,$c,$x)=split/ /,$_;
/ .+ /; # $n=$`, $c=$&, $x=$'

एक छोटे नाम के साथ लंबे नामों के साथ उप प्रतिस्थापित करें

यदि आप printअपने कोड में चार या अधिक बार कहते हैं (यह स्पष्ट रूप से आपके द्वारा कॉल की जा रही दिनचर्या की लंबाई के साथ भिन्न होता है), इसे एक छोटे उप नाम के साथ बदलें:

sub p{print@_}p;p;p;p

बनाम

print;print;print;print

सशर्त इन्क्रीमेंटर्स / डिक्रीमेंटर्स बदलें

यदि आपके पास कोड है:

$i--if$i>0

आप उपयोग कर सकते हैं:

$i-=$i>0

इसके बजाय कुछ बाइट्स बचाने के लिए।

पूर्णांक में परिवर्तित करें

यदि आप एक चर को असाइन नहीं कर रहे हैं और इसलिए ब्रेडबॉक्स की टिप का उपयोग नहीं कर सकते हैं, तो आप अभिव्यक्ति का उपयोग कर सकते हैं 0|:

rand 25 # random float eg. 19.3560355885212

int rand 25 # random int

0|rand 25 # random int

rand 25|0 # random int

~~rand 25 # random int

हालाँकि यह ध्यान देने योग्य है कि सरणी इंडेक्स तक पहुँचने के लिए आपको पूर्णांक का उपयोग करने की आवश्यकता नहीं है:

@letters = A..Z;
$letters[rand 26]; # random letter
— डोम हेस्टिंग्स
स्रोत
9

redoबिना किसी ब्लॉक के लूप व्यवहार जोड़ता है forया while। {redo}एक अनंत लूप है।

— user130144
स्रोत
7

फ़ंक्शन कॉल को छोटा न करें।

पर्ल आपको NAME LISTसिंटैक्स का उपयोग करके एक ज्ञात (कोर या पूर्ववर्ती) फ़ंक्शन को कॉल करने देता है । इससे आपको &सजग (यदि आप अभी भी इसका उपयोग कर रहे थे) और साथ ही कोष्ठकों को छोड़ सकते हैं।

उदाहरण के लिए: $v=join'',<>

पूर्ण प्रलेखन

— जेबी
स्रोत
5

असाइनमेंट एक्सप्रेशन के मान का उपयोग करने का प्रयास करें, जैसे:

# 14 characters
$n=pop;$o=$n&1

# 13 characters, saves 1
$o=($n=pop)&1

यह काम करता है क्योंकि $nपर्ल में 2 अक्षर हैं। आप बदल सकते हैं $nकरने के लिए ()किसी कीमत पर, और कोष्ठक में काम ले जाकर 1 अर्धविराम सहेजें।

— kernigh
स्रोत
5

नेस्टेड टर्नरी लॉजिक के भीतर आप कई अलग-अलग स्टेटमेंट चला सकते हैं।

मान लीजिए आप एक बड़ा है if- elsifबयान। यह किसी भी तर्क और बयानों की संख्या हो सकती है।

if( $_ < 1 ) {
    $a=1;
    $b=2;
    $c=3;
    say $a.$b.$c;
} elsif($_ < 2 ) {
    $a=3;
    $b=2;
    $c=1;
    say $a.$b.$c;
} elsif( $_ < 3) {
    $a=2;
    $b=2;
    $c=2;
    say $a.$b.$c;
}

आप (cmd1, cmd2, cmd3)सभी आदेशों को चलाने के लिए टर्नरी ऑपरेटर के अंदर का उपयोग कर सकते हैं ।

$_ < 1 ?
    ($a=1,$b=2,$c=3,say$a.$b.$c):
$_ < 2 ?
    ($a=3,$b=2,$c=1,say$a.$b.$c):
$_ < 3 ?
    ($a=2,$b=2,$c=2,say$a.$b.$c):
0; #put the else here if we have one

यहाँ एक उदाहरण है:

perl -nE'$_<1?($a=1,$b=2,$c=3,say$a.$b.$c):$_<2?($a=3,$b=2,$c=1,say$a.$b.$c):$_<3?($a=2,$b=2,$c=2,say$a.$b.$c):0;' <(echo 2)
— hmatt1
स्रोत
4

के select(undef,undef,undef,$timeout)बजाय का उपयोग करेंTime::HiRes

( Https://stackoverflow.com/a/896928/4739548 से लिया गया )

कई चुनौतियों के लिए आपको पूर्णांक की तुलना में अधिक सटीक नींद की आवश्यकता होती है। select()समयबाह्य तर्क बस ऐसा कर सकते हैं।

select($u,$u,$u,0.1)

की तुलना में बहुत अधिक कुशल है:

import Time::HiRes qw(sleep);sleep(0.1)

पूर्व केवल 20 बाइट्स है, जबकि उत्तरार्द्ध 39 तक लेता है। हालांकि, पूर्व की आवश्यकता है कि आप इसका उपयोग नहीं कर रहे हैं $uऔर इसे कभी भी परिभाषित नहीं किया है।

यदि आप इसका उपयोग करने जा रहे हैं तो बहुत अधिक आयात Time::HiResभुगतान बंद हो जाता है, लेकिन यदि आपको केवल एक बार इसकी आवश्यकता है, तो select($u,$u,$u,0.1)19 बाइट्स का उपयोग करके बचत होती है, जो निश्चित रूप से ज्यादातर मामलों में सुधार है।

— ASCIIThenANSI
स्रोत
1

अपने प्रिंट स्टेटमेंट को छोटा करें

जब तक चुनौती अन्यथा निर्दिष्ट नहीं हो जाती, आपको नई रूपरेखाओं की आवश्यकता नहीं है।
हमारी 'चुनौती' कहती है 'आउटपुट एक यादृच्छिक संख्या 0 से 9 तक STDOUT'। हम यह कोड ले सकते हैं (28 बाइट्स):

$s=int(rand(10));print"$s\n"

और इसे छोटा करें (25 बाइट्स):

$s=int(rand(10));print $s

केवल चर को प्रिंट करके। यह अंतिम केवल इस चुनौती पर विशेष रूप से लागू होता है (19 बाइट्स):

print int(rand(10))

लेकिन यह केवल तभी काम करता है जब आपको असाइनमेंट और प्रिंटिंग के बीच वैरिएबल के लिए कुछ भी करने की आवश्यकता नहीं होती है।

— ASCIIThenANSI
स्रोत
पिछले एक पहले से ही यहाँ सूचीबद्ध है ।
— Sp3000
@ Sp3000 धन्यवाद, मैंने अपना उत्तर अपडेट कर दिया है।
— ASCIIThenANSI
1

स्ट्रिंग लिटरल्स जैसे ग्लब्स का इस्तेमाल करें

कभी-कभी (अक्सर जब क्वीन या प्रतिबंधित-स्रोत चुनौतियों से निपटने के लिए) आप घोंसला स्ट्रिंग शाब्दिक क्षमता से बहुत लाभ उठाते हैं। आम तौर पर, आप ऐसा करेंगे q(…)। हालांकि, स्ट्रिंग के अंदर आपको किन पात्रों की आवश्यकता है, इसके आधार पर, आप एक बाइट को बचाने और <…>ग्लोब ऑपरेटर का उपयोग करने में सक्षम हो सकते हैं । (ध्यान दें कि कोण कोष्ठक के अंदर क्या एक फ़ाइलहैंडल की तरह नहीं दिख सकता है, और यह नहीं देख सकता है कि इसका नाम फ़ाइल नाम की सूची में विस्तारित किया जाना है, जिसका अर्थ है कि बहुत सारे वर्ण सही ढंग से काम नहीं करेंगे।)

0

अभिव्यक्ति regexe का उपयोग करें।

इसका स्पष्ट चित्रण साइन वेव में इनपुट को आकार देने वाले कोड का अनुसरण कर रहा है:

s/./print" "x(sin($i+=.5)*5+5).$&/eg;

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

— क्रेज़सटेस्टो ज़्वेज़्स्की
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.