क्या कोई O (1 / n) एल्गोरिदम हैं?

Question

क्या कोई O (1 / n) एल्गोरिदम हैं?

या कुछ और जो ओ (1) से कम है?

Comments

अधिकांश प्रश्न यह मानते हैं कि क्या "ओ (1 / n) की समय जटिलता के साथ कोई एल्गोरिदम है?" क्या हम मान लेंगे कि यह मामला है? बिग-ओ (और बिग-थीटा, आदि) फ़ंक्शन का वर्णन करते हैं, एल्गोरिदम नहीं। (मैं फ़ंक्शन और एल्गोरिदम के बीच कोई समानता नहीं जानता हूं।)

— jyoungdev

कंप्यूटर विज्ञान में "ओ (एक्स) एल्गोरिथ्म" की सामान्य रूप से समझ में आने वाली परिभाषा है: एक एल्गोरिथ्म जिसकी समय जटिलता हे (एक्स) (कुछ अभिव्यक्ति एक्स के लिए) है।

— डेविड

मैंने बफ़र ट्री का उपयोग करके I / O कुशल प्राथमिकता कतार एल्गोरिथ्म के मामले में इस तरह की बाध्यता सुनी है। बफ़र ट्री में, प्रत्येक ऑपरेशन O (1 / B) I / Os लेता है; जहां B ब्लॉक आकार है। और n संचालन के लिए कुल I / Os O (n / B.log (आधार M / B) (n / B)) है, जहां लॉग भाग बफर ट्री की ऊंचाई है।

— CODError

O (1 / n) त्रुटि प्रायिकता के साथ बहुत सारे एल्गोरिदम हैं। उदाहरण के लिए ओ (एन लॉग एन) बाल्टी के साथ एक ब्लूम फ़िल्टर।

— थॉमस अहले

आप मुर्गियों को जोड़कर तेजी से अंडे नहीं दे सकते।

— व्याक

Answer 1

यह सवाल उतना बेवकूफ नहीं है जितना यह लग सकता है। कम से कम सैद्धांतिक रूप से, O (1 / n ) जैसी कोई चीज पूरी तरह से समझदार है जब हम बिग O संकेतन की गणितीय परिभाषा लेते हैं :

अब आप कर सकते हैं आसानी से स्थानापन्न जी ( एक्स ) के लिए 1 / एक्स ... यह स्पष्ट है कि उपरोक्त परिभाषा अभी भी कुछ के लिए रखती है च ।

स्पर्शोन्मुखी रन-टाइम वृद्धि का आकलन करने के उद्देश्य से, यह कम व्यवहार्य है ... एक सार्थक एल्गोरिथ्म तेजी से नहीं बढ़ सकता क्योंकि इनपुट बढ़ता है। निश्चित रूप से, आप इसे पूरा करने के लिए एक मनमाने ढंग से एल्गोरिथ्म का निर्माण कर सकते हैं, जैसे निम्नलिखित एक:

def get_faster(list):
    how_long = (1 / len(list)) * 100000
    sleep(how_long)

स्पष्ट रूप से, यह फ़ंक्शन इनपुट आकार बढ़ने पर कम समय व्यतीत करता है ... कम से कम कुछ सीमा तक, हार्डवेयर द्वारा लागू (संख्याओं की सटीकता, न्यूनतम समय जो sleepप्रतीक्षा कर सकता है, तर्कों को संसाधित करने का समय आदि): यह सीमा तब होगी निरंतर कम बाउंड तो वास्तव में उपरोक्त फ़ंक्शन में अभी भी रनटाइम O (1) है।

लेकिन वहाँ रहे हैं तथ्य यह है वास्तविक दुनिया एल्गोरिदम जहां क्रम (कम से कम आंशिक रूप से) कम कर सकते हैं जब इनपुट आकार बढ़ता में। ध्यान दें कि ये एल्गोरिदम O (1) के नीचे रनटाइम व्यवहार का प्रदर्शन नहीं करेंगे , हालांकि। फिर भी, वे दिलचस्प हैं। उदाहरण के लिए, हॉर्सपूल द्वारा बहुत सरल पाठ खोज एल्गोरिथ्म लें । यहां, अपेक्षित रनटाइम कम हो जाएगा क्योंकि खोज पैटर्न की लंबाई बढ़ जाती है (लेकिन हाइस्टैक की बढ़ती लंबाई एक बार फिर से रनटाइम में वृद्धि करेगी)।

Comments

'हार्डवेयर द्वारा लागू' एक ट्यूरिंग मशीन पर भी लागू होता है। ओ (1 / n) के मामले में हमेशा एक इनपुट आकार होगा जिसके लिए एल्गोरिथ्म को किसी भी ऑपरेशन को निष्पादित करने के लिए नहीं माना जाता है। और इसलिए मुझे लगता है कि O (1 / n) समय जटिलता वास्तव में प्राप्त करना असंभव है।

— रोलैंड एवाल्ड

मेहरदाद, आप समझ नहीं रहे हैं। O अंकन n -> - के रूप में सीमा (तकनीकी रूप से सीमित ) के बारे में कुछ है । एल्गोरिथम / प्रोग्राम का रनिंग टाइम कुछ मशीन पर चरणों की संख्या है, और इसलिए असतत है - उस समय एक गैर-शून्य निचला बाउंड होता है जो एक एल्गोरिथ्म ("एक कदम") ले सकता है। यह है संभव है कि तक कुछ परिमित एन एक कार्यक्रम n के साथ कम कई कदम लेता है, लेकिन एक ही तरीका है एक एल्गोरिथ्म हे (1 / n), या वास्तव में ओ (1), अगर यह पर्याप्त रूप से सभी के लिए समय 0 लेता है हो सकता है बड़े एन - जो संभव नहीं है।

— श्रीवत्सआर

हम इस बात से असहमत नहीं हैं कि O (1 / n) फ़ंक्शन (गणितीय अर्थ में) मौजूद हैं। जाहिर है वे करते हैं। लेकिन संगणना स्वाभाविक रूप से असतत है। कुछ ऐसा है जिसकी सीमा कम होती है, जैसे कि प्रोग्राम का रनिंग टाइम - वॉन न्यूमैन आर्किटेक्चर या विशुद्ध रूप से अमूर्त ट्यूरिंग मशीन पर - O (1 / n) नहीं हो सकता है। समान रूप से, कुछ ऐसा है जो O (1 / n) है जिसका निचला भाग नहीं हो सकता है। (आपके "स्लीप" फ़ंक्शन को आमंत्रित करना होगा, या चर "सूची" की जांच करनी होगी - या इनपुट टेप को ट्यूरिंग मशीन पर जांचना होगा। इसलिए समय के साथ n कुछ change + 1 / के साथ बदल जाएगा। n, जो O (1 / n) नहीं है

— श्रीवत्सआर

यदि T (0) = =, तो यह रुका नहीं है। "टी (0) = but जैसी कोई चीज नहीं है, लेकिन यह अभी भी रुकता है"। इसके अलावा, यहां तक ​​कि अगर आप R∪ {even} में काम करते हैं और T (0) = and, और T (n + 1) = T (n) / 2 परिभाषित करते हैं, तो T (n) = ∞ सभी n के लिए। मुझे दोहराने दें: यदि असतत-मूल्यवान फ़ंक्शन O (1 / n) है, तो सभी पर्याप्त रूप से बड़े n के लिए यह 0. है। [प्रमाण: T (n) = O (1 / n) का अर्थ है कि एक निरंतर c मौजूद है जैसे कि n> N0, T (n) <c (1 / n) के लिए, जिसका अर्थ है कि किसी भी n> अधिकतम (N0,1 / c), T (n) <1 के लिए, जिसका अर्थ है T (n) = 0]। कोई मशीन, असली है या सार, 0 समय लग सकता है: यह है इनपुट को देखने के लिए। खैर, मशीन के अलावा जो कभी कुछ नहीं करता है, और जिसके लिए टी (एन) = 0 सभी एन के लिए।

— श्रीवत्सआर

आपको किसी भी उत्तर को शुरू करना होगा जो "यह प्रश्न उतना मूर्ख नहीं है जितना यह प्रतीत हो सकता है।"

— टेलीमेकस

Answer 2

हाँ।

रनटाइम O (1 / n), "खाली" एल्गोरिथ्म के साथ ठीक एक एल्गोरिथ्म है।

एक एल्गोरिथ्म के लिए O (1 / n) होना का अर्थ है कि यह एक निर्देश के एल्गोरिथ्म की तुलना में कम चरणों में asymptotically निष्पादित करता है। यदि यह सभी n> n0 के लिए एक से कम चरणों में निष्पादित होता है, तो इसमें उन n के लिए बिल्कुल कोई निर्देश नहीं होना चाहिए। 'अगर n> n0' की जाँच में कम से कम 1 निर्देश की लागत है, तो इसमें सभी n के लिए कोई निर्देश नहीं होना चाहिए।

सारांश: केवल एल्गोरिथ्म जो O (1 / n) है, वह खाली एल्गोरिथ्म है, जिसमें कोई निर्देश नहीं है ।

Comments

तो अगर किसी ने पूछा कि खाली एल्गोरिथम की समय जटिलता क्या है, तो आप O (1 / n) के साथ उत्तर देंगे ??? किसी तरह मुझे शक हुआ।

— फाकलर

इस सूत्र में यह एकमात्र सही उत्तर है, और (मेरे उत्थान के बावजूद) यह शून्य मतों पर है। ऐसा स्टैकऑवरफ्लो है, जहां "सही दिखने वाले" जवाबों को वास्तव में सही लोगों की तुलना में अधिक वोट दिया जाता है।

— श्रीवत्सआर

नहीं, इसकी रेटिंग 0 है क्योंकि यह गलत है। N के संबंध में एक बड़ा-ओह मान व्यक्त करना जब वह N से स्वतंत्र है तो गलत है। दूसरा, किसी भी प्रोग्राम को चलाना, यहां तक ​​कि जो अभी मौजूद है, कम से कम एक निरंतर समय लेता है, ओ (1)। यहां तक ​​कि अगर ऐसा नहीं था, तो यह O (0) होगा, O (1 / n) नहीं।

— kenj0418

कोई भी फ़ंक्शन जो O (0) है, वह भी O (1 / n) है, और O (n), भी O (n ^ 2), O (2 ^ n) भी है। आह, क्या कोई सरल परिभाषा नहीं समझता है? O () एक ऊपरी बाउंड है।

— श्रीवत्सआर

@ kenj0418 आप हर एक वाक्य में गलत होने में कामयाब रहे। "N के स्वतंत्र होने पर N के संबंध में एक बड़ा-ओह मान व्यक्त करना गलत है।" एक स्थिर फ़ंक्शन एक पूरी तरह से नासमझ फ़ंक्शन है। "दूसरा, किसी भी कार्यक्रम को चलाने वाला, यहां तक ​​कि जो अभी मौजूद है, कम से कम निरंतर समय लेता है, ओ (1)।" जटिलता की परिभाषा वास्तव में किसी भी कार्यक्रम को चलाने के बारे में कुछ नहीं कहती है। "यह O (0) होगा, O (1 / n) नहीं"। देखें @ श्रीवत्सआर की टिप्पणी

— अलेक्सी रोमानोव

Answer 3

शार्पूथ सही है, ओ (1) सबसे अच्छा संभव प्रदर्शन है। हालांकि, यह एक तेजी से समाधान का मतलब नहीं है, बस एक निश्चित समय समाधान है।

एक दिलचस्प संस्करण, और शायद जो वास्तव में सुझाया जा रहा है, वह यह है कि जनसंख्या बढ़ने पर कौन सी समस्याएं आसान हो जाती हैं। मैं 1 के बारे में सोच सकता हूँ, यद्यपि यह बात सामने आई है और जुबान में जवाब है:

क्या किसी सेट के दो लोगों का जन्मदिन समान है? जब n 365 से अधिक हो जाए, तो सही लौटें। हालांकि 365 से कम के लिए, यह O (n ln n) है। शायद एक बढ़िया जवाब नहीं है क्योंकि समस्या धीरे-धीरे आसान नहीं होती है, लेकिन n> 365 के लिए सिर्फ O (1) बन जाती है।

Comments

366. लीप वर्ष के बारे में मत भूलना!

— निक जॉनसन

तुम सही हो। कंप्यूटर की तरह, मैं कभी-कभार राउंडिंग एरर के अधीन आता हूं :-)

— एड्रियन

+1। कई एनपी-पूर्ण समस्याएं हैं जो n के रूप में "चरण संक्रमण" से गुजरती हैं, अर्थात वे जल्दी से बहुत आसान हो जाते हैं या बहुत कठिन हो जाते हैं क्योंकि आप एन के एक निश्चित सीमा मूल्य से अधिक हो जाते हैं। एक उदाहरण संख्या विभाजन समस्या है: n nonggative पूर्णांक का एक सेट दिया गया है, उन्हें दो भागों में विभाजित करें ताकि प्रत्येक भाग का योग बराबर हो। यह n की एक निश्चित सीमा मूल्य पर नाटकीय रूप से आसान हो जाता है।

— j_random_hacker

Answer 4

यह संभव नहीं है। बिग-ओ की परिभाषा असमानता से अधिक नहीं है:

A(n) = O(B(n))
<=>
exists constants C and n0, C > 0, n0 > 0 such that
for all n > n0, A(n) <= C * B(n)

तो बी (एन) वास्तव में अधिकतम मूल्य है, इसलिए यदि यह घटता है क्योंकि n बढ़ता है तो अनुमान नहीं बदलेगा।

Comments

मुझे संदेह है कि यह उत्तर "सही" है, लेकिन दुर्भाग्य से मुझे इसे समझने के लिए बुद्धि की कमी है।

— freespace

AFAIK में यह स्थिति सभी n के लिए सही नहीं है, लेकिन सभी n> n_0 के लिए (यानी, केवल जब इनपुट का आकार एक विशिष्ट सीमा तक पहुँचता है)।

— रोलैंड एवाल्ड

मैं नहीं देखता कि परिभाषा (यहां तक ​​कि सही) ने ओपी के सवाल का कैसे विरोध किया। परिभाषा पूरी तरह से मनमाने कार्यों के लिए रखती है! 1 / n बी के लिए एक पूरी तरह से समझदार कार्य है, और वास्तव में आपके समीकरण में यह विरोधाभास नहीं है (बस गणित करें)। तो नहीं, बहुत सहमति के बावजूद, यह जवाब वास्तव में गलत है । माफ़ करना।

— कोनराड रुडोल्फ

गलत! मुझे नीचता पसंद नहीं है लेकिन आप कहते हैं कि जब कोई स्पष्ट सहमति नहीं है तो यह असंभव है। व्यवहार में आप सही हैं, यदि आप 1 / n रनटाइम (आसान) के साथ एक फ़ंक्शन का निर्माण करते हैं तो यह अंततः कुछ न्यूनतम समय को प्रभावित करेगा, प्रभावी रूप से इसे ओ (1) एल्गोरिदम बनाते समय लागू करेगा। हालांकि पेपर पर एल्गोरिदम को O (1 / n) होने से रोकने के लिए कुछ भी नहीं है।

— जेरिको

@ जैसन: हां, अब जब आप इसे कहते हैं ... :) @jheriko: O (1 / n) की समय जटिलता कागज़ात IMHO पर काम नहीं करती। हम ग्रोथ फंक्शन (इनपुट साइज़) = #ops को ट्यूरिंग मशीन के लिए चिह्नित कर रहे हैं। यदि यह x चरणों के बाद लंबाई n = 1 के इनपुट के लिए रुकावट करता है, तो मैं एक इनपुट आकार n >> x चुनूंगा, अर्थात काफी बड़ा, अगर एल्गोरिथ्म O (1 / n) में है, तो कोई ऑपरेशन नहीं होना चाहिए किया हुआ। ट्यूरिंग मशीन को यह कैसे नोटिस करना चाहिए (यह एक बार टेप से पढ़ने की अनुमति नहीं है)?

— रोलैंड एवाल्ड

Answer 5

बड़े ओ नोटेशन की मेरी पिछली सीख से, भले ही आपको 1 चरण की आवश्यकता हो (जैसे कि एक चर की जांच करना, एक असाइनमेंट करना), वह ओ (1) है।

ध्यान दें कि O (1) O (6) के समान है, क्योंकि "स्थिर" कोई फर्क नहीं पड़ता। इसलिए हम कहते हैं कि O (n) O (3n) के समान है।

इसलिए यदि आपको 1 चरण की भी आवश्यकता है, तो वह O (1) है ... और चूंकि आपके प्रोग्राम को कम से कम 1 चरण की आवश्यकता है, तो न्यूनतम एल्गोरिथम जा सकता है O (1)। जब तक हम ऐसा नहीं करते हैं, तब तक यह O (0) है, मुझे लगता है? यदि हम कुछ भी करते हैं, तो यह ओ (1) है, और यह न्यूनतम है कि यह जा सकता है।

(यदि हम इसे नहीं करना चुनते हैं, तो यह एक ज़ेन या ताओ प्रश्न बन सकता है ... प्रोग्रामिंग के दायरे में, ओ (1) अभी भी न्यूनतम है)।

या इसके बारे में कैसे:

प्रोग्रामर : मालिक, मुझे इसे ओ (1) समय में करने का एक तरीका मिला!
बॉस : इसे करने की कोई आवश्यकता नहीं है, हम आज सुबह दिवालिया हो गए हैं।
प्रोग्रामर : ओह तो, यह ओ (0) हो जाता है।

Comments

आपके मजाक ने मुझे प्रोग्रामिंग के ताओ से कुछ याद दिलाया: canonical.org/~kragen/tao-of-programming.html#book8 (8.3)

— kenj0418

शून्य चरणों से मिलकर एक एल्गोरिथ्म हे (0) है। यह एक बहुत आलसी एल्गोरिथ्म है।

— nalply

Answer 6

नहीं, यह संभव नहीं है:

जैसा कि n 1 / n में अनंतता को दर्शाता है, हम अंततः 1 / (inf) प्राप्त करते हैं, जो प्रभावी रूप से 0 है।

इस प्रकार, समस्या का बड़ा-ओह वर्ग बड़े पैमाने पर n के साथ O (0) होगा, लेकिन कम n के साथ निरंतर समय के करीब। यह समझदार नहीं है, क्योंकि लगातार समय की तुलना में तेजी से किया जा सकता है:

void nothing() {};

और यह भी यकीनन है!

जैसे ही आप एक कमांड निष्पादित करते हैं, आप कम से कम O (1) में हैं, इसलिए नहीं, हमारे पास O (1 / n) का एक बड़ा-ओह वर्ग नहीं हो सकता है!

Answer 7

समारोह (NOOP) बिल्कुल नहीं चलने के बारे में क्या? या एक निश्चित मूल्य का उपयोग कर। क्या वह माना जाएगा?

Comments

वह अभी भी O (1) रनटाइम है।

— कोनराड रुडोल्फ

ठीक है, वह अभी भी ओ (1) है। मैं यह नहीं देखता कि कोई इसे कैसे समझ सकता है, और फिर भी एक और जवाब में दावा करता है कि NO-OP से कम कुछ संभव है।

— श्रीवत्सआर

श्रीवत्सर: बिल्कुल विरोधाभास नहीं है। आप यह समझने में विफल रहते हैं कि बड़े O संकेतन को फ़ंक्शन में बिताए गए समय के साथ कुछ नहीं करना है - बल्कि, यह बताता है कि बदलते इनपुट (एक निश्चित मूल्य के ऊपर) के साथ उस समय में कैसे परिवर्तन होता है। अधिक के लिए अन्य टिप्पणी धागा देखें।

— कोनराड रुडोल्फ

मैं इसे पूरी तरह से अच्छी तरह समझ लेता हूं, धन्यवाद। बिंदु - जैसा कि मैंने दूसरे धागे में कई बार बनाया है - यह है कि यदि समय इनपुट ओ के साथ घटता है, दर ओ (1 / n) पर है, तो इसे अंततः NOOP द्वारा लिए गए समय से कम होना चाहिए। इससे पता चलता है कि कोई भी एल्गोरिथ्म O (1 / n) asymptotically नहीं हो सकता है, हालांकि निश्चित रूप से इसका रनटाइम एक सीमा तक घट सकता है।

— श्रीवत्सआर

हां ... जैसा कि मैंने कहीं और कहा है, कोई भी एल्गोरिथ्म जो O (1 / n) है, उसे सभी इनपुट के लिए शून्य समय भी लेना चाहिए, इसलिए इस बात पर निर्भर करता है कि आप null एल्गोरिथ्म को 0 समय पर मानते हैं या नहीं, एक O (1) है / n) एल्गोरिथ्म। इसलिए यदि आप NOOP को O (1) मानते हैं, तो कोई O (1 / n) एल्गोरिदम नहीं हैं।

— श्रीवत्सआर

Answer 8

मैं प्रायः उन संभावनाओं का वर्णन करने के लिए O (1 / n) का उपयोग करता हूं जो इनपुट के रूप में छोटे हो जाते हैं - उदाहरण के लिए, संभावना है कि एक उचित सिक्का log2 (n) फ़्लिप पर पूंछ पर आता है O (1 / n)।

Comments

हालांकि यह बड़ा ओ नहीं है। आप प्रश्न का उत्तर देने के लिए इसे फिर से परिभाषित नहीं कर सकते।

— ज़िफरे

यह पुनर्वितरण नहीं है, यह वास्तव में बड़े ओ की परिभाषा है।

— श्रीवत्सआर

मैं व्यापार द्वारा एक सैद्धांतिक कंप्यूटर वैज्ञानिक हूं। यह एक फ़ंक्शन के एसिम्प्टोटिक क्रम के बारे में है।

— डेव

बिग ओ एक मनमाना वास्तविक कार्य की एक संपत्ति है। समय जटिलता इसके संभावित अनुप्रयोगों में से एक है। अंतरिक्ष जटिलता (एक एल्गोरिथ्म का उपयोग करने वाली मेमोरी की मात्रा) एक और है। यह प्रश्न O (1 / n) एल्गोरिदम के बारे में है जिसका तात्पर्य है कि यह इनमें से एक है (जब तक कि कोई अन्य एल्गोरिदम लागू नहीं होता है जिसके बारे में मुझे नहीं पता है)। अन्य अनुप्रयोगों में जनसंख्या वृद्धि के आदेश शामिल हैं, जैसे कॉनवे के जीवन में। यह भी देखें en.wikipedia.org/wiki/Big_O_notation

— स्टीवर्ट

@Dave: प्रश्न यह नहीं था कि क्या O (1 / n) फ़ंक्शन मौजूद हैं, जो स्पष्ट रूप से मौजूद हैं। इसके बजाय, यह था कि क्या O (1 / n) एल्गोरिदम मौजूद है, जो (शून्य फ़ंक्शन के संभावित अपवाद के साथ) मौजूद नहीं हो सकता है

— Casebash

Answer 9

O (1) का अर्थ है "निरंतर समय"।

जब आप एक लूप से जल्दी बाहर निकलते हैं [1] तो आप (बिग-ओ नोटेशन में) एक ओ (१) एल्गोरिदम को ओ (एन) में बदल रहे हैं, लेकिन इसे तेजी से बना रहे हैं।

चाल सामान्य रूप से है निरंतर समय एल्गोरिथ्म सबसे अच्छा है, और रैखिक बेहतर है तो घातीय है, लेकिन छोटी मात्रा में एन के लिए, घातीय एल्गोरिदम वास्तव में तेज हो सकता है।

1: इस उदाहरण के लिए एक स्थिर सूची लंबाई मान लें

Answer 10

इस प्रश्न को पढ़ने वाले और बातचीत के बारे में क्या समझना चाहते हैं, इसके लिए यह मदद कर सकता है:

|    |constant |logarithmic |linear|  N-log-N |quadratic|  cubic  |  exponential  |
|  n |  O(1)   | O(log n)   | O(n) |O(n log n)|  O(n^2) |  O(n^3) |     O(2^n)    |
|  1 |       1 |          1 |     1|         1|        1|       1 |             2 |
|  2 |       1 |          1 |     2|         2|        4|       8 |             4 |
|  4 |       1 |          2 |     4|         8|       16|      64 |            16 |
|  8 |       1 |          3 |     8|        24|       64|     512 |           256 |
| 16 |       1 |          4 |    16|        64|      256|   4,096 |         65536 |
| 32 |       1 |          5 |    32|       160|    1,024|  32,768 | 4,294,967,296 |
| 64 |       1 |          6 |    64|       384|    4,069| 262,144 |   1.8 x 10^19 |

Answer 11

मेरा मानना ​​है कि क्वांटम एल्गोरिदम सुपरपोज़िशन के माध्यम से "एक ही बार में" कई संगणनाएँ कर सकते हैं ...

मुझे संदेह है कि यह एक उपयोगी उत्तर है।

Comments

यही कारण है कि अभी भी लगातार समय हो सकता है, यानी हे (1), जिसका अर्थ यह आकार के डेटा के लिए चलाने के लिए समय की एक ही राशि लेता है n यह के आकार 1. डेटा के लिए करता है के रूप में

— freespace

लेकिन क्या होगा अगर समस्या एक पीली थी? (आह। हा हा हा।)

— जेफ मीटबॉल यांग

यह एक सुपर स्थिति होगी।

— डैनियल ईयरविकर

क्वांटम एल्गोरिदम कई संगणना कर सकते हैं, लेकिन आप केवल एक संगणना के परिणाम को प्राप्त कर सकते हैं, और आप यह नहीं चुन सकते हैं कि कौन सा परिणाम प्राप्त करना है। शुक्र है, आप एक पूरे (उदाहरण के लिए, QFT) के रूप में एक क्वांटम रजिस्टर पर भी ऑपरेशन कर सकते हैं, इसलिए आप कुछ पाने के लिए बहुत अधिक संभावना है :)

— Gracenotes

यह शायद उपयोगी नहीं है, लेकिन यह सच होने का फायदा है, जो इसे कुछ अधिक वोट किए गए उत्तरों B-) से ऊपर रखता है

— ब्रायन पोस्टो

Answer 12

कई लोगों के पास सही उत्तर है (नहीं) यह साबित करने का एक और तरीका है: एक फ़ंक्शन के लिए, आपको फ़ंक्शन को कॉल करना होगा, और आपको एक जवाब वापस करना होगा। इसमें कुछ निश्चित समय लगता है। EVEN यदि शेष प्रसंस्करण में बड़े इनपुट के लिए कम समय लगता है, तो उत्तर को प्रिंट करना (जो कि हम एक बिट होने के लिए मान सकते हैं) कम से कम निरंतर समय लेता है।

Answer 13

यदि समाधान मौजूद है, तो इसे तैयार किया जा सकता है और निरंतर समय में पहुँचा जा सकता है = तुरंत। उदाहरण के लिए एक LIFO डेटा संरचना का उपयोग करते हुए यदि आप जानते हैं कि क्रमबद्ध क्वेरी रिवर्स ऑर्डर के लिए है। फिर डेटा पहले से ही सॉर्ट किया जाता है, यह देखते हुए कि उपयुक्त मॉडल (LIFO) चुना गया था।

Answer 14

जनसंख्या बढ़ने पर कौन सी समस्याएं आसान हो जाती हैं? एक उत्तर बिट्टोरेंट जैसी चीज है जहां डाउनलोड गति नोड्स की संख्या का व्युत्क्रम कार्य है। एक कार के विपरीत, जो आपके द्वारा लोड किए जाने से अधिक धीमा हो जाता है, फ़ाइल-साझाकरण नेटवर्क जैसे बिटोरेंट से जुड़े नोड्स को गति देता है।

Comments

हां, लेकिन समानांतर कंप्यूटर में प्रोसेसर की संख्या की तरह बिटोरेंट नोड्स की संख्या अधिक है। इस स्थिति में "एन" डाउनलोड होने की कोशिश कर रहे फ़ाइल का आकार होगा। जैसे आप लगातार कंप्यूटरों में लंबाई एन के एक अनारक्षित सरणी में एक तत्व पा सकते हैं यदि आपके पास एन कंप्यूटर थे, तो आप निरंतर समय में आकार एन की एक फ़ाइल डाउनलोड कर सकते हैं यदि आपके पास एन कंप्यूटर आपको डेटा भेजने की कोशिश कर रहा था।

— किबी

Answer 15

आप O (1) से नीचे नहीं जा सकते, हालांकि O (k) जहां k, N से कम है, संभव है। हमने उन्हें सबलाइनर टाइम एल्गोरिदम कहा । कुछ समस्याओं में, सब्लिनियर टाइम एल्गोरिथ्म केवल एक विशेष समस्या के अनुमानित समाधान दे सकता है। हालांकि, कभी-कभी, एक अनुमानित समाधान ठीक है, शायद इसलिए कि डेटासेट बहुत बड़ा है, या इस तरह यह सभी को कम्प्यूटेशनल रूप से महंगा भी है।

Comments

पक्का नहीं मै समझ गया। Log (N) N से कम है। क्या इसका मतलब यह है कि Log (N) एक सबलाइनियर एल्गोरिथम है? और कई लॉग (एन) एल्गोरिदम मौजूद हैं। ऐसा ही एक उदाहरण एक द्विआधारी पेड़ में एक मूल्य पा रहा है। हालांकि, ये अभी भी 1 / एन से अलग हैं, क्योंकि लॉग (एन) हमेशा बढ़ रहा है, जबकि 1 / एन एक घटता हुआ कार्य है।

— किबी

परिभाषा को देखते हुए, सब्लिनियर टाइम अल्गोरिद्म कोई भी एल्गोरिथम है जिसका समय आकार N की तुलना में धीमा बढ़ता है। इसलिए इसमें लॉगरिदमिक टाइम एल्गोरिथ्म शामिल है, जो कि लॉग (N) है।

— हाओ वूई लिम

उह, सुबलीन टाइम एल्गोरिदम सटीक उत्तर दे सकते हैं, जैसे कि रैम मशीन पर एक ऑर्डर किए गए सरणी में बाइनरी सर्च।

— ए। रेक्स

@ए। रेक्स: हाओ वूई लिम ने कहा "कुछ समस्याओं में"।

— लार्स सेप

Answer 16

इस बारे में क्या:

void FindRandomInList(list l)
{
    while(1)
    {
        int rand = Random.next();
        if (l.contains(rand))
            return;
    }
}

जैसे-जैसे सूची का आकार बढ़ता जाता है, कार्यक्रम का अपेक्षित क्रम कम होता जाता है।

Comments

मुझे लगता है कि आप O (n) का अर्थ नहीं समझते हैं

— Markus Lausberg

हालांकि सूची के साथ नहीं, सरणी या हैश के साथ कहां constainsहै O (1)

— vava

ठीक है, यादृच्छिक फ़ंक्शन को एक आलसी सरणी के रूप में सोचा जा सकता है, इसलिए आप मूल रूप से "आलसी यादृच्छिक सूची" में प्रत्येक तत्व को खोज रहे हैं और यह जांच रहे हैं कि क्या यह इनपुट सूची में निहित है। मुझे लगता है कि यह रैखिक से भी बदतर है, बेहतर नहीं है।

— hasen

यदि आपको लगता है कि int मूल्यों के सीमित सेट है, तो वह कुछ बिंदु मिल गया है। इसलिए जब l में 2 <sup> 64 </ sup> मान शामिल होंगे, यह सभी तरह से तात्कालिक होने वाला है। जो इसे वैसे भी O (1) से भी बदतर बनाता है :)

— vava

Answer 17

O (1 / n) कम नहीं है तो O (1), इसका मूल रूप से मतलब है कि आपके पास जितना अधिक डेटा होगा, उतनी ही तेजी से एल्गोरिथ्म जाएगा। कहते हैं कि आपको एक सरणी मिलती है और इसे हमेशा 10 ¹⁰⁰ तत्वों तक भरें अगर इसमें कम है तो कुछ भी न करें और अगर कुछ अधिक है तो कुछ भी न करें। यह एक O (1 / n) नहीं है, लेकिन O (-n) की तरह कुछ है :) बहुत बुरा O- बड़ा अंकन नकारात्मक मान नहीं देता है।

Comments

"O (1 / n) कम नहीं है तो O (1)" - यदि कोई फ़ंक्शन f O (1 / n) है, तो वह भी O (1) है। और बड़ा-ओह एक "रिश्ते से कम" की तरह बहुत कुछ महसूस करता है: यह रिफ्लेक्टिव है, यह सकर्मक है, और अगर हम f और g के बीच समरूपता है, तो दोनों समान हैं, जहां बड़े-थेटा हमारे समकक्ष संबंध हैं। ISTR "वास्तविक" आदेश देने वाले संबंधों को <= b और b <= a की आवश्यकता होती है, हालांकि, a और b का अर्थ है, और netcraft ^ W विकिपीडिया इसकी पुष्टि करता है। इसलिए एक अर्थ में, यह कहना उचित है कि वास्तव में O (1 / n) "O (1)" से कम है।

— जोनास कोल्कर

Answer 18

जैसा कि बताया गया है, अशक्त कार्य के संभावित अपवाद के अलावा, कोई O(1/n)कार्य नहीं हो सकता है, क्योंकि समय लगने पर 0 को अप्रोच करना होगा।

बेशक, कुछ एल्गोरिदम हैं, जैसे कि कोनराड द्वारा परिभाषित, जो ऐसा लगता है कि उन्हें कम से O(1)कम कुछ अर्थों में कम होना चाहिए ।

def get_faster(list):
    how_long = 1/len(list)
    sleep(how_long)

यदि आप इन एल्गोरिदम की जांच करना चाहते हैं, तो आपको या तो अपने स्वयं के असममित माप को परिभाषित करना चाहिए, या समय की अपनी धारणा को। उदाहरण के लिए, उपरोक्त एल्गोरिथ्म में, मैं कई बार "नि: शुल्क" संचालन के एक निर्धारित राशि के उपयोग की अनुमति दे सकता था। उपरोक्त एल्गोरिथ्म में, अगर मैं हर चीज के लिए समय को छोड़कर t 'को परिभाषित करता हूं लेकिन नींद है, तो t' = 1 / n, जो O (1 / n) है। शायद बेहतर उदाहरण हैं, क्योंकि स्पर्शोन्मुख व्यवहार तुच्छ है। वास्तव में, मुझे यकीन है कि कोई भी व्यक्ति होश में आ सकता है जो गैर-तुच्छ परिणाम देता है।

Answer 19

बाकी के अधिकांश उत्तर बड़े-ओ की व्याख्या करते हैं जो कि विशेष रूप से एल्गोरिथ्म के चलने के समय के बारे में हैं। लेकिन चूंकि प्रश्न का उल्लेख नहीं किया गया था, इसलिए मुझे लगा कि संख्यात्मक विश्लेषण में बिग-ओ के अन्य अनुप्रयोग का उल्लेख करने योग्य है, जो त्रुटि के बारे में है।

कई एल्गोरिदम ओ (एच ^ पी) या ओ (एन ^ {- पी}) हो सकते हैं, इस पर निर्भर करते हुए कि आप चरण-आकार (एच) या डिवीजनों की संख्या (एन) के बारे में बात कर रहे हैं। उदाहरण के लिए, यूलर की विधि में , आप y (h) के एक अनुमान को देखते हैं, जिसे आप y (0) और डाई / dx (y का व्युत्पन्न) जानते हैं। Y (h) का आपका अनुमान अधिक सटीक है क्योंकि h लगभग 0. है, इसलिए कुछ मनमाना x के लिए y (x) ज्ञात करने के लिए, व्यक्ति अंतराल 0 से x लेता है, इसे n टुकड़ों तक विभाजित करता है, और Euler की विधि चलाता है प्रत्येक बिंदु पर, y (0) से y (x / n) तक y (2x / n), और इसी तरह से।

तो Euler की विधि तब O (h) या O (1 / n) एल्गोरिथम है, जहाँ h को आमतौर पर एक स्टेप साइज़ के रूप में व्याख्या किया जाता है और n को एक अंतराल को विभाजित करने की संख्या के रूप में व्याख्या की जाती है।

फ़्लोटिंग पॉइंट राउंडिंग त्रुटियों के कारण, वास्तविक संख्यात्मक विश्लेषण अनुप्रयोगों में आपके पास O (1 / h) भी हो सकता है । जितना छोटा आप अपना अंतराल बनाते हैं, कुछ एल्गोरिदम के कार्यान्वयन के लिए उतना अधिक रद्दीकरण होता है, महत्वपूर्ण अंकों का अधिक नुकसान होता है, और इसलिए अधिक त्रुटि होती है, जो एल्गोरिथ्म के माध्यम से प्रचारित होती है।

यूलर की विधि के लिए, यदि आप फ्लोटिंग पॉइंट का उपयोग कर रहे हैं, तो एक छोटे से पर्याप्त कदम और रद्दीकरण का उपयोग करें और आप एक बड़ी संख्या में एक छोटी संख्या जोड़ रहे हैं, जिससे बड़ी संख्या अपरिवर्तित रह जाएगी। उन एल्गोरिदम के लिए जो एक दूसरे से दो संख्याओं के घटाव के माध्यम से व्युत्पन्न की गणना करते हैं, दो बहुत करीबी पदों पर मूल्यांकन किया गया है, y (x) के साथ (y (x + h) - y (x) / h) को सुचारू कार्यों में y (x + h) y (x) के करीब हो जाता है जिसके परिणामस्वरूप बड़े रद्दीकरण और कम महत्वपूर्ण आंकड़ों के साथ व्युत्पन्न के लिए एक अनुमान है। यह बदले में आप जिस भी एल्गोरिथ्म के लिए व्युत्पन्न की आवश्यकता का प्रचार करेंगे (जैसे, एक सीमा मूल्य समस्या)।

Answer 20

ठीक है, मैंने इसके बारे में थोड़ा सोच लिया, और शायद वहाँ एक एल्गोरिथ्म मौजूद है जो इस सामान्य रूप का अनुसरण कर सकता है:

आपको 1000 नोड ग्राफ के लिए ट्रैवलिंग सेल्समैन समस्या की गणना करने की आवश्यकता है, हालांकि, आपको नोड्स की एक सूची भी दी जाती है, जिसे आप नहीं देख सकते हैं। जैसे-जैसे अविवेकी नोड्स की सूची बड़ी होती जाती है, समस्या को हल करना आसान होता जाता है।

Comments

यह ओ (एन) में फिर एन के विभिन्न प्रकार है। इस ट्रिक से आप कह सकते हैं कि हर एल्गोरिथ्म में O (q) है जहाँ q उदाहरण के लिए चीन में रहने वाले लोगों की संख्या है।

— वावा

बॉयर-मूर एक समान प्रकार (O (n / m)) का है, लेकिन यह वास्तव में "O (1)" से बेहतर नहीं है, क्योंकि n> = m है। मुझे लगता है कि आपके "अप्रतिस्पर्धी TSP" के लिए भी यही सच है।

— निकी

इस मामले में भी TSP का रन-टाइम NP-Complete है, आप बस ग्राफ़ से नोड्स निकाल रहे हैं, और इसलिए प्रभावी रूप से n कम हो रहा है।

— एड जेम्स

Answer 21

मुझे एक एल्गोरिथ्म दिखाई दे रहा है जो O (1 / n) है जो ऊपरी तौर पर एक ऊपरी सीमा में है:

आपके पास इनपुट की एक बड़ी श्रृंखला है जो रूटीन के लिए कुछ बाहरी होने के कारण बदल रहे हैं (हो सकता है कि वे हार्डवेयर को प्रतिबिंबित करते हैं या ऐसा करने वाले प्रोसेसर में कुछ अन्य कोर भी हो सकते हैं।) और आपको एक यादृच्छिक लेकिन वैध एक का चयन करना होगा।

अब, अगर यह नहीं बदल रहा था, तो आप केवल वस्तुओं की एक सूची बना देंगे, एक बेतरतीब ढंग से चुनें और ओ (1) समय प्राप्त करें। हालांकि, डेटा की गतिशील प्रकृति एक सूची बनाने में बाधा डालती है, आपको बस यादृच्छिक रूप से जांच करनी होगी और जांच की वैधता का परीक्षण करना होगा। (और ध्यान दें कि स्वाभाविक रूप से इसकी कोई गारंटी नहीं है कि उत्तर तब भी मान्य है जब वह वापस आ जाता है। यह अभी भी उपयोग कर सकता है - कहते हैं, एक गेम में एक इकाई के लिए एआई। यह एक लक्ष्य पर शूट कर सकता है जो दृष्टि से बाहर हो गया था। ट्रिगर खींच रहा है।)

यह अनन्तता का सबसे खराब स्थिति वाला प्रदर्शन है, लेकिन एक औसत मामले का प्रदर्शन जो डेटा स्पेस के भरते ही नीचे चला जाता है।

Answer 22

संख्यात्मक विश्लेषण में, सन्निकटन एल्गोरिदम में सन्निकटन सहिष्णुता में उप-निरंतर असममित जटिलता होनी चाहिए।

class Function
{
    public double[] ApproximateSolution(double tolerance)
    {
        // if this isn't sub-constant on the parameter, it's rather useless
    }
}

Comments

क्या आप वास्तव में उप-स्थिरांक, या उदासीनता का मतलब है? सन्निकटन एल्गोरिदम उप-स्थिर क्यों होना चाहिए? और इसका क्या मतलब है ??

— लार्स सेप

@ LarsH, सन्निकटन एल्गोरिदम की त्रुटि चरण आकार (या इसकी एक सकारात्मक शक्ति) के लिए आनुपातिक है, इसलिए आपका चरण आकार जितना छोटा होगा, उतनी ही छोटी त्रुटि होगी। लेकिन एक अनुमानित समस्या की जांच करने का एक और सामान्य तरीका यह है कि एक अंतराल को कितनी बार विभाजित किया गया है, इसकी तुलना में त्रुटि है। एक अंतराल के विभाजन की संख्या कदम के आकार के विपरीत आनुपातिक है, इसलिए विभाजन की संख्या की कुछ सकारात्मक शक्ति के विपरीत त्रुटि आनुपातिक है - जैसे-जैसे आप विभाजन की संख्या बढ़ाते हैं, आपकी त्रुटि कम होती जाती है।

— एंड्रयू लेई

@AndrewLei: वाह, लगभग 7 साल बाद एक जवाब! मुझे समझ में आया कि सैम का जवाब अब मैंने पहले से बेहतर कर दिया। प्रतिक्रिया देने के लिये धन्यवाद।

— लार्स

Answer 23

मुझे लगता है कि ओ (1) से कम संभव नहीं है। किसी भी समय एल्गो को O (1) कहा जाता है। लेकिन O (1 / n) के लिए नीचे दिए गए फ़ंक्शन के बारे में कैसे। (मुझे पता है कि इस समाधान में पहले से ही कई प्रकार प्रस्तुत किए गए हैं, लेकिन मुझे लगता है कि उन सभी में कुछ खामियां हैं (प्रमुख नहीं, वे अवधारणा को अच्छी तरह से समझाते हैं)। तो यहां एक है, बस तर्क के लिए:

def 1_by_n(n, C = 10):   #n could be float. C could be any positive number
  if n <= 0.0:           #If input is actually 0, infinite loop.
    while True:
      sleep(1)           #or pass
    return               #This line is not needed and is unreachable
  delta = 0.0001
  itr = delta
  while delta < C/n:
    itr += delta

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

कोई यह तर्क दे सकता है कि यह मशीन की शुद्धता से बंधेगा। इस प्रकार sinc eit की ऊपरी सीमा है यह O (1) है। लेकिन हम स्ट्रिंग में n और C के इनपुट्स लेने के साथ ही उसे बायपास भी कर सकते हैं। और इसके अलावा और तुलना स्ट्रिंग पर की जाती है। विचार यह है कि, इसके साथ हम n मनमाने ढंग से छोटे को कम कर सकते हैं। इस प्रकार फ़ंक्शन की ऊपरी सीमा बाध्य नहीं होती है, तब भी जब हम n = 0 को अनदेखा करते हैं।

मेरा यह भी मानना ​​है कि हम यह नहीं कह सकते कि रन टाइम O (1 / n) है। लेकिन हमें ओ (1 + 1 / n) जैसा कुछ कहना चाहिए

Answer 24

एक एल्गोरिथ्म का निर्माण संभव हो सकता है जो कि ओ (1 / n) है। एक उदाहरण एक लूप होगा जो f (n) के कई गुणकों को पुन: प्रसारित करता है जहां f (n) कुछ फ़ंक्शन है जिसका मान n से अधिक होने की गारंटी है और f (n) -n की सीमा n के रूप में n के पास है शून्य। च (n) की गणना को भी सभी n के लिए स्थिर होना चाहिए। मुझे पता नहीं है कि हाथ क्या f (n) लगेगा या ऐसा एल्गोरिथम किस अनुप्रयोग का होगा, मेरी राय में हालांकि ऐसा कोई फ़ंक्शन हो सकता है, लेकिन परिणामी एल्गोरिथ्म के साथ एक एल्गोरिथम की संभावना को साबित करने के अलावा कोई उद्देश्य नहीं होगा। हे (1 / n)।

Comments

आपके लूप को एक चेक की आवश्यकता होती है जो कम से कम निरंतर समय लेता है, इसलिए परिणामस्वरूप एल्गोरिथ्म में कम से कम जटिलता ओ (1) है।

— स्टीफन रीच

Answer 25

मैं एल्गोरिदम के बारे में नहीं जानता, लेकिन O (1) से कम जटिलता यादृच्छिक एल्गोरिदम में दिखाई देती है। दरअसल, ओ (1) (थोड़ा ओ) ओ (1) से कम है। इस तरह की जटिलता आमतौर पर यादृच्छिक एल्गोरिदम में दिखाई देती है। उदाहरण के लिए, जैसा कि आपने कहा, जब किसी घटना की संभावना 1 / n क्रम की होती है, तो वे इसे ओ (1) के साथ निरूपित करते हैं। या जब वे कहना चाहते हैं कि कुछ उच्च संभावना के साथ होता है (उदाहरण 1 - 1 / n) तो वे इसे 1 - ओ (1) के साथ निरूपित करते हैं।

Answer 26

यदि इनपुट डेटा की परवाह किए बिना उत्तर समान है, तो आपके पास O (0) एल्गोरिथम है।

या दूसरे शब्दों में - इनपुट डेटा सबमिट किए जाने से पहले उत्तर ज्ञात होता है - फ़ंक्शन को अनुकूलित किया जा सकता है - इसलिए O (0)

Comments

वास्तव में? आपको अभी भी एक मूल्य वापस करने की आवश्यकता होगी, तो क्या यह अभी भी ओ (1) नहीं होगा?

— जोकिम सॉयर

नहीं, O (0) का अर्थ है कि सभी इनपुट के लिए शून्य समय लगेगा। O (1) निरंतर समय है।

— पीट किरकम

Answer 27

बिग-ओ नोटेशन एक एल्गोरिथ्म के लिए सबसे खराब स्थिति का प्रतिनिधित्व करता है जो कि इसके विशिष्ट रन समय के समान नहीं है। यह सिद्ध करना सरल है कि एक O (1 / n) एल्गोरिथ्म एक O (1) एल्गोरिथम है। परिभाषा के अनुसार,
O (1 / n) -> T (n) <= 1 / n, सभी n> = C> 0
O (1 / n) -> T (n) <= 1 / C, के बाद से 1 / n <= 1 / C सभी n> = C
O (1 / n) -> O (1) के लिए, क्योंकि Big-O अंकन स्थिरांक को अनदेखा करता है (अर्थात C का मान मायने नहीं रखता)

Comments

नहीं: बिग ओ नोटेशन का उपयोग औसत-केस और अपेक्षित समय (और यहां तक ​​कि सर्वश्रेष्ठ-केस) परिदृश्यों के बारे में बात करने के लिए भी किया जाता है। बाकी इस प्रकार है।

— कोनराड रुडोल्फ

'O' संकेतन निश्चित रूप से एक ऊपरी सीमा को परिभाषित करता है (एल्गोरिथम जटिलता के संदर्भ में, यह सबसे खराब स्थिति होगी)। ओमेगा और थीटा का उपयोग क्रमशः सर्वश्रेष्ठ और औसत मामले को दर्शाने के लिए किया जाता है।

— रोलैंड एवाल्ड

रोलैंड: यह एक गलत धारणा है; ऊपरी बाध्य सबसे खराब स्थिति के समान नहीं है, दोनों स्वतंत्र अवधारणाएं हैं। hashtable-containsएल्गोरिथ्म के अपेक्षित (और औसत) रनटाइम पर विचार करें जिसे ओ (1) के रूप में दर्शाया जा सकता है - और सबसे खराब स्थिति को थीटा (एन) के रूप में बहुत सटीक रूप से दिया जा सकता है! ओमेगा और थीटा को बस अन्य सीमा को निरूपित करने के लिए इस्तेमाल किया जा सकता है लेकिन इसे फिर से कहने के लिए : उन्हें औसत या सर्वोत्तम मामले से कोई लेना-देना नहीं है।

— कोनराड रुडोल्फ

कोनराड: सच। फिर भी, ओमेगा, थेटा और ओ का उपयोग आमतौर पर सीमा को व्यक्त करने के लिए किया जाता है , और यदि सभी संभावित आदानों पर विचार किया जाता है, तो ओ ऊपरी सीमा का प्रतिनिधित्व करते हैं, आदि

— रोलैंड एवाल्ड 25'09

यह तथ्य कि O (1 / n) O (1) का सबसेट है, तुच्छ है और परिभाषा से सीधे अनुसरण करता है। वास्तव में, यदि एक फ़ंक्शन g O (h) है, तो कोई फ़ंक्शन f जो O (g) है, वह O (h) भी है।

— तोबियों

Answer 28

कुछ भी O (1) से छोटा नहीं है Big-O संकेतन का अर्थ एल्गोरिथम के लिए जटिलता का सबसे बड़ा क्रम है

यदि एक एल्गोरिथ्म में n ^ 3 + n ^ 2 + n + 5 का रनटाइम है तो वह O (n ^ 3) है। निम्न शक्तियां यहां बिल्कुल भी मायने नहीं रखती हैं क्योंकि n -> Inf, n ^ 2 की तुलना में अप्रासंगिक होगा। n ^ 3

इसी तरह n -> Inf, O (1 / n) O (1) की तुलना में अप्रासंगिक होगा इसलिए 3 + O (1 / n) O के समान होगा (1) इस प्रकार O (1) बनाना सबसे छोटा संभव कम्पेनसेशनल होगा जटिलता

Answer 29

inline void O0Algorithm() {}

Comments

यह एक O (1) एल्गोरिदम होगा।

— लेज़स वी। कार्लसन

यह भी है, लेकिन मुद्दा यह है कि यह 1 (1) नहीं है। और मेरा जवाब क्यों डाउन किया गया है? अगर आपको लगता है कि मैं गलत हूं, तो कैसे समझाऊं?

— स्टीवर्ट

मैंने अन्यत्र पूछा कि क्या, मूल रूप से, यह बहुत सही उत्तर सही है या नहीं, और यह विवादित प्रतीत होता है: stackoverflow.com/questions/3209139/…

— 14:46 पर jyoungdev

वैसे यह इनलाइन है, इसलिए आप इसे O (0) मान सकते हैं। हालांकि, सभी ओ (0) एल्गोरिदम तुच्छ हैं (कुछ भी नहीं कर रहे हैं), इसलिए ... बहुत दिलचस्प जवाब नहीं।

— स्टीफन रीच

@StefanReich सच है, यह एक बहुत ही दिलचस्प जवाब नहीं है, लेकिन यह एक जवाब है।

— स्टीवर्ट

Answer 30

यहाँ एक सरल O (1 / n) एल्गोरिथ्म है। और यह भी कुछ दिलचस्प करता है!

function foo(list input) {
  int m;
  double output;

  m = (1/ input.size) * max_value;  
  output = 0;
  for (int i = 0; i < m; i++)
    output+= random(0,1);

  return output;
}

O (1 / n) संभव है क्योंकि यह वर्णन करता है कि इनपुट के बढ़ते आकार को देखते हुए फ़ंक्शन का आउटपुट कैसे बदलता है। यदि हम किसी फ़ंक्शन को निष्पादित करने वाले निर्देशों की संख्या का वर्णन करने के लिए फ़ंक्शन 1 / n का उपयोग कर रहे हैं, तो कोई आवश्यकता नहीं है कि फ़ंक्शन किसी भी इनपुट आकार के लिए शून्य निर्देश लेता है। इसके बजाय, यह है कि प्रत्येक इनपुट आकार के लिए, कुछ सीमा से ऊपर, आवश्यक निर्देशों की संख्या 1 / n द्वारा गुणा किए गए सकारात्मक स्थिर से ऊपर बंधी हुई है। जैसा कि कोई वास्तविक संख्या नहीं है जिसके लिए 1 / n 0 है, और स्थिर सकारात्मक है, तो कोई कारण नहीं है कि फ़ंक्शन 0 या उससे कम निर्देश लेने के लिए विवश होगा।

Comments

चूँकि O (1 / n) क्षैतिज रेखा = 1 से नीचे आएगा, और जब n अनंत तक पहुँचता है, तो आपका कोड अभी भी दिए गए कई चरणों को अंजाम देगा, यह एल्गोरिथ्म O (1) एल्गोरिथम है। बिग-ओ नोटेशन एल्गोरिथ्म के सभी अलग-अलग हिस्सों का एक फ़ंक्शन है, और यह सबसे बड़ा उठाता है। चूंकि विधि हमेशा कुछ निर्देशों को चलाएगी, जब n अनंत तक पहुंचता है, तो आपको हर बार निष्पादित करने वाले उन्हीं निर्देशों के साथ छोड़ दिया जाता है, और इस प्रकार यह विधि निरंतर समय में चलेगी। दी, यह ज्यादा समय नहीं होगा, लेकिन यह बिग-ओ नोटेशन के लिए प्रासंगिक नहीं है।

— लास वी। कार्लसन