Efficiently inserting a decimal in perl string -

मैं कोड भर आया:

  sub insertDecimal {my $ number = shift; मेरी $ sigDigRight = शिफ्ट; यदि ($ संख्या = ~ /। ./) {वापसी ($ संख्या); } एल्सफ़ (लंबाई $ संख्या & lt; $ sigDigRight) {वापसी ($ संख्या); } Else {my $ leftSide = substr ($ संख्या, 0, (लंबाई $ संख्या) - $ sigDigRight); मेरी $ rightSide = substr ($ संख्या, (लंबाई $ संख्या) - $ sigDigRight,); वापसी ($ बाएं साइड। "।" $ सही साइड); }}  

और मुझे इस रूप में सुधार / पुनः लिखने की उम्मीद थी:

  sub insertDecimal {my ($ number, $ sigDigRight) = @_; इंडेक्स ($ संख्या, '।') = $ 1 या लंबाई $ संख्या & lt; $ SigDigRight; # हाँ! उपस्ट्रैक्ट एक एलवीआरएड लेता है ... इसे अधिक के लिए प्रतिलिपि करें :) substr ($ संख्या, - $ sigDigRight, 0) = '।'; वापसी संख्या $;  
 प्रश्न:  
 प्रश्न:  
   
 Li> डालने के बेहतर तरीके के साथ  अतिप्रवाह  किसी भी व्यक्ति को अधिक कुशल बनाने के लिए?  
 कैसे मुझे कोई सुधार नहीं दिखाई दे, बिल्कुल (74 एमएम रिकॉर्ड पर सिर्फ एक मिनट बेहतर)?  
 अगर पर्ल संकलक पहले संस्करण के कोड को अधिक कुशल बनाने के लिए पुन: जगी है, तो क्या मैं वैसे भी निष्पादन के लिए बेहतर पथ देख सकता हूँ जो कि पर्ल ने चुना है?    
 
 
 दोनों रूटीन अनिवार्य रूप से एक समान काम करने लगेगा:  
 
 
 स्कैन करें  $ संख्या  एक एकल वर्ण के लिए (कोई भी कंपाइलर उस रेगेक्स मैच को  index  से कम करने में सक्षम होना चाहिए) 
 
 
 
 लंबाई की तुलना करें  $ number  से एक सीमा 
 
 
 
 संभवतः  $ number  
 
 
 में कहीं भी एक अक्षर डालें > 
 
 लावल्यू  सबस्ट्रेट  का उपयोग करना (या, सिर्फ  substr  के चौथे तर्क का लाभ लेना) सम्मिलन को थोड़ा और अधिक कुशल बना सकता है, लेकिन, आखिरकार, चीजों को स्थानांतरित करना होगा। 
 
 मेरे लिए आंख, ऑप्टिमाइजेशन का सबसे बड़ा अवसर दशमलव बिंदु के लिए चेक के आगे की लंबाई की जांच को आगे ले जाने से आता है। 
 
 मुझे आपकी रूटीन को फिर से लिखने का प्रलोभन होगा 
 
  उप डालें दशमलव (मेरी $ $ संख्या, $ sigDigRight) = @_; लंबाई ($ संख्या) & lt; $ SigDigRight; यदि सूचकांक ($ संख्या, '।') & Gt; = 0; Substr ($ संख्या, - $ sigDigRight, 0, '।'); $ संख्या; }  
 
 मुझे समझने में आसान होने के लिए सरल निर्णय और छोटी लाइन मिलती हैं I मुझे नहीं लगता कि यह फ़ंक्शन की शुद्धता को बदलना चाहिए। 
 
 एक बदसूरत विकल्प है: 
 
  उप gah {my ($ number, $ sigDigRight) = @_; मेरी $ n = लंबाई ($ संख्या) - $ sigDigRight; जब तक कि $ n & gt; 0; $ Number = ~ s {\ A ([^।] {$ N}) ([^।] +) \ Z} {$ 1. $ 2} x; $ संख्या; }  
 
 यह ।  की प्रतिस्थापन प्रक्रिया के लिए जांच को जोड़ती है। 
 
 दोबारा, मैं यह निश्चित नहीं कर सकता कि यह आपकी कल्पना सही है, लेकिन यह आपके लिए कुछ अन्वेषण करना है। 
 
 मैं संभवत:  gah  के लिए विकल्प नहीं चुनता जब तक कि सुधार 20% से ज्यादा नहीं होता जो कम से कम एक घंटे या उससे अधिक समय तक लेता था। मेरे सिस्टम पर, यह 1,000% तक एक सरल उदाहरण को धीमा कर देती है।