मैं खुद को सिखाने की कोशिश कर रहा हूं कि एक मनमानी फ़ंक्शन के लिए बिगओ नोटेशन की गणना कैसे करें। मुझे यह फ़ंक्शन एक पाठ्यपुस्तक में मिला। पुस्तक दावा करती है कि फ़ंक्शन O (n 2 ) है। यह क्यों है के रूप में एक स्पष्टीकरण देता है, लेकिन मैं पालन करने के लिए संघर्ष कर रहा हूं। मुझे आश्चर्य है कि अगर कोई मुझे गणित दिखाने में सक्षम हो सकता है तो ऐसा क्यों है। मौलिक रूप से, मैं समझता हूं कि यह O (n 3 ) से कुछ कम है , लेकिन मैं स्वतंत्र रूप से O (n 2 ) पर नहीं उतर सकता
मान लीजिए कि हमें संख्याओं के तीन अनुक्रम दिए गए हैं, ए, बी, और सी। हम मानेंगे कि किसी भी व्यक्तिगत अनुक्रम में डुप्लिकेट मान नहीं हैं, लेकिन हो सकता है कि कुछ संख्याएँ दो या तीन अनुक्रमों में हों। तीन-तरफ़ा सेट असंगति समस्या यह निर्धारित करने के लिए है कि तीन अनुक्रमों का प्रतिच्छेदन खाली है, अर्थात्, कोई तत्व x नहीं है जैसे कि x, A, x, B, और x dis C।
संयोग से, यह मेरे लिए एक होमवर्क समस्या नहीं है - कि जहाज वर्षों पहले रवाना हो गया है:), बस मुझे होशियार होने की कोशिश कर रहा है।
def disjoint(A, B, C):
"""Return True if there is no element common to all three lists."""
for a in A:
for b in B:
if a == b: # only check C if we found match from A and B
for c in C:
if a == c # (and thus a == b == c)
return False # we found a common value
return True # if we reach this, sets are disjoint
[संपादित करें] पाठ्यपुस्तक के अनुसार:
उन्नत संस्करण में, यह केवल ऐसा नहीं है कि हम भाग्यशाली होने पर समय की बचत करते हैं। हम दावा करते हैं कि असहमति के लिए सबसे खराब समय चल रहा है ओ (एन 2 ) है।
पुस्तक की व्याख्या, जिसे मैं पालन करने के लिए संघर्ष करता हूं, वह है:
समग्र रूप से चलने वाले समय के लिए, हम कोड की प्रत्येक पंक्ति को निष्पादित करने में लगने वाले समय की जांच करते हैं। A से अधिक लूप के प्रबंधन के लिए O (n) समय की आवश्यकता होती है। कुल ओ (एन 2 ) समय के लिए बी खातों पर लूप के लिए प्रबंधन , क्योंकि उस लूप को अलग-अलग समय पर निष्पादित किया जाता है। परीक्षण a == b का मूल्यांकन O (n 2 ) बार किया जाता है। बिताया गया शेष समय इस बात पर निर्भर करता है कि कितने मिलान (ए, बी) जोड़े मौजूद हैं। जैसा कि हमने उल्लेख किया है, ऐसे अधिकांश जोड़े ऐसे हैं, और इसलिए C के ऊपर लूप का प्रबंधन, और उस लूप के शरीर के भीतर कमांड, अधिकांश O (n 2 ) समय पर उपयोग करते हैं । बिताया गया कुल समय O (n 2 ) है।
(और उचित क्रेडिट देने के लिए ...) पुस्तक है: माइकल टी। गुडरिक एट द्वारा पायथन में डेटा संरचनाएं और एल्गोरिदम। सभी, विली प्रकाशन, स्नातकोत्तर। 135
[संपादित करें] एक औचित्य; अनुकूलन से पहले कोड नीचे दिया गया है:
def disjoint1(A, B, C):
"""Return True if there is no element common to all three lists."""
for a in A:
for b in B:
for c in C:
if a == b == c:
return False # we found a common value
return True # if we reach this, sets are disjoint
उपरोक्त में, आप स्पष्ट रूप से देख सकते हैं कि यह O (n 3 ) है, क्योंकि प्रत्येक लूप को अपने पूरे भाग में चलना चाहिए। पुस्तक यह कहती है कि सरलीकृत उदाहरण (पहले दिए गए) में, तीसरा लूप केवल O (n 2 ) की जटिलता है, इसलिए जटिलता समीकरण k + O (n 2 ) + O (n 2 ) के रूप में जाता है जो अंततः उपज देता है ओ (एन 2 )।
हालांकि मैं यह साबित नहीं कर सकता कि यह मामला है (इस प्रकार प्रश्न), पाठक इस बात से सहमत हो सकता है कि सरलीकृत एल्गोरिथ्म की जटिलता मूल से कम से कम है।
[संपादित करें] और यह साबित करने के लिए कि सरलीकृत संस्करण द्विघात है:
if __name__ == '__main__':
for c in [100, 200, 300, 400, 500]:
l1, l2, l3 = get_random(c), get_random(c), get_random(c)
start = time.time()
disjoint1(l1, l2, l3)
print(time.time() - start)
start = time.time()
disjoint2(l1, l2, l3)
print(time.time() - start)
पैदावार:
0.02684807777404785
0.00019478797912597656
0.19134306907653809
0.0007600784301757812
0.6405444145202637
0.0018095970153808594
1.4873297214508057
0.003167390823364258
2.953308343887329
0.004908084869384766
चूंकि दूसरा अंतर बराबर है, सरलीकृत फ़ंक्शन वास्तव में द्विघात है:
[संपादित करें] और अभी तक और भी सबूत:
अगर मैं सबसे खराब स्थिति मानता हूं (ए = बी! = सी),
if __name__ == '__main__':
for c in [10, 20, 30, 40, 50]:
l1, l2, l3 = range(0, c), range(0,c), range(5*c, 6*c)
its1 = disjoint1(l1, l2, l3)
its2 = disjoint2(l1, l2, l3)
print(f"iterations1 = {its1}")
print(f"iterations2 = {its2}")
disjoint2(l1, l2, l3)
पैदावार:
iterations1 = 1000
iterations2 = 100
iterations1 = 8000
iterations2 = 400
iterations1 = 27000
iterations2 = 900
iterations1 = 64000
iterations2 = 1600
iterations1 = 125000
iterations2 = 2500
दूसरे अंतर परीक्षण का उपयोग करना, सबसे खराब स्थिति परिणाम बिल्कुल द्विघात है।
