क्या पुनरावृति स्ट्रिंग एपेंड की समय-जटिलता वास्तव में हे (n ^ 2), या O (n) है?

Question 1

मैं सीटीआई से बाहर एक समस्या पर काम कर रहा हूं।

अध्याय 1 की तीसरी समस्या आपने एक स्ट्रिंग ली है जैसे कि

'Mr John Smith '

और आपको मध्यस्थ स्थानों को बदलने के लिए कहता है %20:

'Mr%20John%20Smith'

लेखक पायथन में इस समाधान की पेशकश करता है, इसे O (n) कहते हैं:

def urlify(string, length):
    '''function replaces single spaces with %20 and removes trailing spaces'''
    counter = 0
    output = ''
    for char in string:
        counter += 1
        if counter > length:
            return output
        elif char == ' ':
            output = output + '%20'
        elif char != ' ':
            output = output + char
    return output

मेरा प्रश्न:

मैं समझता हूं कि यह वास्तविक स्ट्रिंग के माध्यम से बाएं से दाएं स्कैनिंग के संदर्भ में ओ (एन) है। लेकिन पायथन अपरिवर्तनीय में तार नहीं हैं? यदि मेरे पास एक स्ट्रिंग है और मैं +ऑपरेटर के साथ एक और स्ट्रिंग जोड़ देता हूं , तो क्या यह आवश्यक स्थान आवंटित नहीं करता है, मूल पर प्रतिलिपि बनाता है, और फिर अपंग स्ट्रिंग पर कॉपी करता है?

अगर मेरे पास nप्रत्येक लंबाई 1 के तार का संग्रह है , तो यह है:

1 + 2 + 3 + 4 + 5 + ... + n = n(n+1)/2

या O (n ^ 2) समय , हाँ? या क्या मैं गलत हूँ कि पायथन को किस तरह से जोड़ा जाता है?

वैकल्पिक रूप से, अगर आप मुझे मछली मारने का तरीका सिखाने के लिए तैयार हैं: तो मैं इसे अपने लिए कैसे खोजूंगा? मैं Google के आधिकारिक स्रोत के अपने प्रयासों में असफल रहा हूँ। मैंने https://wiki.python.org/moin/TimeComplexity पाया, लेकिन इसमें स्ट्रिंग्स पर कुछ भी नहीं है।

Question 2

सीपीथॉन में, पायथन के मानक कार्यान्वयन, एक कार्यान्वयन विवरण है जो इसे आमतौर पर O (n) बनाता है, कोड++= में लागू किया गया है जो दो स्ट्रिंग ऑपरेंड के लिए या उसके साथ बाईटकोड मूल्यांकन लूप कॉल करता है । यदि पायथन को पता चलता है कि बाएं तर्क में कोई अन्य संदर्भ नहीं है, तो यह reallocस्ट्रिंग को जगह में बदलकर प्रतिलिपि से बचने का प्रयास करता है। यह ऐसा कुछ नहीं है जिस पर आपको कभी भरोसा करना चाहिए, क्योंकि यह एक कार्यान्वयन विवरण है और क्योंकि यदि reallocस्ट्रिंग को अक्सर स्थानांतरित करने की आवश्यकता होती है, तो प्रदर्शन ओ (एन ^ 2) के लिए वैसे भी खराब हो जाता है।

अजीब कार्यान्वयन विस्तार के बिना, एल्गोरिथ्म ओ (एन ^ 2) है जिसमें शामिल नकल की द्विघात राशि है। इस तरह कोड केवल सी + + और यहां तक कि सी ++ में आप का उपयोग करना चाहते हैं के साथ एक भाषा में समझ में आता है +=।

Question 3

लेखक यहाँ होने वाले अनुकूलन पर निर्भर करता है, लेकिन स्पष्ट रूप से भरोसेमंद नहीं है। strA = strB + strCआम तौर पर O(n), फ़ंक्शन बना रहा है O(n^2)। हालांकि, यह सुनिश्चित करना बहुत आसान है कि यह पूरी प्रक्रिया है O(n), एक सरणी का उपयोग करें:

output = []
    # ... loop thing
    output.append('%20')
    # ...
    output.append(char)
# ...
return ''.join(output)

संक्षेप में, appendऑपरेशन को बढ़ाया जाता है O(1) , (हालांकि आप इसे O(1)सही आकार में सरणी को पूर्व-आवंटित करके मजबूत बना सकते हैं ), जिससे लूप बन जाता है O(n)।

और फिर joinयह भी है O(n), लेकिन यह ठीक है क्योंकि यह लूप के बाहर है।

Question 4

मुझे पायथन स्पीड पर पाठ का यह टुकड़ा मिला > सबसे अच्छा एल्गोरिदम और सबसे तेज़ टूल का उपयोग करें :

स्ट्रिंग संघनन सबसे अच्छा है ''.join(seq)जिसके साथ एक O(n)प्रक्रिया है। इसके विपरीत, '+'या '+='ऑपरेटरों के उपयोग से एक O(n^2)प्रक्रिया हो सकती है क्योंकि प्रत्येक मध्यवर्ती चरण के लिए नए तार बनाए जा सकते हैं। CPython 2.4 दुभाषिया इस मुद्दे को कुछ हद तक कम करता है; हालाँकि, ''.join(seq)सबसे अच्छा अभ्यास है

Question 5

भविष्य के आगंतुकों के लिए: चूँकि यह CTCI प्रश्न है, इसलिए urllib पैकेज सीखने के लिए किसी भी संदर्भ की आवश्यकता नहीं है, विशेष रूप से OP और पुस्तक के अनुसार, यह प्रश्न Arrays और Strings के बारे में है।

यहाँ एक और पूर्ण समाधान है, जो @ njzk2 के छद्म से प्रेरित है:

text = 'Mr John Smith'#13 
special_str = '%20'
def URLify(text, text_len, special_str):
    url = [] 
    for i in range(text_len): # O(n)
        if text[i] == ' ': # n-s
            url.append(special_str) # append() is O(1)
        else:
            url.append(text[i]) # O(1)

    print(url)
    return ''.join(url) #O(n)


print(URLify(text, 13, '%20'))